{"version":3,"file":"roadtrip.6da856baf0724c9413c2.js","mappings":";UAAIA,EACAC,oBCMJC,EAAAA,EANiBC,SAASC,cAAc,4BACnBC,IAAIC,MAAM,KAAK,GACvBA,MAAM,KAAKC,MAAM,GAAI,GAAGC,KAAK,KAAO,gBCKhD,WACD,aAGA,GAAsB,iBAAXC,OAMX,GAAI,yBAA0BA,QAC1B,8BAA+BA,QAC/B,sBAAuBA,OAAOC,0BAA0BC,UAIpD,mBAAoBF,OAAOC,0BAA0BC,WACzDC,OAAOC,eAAeJ,OAAOC,0BAA0BC,UACrD,iBAAkB,CAClBG,IAAK,WACH,OAAOC,KAAKC,kBAAoB,CAClC,QAXN,CAqBA,IAAIb,EAAWM,OAAON,SASlBc,EAAW,GA+EfC,EAAqBP,UAAUQ,iBAAmB,IAQlDD,EAAqBP,UAAUS,cAAgB,KAM/CF,EAAqBP,UAAUU,uBAAwB,EAQvDH,EAAqBP,UAAUW,QAAU,SAASC,GAKhD,IAJ8BR,KAAKS,oBAAoBC,MAAK,SAASC,GACnE,OAAOA,EAAKC,SAAWJ,CACzB,IAEA,CAIA,IAAMA,GAA6B,GAAnBA,EAAOK,SACrB,MAAM,IAAIC,MAAM,6BAGlBd,KAAKe,oBACLf,KAAKS,oBAAoBO,KAAK,CAACJ,QAASJ,EAAQS,MAAO,OACvDjB,KAAKkB,wBACLlB,KAAKmB,wBATL,CAUF,EAOAhB,EAAqBP,UAAUwB,UAAY,SAASZ,GAClDR,KAAKS,oBACDT,KAAKS,oBAAoBY,QAAO,SAASV,GAE3C,OAAOA,EAAKC,SAAWJ,CACzB,IACKR,KAAKS,oBAAoBa,SAC5BtB,KAAKuB,0BACLvB,KAAKwB,sBAET,EAMArB,EAAqBP,UAAU6B,WAAa,WAC1CzB,KAAKS,oBAAsB,GAC3BT,KAAKuB,0BACLvB,KAAKwB,qBACP,EASArB,EAAqBP,UAAU8B,YAAc,WAC3C,IAAIC,EAAU3B,KAAK4B,eAAepC,QAElC,OADAQ,KAAK4B,eAAiB,GACfD,CACT,EAYAxB,EAAqBP,UAAUiC,gBAAkB,SAASC,GACxD,IAAIC,EAAYD,GAAiB,CAAC,GAGlC,OAFKE,MAAMC,QAAQF,KAAYA,EAAY,CAACA,IAErCA,EAAUG,OAAOb,QAAO,SAASc,EAAGC,EAAGC,GAC5C,GAAgB,iBAALF,GAAiBG,MAAMH,IAAMA,EAAI,GAAKA,EAAI,EACnD,MAAM,IAAIrB,MAAM,0DAElB,OAAOqB,IAAME,EAAED,EAAI,EACrB,GACF,EAcAjC,EAAqBP,UAAU2C,iBAAmB,SAASC,GACzD,IACIC,GADeD,GAAkB,OACVjD,MAAM,OAAOmD,KAAI,SAASC,GACnD,IAAIC,EAAQ,wBAAwBC,KAAKF,GACzC,IAAKC,EACH,MAAM,IAAI9B,MAAM,qDAElB,MAAO,CAACgC,MAAOC,WAAWH,EAAM,IAAKI,KAAMJ,EAAM,GACnD,IAOA,OAJAH,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GACnCA,EAAQ,GAAKA,EAAQ,IAAMA,EAAQ,GAE5BA,CACT,EAQAtC,EAAqBP,UAAUsB,sBAAwB,WAChDlB,KAAKiD,2BACRjD,KAAKiD,0BAA2B,EAI5BjD,KAAKK,cACPL,KAAKkD,oBAAsBC,YACvBnD,KAAKmB,uBAAwBnB,KAAKK,gBAGtC+C,EAAS1D,OAAQ,SAAUM,KAAKmB,wBAAwB,GACxDiC,EAAShE,EAAU,SAAUY,KAAKmB,wBAAwB,GAEtDnB,KAAKM,uBAAyB,qBAAsBZ,SACtDM,KAAKqD,aAAe,IAAIC,iBAAiBtD,KAAKmB,wBAC9CnB,KAAKqD,aAAa9C,QAAQnB,EAAU,CAClCmE,YAAY,EACZC,WAAW,EACXC,eAAe,EACfC,SAAS,MAKnB,EAOAvD,EAAqBP,UAAU2B,wBAA0B,WACnDvB,KAAKiD,2BACPjD,KAAKiD,0BAA2B,EAEhCU,cAAc3D,KAAKkD,qBACnBlD,KAAKkD,oBAAsB,KAE3BU,EAAYlE,OAAQ,SAAUM,KAAKmB,wBAAwB,GAC3DyC,EAAYxE,EAAU,SAAUY,KAAKmB,wBAAwB,GAEzDnB,KAAKqD,eACPrD,KAAKqD,aAAa5B,aAClBzB,KAAKqD,aAAe,MAG1B,EASAlD,EAAqBP,UAAUuB,uBAAyB,WACtD,IAAI0C,EAAc7D,KAAK8D,eACnBC,EAAWF,EAAc7D,KAAKgE,eAyW3B,CACLC,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GA7WVtE,KAAKS,oBAAoB8D,SAAQ,SAAS5D,GACxC,IAAIH,EAASG,EAAKC,QACd4D,EAAaC,EAAsBjE,GACnCkE,EAAqB1E,KAAK2E,oBAAoBnE,GAC9CoE,EAAWjE,EAAKM,MAChB4D,EAAmBhB,GAAea,GAClC1E,KAAK8E,kCAAkCtE,EAAQuD,GAE/CgB,EAAWpE,EAAKM,MAAQ,IAAItB,EAA0B,CACxDqF,KAiOGtF,OAAOuF,aAAeA,YAAYC,KAAOD,YAAYC,MAhOxD1E,OAAQA,EACR2E,mBAAoBX,EACpBY,WAAYrB,EACZc,iBAAkBA,IAGfD,EAEMf,GAAea,EAGpB1E,KAAKqF,qBAAqBT,EAAUG,IACtC/E,KAAK4B,eAAeZ,KAAK+D,GAMvBH,GAAYA,EAASU,gBACvBtF,KAAK4B,eAAeZ,KAAK+D,GAZ3B/E,KAAK4B,eAAeZ,KAAK+D,EAe7B,GAAG/E,MAECA,KAAK4B,eAAeN,QACtBtB,KAAKuF,UAAUvF,KAAK0B,cAAe1B,KAEvC,EAeAG,EAAqBP,UAAUkF,kCAC3B,SAAStE,EAAQuD,GAGnB,GAA+C,QAA3CrE,OAAO8F,iBAAiBhF,GAAQiF,QAApC,CAOA,IALA,IAoP+BC,EAAOC,EAClC1B,EACAC,EACAC,EACAC,EACAC,EACAC,EAzPAO,EADaJ,EAAsBjE,GAEnCoF,EAASC,EAAcrF,GACvBsF,GAAS,GAELA,GAAQ,CACd,IAAIC,EAAa,KACbC,EAAyC,GAAnBJ,EAAO/E,SAC7BnB,OAAO8F,iBAAiBI,GAAU,CAAC,EAGvC,GAAmC,QAA/BI,EAAoBP,QAAmB,OAmB3C,GAjBIG,GAAU5F,KAAKiG,MAAQL,GAAUxG,GACnC0G,GAAS,EACTC,EAAahC,GAMT6B,GAAUxG,EAAS8G,MACnBN,GAAUxG,EAAS+G,iBACa,WAAhCH,EAAoBI,WACtBL,EAAatB,EAAsBmB,IAMnCG,IAsNyBL,EArNgBK,EAqNTJ,EArNqBd,EAsNvDZ,SACAC,SACAC,SACAC,SACAC,SACAC,SALAL,EAAMoC,KAAKC,IAAIZ,EAAMzB,IAAK0B,EAAM1B,KAChCC,EAASmC,KAAKE,IAAIb,EAAMxB,OAAQyB,EAAMzB,QACtCC,EAAOkC,KAAKC,IAAIZ,EAAMvB,KAAMwB,EAAMxB,MAClCC,EAAQiC,KAAKE,IAAIb,EAAMtB,MAAOuB,EAAMvB,OAEpCE,EAASJ,EAASD,IA3NlBY,GA0NAR,EAAQD,EAAQD,IAGH,GAAKG,GAAU,GAAM,CACpCL,IAAKA,EACLC,OAAQA,EACRC,KAAMA,EACNC,MAAOA,EACPC,MAAOA,EACPC,OAAQA,KAjOiB,MAEzBsB,EAASC,EAAcD,EACzB,CACA,OAAOf,CAvCsD,CAwC/D,EAQA1E,EAAqBP,UAAUoE,aAAe,WAC5C,IAAID,EACJ,GAAI/D,KAAKiG,KACPlC,EAAWU,EAAsBzE,KAAKiG,UACjC,CAEL,IAAIO,EAAOpH,EAAS+G,gBAChBD,EAAO9G,EAAS8G,KACpBnC,EAAW,CACTE,IAAK,EACLE,KAAM,EACNC,MAAOoC,EAAKC,aAAeP,EAAKO,YAChCpC,MAAOmC,EAAKC,aAAeP,EAAKO,YAChCvC,OAAQsC,EAAKE,cAAgBR,EAAKQ,aAClCpC,OAAQkC,EAAKE,cAAgBR,EAAKQ,aAEtC,CACA,OAAO1G,KAAK2G,wBAAwB5C,EACtC,EASA5D,EAAqBP,UAAU+G,wBAA0B,SAASC,GAChE,IAAInE,EAAUzC,KAAK6G,kBAAkBnE,KAAI,SAASC,EAAQP,GACxD,MAAsB,MAAfO,EAAOK,KAAeL,EAAOG,MAChCH,EAAOG,OAASV,EAAI,EAAIwE,EAAKvC,MAAQuC,EAAKtC,QAAU,GAC1D,IACIwC,EAAU,CACZ7C,IAAK2C,EAAK3C,IAAMxB,EAAQ,GACxB2B,MAAOwC,EAAKxC,MAAQ3B,EAAQ,GAC5ByB,OAAQ0C,EAAK1C,OAASzB,EAAQ,GAC9B0B,KAAMyC,EAAKzC,KAAO1B,EAAQ,IAK5B,OAHAqE,EAAQzC,MAAQyC,EAAQ1C,MAAQ0C,EAAQ3C,KACxC2C,EAAQxC,OAASwC,EAAQ5C,OAAS4C,EAAQ7C,IAEnC6C,CACT,EAaA3G,EAAqBP,UAAUyF,qBAC3B,SAAST,EAAUG,GAIrB,IAAIgC,EAAWnC,GAAYA,EAASU,eAChCV,EAAS3E,mBAAqB,GAAK,EACnC+G,EAAWjC,EAASO,eACpBP,EAAS9E,mBAAqB,GAAK,EAGvC,GAAI8G,IAAaC,EAEjB,IAAK,IAAI5E,EAAI,EAAGA,EAAIpC,KAAKiH,WAAW3F,OAAQc,IAAK,CAC/C,IAAIL,EAAY/B,KAAKiH,WAAW7E,GAIhC,GAAIL,GAAagF,GAAYhF,GAAaiF,GACtCjF,EAAYgF,GAAahF,EAAYiF,EACvC,OAAO,CAEX,CACF,EAQA7G,EAAqBP,UAAUkE,aAAe,WAC5C,OAAQ9D,KAAKiG,MAAQiB,EAAa9H,EAAUY,KAAKiG,KACnD,EASA9F,EAAqBP,UAAU+E,oBAAsB,SAASnE,GAC5D,OAAO0G,EAAalH,KAAKiG,MAAQ7G,EAAUoB,EAC7C,EAQAL,EAAqBP,UAAUmB,kBAAoB,WAC7Cb,EAASiH,QAAQnH,MAAQ,GAC3BE,EAASc,KAAKhB,KAElB,EAOAG,EAAqBP,UAAU4B,oBAAsB,WACnD,IAAI4F,EAAQlH,EAASiH,QAAQnH,OACf,GAAVoH,GAAalH,EAASmH,OAAOD,EAAO,EAC1C,EA0LA1H,OAAOS,qBAAuBA,EAC9BT,OAAOC,0BAA4BA,CAjsBnC,CAwBA,SAASA,EAA0BsB,GACjCjB,KAAKgF,KAAO/D,EAAM+D,KAClBhF,KAAKQ,OAASS,EAAMT,OACpBR,KAAKoF,WAAanE,EAAMmE,WACxBpF,KAAKmF,mBAAqBlE,EAAMkE,mBAChCnF,KAAK6E,iBAAmB5D,EAAM4D,kBA+mBvB,CACLZ,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,GApnBVtE,KAAKsF,iBAAmBrE,EAAM4D,iBAG9B,IAAIL,EAAaxE,KAAKmF,mBAClBmC,EAAa9C,EAAWH,MAAQG,EAAWF,OAC3CO,EAAmB7E,KAAK6E,iBACxB0C,EAAmB1C,EAAiBR,MAAQQ,EAAiBP,OAM/DtE,KAAKC,kBAHHqH,EAGuBE,QAAQD,EAAmBD,GAAYG,QAAQ,IAG/CzH,KAAKsF,eAAiB,EAAI,CAEvD,CAYA,SAASnF,EAAqBuH,EAAUC,GAEtC,IA8dgBC,EAAIC,EAChBC,EA/dAC,EAAUJ,GAAe,CAAC,EAE9B,GAAuB,mBAAZD,EACT,MAAM,IAAI5G,MAAM,+BAGlB,GAAIiH,EAAQ9B,MAAiC,GAAzB8B,EAAQ9B,KAAKpF,SAC/B,MAAM,IAAIC,MAAM,2BAIlBd,KAAKmB,wBAmdWyG,EAldZ5H,KAAKmB,uBAAuB6G,KAAKhI,MAkdjB6H,EAldwB7H,KAAKI,iBAmd7C0H,EAAQ,KACL,WACAA,IACHA,EAAQG,YAAW,WACjBL,IACAE,EAAQ,IACV,GAAGD,GAEP,GAxdA7H,KAAKuF,UAAYmC,EACjB1H,KAAKS,oBAAsB,GAC3BT,KAAK4B,eAAiB,GACtB5B,KAAK6G,kBAAoB7G,KAAKuC,iBAAiBwF,EAAQG,YAGvDlI,KAAKiH,WAAajH,KAAK6B,gBAAgBkG,EAAQhG,WAC/C/B,KAAKiG,KAAO8B,EAAQ9B,MAAQ,KAC5BjG,KAAKkI,WAAalI,KAAK6G,kBAAkBnE,KAAI,SAASC,GACpD,OAAOA,EAAOG,MAAQH,EAAOK,IAC/B,IAAGvD,KAAK,IACV,CAydA,SAAS2D,EAAS+E,EAAMC,EAAOR,EAAIS,GACG,mBAAzBF,EAAKG,iBACdH,EAAKG,iBAAiBF,EAAOR,EAAIS,IAAkB,GAEjB,mBAApBF,EAAKI,aACnBJ,EAAKI,YAAY,KAAOH,EAAOR,EAEnC,CAWA,SAAShE,EAAYuE,EAAMC,EAAOR,EAAIS,GACG,mBAA5BF,EAAKK,oBACdL,EAAKK,oBAAoBJ,EAAOR,EAAIS,IAAkB,GAEnB,mBAArBF,EAAKM,cACnBN,EAAKM,aAAa,KAAOL,EAAOR,EAEpC,CAkCA,SAASnD,EAAsBiE,GAC7B,IAAI9B,EAEJ,IACEA,EAAO8B,EAAGjE,uBACZ,CAAE,MAAOkE,GAGT,CAEA,OAAK/B,GAGCA,EAAKvC,OAASuC,EAAKtC,SACvBsC,EAAO,CACL3C,IAAK2C,EAAK3C,IACVG,MAAOwC,EAAKxC,MACZF,OAAQ0C,EAAK1C,OACbC,KAAMyC,EAAKzC,KACXE,MAAOuC,EAAKxC,MAAQwC,EAAKzC,KACzBG,OAAQsC,EAAK1C,OAAS0C,EAAK3C,MAGxB2C,GAUA,CACL3C,IAAK,EACLC,OAAQ,EACRC,KAAM,EACNC,MAAO,EACPC,MAAO,EACPC,OAAQ,EAfZ,CA0BA,SAAS4C,EAAatB,EAAQgD,GAE5B,IADA,IAAIT,EAAOS,EACJT,GAAM,CACX,GAAIA,GAAQvC,EAAQ,OAAO,EAE3BuC,EAAOtC,EAAcsC,EACvB,CACA,OAAO,CACT,CASA,SAAStC,EAAcsC,GACrB,IAAIvC,EAASuC,EAAKU,WAElB,OAAIjD,GAA6B,IAAnBA,EAAO/E,UAAkB+E,EAAOkD,KAErClD,EAAOkD,KAGZlD,GAAUA,EAAOmD,aAEZnD,EAAOmD,aAAaF,WAGtBjD,CACT,CAOA,CA5tBA,iDCRe,MAAMoD,EACnB,WAAAC,CAAYlB,GACV/H,KAAK+H,QAAUiB,EAA8BE,sBAAsBnB,GACnE/H,KAAKmJ,MACP,CAEA,4BAAOD,CAAsBE,GAC3B,MAAMC,EAAkB,CACtBC,8BAA+B,0BAC/BC,aAAc,WACdC,oCAAqC,kCAGvC,IAAK,MAAMC,KAAYL,EACrBC,EAAgBI,GAAYL,EAAaK,GAU3C,OAPAJ,EAAgBC,8BAC2C,iBAAlDD,EAAgBC,8BACnBlK,SAASsK,iBACPL,EAAgBC,+BAElBD,EAAgBC,8BAEfD,CACT,CAEA,IAAAF,GACMnJ,KAAK+H,QAAQuB,8BAA8BhI,QAC7CU,MAAMpC,UAAU2E,QAAQoF,KACtB3J,KAAK+H,QAAQuB,+BACbZ,IACE,IAAIkB,EAAU,GACVC,EAAY,GAChB,MAAMC,EAAUpB,EAAGgB,iBACjB1J,KAAK+H,QAAQyB,qCAGfI,EAAU5J,KAAK+J,WAAWD,GAE1B,IAAK,IAAI1H,EAAI,EAAGA,EAAIwH,EAAQtI,OAAQc,IAAK,CACvC,MAAM4H,EAAKtK,OAAOuK,WAAWL,EAAQxH,GAAG8H,OAEpCxK,OAAOuK,YAAcD,EAAGJ,SAC1BC,EAAU7I,KAAK4I,EAAQxH,GAAG9C,KAG5B0K,EAAGG,aAAY,KACb,GAAIH,EAAGJ,QAAS,CACF,IAAIQ,OAAOpK,KAAKqK,aAAaT,EAAQxH,GAAG9C,MAC3CgL,KAAK5B,EAAG6B,MAAMC,mBACrB9B,EAAG6B,MAAMC,gBAAkB,QAAUZ,EAAQxH,GAAG9C,IAAM,KAE1D,KAAO,CACO,IAAI8K,OAAOpK,KAAKqK,aAAaT,EAAQxH,EAAI,GAAG9C,MAC/CgL,KAAK5B,EAAG6B,MAAMC,mBACrB9B,EAAG6B,MAAMC,gBACP,QAAUZ,EAAQxH,EAAI,GAAG9C,IAAM,KAErC,IAEJ,CAEA,GAAIoJ,EAAG+B,UAAUC,SAAS1K,KAAK+H,QAAQwB,aAAaoB,UAAU,IAC5D3K,KAAK4K,eAAelC,EAAImB,EAAWD,OAC9B,CACL,IAAItK,EAAMuK,EAAUvI,OAASuI,EAAUgB,MAAQjB,EAAQ,GAAGtK,IAC1DoJ,EAAG6B,MAAMC,gBAAkB,QAAUlL,EAAM,IAC7C,IAIR,CAEA,UAAAyK,CAAWe,GACT,IAAIlB,EAAU,GAWd,OATA5H,MAAMpC,UAAU2E,QAAQoF,KAAKmB,GAAYC,IACvC,MAAMC,EAAY,CAChB1L,IAAKyL,EAAOE,aAAa,YACzBf,MAAOa,EAAOE,aAAa,eAG7BrB,EAAQ5I,KAAKgK,EAAU,IAGlBpB,CACT,CAEA,cAAAgB,CAAetB,EAA+BO,EAAWD,GACvD,MAAMsB,EAAOlL,KACPmL,EAAW,IAAIhL,sBAAqBiL,IACxCA,EAAQ7G,SAAQ,SAAStD,GACvB,GAAIA,EAAMqE,eAAgB,CACxB,MAAM+F,EAAYpK,EAAMT,OACxB6K,EAAUZ,UAAUa,OAAOJ,EAAKnD,QAAQwB,aAAaoB,UAAU,IAC/DQ,EAAS/J,UAAUiK,GAEnB,IAAI/L,EAAMuK,EAAUvI,OAASuI,EAAUgB,MAAQjB,EAAQ,GAAGtK,IAC1D+L,EAAUd,MAAMC,gBAAkB,QAAUlL,EAAM,IACpD,CACF,GAAE,IAEJ6L,EAAS5K,QAAQ+I,EACnB,CAEA,YAAAe,CAAakB,GACX,OAAOA,EAAOC,QAAQ,sBAAuB,OAC/C,yBCzGF,IAAIC,EAAM,6BACNC,EAAY,mDACZC,EAA2B,oBAAVC,MAAwB,CAACrB,MAAO,CAAC,kBAAmB,IAAM,IAAIqB,MAC/EC,EAAoB,eAAgBF,EAAQpB,MAC5CuB,EAAyB,oBAAqBH,EAAQpB,MACtDwB,EAAc,oBAAqBJ,EAAQpB,MAC3CyB,EAAmD,iBAAvBL,EAAQM,WACpCC,EAAqBP,EAAQV,aAC7BkB,EAAqBR,EAAQS,aAC7BC,GAAkB,EAoCtB,SAASC,EAAeC,EAAKlI,EAAOC,GAEnC,IAAIkI,EAnCI,wEAmC4BnI,GAAS,GAnCwC,cAmCrCC,GAAU,GAnC8C,iBAsCpG4H,EAAmBvC,KAAK4C,EAAK,SAAWC,GAC3CL,EAAmBxC,KAAK4C,EAAK,MAAOC,EAEtC,CAEA,SAASC,EAAaF,EAAK7E,GAGtB6E,EAAIG,aACPhF,EAAS6E,GAETtE,WAAWwE,EAAc,IAAKF,EAAK7E,EAErC,CAEA,SAASiF,EAAOjE,GACf,IAAI6B,EA/BL,SAAkB7B,GAIjB,IAHA,IACIkE,EADArC,EAAQ/E,iBAAiBkD,GAAImE,WAE7BC,EAAQ,CAAC,EAC+B,QAApCF,EAASlB,EAAU7I,KAAK0H,KAC/BuC,EAAMF,EAAO,IAAMA,EAAO,GAE3B,OAAOE,CACR,CAuBaC,CAASrE,GACjBsE,EAAMtE,EAAG+C,GAIb,GAHAlB,EAAM,cAAgBA,EAAM,eAAiB,QAGxCyC,EAAIT,IAAK,CAEb,GAA4B,SAAxBhC,EAAM,cACT,OAID,IACEyC,EAAIC,UACLpB,IACCtB,EAAM,mBAEP,MAEF,CAGA,IAAKyC,EAAIT,IAAK,CACbS,EAAIT,IAAM,IAAIX,MAAMlD,EAAGrE,MAAOqE,EAAGpE,QACjC0I,EAAIT,IAAIW,OAAShB,EAAmBvC,KAAKjB,EAAI,oBAAsBA,EAAGwE,OACtEF,EAAIT,IAAIjN,IAAM4M,EAAmBvC,KAAKjB,EAAI,iBAAmBA,EAAGpJ,IAIhE6M,EAAmBxC,KAAKjB,EAAI,eAAgBA,EAAGpJ,KAC3CoJ,EAAGwE,QACNf,EAAmBxC,KAAKjB,EAAI,kBAAmBA,EAAGwE,QAGnDZ,EAAe5D,EAAIA,EAAGgE,cAAgBhE,EAAGrE,MAAOqE,EAAGyE,eAAiBzE,EAAGpE,QAGnEoE,EAAGwE,SACNxE,EAAGwE,OAAS,IAEb,KAiCF,SAAuBxE,GACtB,IAAI0E,EAAc,CACjBrN,IAAK,SAAasN,GACjB,OAAO3E,EAAG+C,GAAKc,IAAIc,GAAc,MAClC,EACAC,IAAK,SAAaxK,EAAOuK,GAIxB,OAHA3E,EAAG+C,GAAKc,IAAIc,GAAc,OAASvK,EACnCqJ,EAAmBxC,KAAKjB,EAAK,YAAc2E,EAAOvK,GAClD6J,EAAOjE,GACA5F,CACR,GAEDjD,OAAOC,eAAe4I,EAAI,MAAO0E,GACjCvN,OAAOC,eAAe4I,EAAI,aAAc,CACvC3I,IAAK,WAAc,OAAOqN,EAAYrN,IAAI,aAAe,IAE1DF,OAAOC,eAAe4I,EAAI,SAAU,CACnC3I,IAAK,WAAc,OAAOqN,EAAYrN,IAAI,SAAW,EACrDuN,IAAK,SAAUC,GAAM,OAAOH,EAAYE,IAAIC,EAAI,SAAW,GAE7D,CApDGC,CAAc9E,EACf,CAAE,MAAOC,GACJjJ,OAAO+N,OAGZ,CACD,EAlGD,SAA4B/E,GAC3B,GAAIA,EAAGwE,SAAWlB,GAAsBtM,OAAOgO,YAAa,CAC3D,IAAIC,EAAKjO,OAAOgO,YAAYE,EAEvBlF,EAAGiF,EAAGE,KAAQnF,EAAGiF,EAAGE,IAAIC,QAE5BH,EAAGI,QAAQrF,EAAI,CAACsF,UAAU,IAGtBtF,EAAGiF,EAAGE,IAAII,SAEdvF,EAAGiF,EAAGE,IAAIK,WAAY,EACtBP,EAAGI,QAAQrF,EAAI,CAACsF,UAAU,KAI3BtF,EAAGuD,WAAavD,EAAGiF,EAAGE,IAAII,QAAUvF,EAAGpJ,GACxC,CACD,CAkFC6O,CAAmBnB,EAAIT,KAEvB7D,EAAG6B,MAAMC,gBAAkB,SAAawC,EAAIT,IAAIN,YAAce,EAAIT,IAAIjN,KAAKkM,QAAQ,KAAM,OAAU,KACnG9C,EAAG6B,MAAM6D,mBAAqB7D,EAAM,oBAAsB,SAC1D7B,EAAG6B,MAAM8D,iBAAmB,YAC5B3F,EAAG6B,MAAM+D,iBAAmB,cAExB,aAAahE,KAAKC,EAAM,eAC3BkC,EAAaO,EAAIT,KAAK,WACjBS,EAAIT,IAAIG,aAAehE,EAAGrE,OAAS2I,EAAIT,IAAIY,cAAgBzE,EAAGpE,OACjEoE,EAAG6B,MAAMgE,eAAiB,UAE1B7F,EAAG6B,MAAMgE,eAAiB,MAE5B,IAEA7F,EAAG6B,MAAMgE,eAAiBhE,EAAM,cAAciB,QAAQ,OAAQ,QAAQA,QAAQ,OAAQ,aAGvFiB,EAAaO,EAAIT,KAAK,SAAUA,GAC/BD,EAAe5D,EAAI6D,EAAIG,aAAcH,EAAIY,cAC1C,GACD,CAuCA,SAASqB,EAAIC,EAAMC,GAClB,IAAIC,GAAiBtC,IAAoBoC,EAIzC,GAHAC,EAAOA,GAAQ,CAAC,EAChBD,EAAOA,GAAQ,MAEV3C,IAA2B4C,EAAKzB,WAAclB,EAClD,OAAO,EAIK,QAAT0C,EACHA,EAAOrP,SAASwP,qBAAqB,OACX,iBAATH,EACjBA,EAAOrP,SAASsK,iBAAiB+E,GACrB,WAAYA,IACxBA,EAAO,CAACA,IAIT,IAAK,IAAIrM,EAAI,EAAGA,EAAIqM,EAAKnN,OAAQc,IAChCqM,EAAKrM,GAAGqJ,GAAOgD,EAAKrM,GAAGqJ,IAAQ,CAC9BwB,SAAUyB,EAAKzB,UAEhBN,EAAO8B,EAAKrM,IAGTuM,IACHvP,SAAS8G,KAAKoC,iBAAiB,QAAQ,SAAUuG,GACvB,QAArBA,EAAErO,OAAOsO,SACZN,EAAIK,EAAErO,OAAQ,CACbyM,SAAUyB,EAAKzB,UAGlB,IAAG,GACHZ,GAAkB,EAClBoC,EAAO,OAIJC,EAAKK,SACRrP,OAAO4I,iBAAiB,SAAUkG,EAAIxG,KAAK,KAAMyG,EAAM,CACtDxB,SAAUyB,EAAKzB,WAGlB,CAEAuB,EAAI3C,kBAAoBA,EACxB2C,EAAI1C,uBAAyBA,EA9D7B,WACC,SAASkD,EAAiBtG,EAAIuG,GAC7B,OAAOvG,EAAG+C,IAAQ/C,EAAG+C,GAAKc,MAAiB,QAAT0C,GAA2B,WAATA,GAAqBvG,EAAG+C,GAAKc,IAAM7D,CACxF,CACKoD,IACJoD,iBAAiBtP,UAAUqL,aAAe,SAAUgE,GACnD,OAAO/C,EAAmBvC,KAAKqF,EAAiBhP,KAAMiP,GAAOA,EAC9D,EAEAC,iBAAiBtP,UAAUwM,aAAe,SAAU6C,EAAMnM,GACzD,OAAOqJ,EAAmBxC,KAAKqF,EAAiBhP,KAAMiP,GAAOA,EAAME,OAAOrM,GAC3E,EAEF,CAmDAsM,GAEAC,EAAOC,QAAUd,iBCkC8C,IAAnBa,EAAOC,UACjDD,EAAOC,QAnOa,SAAUC,GAC9B,aAEA,IAAIC,EAASC,UAAUC,UAAUvI,QAAQ,UAAY,EAEjDwE,EAAyB,IAAIC,MAC7BC,EAAyB,eAAgBF,EAAQpB,QAAUiF,EAC3D1D,EAAyB,oBAAqBH,EAAQpB,QAAUiF,EAChE9D,EAAyB,kDAY7B,SAASqB,EAAU4C,GAKf,IAJF,IAAIpF,EAAS/E,iBAAiBmK,GAAK9C,WAC/BD,EAAS,KACTE,EAAS,CAAC,EAEgC,QAApCF,EAASlB,EAAU7I,KAAK0H,KAC9BuC,EAAMF,EAAO,IAAMA,EAAO,GAG5B,OAAIE,EAAM,mBAiJd,SAAwBvC,IACjBA,EAAM,mBAAmBpD,QAAQ,QACpCoD,EAAM,qBAAuB,QACrBA,EAAM,mBAAmBpD,QAAQ,SACzCoD,EAAM,qBAAuB,QAE7BA,EAAM,qBAAuB,UAE1BA,EAAM,mBAAmBpD,QAAQ,OACpCoD,EAAM,qBAAuB,OACrBA,EAAM,mBAAmBpD,QAAQ,UACzCoD,EAAM,qBAAuB,SAE7BA,EAAM,qBAAuB,SAE/B,OAAOA,CACT,CAhKaqF,CAAc9C,GAEhBA,CACX,CAkCA,SAAS+C,EAAOF,EAAKpF,GAEnB,GAA4B,SAAxBA,EAAM,cAAV,CAIA,IAAIuF,EAASH,EAAIpF,MACbwF,EAASrQ,OAAO8F,iBAAiBmK,GAGjCK,EAAQ5Q,SAAS6Q,cAAc,cACnCD,EAAME,YAAYP,EAAI9G,WAAWsH,aAAaH,EAAOL,IAGrD,IAAIS,EAAU,CACZ9L,OAAW,OACXD,MAAW,OACXgM,UAAW,cACX5K,QAAW,eACXW,SAAW,UAOb,IAAK,IAAIkK,IAJT,mJAAmJ9E,QAAQ,QAAQ,SAAU8E,GAC3KF,EAAQE,GAAOP,EAAOO,EACxB,IAEgBF,EACdJ,EAAMzF,MAAM+F,GAAOF,EAAQE,GAG7BR,EAAOS,OAAUT,EAAOnN,OAASmN,EAAOU,QAAU,EAClDV,EAAOrK,QAAU,QACjBqK,EAAOW,QAAU,EAGjBd,EAAIrH,iBAAiB,iBAAkBoI,GACvChR,OAAO4I,iBAAiB,kBAAmBoI,GAIvCf,EAAIgB,YAAc,IACpBhB,EAAInH,oBAAoB,iBAAkBkI,GAC1CA,IAvCM,CA8CR,SAASA,IAIP,IAEIE,EAFcjB,EAAIkB,WACJlB,EAAImB,YAGlBC,EAAaf,EAAMvJ,YACnBuK,EAAahB,EAAMtJ,aACnBuK,EAAaF,EAAYC,EAEzBE,EAAY,EACZC,EAAY,EAChBrB,EAAOsB,WAAatB,EAAOuB,UAAY,GAKnCT,EAAaK,EACW,YAAxB1G,EAAM,cAAsD,UAAxBA,EAAM,gBAC5C2G,EAAYF,EAAaJ,EACzBO,EAAYJ,EAAYH,EAExBd,EAAOzL,MAASgC,KAAKiL,MAAMJ,GAAa,KACxCpB,EAAOxL,OAAS0M,EAAa,KAEM,SAA/BzG,EAAM,qBACRuF,EAAOsB,WAAa,EACkB,UAA/B7G,EAAM,qBACbuF,EAAOsB,WAAa/K,KAAKiL,MAAMP,EAAYG,GAAa,KAExDpB,EAAOsB,WAAa/K,KAAKiL,OAAOP,EAAYG,GAAa,GAAK,OAEhEC,EAAWJ,EAAYH,EAEvBd,EAAOzL,MAAY0M,EAAY,KAC/BjB,EAAOxL,OAAY+B,KAAKiL,MAAMH,GAAY,KAEP,QAA/B5G,EAAM,qBACRuF,EAAOuB,UAAY,EACmB,WAA/B9G,EAAM,qBACbuF,EAAOuB,UAAYhL,KAAKiL,MAAMN,EAAaG,GAAY,KAEvDrB,EAAOuB,UAAYhL,KAAKiL,OAAON,EAAaG,GAAY,GAAK,MAI7DxB,EAAI4B,UACN5B,EAAI6B,MACR,CACF,CA7JK3F,GAAsBC,IA4B3B,SAAqByD,GACnB,IAAInI,GAAS,EAERmI,EAGQ,WAAYA,IAGvBA,EAAS,CAACA,IAJVA,EAASnQ,SAASsK,iBAAiB,SAOrC,KAAO6F,IAASnI,IAAQ,CACtB,IAAImD,EAAQwC,EAASwC,EAAOnI,KAGxBmD,EAAM,eAAiBA,EAAM,sBAE/BA,EAAM,cAAgBA,EAAM,eAAiB,OAC7CsF,EAAMN,EAAOnI,GAAQmD,GAEzB,CACF,CAjDEkH,CAAWlC,GA2Lb,SAAmBmC,EAAMzC,EAAM0C,GAC7BA,EAAMA,GAAOjS,OACb,IAAIkS,GAAU,EACVC,EAAU,KAId,IACEA,EAAM,IAAIC,YAAY7C,EACxB,CAAE,MAAOJ,IACPgD,EAAMzS,SAAS2S,YAAY,UACvBC,UAAU/C,GAAM,GAAM,EAC5B,CAEA,IAAIgD,EAAO,WACLL,IAEJA,GAAU,EACVM,uBAAsB,WACpBP,EAAIQ,cAAcN,GAClBD,GAAU,CACZ,IACF,EAEAD,EAAIrJ,iBAAiBoJ,EAAMO,EAC7B,CAnNEG,CAAS,SAAU,mBAoNvB,kBCtQA,OASA,SAAU1S,GAET,IAIMoI,EAEAuK,EAEAC,EAqBAC,EAOAC,EAIAxI,EACAb,EAzCFsJ,EAAKhD,UAAUC,UAEdhQ,EAAOgT,oBAAuB,OAASpI,KAAKmI,IAAOA,EAAGE,MAAM,cAAgBvI,OAAOwI,GAAK,IAC5FtK,iBAAiB,UAGZ+J,EAAWjT,SAAS6Q,cAAc,UAElCqC,EAAa,SAAS/F,GACzB,IAAIxB,EAAQ8H,EACRC,EAAUvG,EAAI1D,WAEqB,YAAnCiK,EAAQC,SAASC,eACpBjI,EAASsH,EAASY,YAElBH,EAAQI,aAAanI,EAAQ+H,EAAQK,mBACrClL,YAAW,WACV6K,EAAQM,YAAYrI,EACrB,OACWwB,EAAI8G,aAAe9G,EAAI+G,YAAc/G,EAAI8G,eACpD9G,EAAI8G,YAAc9G,EAAI+G,YACtBT,EAAQtG,EAAIsG,MACZtG,EAAIsG,OAAS,SACb5K,YAAW,WACVsE,EAAIsG,MAAQA,CACb,IAEF,EAEIN,EAAkB,WACrB,IAAInQ,EACAqM,EAAOrP,SAASsK,iBAAiB,qCACrC,IAAKtH,EAAI,EAAGA,EAAIqM,EAAKnN,OAAQc,IAC5BkQ,EAAW7D,EAAKrM,GAElB,EACIoQ,EAAW,WACde,aAAazL,GACbA,EAAQG,WAAWsK,EAAiB,GACrC,EACIvI,EAAKtK,EAAOuK,YAAcA,WAAW,4BACrCd,EAAO,WACVqJ,IAEIxI,GAAMA,EAAGG,aACZH,EAAGG,YAAYqI,EAEjB,EAEAH,EAASnF,OAAS,6EAEd,YAAY5C,KAAKlL,SAASuR,YAAc,IAC3CxH,IAEA/J,SAASkJ,iBAAiB,mBAAoBa,GAGxCqJ,GAGT,CA9DD,CA8DG9S,QAQH,SAAWA,EAAQN,EAAUoU,GAE5B,aAKA,IAAUC,EAAQC,EAAwBC,EAF1CvU,EAAS6Q,cAAe,WAIxB,IAAItC,EAAK,CAAC,EACNiG,GAAqB,EACrBC,EAAO,WAAY,EACnBC,EAAQ1U,EAAS6Q,cAAe,OAChC8D,EAAaD,EAAM7I,aACnB+I,EAAaF,EAAM1H,aACnB6H,EAAgBH,EAAMI,gBACtBC,EAAU/U,EAAS+G,gBACnBiO,EAAQ,CAAC,EACTC,EAAM,CAETC,UAAW,IAERC,EAAU,aACVC,EAAaD,EAAU,MAGvB9B,EAAKhD,UAAUC,UACf+E,EAAe,SAAWnK,KAAKmI,IAAQ,OAASnI,KAAKmI,IAAOA,EAAGE,MAAM,cAAgBvI,OAAOwI,GAAK,GACjG8B,EAAa,aACbC,EAAW,oBACXC,EAAU,sBACVC,EAAanV,EAAOoV,eAMpBC,EAAQ,4BACRC,GAAY,EAEZC,EAAW,CAAC,EACZC,EAAkB,CAAC,EACnBC,EAAMzV,EAAO0V,iBACbC,EAAQ,CACXC,GAAI,EACJ,GAAM,IAEHC,EAASnW,EAAS6Q,cAAe,KAKjCuF,GAAa,EAKbC,EAAqB,oBACrBC,EAA6B,qBAC7BC,EAAwB,qBACxBC,EAAsB,QACtBC,EAA0B,QAO1BC,EAAqB,oDAErBC,EAAK,SAASpE,EAAKE,EAAKjK,EAAIoO,GAC1BrE,EAAIrJ,iBACRqJ,EAAIrJ,iBAAiBuJ,EAAKjK,EAAIoO,IAAW,GAC9BrE,EAAIpJ,aACfoJ,EAAIpJ,YAAa,KAAOsJ,EAAKjK,EAE/B,EAMIqO,EAAU,SAASrO,GACtB,IAAIsO,EAAQ,CAAC,EACb,OAAO,SAASC,GAIf,OAHOA,KAASD,IACfA,EAAOC,GAAUvO,EAAGuO,IAEdD,EAAOC,EACf,CACD,EAMA,SAASC,EAAQC,GAChB,MAAc,MAANA,GACM,OAANA,GACM,OAANA,GACM,OAANA,GACM,OAANA,CACT,CASA,IAEKC,EASAC,EAiwBMC,EAaLC,EACAlK,EACAjC,EA0cAoM,EAqBoBzE,EAAM0E,EACzB9O,GAAS+O,GACTC,GAtBDC,GAEAC,GAcAC,GAyBAC,GA/wCFC,IAECZ,EAAY,wBASZC,EAAWN,GAAQ,SAASkB,GAE/B,MAAO,UAVM,WAEb,IADA,IAAIC,EAAOC,UAAWjQ,EAAQ,EAAGmE,EAAS6L,EAAK,KACtChQ,KAASgQ,GACjB7L,EAASA,EAAOC,QAAQ4L,EAAKhQ,GAAQgQ,IAAOhQ,IAE7C,OAAOmE,CACR,CAIoBC,EAAS2L,GAAO,IAAIG,cAEtC,WAAY,KAGZ,KAAM,KAGN,oBAAqB,SAGrB,oBAAqB,SAGrB,eAAgB,OAGhB,2BAA4B,cAE5B,8CAA+C,IAC5C,GACL,IAEO,SAASH,EAAK7V,GACpB,IAAIiW,EACJ,KAAMJ,KAAOlC,GAEZ,GADAA,EAASkC,IAAO,EACZ7V,IAAWiW,EAAeJ,EAAIxE,MAAO2D,IACxCrB,EAASkC,GAAOI,EAAc,GAAMlC,EAAMkC,EAAc,SAGxD,IACCtC,EAASkC,GAAO,IAAIK,SAAS,IAAKjB,EAASY,GAA3B,CAAiC9B,EAClD,CAAE,MAAMxG,GAAI,CAId,OAAOoG,EAASkC,EACjB,GAGGM,GAAgB,SAAUC,EAAWC,GAOxC,OANKD,EAAUE,GACdF,EAAUG,OAASlK,EAAGmK,eAAgBH,GAAa,SACnDD,EAAUK,IAAML,EAAUE,EAAIF,EAAUG,QAExCH,EAAUK,IAAML,EAAUM,EAEpBN,CACR,EAMIhK,GAAc,SAAUuK,GAE3B,GAAKrE,EAAL,CAEA,IAAIsE,EAAU9V,EAAG+V,EAEbpQ,EAAUkQ,GAAO,CAAC,EAatB,GAXKlQ,EAAQmQ,UAA0C,IAA9BnQ,EAAQmQ,SAASrX,WACQ,QAA5CkH,EAAQmQ,SAASnF,SAASC,cAC9BjL,EAAQmQ,SAAY,CAAEnQ,EAAQmQ,WAE9BnQ,EAAQqQ,QAAUrQ,EAAQmQ,SAC1BnQ,EAAQmQ,SAAY,OAMhBC,GAFND,EAAWnQ,EAAQmQ,UAAYvK,EAAG0K,IAAMtQ,EAAQqQ,SAAWhZ,EAAa2I,EAAQuQ,YAAcvQ,EAAQiG,SAAaL,EAAG4K,IAAM5K,EAAG6K,WAEzGlX,OAAU,CAM/B,IAJAqM,EAAG8K,SAAU1Q,GACbyN,GAAa,EAGPpT,EAAI,EAAGA,EAAI+V,EAAM/V,IACtBuL,EAAGI,QAAQmK,EAAU9V,GAAK2F,GAG3B4F,EAAG+K,YAAa3Q,EACjB,CA5BiC,CA6BlC,EA4GA,SAAS4Q,GAAetW,EAAGuW,GAC1B,OAAOvW,EAAE0V,IAAMa,EAAEb,GAClB,CAuBA,SAASc,GAAoBvZ,EAAKgO,GACjC,IAAIlL,EAAGsV,EAAWoB,EAClB,GAAKxZ,GAAOgO,EAGX,IAFAwL,EAAanL,EAAGoL,SAAUzL,GAC1BhO,EAAMqO,EAAGqL,QAAQ1Z,GACX8C,EAAI,EAAGA,EAAI0W,EAAWxX,OAAQc,IACnC,GAAK9C,IAAQqO,EAAGqL,QAAQF,EAAY1W,GAAI6W,KAAO,CAC9CvB,EAAYoB,EAAY1W,GACxB,KACD,CAGF,OAAOsV,CACR,CA3IShY,EAAO+N,SAAWA,QAAQyL,KAO5BxE,KAAcZ,IACpBY,EAAa,OAIdN,EAAO,eAAiB,EACxBA,EAAO,cAAgB,EACvBA,EAAO,cAAgB,EAmBvBA,EAAO,iBAAoBhV,EAAS+Z,eAAeC,WAAY,2CAA4C,OAunB3GzL,EAAGE,IAAM,MAAO,IAAIwL,MAAOC,WAAWC,OAAO,EAAG,GAGhD5L,EAAG6L,UAAY,WAAY1F,EAC3BnG,EAAG8L,SAAW,UAAW3F,EACzBnG,EAAG+L,aAAeha,EAAOgT,mBAIrB/E,EAAG6L,WAAa7L,EAAG+L,aAAe/L,EAAG8L,WAC9BjD,EAKPpX,EAAS6Q,cAAc,OAJzB6D,EAAM5G,OAAS,UACfsJ,EAAOlX,IAAM,UACbqO,EAAG6L,UAAY1F,EAAM6F,WAAanD,EAAOmD,SACzChM,EAAG+L,WAAa/L,EAAG6L,WAAa7L,EAAG+L,YAKjC/L,EAAG6L,YAAc7L,EAAG8L,UAIlBhD,EAAS,6EACTlK,EAAMnN,EAAS6Q,cAAc,OAC7B3F,EAAO,WAGI,IAFFiC,EAAIlI,QAGfsJ,EAAG8L,UAAW,GAGf/F,EAAyB/F,EAAG6L,YAAc7L,EAAG8L,SAE7C7F,GAAqB,EAErB3L,WAAWyF,GACZ,EAEAnB,EAAIqN,OAAStP,EACbiC,EAAIsN,QAAUvP,EACdiC,EAAIH,aAAa,QAAS,OAE1BG,EAAIW,OAASuJ,8FACblK,EAAIjN,IAAMmX,GAIX7C,GAAqB,EAKtBjG,EAAG6K,SAAW,0BACd7K,EAAG4K,IAAM5K,EAAG6K,SACZ7K,EAAG0G,IAAMA,EAKT1G,EAAGwH,IAAOA,GAAQ,EAClBxH,EAAGmM,EAAIzE,EAGP1H,EAAGyG,MAASA,EAEZzG,EAAGoM,QAAUlG,EAQblG,EAAGqL,QAAU/C,GAAQ,SAAS3W,GAE7B,OADAiW,EAAOyE,KAAO1a,EACPiW,EAAOyE,IACf,IASArM,EAAG0K,IAAM,SAASD,EAASG,GAC1B,MAAS,kBAAmBH,EAAYA,EAAQ1O,iBAAiB6O,GAAO,EACzE,EAOA5K,EAAGsM,aAAe,WASjB,OARKva,EAAOuK,aAAeA,WAAY,uBAA0B,CAAC,GAAGL,QACpE+D,EAAGsM,aAAe,SAAU/P,GAC3B,OAAQA,GAAWD,WAAYC,GAAgB,OAChD,EAEAyD,EAAGsM,aAAetM,EAAGuM,IAGfvM,EAAGsM,aAAaE,MAAOna,KAAMqX,UACrC,EAQA1J,EAAGuM,IAAM,SAAUhQ,GAClB,OAAOA,GAAQgN,GAAQhN,EACxB,EAWAyD,EAAGyM,WAAa,SAAUC,GAEzB,IAAIvX,EAAQoU,GAAQmD,GAAiB,KAAS,EAK9C,OAJIvX,EAAQ,IACXA,GAAQ,GAGFA,CACR,EAMA6K,EAAG2M,aAAe,SAAU5I,GAC3B,OAAO,GAAW0C,EAAO1C,EAC1B,EAOA/D,EAAG4M,UAAYtE,GAAQ,SAAUuE,GAChC,IAAI7H,GAAU6H,GAAiB,IAAK7H,MAAMiC,GAC1C,MAAO,CACN1K,MAAOyI,GAASA,EAAM,GACtBrR,OAAQqR,GAASA,EAAM,GAEzB,IAEAhF,EAAGoL,SAAW,SAAUzL,GAIvB,OAHMA,EAAImN,QACTnN,EAAImN,MAloBN,SAAqBtE,EAAO7I,GAE3B,SAASoN,EAAkBC,GAC1B,IAAIC,EACAjI,EAAQgI,EAAM9X,KAAKsT,EAAMxL,UAAUkQ,IACvC,GAAIlI,EAGH,OAFAiI,EAAQjI,EAAO,GACfkI,GAAOD,EAAMtZ,OACNsZ,CAET,CAEA,IACI3B,EACA7L,EACA0N,EACAC,EACA1E,EALA2E,EAAc7E,EAAM7U,OASpBuZ,EAAM,EAGN/B,EAAa,GASjB,SAASmC,IAGR,IAKIrD,EAAGI,EAAGkD,EAAG9Y,EAET+Y,EAAMC,EAAUtY,EAAOuY,EAAQC,EAP/BC,GAAS,EAMT7D,EAAY,CAAC,EAKjB,IAAKtV,EAAI,EAAIA,EAAIgL,EAAY9L,OAAQc,IAGpCgZ,GAFAD,EAAO/N,EAAahL,IAEH+Y,EAAK7Z,OAAS,GAC/BwB,EAAQqY,EAAKxQ,UAAU,EAAGwQ,EAAK7Z,OAAS,GACxC+Z,EAASG,SAAS1Y,EAAO,IACzBwY,EAAWvY,WAAWD,GAIlB+S,EAAwBvL,KAAKxH,IAAwB,MAAbsY,IAGvCxD,GAAKI,KAAIuD,GAAS,GAKP,IAAXF,EAAeE,GAAS,EAAa3D,EAAIyD,GAInCvF,EAAmBxL,KAAKxH,IAAwB,MAAbsY,IAIzCxD,GAAKI,GAAKkD,KAAIK,GAAS,GAKvBD,EAAW,EAAIC,GAAS,EAAavD,EAAIsD,GAInCzF,EAAwBvL,KAAKxH,IAAwB,MAAbsY,IAG9CF,GAAKlD,KAAIuD,GAAS,GAKP,IAAXF,EAAeE,GAAS,EAAaL,EAAIG,GAGtCE,GAAS,EAMbA,IACJ7D,EAAUuB,IAAMA,EAEZrB,IAAKF,EAAUE,EAAIA,GACnBI,IAAKN,EAAUM,EAAIA,GACnBkD,IAAKxD,EAAUwD,EAAIA,GAClBA,GAAMlD,GAAMJ,IAAIF,EAAUM,EAAI,GACf,IAAhBN,EAAUM,IAAU1K,EAAImO,OAAQ,GACpC/D,EAAUpK,IAAMA,EAEhBwL,EAAW9X,KAAK0W,GAElB,CAQA,SAASgE,IAWR,IARAhB,EAAkBjF,GAGlBqF,EAAoB,GAGpBC,EAAQ,kBAEK,CAUZ,GAPA1E,EAAIF,EAAMwF,OAAOd,GAOH,kBAAVE,EAOH,GAAI3E,EAAQC,GACPyE,IACH1N,EAAYpM,KAAK8Z,GACjBA,EAAoB,GACpBC,EAAQ,wBAOH,IAAU,MAAN1E,EAMV,OALAwE,GAAO,EACHC,GACH1N,EAAYpM,KAAK8Z,QAElBG,IAKM,GAAU,MAAN5E,EACVyE,GAAwCzE,EACxC0E,EAAQ,gBAKF,IAAU,KAAN1E,EAKV,OAJIyE,GACH1N,EAAYpM,KAAK8Z,QAElBG,IAMAH,GAAwCzE,CACzC,OAIM,GAAc,cAAV0E,EAIV,GAAU,MAAN1E,EACHyE,GAAwCzE,EACxC0E,EAAQ,oBAKF,IAAU,KAAN1E,EAGV,OAFAjJ,EAAYpM,KAAK8Z,QACjBG,IAMAH,GAAwCzE,CACzC,MAGM,GAAc,qBAAV0E,EAIV,GAAI3E,EAAQC,QAGL,IAAU,KAANA,EAEV,YADA4E,IAMAF,EAAQ,gBACRF,GAAO,CAER,CAIDA,GAAO,CAGR,CACD,CAKA,OAAa,CAIZ,GAHAH,EAAkBhF,GAGdmF,GAAOG,EACV,OAAOlC,EAKRG,EAAMyB,EAAkB/E,GAGxBvI,EAAc,GAKQ,MAAlB6L,EAAIzZ,OAAO,IACdyZ,EAAMA,EAAIzN,QAAQoK,EAAqB,IAEvCqF,KAIAS,GAIF,CACD,CAiXcE,CAAYtO,EAAIJ,OAAQI,IAE9BA,EAAImN,KACZ,EAOA9M,EAAGkO,WAAa,WACf,IAAI3V,EACJ,IAAMuN,IAAWvN,EAAO9G,EAAS8G,MAAQ,CACxC,IAAI4V,EAAM1c,EAAS6Q,cAAe,OACjC8L,EAAkB5H,EAAQ5J,MAAMyR,QAChCC,EAAkB/V,EAAKqE,MAAMyR,QAE9BF,EAAIvR,MAAMyR,QA7/BI,uJAigCd7H,EAAQ5J,MAAMyR,QAAUjH,EACxB7O,EAAKqE,MAAMyR,QAAUjH,EAErB7O,EAAKgK,YAAa4L,GAClBrI,EAASqI,EAAIxI,YACbpN,EAAKkN,YAAa0I,GAGlBrI,EAAS1Q,WAAY0Q,EAAQ,IAG7BU,EAAQ5J,MAAMyR,QAAUD,EACxB7V,EAAKqE,MAAMyR,QAAUC,CAEtB,CACA,OAAOxI,GAAU,EAClB,EAKA9F,EAAGmK,eAAiB,SAAUoE,GAI7B,KAAOA,KAAqBhH,IAAoBb,EAAI8H,GAAK,CACxD,IAAIC,EAAgBzO,EAAGyM,WAnYzB,SAAoBiC,GAUnB,IAMIja,EACAka,EACAC,EACAC,EACAC,EACAC,EAqFuCC,EAhGvCC,EAA0B,0GAI1BC,EAAe,0CAgHnB,IAHAN,GADAD,EA5FA,SAA8BQ,GAC7B,IAAIC,EACAC,EAAY,GACZC,EAAiB,GACjBC,EAAY,GACZC,EAAa,EACbtC,EAAM,EACNuC,GAAY,EAEhB,SAASC,IACJL,IACHC,EAAejc,KAAKgc,GACpBA,EAAY,GAEd,CAEA,SAASM,IACJL,EAAe,KAClBC,EAAUlc,KAAKic,GACfA,EAAiB,GAEnB,CAGA,OAAa,CAGZ,GAAe,MAFfF,EAASD,EAAInB,OAAOd,IAKnB,OAFAwC,IACAC,IACOJ,EACD,GAAIE,EAAJ,CACN,GAAgB,MAAXL,GAAqC,MAAjBD,EAAIjC,EAAM,GAAa,CAC/CuC,GAAY,EACZvC,GAAO,EACPwC,IACA,QACD,CACCxC,GAAO,CA+BT,KAtCO,CAUA,GAAIzE,EAAQ2G,GAAS,CAI3B,GAAMD,EAAInB,OAAOd,EAAM,IAAMzE,EAAS0G,EAAInB,OAAOd,EAAM,MAAWmC,EAAY,CAC7EnC,GAAO,EACP,QACD,CAAO,GAAmB,IAAfsC,EAAkB,CAC5BE,IACAxC,GAAM,EACN,QACD,CAECkC,EAAS,GAEX,MAAO,GAAe,MAAXA,EACVI,GAAc,OACR,GAAe,MAAXJ,EACVI,GAAc,MACR,IAAe,MAAXJ,EAAgB,CAC1BM,IACAC,IACAzC,GAAO,EACP,QACD,CAAO,GAAiB,MAAXkC,GAA4C,MAAxBD,EAAInB,OAAOd,EAAM,GAAc,CAC/DuC,GAAY,EACZvC,GAAO,EACP,QACD,EAEAmC,GAAwBD,EACxBlC,GAAO,CAHP,CAID,CACD,CAkBoB0C,CAAqBlB,IACG/a,OAGvCc,EAAI,EAAGA,EAAIma,EAAyBna,IAkBxC,GAFAqa,GAfAD,EAAeF,EAAkBla,IAeCoa,EAAalb,OAAS,GApCdqb,EAsCJF,EArClCG,EAAwBtS,KAAKqS,IAAO5Z,WAAW4Z,IAAM,GACrDE,EAAavS,KAAKqS,IAIX,MAANA,GAAqB,OAANA,GAAsB,OAANA,EAgCpC,CAUA,GATCD,EAAOD,EACPD,EAAa3R,MAQc,IAAxB2R,EAAalb,OAChB,OAAOob,EAYR,GADAF,EAAeA,EAAa/c,KAAK,KAC3BkO,EAAGsM,aAAcuC,GAKvB,OAAOE,CAvBP,CA4BD,MAAO,OACR,CAiNqCc,CAAYtB,IAE/ChH,EAAiBgH,GAAuBE,GAAgB/G,EAAMhR,KAC/D,CAEA,OAAO6Q,EAAiBgH,EACzB,EAYAvO,EAAG8P,OAAS,SAAUnQ,GACrB,IAAIwL,EACJ,GAAKxL,EAIJ,IAAM,IAAIlL,EAAI,EAAGsb,GAFjB5E,EAAanL,EAAGoL,SAAUzL,IAEQhM,OAAQc,EAAIsb,EAAKtb,IAClDqV,GAAeqB,EAAY1W,GAAKkL,EAAIuF,OAGtC,OAAOiG,CACR,EAEAnL,EAAG8P,OAAO1F,IAAMN,GAEhB9J,EAAGgQ,kBAAoB,SAAU7E,EAAYvM,GAC5C,GAAMuM,EAAWxX,OAAjB,CACA,IAAIoW,EACHtV,EACAwb,EACAtc,EACAuc,EACA5P,EACA6P,EACAC,EACAC,EAt1BqBC,EAAYC,EAAaC,EAAUC,EACrDC,EAAsBC,EAAOC,EAu1B7BC,EAAYjS,EAAKoB,EAAGE,IACpB4Q,EAAM9Q,EAAGwH,IAwBb,GAtBAlH,EAASuQ,EAAUvQ,QAAU1B,EAAImI,GAEjCoJ,EAASU,EAAUV,QA/yBpB,SAAsBvR,EAAKjN,EAAKgO,GAC/B,IAAIoK,EAiBJ,OAhBMpK,GAAOhO,IAEZgO,GADAA,EAAMf,EAAKoB,EAAGE,IAAK6Q,OACNpR,EAAIA,EAAIhM,OAAS,KAG/BoW,EAAYmB,GAAmBvZ,EAAKgO,MAGnChO,EAAMqO,EAAGqL,QAAQ1Z,GACjBiN,EAAKoB,EAAGE,IAAKI,OAAS3O,EACtBiN,EAAKoB,EAAGE,IAAKiQ,OAASpG,EAEhBA,EAAUK,KACfN,GAAeC,EAAWA,EAAUpK,IAAIuF,QAGnC6E,CACR,CA4xB8BiH,CAAYpS,EAAK0B,EAAQ6K,EAAW,GAAGxL,KAG/DwQ,GAAUA,EAAOxQ,MAAQwL,EAAY,GAAIxL,OAI7C0Q,EAAevJ,IAAiBlI,EAAIoN,UAAYmE,EAAO/F,IAAM,GAAM0G,KAGlEX,EAAOc,QAAS,EAIXd,EAAO/F,KAAO0G,IAClBZ,EAAgBC,MAKbD,EAOL,IALA/E,EAAW5W,KAAMyW,IAGjBkF,EAAgB/E,GADhBxX,EAASwX,EAAWxX,QACiB,GAE/Bc,EAAI,EAAGA,EAAId,EAAQc,IAExB,IADAsV,EAAYoB,EAAY1W,IACT2V,KAAO0G,EAAM,CAS1BZ,EAJG/E,EAJJ8E,EAAIxb,EAAI,KAKN4b,GAAe/P,IAAWN,EAAGqL,QAAStB,EAAUuB,QAh4B/BgF,EAi4BLnF,EAAY8E,GAAI7F,IAj4BCmG,EAi4BIxG,EAAUK,IAj4BDoG,EAi4BMM,EAj4BIL,EAi4BCtF,EAAY8E,GAAIgB,OAh4BtEP,SAAsBC,SAAOC,SAGX,aAAlBlK,EAAIC,UACF2J,EAAa,IACjBM,EAAcJ,EAAW,GAKzBG,GAHUJ,EAAcC,IACxBE,EAAchY,KAAKwY,IAAIZ,EAAa,GAAK,MAIrCG,IACHE,GAAS,GAAMD,GAGhBE,EAAcN,EAAaK,GAG5BC,EAAeJ,EAAW,EACzB9X,KAAKyY,KAAKb,EAAaC,GACvBD,EAGKM,EAAcJ,GA02BDrF,EAAY8E,GAGZlG,EAEjB,KACD,CAIGmG,IAEJE,EAAepQ,EAAGqL,QAAS6E,EAAc5E,KAEzCuF,EAAUvQ,OAAS8P,EACnBS,EAAUV,OAASD,EAEdE,IAAiB9P,GACrBN,EAAGoR,OAAQxS,EAAKsR,GAEjBlQ,EAAGoM,QAASxN,GA1EqB,CA4EnC,EAEAoB,EAAGoR,OAAS,SAAUxS,EAAKsR,GAC1B,IAAImB,EACJzS,EAAIjN,IAAMue,EAAc5E,IAGQ,kBAA3B4E,EAAcvQ,IAAIoE,OACtBsN,EAAYzS,EAAIhC,MAAMlG,MACtBkI,EAAIhC,MAAMlG,MAASkI,EAAI+G,YAAc,EAAK,KAIrC/G,EAAI+G,YAAc,IACtB/G,EAAIhC,MAAMlG,MAAQ2a,GAGrB,EAEArR,EAAGsR,OAAS,SAAU1S,GACrB,IAAInK,EAAGkL,EAAKgN,EACR3H,GAAQ,EACR+L,EAAOnS,EAAMoB,EAAGE,IAAK6Q,KAEzB,IAAMtc,EAAI,EAAGA,EAAIsc,EAAKpd,SAAWqR,EAAOvQ,IAGvC,IAFAkL,EAAMoR,EAAKtc,IAED8K,QAAWS,EAAGsM,aAAc3M,EAAIpD,SAAaoQ,EAAe3M,EAAG2M,aAAchN,EAAIoE,OAA3F,CAIsB,YAAjB4I,IACJhN,EAAMgN,GAGP3H,EAAQrF,EACR,KAPA,CAUD,OAAOqF,CACR,EAEAhF,EAAGuR,UAAY,SAAUte,EAASgF,EAAQmC,GACzC,IAAIoX,EAAiBC,EAAUC,EAAcC,EAEzCC,EAAa3Z,GAA4C,YAAlCA,EAAOmN,SAASC,cACvCwL,EAAY5d,EAAS+M,EAAGE,KAEvB2Q,EAAUlf,MAAQkU,GAAazL,EAAQzI,OAC3Ckf,EAAUlf,IAAMyU,EAAWpK,KAAM/I,EAAS,OACrC4d,EAAUlf,IACd0U,EAAWrK,KAAM/I,EAAS2T,EAASiK,EAAUlf,KAE7C2U,EAActK,KAAM/I,EAAS2T,KAI1BiK,EAAUtR,SAAWsG,GAAazL,EAAQmF,SAAWS,EAAG6L,WAAa5Y,EAAQsM,UACjFiS,EAAkBpL,EAAWpK,KAAM/I,EAAS,UAC5C4d,EAAUtR,OAASiS,EACnBG,GAAe,GAGhBd,EAAUE,KAAO,GAEZa,IACJf,EAAUgB,KAAM,EAz4BlB,SAA+B1M,EAASgG,GACvC,IAAI1W,EAAGsb,EAAK3S,EAAQmC,EAKhBpD,EAAUgJ,EAAQlE,qBAAsB,UAE5C,IAAMxM,EAAI,EAAGsb,EAAM5T,EAAQxI,OAAQc,EAAIsb,EAAKtb,KAC3C2I,EAASjB,EAAS1H,IACVuL,EAAGE,KAAO,GAClBX,EAASnC,EAAOE,aAAc,YAI7B6N,EAAW9X,KAAM,CAChBkM,OAAQA,EACRhD,MAAOa,EAAOE,aAAc,SAC5ByG,KAAM3G,EAAOE,aAAc,QAC3B4H,MAAO9H,EAAOE,aAAc,UAIhC,CAm3BEwU,CAAsB7Z,EAAQ4Y,EAAUE,OAGpCF,EAAUtR,QACdkS,EAAW,CACVlS,OAAQsR,EAAUtR,OAClB2F,MAAOkB,EAAWpK,KAAM/I,EAAS,UAGlC4d,EAAUE,KAAK1d,KAAMoe,IAErBC,GAAgB3L,GAA0B8K,EAAUlf,MAAQqV,EAASrK,KAAKkU,EAAUtR,QAAU,OAGxEsR,EAAUlf,KAAQuZ,GAAmB2F,EAAUlf,IAAK8f,IAAcA,EAAS3D,QAChG2D,EAASlS,QAAU,KAAOsR,EAAUlf,IACpC8f,EAAS3E,MAAMzZ,KAAK,CACnBiY,IAAKuF,EAAUlf,IACf0Y,EAAG,EACH1K,IAAK8R,MAIIZ,EAAUlf,KACrBkf,EAAUE,KAAK1d,KAAM,CACpBkM,OAAQsR,EAAUlf,IAClBuT,MAAO,OAIT2L,EAAUV,OAAS,KACnBU,EAAUvQ,OAASuF,EAInBgL,EAAUtQ,YAAeqR,GAAgBH,IAAazR,EAAG6L,WAAgB6F,IAAiB1R,EAAG8L,UAExF6F,GAAgB3R,EAAG6L,YAAcgF,EAAUtQ,YAC1CiR,GACJnL,EAAWrK,KAAM/I,EAAS4T,EAAY2K,GACtCve,EAAQsM,OAAS,IAEjB+G,EAActK,KAAM/I,EAAS4T,IAI3BgK,EAAUtQ,YAAcsQ,EAAUtR,UAAasR,EAAUlf,KAAOsB,EAAQtB,KAASsB,EAAQtB,MAAQqO,EAAGqL,QAAQwF,EAAUlf,QACnG,OAAlBkf,EAAUlf,IACbsB,EAAQsT,gBAAgB,OAExBtT,EAAQtB,IAAMkf,EAAUlf,KAI1Bkf,EAAU5R,QAAS,CACpB,EAEAe,EAAGI,QAAU,SAASnN,EAASmH,GAC9B,IAAIyW,EACAkB,EAAU3X,EAAQiG,UAAYjG,EAAQuQ,WAGpC1X,EAAS+M,EAAGE,MACjBjN,EAAS+M,EAAGE,IAAO,CAAC,GAGrB2Q,EAAY5d,EAAS+M,EAAGE,KAKlB6R,GAAWlB,EAAU1Q,SAAW6F,KAIhC6K,EAAU5R,SAAU7E,EAAQuQ,YACjC3K,EAAGuR,UAAWte,EAASA,EAAQiI,WAAYd,GAGtCyW,EAAUtQ,UAGfsQ,EAAU1Q,OAAS6F,EAlhCrB,SAA6BpH,GAC5B,IAAIoT,EACAC,EAAcjS,EAAGsR,OAAQ1S,GACzBsT,GAAY,EACK,YAAhBD,IACJC,EAAYlM,EACPiM,IACJD,EAAmBhS,EAAG8P,OAAQmC,GAC9BjS,EAAGgQ,kBAAmBgC,EAAkBpT,KAG1CA,EAAKoB,EAAGE,IAAKC,OAAS+R,CACvB,CAogCEC,CAAoBlf,GAItB,EAEA+M,EAAG8K,SAAW,WACPjD,IAAcR,GAAcG,IAAQzV,EAAO0V,mBAtkCjDJ,GAAY,EACZG,EAAMzV,EAAO0V,iBACbH,EAAW,CAAC,EACZC,EAAkB,CAAC,EAEnBvH,EAAGwH,IAAMA,GAAO,EAEhBE,EAAMhR,MAAQgC,KAAKC,IAAI5G,EAAOqgB,YAAc,EAAG5L,EAAQ1N,aACvD4O,EAAM/Q,OAAS+B,KAAKC,IAAI5G,EAAOsgB,aAAe,EAAG7L,EAAQzN,cAEzD2O,EAAM4K,GAAK5K,EAAMhR,MAAQ,IACzBgR,EAAM6K,GAAK7K,EAAM/Q,OAAS,IAE1BqP,EAAS,CAAE0B,EAAM/Q,OAAQ+Q,EAAMhR,MAAO8Q,GAAM1V,KAAK,KAEjD4V,EAAM8K,GAAKxS,EAAGkO,aACdxG,EAAM+K,IAAM/K,EAAM8K,GAyjCnB,EAGKxS,EAAG+L,YACPhM,GAAcmG,EACdlG,EAAGI,QAAU8F,IAMRiD,GAAWpX,EAAO6I,YAAc,QAAU,WAE1CwO,GAAM,WACT,IAAIpG,EAAavR,EAASuR,YAAc,GAExCqG,GAAU/O,WAAW8O,GAAoB,YAAfpG,EAA2B,IAAO,KACvDvR,EAAS8G,OACbyH,EAAG0S,YACH3J,EAAaA,GAAcI,GAASxM,KAAKqG,KAExC4C,aAAcyD,IAIjB,EAEIA,GAAU/O,WAAW8O,GAAK3X,EAAS8G,KAAO,EAAI,IAyB9C+Q,GAAkB9C,EAAQzN,aAS9BqP,EAAIrW,EAAQ,UA9BYuS,EAsBT,WACd+C,EAAY3O,KAAKC,IAAI5G,EAAOqgB,YAAc,EAAG5L,EAAQ1N,eAAiB4O,EAAMhR,OAAS8P,EAAQzN,eAAiBuQ,GAC9GA,GAAkB9C,EAAQzN,aACrBsO,GACJrH,EAAG0S,UAEL,EA5B8B1J,EA8BW,GA5BpCE,GAAQ,WACX,IAAIyJ,EAAO,IAAKjH,KAAUzC,GAEtB0J,EAAO3J,EACV9O,GAAUI,WAAW4O,GAAOF,EAAO2J,IAEnCzY,GAAU,KACVoK,IAEF,EAEO,WACN2E,GAAY,IAAIyC,KAEXxR,KACJA,GAAUI,WAAW4O,GAAOF,GAE9B,IAYDZ,EAAI3W,EAAU,mBAAoB2X,KAIpCpJ,EAAGD,YAAcA,GAEjBC,EAAG0S,SAAW3S,GACdC,EAAG+K,YAAc7E,EAGjBnG,GAAYE,EAAID,EAEhBjO,EAAOoV,eAAiB,CACvBnH,GAAIA,EACJ3M,KAAM,SAASoW,GACd,IAAInI,EAAOmI,EAAKmJ,QACQ,mBAAb5S,EAAGsB,GACbtB,EAAGsB,GAAMkL,MAAMxM,EAAIyJ,IAEnB/C,EAAIpF,GAAQmI,EAAK,GACb5B,GACH7H,EAAG0S,SAAU,CAAErS,UAAU,IAG5B,GAGD,KAAO6G,GAAcA,EAAWvT,QAC/B5B,EAAOoV,eAAe9T,KAAK6T,EAAW0L,SAIvC7gB,EAAOgO,YAAcA,GAGwC,iBAAnB2B,EAAOC,QAEhDD,EAAOC,QAAU5B,IAGjB,aAAoC,OAAOA,EAAc,oCAIpDC,EAAG+L,aACRtF,EAAO,cA5sCR,SAA4B1C,EAAM8O,GAGjC,IAAI1M,EAAQ,IAAIpU,EAAOkM,MAUvB,OATAkI,EAAM+F,QAAU,WACfzF,EAAO1C,IAAS,EAChBhE,IACD,EACAoG,EAAM8F,OAAS,WACdxF,EAAO1C,GAAyB,IAAhBoC,EAAMzP,MACtBqJ,IACD,EACAoG,EAAMxU,IAAMkhB,EACL,SACR,CA8rCyBC,CAAkB,aAAc,2IAGxD,CAx7CF,CAw7CK/gB,OAAQN,sBC//CZ,WACG,aACA,GAAsB,oBAAXM,QAA0BA,OAAO4I,iBAAkB,CAC1D,IACIoY,EACAC,EA2MAC,EA7MA1K,EAAQrW,OAAOghB,OAAO,MAGtBC,EAAiB,WACjBvN,aAAaoN,GACbA,EAAM1Y,WAAWyY,EAAe,IACpC,EACIK,EAAmB,WAEvB,EA4BIC,EAAgB,SAAU/H,GAI1B,SAASgI,EAAUC,GACf,IAAI7e,EAOJ,YANqBmR,IAAjB0N,EAAIC,SACJ9e,EAAI6e,GAEJ7e,EAAIjD,SAAS6Q,cAAc,MACzB+J,KAAOkH,EAEN7e,EAAE8e,SAAS3V,QAAQ,KAAM,IAAMnJ,EAAEyG,IAC5C,CACA,IAAIsY,EACAC,EACAC,EAWJ,OAVI5hB,OAAO6hB,iBACPH,EAAU,IAAIG,eACdF,EAASJ,EAAUO,UACnBF,EAAUL,EAAUhI,GAEhBmI,OAD4B5N,IAA5B4N,EAAQK,iBAA6C,KAAZH,GAAkBA,IAAYD,EAC7DK,qBAAkBlO,EAElB+N,gBAGXH,CACX,EACIO,EAAU,+BACdjB,EAAgB,WACZ,IAAIkB,EACAC,EAEAC,EACA9H,EACA5X,EAEA2f,EACAX,EACAnI,EACA+I,EACAC,EALAC,EAAkB,EAMtB,SAASC,IAtEQ,IACbhX,EAwEwB,KADxB+W,GAAmB,KAEfnB,IAxERrhB,OAAO4I,iBAAiB,SAAUwY,GAAgB,GAClDphB,OAAO4I,iBAAiB,oBAAqBwY,GAAgB,GACzDphB,OAAO4D,mBACP6H,EAAW,IAAI7H,iBAAiBwd,IACvBvgB,QAAQnB,SAAS+G,gBAAiB,CACvC3C,WAAW,EACXE,SAAS,EACTH,YAAY,IAEhBwd,EAAmB,WACf,IACI5V,EAAS1J,aACT/B,OAAO8I,oBAAoB,SAAUsY,GAAgB,GACrDphB,OAAO8I,oBAAoB,oBAAqBsY,GAAgB,EACpE,CAAE,MAAOsB,GAAS,CACtB,IAEAhjB,SAAS+G,gBAAgBmC,iBAAiB,qBAAsBwY,GAAgB,GAChFC,EAAmB,WACf3hB,SAAS+G,gBAAgBqC,oBAAoB,qBAAsBsY,GAAgB,GACnFphB,OAAO8I,oBAAoB,SAAUsY,GAAgB,GACrDphB,OAAO8I,oBAAoB,oBAAqBsY,GAAgB,EACpE,GAqDJ,CACA,SAASuB,EAAeC,GACpB,OAAO,YACsB,IAArBpM,EAAMoM,EAAKV,QACXU,EAAKC,MAAMC,eAAeb,EAAS,aAAc,IAAMW,EAAKR,MACxDQ,EAAKC,MAAME,aAAa,SACxBH,EAAKC,MAAMnW,aAAa,OAAQ,IAAMkW,EAAKR,MAGvD,CACJ,CACA,SAASY,EAAWT,GAChB,OAAO,WACH,IAEIU,EAFAzc,EAAO9G,SAAS8G,KAChB0c,EAAIxjB,SAAS6Q,cAAc,KAE/BgS,EAAIrI,OAAS,KACbgJ,EAAEC,UAAYZ,EAAIa,cAClBH,EAAMC,EAAEhU,qBAAqB,OAAO,MAEhC+T,EAAIvW,aAAa,cAAe,QAChCuW,EAAIpY,MAAMwY,SAAW,WACrBJ,EAAIpY,MAAMlG,MAAQ,EAClBse,EAAIpY,MAAMjG,OAAS,EACnBqe,EAAIpY,MAAMnE,SAAW,SACrBF,EAAKgN,aAAayP,EAAKzc,EAAK8c,aAEhCb,GACJ,CACJ,CACA,SAASc,EAAehB,GACpB,OAAO,WACHA,EAAIpI,QAAU,KACdoI,EAAIiB,UAAY,KAChBf,GACJ,CACJ,CAIA,IAHApB,IAEAiB,EAAO5iB,SAASwP,qBAAqB,OAChCxM,EAAI,EAAGA,EAAI4f,EAAK1gB,OAAQc,GAAK,EAAG,CACjC,IACIyf,EAAMG,EAAK5f,GAAGqC,uBAClB,CAAE,MAAO2d,GAELP,GAAM,CACV,CASAD,GAJI3I,GAJJe,EAAOgI,EAAK5f,GAAG6I,aAAa,SACjB+W,EAAK5f,GAAG+gB,eAAexB,EAAS,SAChCK,EAAK5f,GAAG6I,aAAa,gBACpB+O,EAAKza,MACPya,EAAKza,MAAM,KAEX,CAAC,GAAI,KAEJ,GACXuiB,EAAO7I,EAAI,GACX8I,EAAWF,GAAoB,IAAbA,EAAI1d,MAA4B,IAAd0d,EAAIzd,OAA2B,IAAZyd,EAAI5d,KAA4B,IAAf4d,EAAI3d,OACxE2d,GAAqB,IAAdA,EAAIxd,OAA8B,IAAfwd,EAAIvd,SAAiByd,GAO3CC,EAAK5f,GAAGqgB,aAAa,SACrBT,EAAK5f,GAAGogB,eAAeb,EAAS,aAAc3H,GAE9C4H,EAAKtgB,UAGO,KADZ2gB,EAAM/L,EAAM0L,KAGR3Z,WAAWoa,EAAe,CACtBE,MAAOP,EAAK5f,GACZwf,KAAMA,EACNE,KAAMA,IACN,QAEItO,IAARyO,QAEgBzO,KADhB4N,EAAUJ,EAAcY,MAEpBK,EAAM,IAAIb,EACVlL,EAAM0L,GAAQK,EACdA,EAAIrI,OAAS8I,EAAWT,GACxBA,EAAIpI,QAAUoJ,EAAehB,GAC7BA,EAAIiB,UAAYD,EAAehB,GAC/BA,EAAImB,KAAK,MAAOxB,GAChBK,EAAIoB,OACJnB,GAAmB,KAK1BH,EAWMH,EAAKtgB,QAAU4U,EAAM0L,IAC5B3Z,WAAWoa,EAAe,CACtBE,MAAOP,EAAK5f,GACZwf,KAAMA,EACNE,KAAMA,IACN,QAfgBtO,IAAhB0C,EAAM0L,GAEN1L,EAAM0L,IAAQ,EACP1L,EAAM0L,GAAMhI,SAGnB1D,EAAM0L,GAAM0B,eACLpN,EAAM0L,GAAMhI,OACnB1D,EAAM0L,IAAQ,EAU9B,CACAI,EAAO,GACPE,GAAmB,EACnBC,GACJ,EAEAvB,EAAU,WACNlhB,OAAO8I,oBAAoB,OAAQoY,GAAS,GAC5CD,EAAM1Y,WAAWyY,EAAe,EACpC,EAC4B,aAAxBthB,SAASuR,WAETjR,OAAO4I,iBAAiB,OAAQsY,GAAS,GAGzCA,GAER,CACJ,CA7NA,0BCAA,SAAU2C,GACN,aAEA,IAeYC,EAfRC,EAAwB,WAEpB,IACI,GAAIF,EAAKG,iBAAwE,QAArD,IAAKH,EAAKG,gBAAgB,WAAY3jB,IAAI,OAClE,OAAOwjB,EAAKG,eAEpB,CAAE,MAAO7U,GAAI,CACb,OAAO,IACV,CARuB,GASxB8U,EAA6BF,GAA4E,QAAnD,IAAKA,EAAsB,CAACphB,EAAG,IAAKuhB,WAE1FC,EAAyBJ,GAA0E,MAAhD,IAAIA,EAAsB,SAAS1jB,IAAI,KAC1F+jB,EAAsB,sBAEtBC,GAA6BN,KACrBD,EAAgB,IAAIC,GACVO,OAAO,IAAK,MACU,WAA7BR,EAAcI,YAEzBhkB,EAAYqkB,EAAwBrkB,UACpCskB,KAAcX,EAAKY,SAAUZ,EAAKY,OAAOC,UAE7C,KAAIX,GAAyBE,GAA8BE,GAA0BE,GAArF,CA4BAnkB,EAAUokB,OAAS,SAAS/U,EAAMnM,GAC9BuhB,EAASrkB,KAAM8jB,GAAsB7U,EAAMnM,EAC/C,EAQAlD,EAAkB,OAAI,SAASqP,UACpBjP,KAAM8jB,GAAsB7U,EACvC,EAQArP,EAAUG,IAAM,SAASkP,GACrB,IAAIqV,EAAOtkB,KAAM8jB,GACjB,OAAO9jB,KAAKukB,IAAItV,GAAQqV,EAAKrV,GAAM,GAAK,IAC5C,EAQArP,EAAU4kB,OAAS,SAASvV,GACxB,IAAIqV,EAAOtkB,KAAM8jB,GACjB,OAAO9jB,KAAKukB,IAAItV,GAAQqV,EAAMrV,GAAMzP,MAAM,GAAK,EACnD,EAQAI,EAAU2kB,IAAM,SAAStV,GACrB,OAAOwV,EAAezkB,KAAM8jB,GAAsB7U,EACtD,EAUArP,EAAU0N,IAAM,SAAa2B,EAAMnM,GAC/B9C,KAAM8jB,GAAqB7U,GAAQ,CAAC,GAAKnM,EAC7C,EAOAlD,EAAUgkB,SAAW,WACjB,IAAkDxhB,EAAGkO,EAAKrB,EAAMnM,EAA5DwhB,EAAOtkB,KAAK8jB,GAAsBY,EAAQ,GAC9C,IAAKpU,KAAOgU,EAER,IADArV,EAAO0V,EAAOrU,GACTlO,EAAI,EAAGU,EAAQwhB,EAAKhU,GAAMlO,EAAIU,EAAMxB,OAAQc,IAC7CsiB,EAAM1jB,KAAKiO,EAAO,IAAM0V,EAAO7hB,EAAMV,KAG7C,OAAOsiB,EAAMjlB,KAAK,IACtB,EAGA,IACImlB,IADsBf,GACaJ,IAA0BE,GAA8BJ,EAAKsB,MAIpGhlB,OAAOC,eAAeyjB,EAAM,kBAAmB,CAC3CzgB,MAAQ8hB,EAEJ,IAAIC,MAAMpB,EAAuB,CAC7BqB,UAAW,SAAStkB,EAAQ4W,GACxB,OAAO,IAAI5W,EAAQ,IAAIyjB,EAAwB7M,EAAK,IAAIwM,WAC5D,IAEJK,IAGR,IAAIc,EAAWxB,EAAKG,gBAAgB9jB,UAEpCmlB,EAASC,UAAW,EAOpBD,EAASxgB,QAAUwgB,EAASxgB,SAAW,SAASmD,EAAUud,GACtD,IAAIX,EAAOY,EAAYllB,KAAK4jB,YAC5B/jB,OAAOslB,oBAAoBb,GAAM/f,SAAQ,SAAS0K,GAC9CqV,EAAKrV,GAAM1K,SAAQ,SAASzB,GACxB4E,EAASiC,KAAKsb,EAASniB,EAAOmM,EAAMjP,KACxC,GAAGA,KACP,GAAGA,KACP,EAKA+kB,EAAS7iB,KAAO6iB,EAAS7iB,MAAQ,WAC7B,IAAoDkjB,EAAGhjB,EAAGwb,EAAtD0G,EAAOY,EAAYllB,KAAK4jB,YAAayB,EAAO,GAChD,IAAKD,KAAKd,EACNe,EAAKrkB,KAAKokB,GAId,IAFAC,EAAKnjB,OAEAE,EAAI,EAAGA,EAAIijB,EAAK/jB,OAAQc,IACzBpC,KAAa,OAAEqlB,EAAKjjB,IAExB,IAAKA,EAAI,EAAGA,EAAIijB,EAAK/jB,OAAQc,IAAK,CAC9B,IAAIkO,EAAM+U,EAAKjjB,GAAIkjB,EAAShB,EAAKhU,GACjC,IAAKsN,EAAI,EAAGA,EAAI0H,EAAOhkB,OAAQsc,IAC3B5d,KAAKgkB,OAAO1T,EAAKgV,EAAO1H,GAEhC,CACJ,EAQAmH,EAASM,KAAON,EAASM,MAAQ,WAC7B,IAAIE,EAAQ,GAIZ,OAHAvlB,KAAKuE,SAAQ,SAAS5D,EAAMsO,GACxBsW,EAAMvkB,KAAKiO,EACf,IACOuW,EAAaD,EACxB,EAQAR,EAASO,OAASP,EAASO,QAAU,WACjC,IAAIC,EAAQ,GAIZ,OAHAvlB,KAAKuE,SAAQ,SAAS5D,GAClB4kB,EAAMvkB,KAAKL,EACf,IACO6kB,EAAaD,EACxB,EAQAR,EAAS3Z,QAAU2Z,EAAS3Z,SAAW,WACnC,IAAIma,EAAQ,GAIZ,OAHAvlB,KAAKuE,SAAQ,SAAS5D,EAAMsO,GACxBsW,EAAMvkB,KAAK,CAACiO,EAAMtO,GACtB,IACO6kB,EAAaD,EACxB,EAGIrB,IACAa,EAASxB,EAAKY,OAAOC,UAAYW,EAASxB,EAAKY,OAAOC,WAAaW,EAAS3Z,QAxMhF,CASA,SAAS6Y,EAAwBwB,KAC7BA,EAASA,GAAU,cAGG/B,iBAAmB+B,aAAkBxB,KACvDwB,EAASA,EAAO7B,YAEpB5jB,KAAM8jB,GAAuBoB,EAAYO,EAC7C,CA2LA,SAASd,EAAO7H,GACZ,IAAItR,EAAU,CACV,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,IAAK,MACL,MAAO,IACP,MAAO,MAEX,OAAOka,mBAAmB5I,GAAKtR,QAAQ,sBAAsB,SAASmH,GAClE,OAAOnH,EAAQmH,EACnB,GACJ,CAEA,SAASgT,EAAO7I,GACZ,OAAOA,EACFtR,QAAQ,QAAS,OACjBA,QAAQ,qBAAqB,SAASmH,GACnC,OAAOiT,mBAAmBjT,EAC9B,GACR,CAEA,SAAS6S,EAAaK,GAClB,IAAIzB,EAAW,CACX0B,KAAM,WACF,IAAIhjB,EAAQ+iB,EAAItF,QAChB,MAAO,CAACwF,UAAgBvS,IAAV1Q,EAAqBA,MAAOA,EAC9C,GASJ,OANIohB,IACAE,EAASb,EAAKY,OAAOC,UAAY,WAC7B,OAAOA,CACX,GAGGA,CACX,CAEA,SAASc,EAAYO,GACjB,IAAInB,EAAO,CAAC,EAEZ,GAAsB,iBAAXmB,EAEP,GAAIxjB,EAAQwjB,GACR,IAAK,IAAIrjB,EAAI,EAAGA,EAAIqjB,EAAOnkB,OAAQc,IAAK,CACpC,IAAIzB,EAAO8kB,EAAOrjB,GAClB,IAAIH,EAAQtB,IAAyB,IAAhBA,EAAKW,OAGtB,MAAM,IAAI0kB,UAAU,+FAFpB3B,EAASC,EAAM3jB,EAAK,GAAIA,EAAK,GAIrC,MAGA,IAAK,IAAI2P,KAAOmV,EACRA,EAAOhB,eAAenU,IACtB+T,EAASC,EAAMhU,EAAKmV,EAAOnV,QAKpC,CAEyB,IAAxBmV,EAAOte,QAAQ,OACfse,EAASA,EAAOjmB,MAAM,IAI1B,IADA,IAAIymB,EAAQR,EAAOlmB,MAAM,KAChBqe,EAAI,EAAGA,EAAIqI,EAAM3kB,OAAQsc,IAAK,CACnC,IAAI9a,EAAQmjB,EAAOrI,GACfxW,EAAQtE,EAAMqE,QAAQ,MAErB,EAAIC,EACLid,EAASC,EAAMqB,EAAO7iB,EAAMtD,MAAM,EAAG4H,IAASue,EAAO7iB,EAAMtD,MAAM4H,EAAQ,KAGrEtE,GACAuhB,EAASC,EAAMqB,EAAO7iB,GAAQ,GAG1C,CACJ,CAEA,OAAOwhB,CACX,CAEA,SAASD,EAASC,EAAMrV,EAAMnM,GAC1B,IAAIojB,EAAuB,iBAAVpjB,EAAqBA,EAClCA,SAAmE,mBAAnBA,EAAM8gB,SAA0B9gB,EAAM8gB,WAAauC,KAAKC,UAAUtjB,GAIlH2hB,EAAeH,EAAMrV,GACrBqV,EAAKrV,GAAMjO,KAAKklB,GAEhB5B,EAAKrV,GAAQ,CAACiX,EAEtB,CAEA,SAASjkB,EAAQikB,GACb,QAASA,GAAO,mBAAqBrmB,OAAOD,UAAUgkB,SAASja,KAAKuc,EACxE,CAEA,SAASzB,EAAe9S,EAAKtE,GACzB,OAAOxN,OAAOD,UAAU6kB,eAAe9a,KAAKgI,EAAKtE,EACrD,CAEH,CApVD,MAoVqB,IAAX,EAAAgZ,EAAyB,EAAAA,EAA4B,oBAAX3mB,OAAyBA,OAASM,sBC5VtF,IAAI0C,EAAM,CACT,eAAgB,CACf,IACA,IACA,IACA,KAED,sBAAuB,CACtB,KACA,IACA,IACA,GAED,wBAAyB,CACxB,KACA,IACA,IACA,KAED,mBAAoB,CACnB,KACA,IACA,IACA,IACA,IACA,IACA,KAED,uBAAwB,CACvB,KACA,IACA,IACA,IAED,eAAgB,CACf,KACA,IACA,IACA,IACA,KAED,aAAc,CACb,KACA,IACA,IACA,KAED,sBAAuB,CACtB,KACA,IACA,IACA,KAED,oBAAqB,CACpB,KACA,IACA,IACA,KAED,mBAAoB,CACnB,KACA,IACA,IACA,IACA,IACA,IACA,KAED,gBAAiB,CAChB,KACA,IACA,IACA,IACA,IAED,cAAe,CACd,KACA,IACA,IACA,KAED,qBAAsB,CACrB,KACA,IACA,IACA,IACA,IACA,IACA,KAED,yBAA0B,CACzB,KACA,IACA,IACA,KAED,wBAAyB,CACxB,IACA,IACA,IACA,MAGF,SAAS4jB,EAAoBC,GAC5B,IAAIC,EAAoBC,EAAE/jB,EAAK6jB,GAC9B,OAAOG,QAAQC,UAAUC,MAAK,KAC7B,IAAI/X,EAAI,IAAI/N,MAAM,uBAAyBylB,EAAM,KAEjD,MADA1X,EAAEgY,KAAO,mBACHhY,CAAC,IAIT,IAAIiY,EAAMpkB,EAAI6jB,GAAMQ,EAAKD,EAAI,GAC7B,OAAOJ,QAAQM,IAAIF,EAAItnB,MAAM,GAAGkD,IAAI8jB,EAAoB3X,IAAI+X,MAAK,IACzDJ,EAAoBO,IAE7B,CACAT,EAAoBjB,KAAO,IAAOxlB,OAAOwlB,KAAK3iB,GAC9C4jB,EAAoBS,GAAK,KACzB1X,EAAOC,QAAUgX,ICtHbW,EAA2B,CAAC,EAGhC,SAAST,EAAoBU,GAE5B,IAAIC,EAAeF,EAAyBC,GAC5C,QAAqB1T,IAAjB2T,EACH,OAAOA,EAAa7X,QAGrB,IAAID,EAAS4X,EAAyBC,GAAY,CACjDH,GAAIG,EACJE,QAAQ,EACR9X,QAAS,CAAC,GAUX,OANA+X,EAAoBH,GAAUvd,KAAK0F,EAAOC,QAASD,EAAQA,EAAOC,QAASkX,GAG3EnX,EAAO+X,QAAS,EAGT/X,EAAOC,OACf,CAGAkX,EAAoBc,EAAID,EC3BxBb,EAAoBe,EAAKlY,IACxB,IAAImY,EAASnY,GAAUA,EAAOoY,WAC7B,IAAOpY,EAAiB,QACxB,IAAM,EAEP,OADAmX,EAAoBxO,EAAEwP,EAAQ,CAAEnlB,EAAGmlB,IAC5BA,CAAM,ECLdhB,EAAoBxO,EAAI,CAAC1I,EAASoY,KACjC,IAAI,IAAIpX,KAAOoX,EACXlB,EAAoBC,EAAEiB,EAAYpX,KAASkW,EAAoBC,EAAEnX,EAASgB,IAC5EzQ,OAAOC,eAAewP,EAASgB,EAAK,CAAEqX,YAAY,EAAM5nB,IAAK2nB,EAAWpX,IAE1E,ECNDkW,EAAoBoB,EAAI,CAAC,EAGzBpB,EAAoB3X,EAAKgZ,GACjBnB,QAAQM,IAAInnB,OAAOwlB,KAAKmB,EAAoBoB,GAAGE,QAAO,CAACC,EAAUzX,KACvEkW,EAAoBoB,EAAEtX,GAAKuX,EAASE,GAC7BA,IACL,KCNJvB,EAAoB1M,EAAK+N,GAEZA,EAAU,IAAM,CAAC,EAAI,uBAAuB,GAAK,uBAAuB,GAAK,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,uBAAuB,IAAM,wBAAwBA,GAAW,MCHvoBrB,EAAoBH,EAAI,WACvB,GAA0B,iBAAf2B,WAAyB,OAAOA,WAC3C,IACC,OAAOhoB,MAAQ,IAAIwX,SAAS,cAAb,EAChB,CAAE,MAAO3I,GACR,GAAsB,iBAAXnP,OAAqB,OAAOA,MACxC,CACA,CAPuB,GCAxB8mB,EAAoBC,EAAI,CAAC9U,EAAKtE,IAAUxN,OAAOD,UAAU6kB,eAAe9a,KAAKgI,EAAKtE,GhBA9EpO,EAAa,CAAC,EACdC,EAAoB,OAExBsnB,EAAoByB,EAAI,CAAChP,EAAK8M,EAAMzV,EAAKuX,KACxC,GAAG5oB,EAAWga,GAAQha,EAAWga,GAAKjY,KAAK+kB,OAA3C,CACA,IAAImC,EAAQC,EACZ,QAAW3U,IAARlD,EAEF,IADA,IAAI8X,EAAUhpB,SAASwP,qBAAqB,UACpCxM,EAAI,EAAGA,EAAIgmB,EAAQ9mB,OAAQc,IAAK,CACvC,IAAIua,EAAIyL,EAAQhmB,GAChB,GAAGua,EAAE1R,aAAa,QAAUgO,GAAO0D,EAAE1R,aAAa,iBAAmB/L,EAAoBoR,EAAK,CAAE4X,EAASvL,EAAG,KAAO,CACpH,CAEGuL,IACHC,GAAa,GACbD,EAAS9oB,SAAS6Q,cAAc,WAEzBoY,QAAU,QACjBH,EAAOrgB,QAAU,IACb2e,EAAoB8B,IACvBJ,EAAO9b,aAAa,QAASoa,EAAoB8B,IAElDJ,EAAO9b,aAAa,eAAgBlN,EAAoBoR,GAExD4X,EAAO5oB,IAAM2Z,GAEdha,EAAWga,GAAO,CAAC8M,GACnB,IAAIwC,EAAmB,CAACC,EAAMpgB,KAE7B8f,EAAOrO,QAAUqO,EAAOtO,OAAS,KACjCrG,aAAa1L,GACb,IAAI4gB,EAAUxpB,EAAWga,GAIzB,UAHOha,EAAWga,GAClBiP,EAAOrf,YAAcqf,EAAOrf,WAAWuK,YAAY8U,GACnDO,GAAWA,EAAQlkB,SAASqD,GAAQA,EAAGQ,KACpCogB,EAAM,OAAOA,EAAKpgB,EAAM,EAExBP,EAAUI,WAAWsgB,EAAiBvgB,KAAK,UAAMwL,EAAW,CAAE9B,KAAM,UAAWlR,OAAQ0nB,IAAW,MACtGA,EAAOrO,QAAU0O,EAAiBvgB,KAAK,KAAMkgB,EAAOrO,SACpDqO,EAAOtO,OAAS2O,EAAiBvgB,KAAK,KAAMkgB,EAAOtO,QACnDuO,GAAc/oB,SAASspB,KAAKxY,YAAYgY,EApCkB,CAoCX,EiBvChD1B,EAAoBmC,EAAKrZ,IACH,oBAAX6U,QAA0BA,OAAOyE,aAC1C/oB,OAAOC,eAAewP,EAAS6U,OAAOyE,YAAa,CAAE9lB,MAAO,WAE7DjD,OAAOC,eAAewP,EAAS,aAAc,CAAExM,OAAO,GAAO,ECL9D0jB,EAAoBqC,IAAOxZ,IAC1BA,EAAOyZ,MAAQ,GACVzZ,EAAO0Z,WAAU1Z,EAAO0Z,SAAW,IACjC1Z,SCHR,IAAI2Z,EACAxC,EAAoBH,EAAE4C,gBAAeD,EAAYxC,EAAoBH,EAAE7E,SAAW,IACtF,IAAIpiB,EAAWonB,EAAoBH,EAAEjnB,SACrC,IAAK4pB,GAAa5pB,IACbA,EAAS8pB,gBACZF,EAAY5pB,EAAS8pB,cAAc5pB,MAC/B0pB,GAAW,CACf,IAAIZ,EAAUhpB,EAASwP,qBAAqB,UAC5C,GAAGwZ,EAAQ9mB,OAEV,IADA,IAAIc,EAAIgmB,EAAQ9mB,OAAS,EAClBc,GAAK,KAAO4mB,IAAc,aAAa1e,KAAK0e,KAAaA,EAAYZ,EAAQhmB,KAAK9C,GAE3F,CAID,IAAK0pB,EAAW,MAAM,IAAIloB,MAAM,yDAChCkoB,EAAYA,EAAUxd,QAAQ,OAAQ,IAAIA,QAAQ,QAAS,IAAIA,QAAQ,YAAa,KACpFgb,EAAoB2C,EAAIH,YClBxBxC,EAAoB5N,EAAIxZ,SAASgqB,SAAW7F,KAAK/B,SAASxH,KAK1D,IAAIqP,EAAkB,CACrB,IAAK,GAGN7C,EAAoBoB,EAAEhK,EAAI,CAACiK,EAASE,KAElC,IAAIuB,EAAqB9C,EAAoBC,EAAE4C,EAAiBxB,GAAWwB,EAAgBxB,QAAWrU,EACtG,GAA0B,IAAvB8V,EAGF,GAAGA,EACFvB,EAAS/mB,KAAKsoB,EAAmB,QAC3B,CAGL,IAAIC,EAAU,IAAI7C,SAAQ,CAACC,EAAS6C,IAAYF,EAAqBD,EAAgBxB,GAAW,CAAClB,EAAS6C,KAC1GzB,EAAS/mB,KAAKsoB,EAAmB,GAAKC,GAGtC,IAAItQ,EAAMuN,EAAoB2C,EAAI3C,EAAoB1M,EAAE+N,GAEpD4B,EAAQ,IAAI3oB,MAgBhB0lB,EAAoByB,EAAEhP,GAfF7Q,IACnB,GAAGoe,EAAoBC,EAAE4C,EAAiBxB,KAEf,KAD1ByB,EAAqBD,EAAgBxB,MACRwB,EAAgBxB,QAAWrU,GACrD8V,GAAoB,CACtB,IAAII,EAAYthB,IAAyB,SAAfA,EAAMsJ,KAAkB,UAAYtJ,EAAMsJ,MAChEiY,EAAUvhB,GAASA,EAAM5H,QAAU4H,EAAM5H,OAAOlB,IACpDmqB,EAAMG,QAAU,iBAAmB/B,EAAU,cAAgB6B,EAAY,KAAOC,EAAU,IAC1FF,EAAMxa,KAAO,iBACbwa,EAAM/X,KAAOgY,EACbD,EAAMI,QAAUF,EAChBL,EAAmB,GAAGG,EACvB,CACD,GAEwC,SAAW5B,EAASA,EAE/D,CACD,EAcF,IAAIiC,EAAuB,CAACC,EAA4BC,KACvD,IAGI9C,EAAUW,GAHToC,EAAUC,EAAaC,GAAWH,EAGhB5nB,EAAI,EAC3B,GAAG6nB,EAASvpB,MAAMqmB,GAAgC,IAAxBsC,EAAgBtC,KAAa,CACtD,IAAIG,KAAYgD,EACZ1D,EAAoBC,EAAEyD,EAAahD,KACrCV,EAAoBc,EAAEJ,GAAYgD,EAAYhD,IAGhD,GAAGiD,EAAsBA,EAAQ3D,EAClC,CAEA,IADGuD,GAA4BA,EAA2BC,GACrD5nB,EAAI6nB,EAAS3oB,OAAQc,IACzBylB,EAAUoC,EAAS7nB,GAChBokB,EAAoBC,EAAE4C,EAAiBxB,IAAYwB,EAAgBxB,IACrEwB,EAAgBxB,GAAS,KAE1BwB,EAAgBxB,GAAW,CAC5B,EAIGuC,EAAqB7G,KAAsB,gBAAIA,KAAsB,iBAAK,GAC9E6G,EAAmB7lB,QAAQulB,EAAqB9hB,KAAK,KAAM,IAC3DoiB,EAAmBppB,KAAO8oB,EAAqB9hB,KAAK,KAAMoiB,EAAmBppB,KAAKgH,KAAKoiB,uHC/EvFC,MAGAC,MAGA,IAAIthB,EAAAA,ECZkBuhB,MAGpB,IAFA,IAAMC,EAAiBprB,SAASsK,iBAAiB,wBAAwB+gB,EAAA,WAMvE,IAHA,IAAM/hB,EAAK8hB,EAAepoB,GAEpBsoB,EADQhiB,EAAGiiB,QAAQC,aACHrrB,MAAM,KAAKmD,KAAK/B,GAASA,EAAKkqB,SAC3C5b,EAAO,EAAGA,EAAOyb,EAAQppB,OAAQ2N,IACxC,QAAQ,KAAYyb,EAAQzb,SAAY2X,MAAMkE,IAC7B,IAAIA,EAAOC,QAAQriB,GAC3BS,MAAM,GAGnB,EAVS/G,EAAI,EAAGA,EAAIooB,EAAelpB,OAAQc,IAAGqoB,GAAA,ECKhDF","sources":["webpack://wls/webpack/runtime/load script","webpack://wls/./src/js/globals/webpackPublicPath.js","webpack://wls/./node_modules/intersection-observer/intersection-observer.js","webpack://wls/./node_modules/lazyload-picturefill-background/src/lazyload-picturefill-background.js","webpack://wls/./node_modules/object-fit-images/dist/ofi.common-js.js","webpack://wls/./node_modules/object-fit-videos/object-fit-videos.js","webpack://wls/./node_modules/picturefill/dist/picturefill.js","webpack://wls/./node_modules/svgxuse/svgxuse.js","webpack://wls/./node_modules/url-search-params-polyfill/index.js","webpack://wls/./src/js/vue/imports/ lazy ^\\.\\/.*\\.js$ namespace object","webpack://wls/webpack/bootstrap","webpack://wls/webpack/runtime/compat get default export","webpack://wls/webpack/runtime/define property getters","webpack://wls/webpack/runtime/ensure chunk","webpack://wls/webpack/runtime/get javascript chunk filename","webpack://wls/webpack/runtime/global","webpack://wls/webpack/runtime/hasOwnProperty shorthand","webpack://wls/webpack/runtime/make namespace object","webpack://wls/webpack/runtime/node module decorator","webpack://wls/webpack/runtime/publicPath","webpack://wls/webpack/runtime/jsonp chunk loading","webpack://wls/./src/js/polyfills/index.js","webpack://wls/./src/js/vue/_index.js","webpack://wls/./src/js/Roadtrip/main.js"],"sourcesContent":["var inProgress = {};\nvar dataWebpackPrefix = \"wls:\";\n// loadScript function to load a script via script tag\n__webpack_require__.l = (url, done, key, chunkId) => {\n\tif(inProgress[url]) { inProgress[url].push(done); return; }\n\tvar script, needAttach;\n\tif(key !== undefined) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tfor(var i = 0; i < scripts.length; i++) {\n\t\t\tvar s = scripts[i];\n\t\t\tif(s.getAttribute(\"src\") == url || s.getAttribute(\"data-webpack\") == dataWebpackPrefix + key) { script = s; break; }\n\t\t}\n\t}\n\tif(!script) {\n\t\tneedAttach = true;\n\t\tscript = document.createElement('script');\n\n\t\tscript.charset = 'utf-8';\n\t\tscript.timeout = 120;\n\t\tif (__webpack_require__.nc) {\n\t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n\t\t}\n\t\tscript.setAttribute(\"data-webpack\", dataWebpackPrefix + key);\n\n\t\tscript.src = url;\n\t}\n\tinProgress[url] = [done];\n\tvar onScriptComplete = (prev, event) => {\n\t\t// avoid mem leaks in IE.\n\t\tscript.onerror = script.onload = null;\n\t\tclearTimeout(timeout);\n\t\tvar doneFns = inProgress[url];\n\t\tdelete inProgress[url];\n\t\tscript.parentNode && script.parentNode.removeChild(script);\n\t\tdoneFns && doneFns.forEach((fn) => (fn(event)));\n\t\tif(prev) return prev(event);\n\t}\n\tvar timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);\n\tscript.onerror = onScriptComplete.bind(null, script.onerror);\n\tscript.onload = onScriptComplete.bind(null, script.onload);\n\tneedAttach && document.head.appendChild(script);\n};","const getScriptsPath = () => {\r\n  const script = document.querySelector('script[src*=\"build/js/\"]');\r\n  const src = script.src.split('?')[0];\r\n  return src.split('/').slice(0, -1).join('/') + '/';\r\n};\r\n\r\n// set the public path to be the path of the main entry script\r\n__webpack_public_path__ = getScriptsPath(); // eslint-disable-line\r\n","/**\n * Copyright 2016 Google Inc. All Rights Reserved.\n *\n * Licensed under the W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE.\n *\n *  https://www.w3.org/Consortium/Legal/2015/copyright-software-and-document\n *\n */\n(function() {\n'use strict';\n\n// Exit early if we're not running in a browser.\nif (typeof window !== 'object') {\n  return;\n}\n\n// Exit early if all IntersectionObserver and IntersectionObserverEntry\n// features are natively supported.\nif ('IntersectionObserver' in window &&\n    'IntersectionObserverEntry' in window &&\n    'intersectionRatio' in window.IntersectionObserverEntry.prototype) {\n\n  // Minimal polyfill for Edge 15's lack of `isIntersecting`\n  // See: https://github.com/w3c/IntersectionObserver/issues/211\n  if (!('isIntersecting' in window.IntersectionObserverEntry.prototype)) {\n    Object.defineProperty(window.IntersectionObserverEntry.prototype,\n      'isIntersecting', {\n      get: function () {\n        return this.intersectionRatio > 0;\n      }\n    });\n  }\n  return;\n}\n\n\n/**\n * A local reference to the document.\n */\nvar document = window.document;\n\n\n/**\n * An IntersectionObserver registry. This registry exists to hold a strong\n * reference to IntersectionObserver instances currently observing a target\n * element. Without this registry, instances without another reference may be\n * garbage collected.\n */\nvar registry = [];\n\n\n/**\n * Creates the global IntersectionObserverEntry constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-entry\n * @param {Object} entry A dictionary of instance properties.\n * @constructor\n */\nfunction IntersectionObserverEntry(entry) {\n  this.time = entry.time;\n  this.target = entry.target;\n  this.rootBounds = entry.rootBounds;\n  this.boundingClientRect = entry.boundingClientRect;\n  this.intersectionRect = entry.intersectionRect || getEmptyRect();\n  this.isIntersecting = !!entry.intersectionRect;\n\n  // Calculates the intersection ratio.\n  var targetRect = this.boundingClientRect;\n  var targetArea = targetRect.width * targetRect.height;\n  var intersectionRect = this.intersectionRect;\n  var intersectionArea = intersectionRect.width * intersectionRect.height;\n\n  // Sets intersection ratio.\n  if (targetArea) {\n    // Round the intersection ratio to avoid floating point math issues:\n    // https://github.com/w3c/IntersectionObserver/issues/324\n    this.intersectionRatio = Number((intersectionArea / targetArea).toFixed(4));\n  } else {\n    // If area is zero and is intersecting, sets to 1, otherwise to 0\n    this.intersectionRatio = this.isIntersecting ? 1 : 0;\n  }\n}\n\n\n/**\n * Creates the global IntersectionObserver constructor.\n * https://w3c.github.io/IntersectionObserver/#intersection-observer-interface\n * @param {Function} callback The function to be invoked after intersection\n *     changes have queued. The function is not invoked if the queue has\n *     been emptied by calling the `takeRecords` method.\n * @param {Object=} opt_options Optional configuration options.\n * @constructor\n */\nfunction IntersectionObserver(callback, opt_options) {\n\n  var options = opt_options || {};\n\n  if (typeof callback != 'function') {\n    throw new Error('callback must be a function');\n  }\n\n  if (options.root && options.root.nodeType != 1) {\n    throw new Error('root must be an Element');\n  }\n\n  // Binds and throttles `this._checkForIntersections`.\n  this._checkForIntersections = throttle(\n      this._checkForIntersections.bind(this), this.THROTTLE_TIMEOUT);\n\n  // Private properties.\n  this._callback = callback;\n  this._observationTargets = [];\n  this._queuedEntries = [];\n  this._rootMarginValues = this._parseRootMargin(options.rootMargin);\n\n  // Public properties.\n  this.thresholds = this._initThresholds(options.threshold);\n  this.root = options.root || null;\n  this.rootMargin = this._rootMarginValues.map(function(margin) {\n    return margin.value + margin.unit;\n  }).join(' ');\n}\n\n\n/**\n * The minimum interval within which the document will be checked for\n * intersection changes.\n */\nIntersectionObserver.prototype.THROTTLE_TIMEOUT = 100;\n\n\n/**\n * The frequency in which the polyfill polls for intersection changes.\n * this can be updated on a per instance basis and must be set prior to\n * calling `observe` on the first target.\n */\nIntersectionObserver.prototype.POLL_INTERVAL = null;\n\n/**\n * Use a mutation observer on the root element\n * to detect intersection changes.\n */\nIntersectionObserver.prototype.USE_MUTATION_OBSERVER = true;\n\n\n/**\n * Starts observing a target element for intersection changes based on\n * the thresholds values.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.observe = function(target) {\n  var isTargetAlreadyObserved = this._observationTargets.some(function(item) {\n    return item.element == target;\n  });\n\n  if (isTargetAlreadyObserved) {\n    return;\n  }\n\n  if (!(target && target.nodeType == 1)) {\n    throw new Error('target must be an Element');\n  }\n\n  this._registerInstance();\n  this._observationTargets.push({element: target, entry: null});\n  this._monitorIntersections();\n  this._checkForIntersections();\n};\n\n\n/**\n * Stops observing a target element for intersection changes.\n * @param {Element} target The DOM element to observe.\n */\nIntersectionObserver.prototype.unobserve = function(target) {\n  this._observationTargets =\n      this._observationTargets.filter(function(item) {\n\n    return item.element != target;\n  });\n  if (!this._observationTargets.length) {\n    this._unmonitorIntersections();\n    this._unregisterInstance();\n  }\n};\n\n\n/**\n * Stops observing all target elements for intersection changes.\n */\nIntersectionObserver.prototype.disconnect = function() {\n  this._observationTargets = [];\n  this._unmonitorIntersections();\n  this._unregisterInstance();\n};\n\n\n/**\n * Returns any queue entries that have not yet been reported to the\n * callback and clears the queue. This can be used in conjunction with the\n * callback to obtain the absolute most up-to-date intersection information.\n * @return {Array} The currently queued entries.\n */\nIntersectionObserver.prototype.takeRecords = function() {\n  var records = this._queuedEntries.slice();\n  this._queuedEntries = [];\n  return records;\n};\n\n\n/**\n * Accepts the threshold value from the user configuration object and\n * returns a sorted array of unique threshold values. If a value is not\n * between 0 and 1 and error is thrown.\n * @private\n * @param {Array|number=} opt_threshold An optional threshold value or\n *     a list of threshold values, defaulting to [0].\n * @return {Array} A sorted list of unique and valid threshold values.\n */\nIntersectionObserver.prototype._initThresholds = function(opt_threshold) {\n  var threshold = opt_threshold || [0];\n  if (!Array.isArray(threshold)) threshold = [threshold];\n\n  return threshold.sort().filter(function(t, i, a) {\n    if (typeof t != 'number' || isNaN(t) || t < 0 || t > 1) {\n      throw new Error('threshold must be a number between 0 and 1 inclusively');\n    }\n    return t !== a[i - 1];\n  });\n};\n\n\n/**\n * Accepts the rootMargin value from the user configuration object\n * and returns an array of the four margin values as an object containing\n * the value and unit properties. If any of the values are not properly\n * formatted or use a unit other than px or %, and error is thrown.\n * @private\n * @param {string=} opt_rootMargin An optional rootMargin value,\n *     defaulting to '0px'.\n * @return {Array<Object>} An array of margin objects with the keys\n *     value and unit.\n */\nIntersectionObserver.prototype._parseRootMargin = function(opt_rootMargin) {\n  var marginString = opt_rootMargin || '0px';\n  var margins = marginString.split(/\\s+/).map(function(margin) {\n    var parts = /^(-?\\d*\\.?\\d+)(px|%)$/.exec(margin);\n    if (!parts) {\n      throw new Error('rootMargin must be specified in pixels or percent');\n    }\n    return {value: parseFloat(parts[1]), unit: parts[2]};\n  });\n\n  // Handles shorthand.\n  margins[1] = margins[1] || margins[0];\n  margins[2] = margins[2] || margins[0];\n  margins[3] = margins[3] || margins[1];\n\n  return margins;\n};\n\n\n/**\n * Starts polling for intersection changes if the polling is not already\n * happening, and if the page's visibility state is visible.\n * @private\n */\nIntersectionObserver.prototype._monitorIntersections = function() {\n  if (!this._monitoringIntersections) {\n    this._monitoringIntersections = true;\n\n    // If a poll interval is set, use polling instead of listening to\n    // resize and scroll events or DOM mutations.\n    if (this.POLL_INTERVAL) {\n      this._monitoringInterval = setInterval(\n          this._checkForIntersections, this.POLL_INTERVAL);\n    }\n    else {\n      addEvent(window, 'resize', this._checkForIntersections, true);\n      addEvent(document, 'scroll', this._checkForIntersections, true);\n\n      if (this.USE_MUTATION_OBSERVER && 'MutationObserver' in window) {\n        this._domObserver = new MutationObserver(this._checkForIntersections);\n        this._domObserver.observe(document, {\n          attributes: true,\n          childList: true,\n          characterData: true,\n          subtree: true\n        });\n      }\n    }\n  }\n};\n\n\n/**\n * Stops polling for intersection changes.\n * @private\n */\nIntersectionObserver.prototype._unmonitorIntersections = function() {\n  if (this._monitoringIntersections) {\n    this._monitoringIntersections = false;\n\n    clearInterval(this._monitoringInterval);\n    this._monitoringInterval = null;\n\n    removeEvent(window, 'resize', this._checkForIntersections, true);\n    removeEvent(document, 'scroll', this._checkForIntersections, true);\n\n    if (this._domObserver) {\n      this._domObserver.disconnect();\n      this._domObserver = null;\n    }\n  }\n};\n\n\n/**\n * Scans each observation target for intersection changes and adds them\n * to the internal entries queue. If new entries are found, it\n * schedules the callback to be invoked.\n * @private\n */\nIntersectionObserver.prototype._checkForIntersections = function() {\n  var rootIsInDom = this._rootIsInDom();\n  var rootRect = rootIsInDom ? this._getRootRect() : getEmptyRect();\n\n  this._observationTargets.forEach(function(item) {\n    var target = item.element;\n    var targetRect = getBoundingClientRect(target);\n    var rootContainsTarget = this._rootContainsTarget(target);\n    var oldEntry = item.entry;\n    var intersectionRect = rootIsInDom && rootContainsTarget &&\n        this._computeTargetAndRootIntersection(target, rootRect);\n\n    var newEntry = item.entry = new IntersectionObserverEntry({\n      time: now(),\n      target: target,\n      boundingClientRect: targetRect,\n      rootBounds: rootRect,\n      intersectionRect: intersectionRect\n    });\n\n    if (!oldEntry) {\n      this._queuedEntries.push(newEntry);\n    } else if (rootIsInDom && rootContainsTarget) {\n      // If the new entry intersection ratio has crossed any of the\n      // thresholds, add a new entry.\n      if (this._hasCrossedThreshold(oldEntry, newEntry)) {\n        this._queuedEntries.push(newEntry);\n      }\n    } else {\n      // If the root is not in the DOM or target is not contained within\n      // root but the previous entry for this target had an intersection,\n      // add a new record indicating removal.\n      if (oldEntry && oldEntry.isIntersecting) {\n        this._queuedEntries.push(newEntry);\n      }\n    }\n  }, this);\n\n  if (this._queuedEntries.length) {\n    this._callback(this.takeRecords(), this);\n  }\n};\n\n\n/**\n * Accepts a target and root rect computes the intersection between then\n * following the algorithm in the spec.\n * TODO(philipwalton): at this time clip-path is not considered.\n * https://w3c.github.io/IntersectionObserver/#calculate-intersection-rect-algo\n * @param {Element} target The target DOM element\n * @param {Object} rootRect The bounding rect of the root after being\n *     expanded by the rootMargin value.\n * @return {?Object} The final intersection rect object or undefined if no\n *     intersection is found.\n * @private\n */\nIntersectionObserver.prototype._computeTargetAndRootIntersection =\n    function(target, rootRect) {\n\n  // If the element isn't displayed, an intersection can't happen.\n  if (window.getComputedStyle(target).display == 'none') return;\n\n  var targetRect = getBoundingClientRect(target);\n  var intersectionRect = targetRect;\n  var parent = getParentNode(target);\n  var atRoot = false;\n\n  while (!atRoot) {\n    var parentRect = null;\n    var parentComputedStyle = parent.nodeType == 1 ?\n        window.getComputedStyle(parent) : {};\n\n    // If the parent isn't displayed, an intersection can't happen.\n    if (parentComputedStyle.display == 'none') return;\n\n    if (parent == this.root || parent == document) {\n      atRoot = true;\n      parentRect = rootRect;\n    } else {\n      // If the element has a non-visible overflow, and it's not the <body>\n      // or <html> element, update the intersection rect.\n      // Note: <body> and <html> cannot be clipped to a rect that's not also\n      // the document rect, so no need to compute a new intersection.\n      if (parent != document.body &&\n          parent != document.documentElement &&\n          parentComputedStyle.overflow != 'visible') {\n        parentRect = getBoundingClientRect(parent);\n      }\n    }\n\n    // If either of the above conditionals set a new parentRect,\n    // calculate new intersection data.\n    if (parentRect) {\n      intersectionRect = computeRectIntersection(parentRect, intersectionRect);\n\n      if (!intersectionRect) break;\n    }\n    parent = getParentNode(parent);\n  }\n  return intersectionRect;\n};\n\n\n/**\n * Returns the root rect after being expanded by the rootMargin value.\n * @return {Object} The expanded root rect.\n * @private\n */\nIntersectionObserver.prototype._getRootRect = function() {\n  var rootRect;\n  if (this.root) {\n    rootRect = getBoundingClientRect(this.root);\n  } else {\n    // Use <html>/<body> instead of window since scroll bars affect size.\n    var html = document.documentElement;\n    var body = document.body;\n    rootRect = {\n      top: 0,\n      left: 0,\n      right: html.clientWidth || body.clientWidth,\n      width: html.clientWidth || body.clientWidth,\n      bottom: html.clientHeight || body.clientHeight,\n      height: html.clientHeight || body.clientHeight\n    };\n  }\n  return this._expandRectByRootMargin(rootRect);\n};\n\n\n/**\n * Accepts a rect and expands it by the rootMargin value.\n * @param {Object} rect The rect object to expand.\n * @return {Object} The expanded rect.\n * @private\n */\nIntersectionObserver.prototype._expandRectByRootMargin = function(rect) {\n  var margins = this._rootMarginValues.map(function(margin, i) {\n    return margin.unit == 'px' ? margin.value :\n        margin.value * (i % 2 ? rect.width : rect.height) / 100;\n  });\n  var newRect = {\n    top: rect.top - margins[0],\n    right: rect.right + margins[1],\n    bottom: rect.bottom + margins[2],\n    left: rect.left - margins[3]\n  };\n  newRect.width = newRect.right - newRect.left;\n  newRect.height = newRect.bottom - newRect.top;\n\n  return newRect;\n};\n\n\n/**\n * Accepts an old and new entry and returns true if at least one of the\n * threshold values has been crossed.\n * @param {?IntersectionObserverEntry} oldEntry The previous entry for a\n *    particular target element or null if no previous entry exists.\n * @param {IntersectionObserverEntry} newEntry The current entry for a\n *    particular target element.\n * @return {boolean} Returns true if a any threshold has been crossed.\n * @private\n */\nIntersectionObserver.prototype._hasCrossedThreshold =\n    function(oldEntry, newEntry) {\n\n  // To make comparing easier, an entry that has a ratio of 0\n  // but does not actually intersect is given a value of -1\n  var oldRatio = oldEntry && oldEntry.isIntersecting ?\n      oldEntry.intersectionRatio || 0 : -1;\n  var newRatio = newEntry.isIntersecting ?\n      newEntry.intersectionRatio || 0 : -1;\n\n  // Ignore unchanged ratios\n  if (oldRatio === newRatio) return;\n\n  for (var i = 0; i < this.thresholds.length; i++) {\n    var threshold = this.thresholds[i];\n\n    // Return true if an entry matches a threshold or if the new ratio\n    // and the old ratio are on the opposite sides of a threshold.\n    if (threshold == oldRatio || threshold == newRatio ||\n        threshold < oldRatio !== threshold < newRatio) {\n      return true;\n    }\n  }\n};\n\n\n/**\n * Returns whether or not the root element is an element and is in the DOM.\n * @return {boolean} True if the root element is an element and is in the DOM.\n * @private\n */\nIntersectionObserver.prototype._rootIsInDom = function() {\n  return !this.root || containsDeep(document, this.root);\n};\n\n\n/**\n * Returns whether or not the target element is a child of root.\n * @param {Element} target The target element to check.\n * @return {boolean} True if the target element is a child of root.\n * @private\n */\nIntersectionObserver.prototype._rootContainsTarget = function(target) {\n  return containsDeep(this.root || document, target);\n};\n\n\n/**\n * Adds the instance to the global IntersectionObserver registry if it isn't\n * already present.\n * @private\n */\nIntersectionObserver.prototype._registerInstance = function() {\n  if (registry.indexOf(this) < 0) {\n    registry.push(this);\n  }\n};\n\n\n/**\n * Removes the instance from the global IntersectionObserver registry.\n * @private\n */\nIntersectionObserver.prototype._unregisterInstance = function() {\n  var index = registry.indexOf(this);\n  if (index != -1) registry.splice(index, 1);\n};\n\n\n/**\n * Returns the result of the performance.now() method or null in browsers\n * that don't support the API.\n * @return {number} The elapsed time since the page was requested.\n */\nfunction now() {\n  return window.performance && performance.now && performance.now();\n}\n\n\n/**\n * Throttles a function and delays its execution, so it's only called at most\n * once within a given time period.\n * @param {Function} fn The function to throttle.\n * @param {number} timeout The amount of time that must pass before the\n *     function can be called again.\n * @return {Function} The throttled function.\n */\nfunction throttle(fn, timeout) {\n  var timer = null;\n  return function () {\n    if (!timer) {\n      timer = setTimeout(function() {\n        fn();\n        timer = null;\n      }, timeout);\n    }\n  };\n}\n\n\n/**\n * Adds an event handler to a DOM node ensuring cross-browser compatibility.\n * @param {Node} node The DOM node to add the event handler to.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to add.\n * @param {boolean} opt_useCapture Optionally adds the even to the capture\n *     phase. Note: this only works in modern browsers.\n */\nfunction addEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.addEventListener == 'function') {\n    node.addEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.attachEvent == 'function') {\n    node.attachEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Removes a previously added event handler from a DOM node.\n * @param {Node} node The DOM node to remove the event handler from.\n * @param {string} event The event name.\n * @param {Function} fn The event handler to remove.\n * @param {boolean} opt_useCapture If the event handler was added with this\n *     flag set to true, it should be set to true here in order to remove it.\n */\nfunction removeEvent(node, event, fn, opt_useCapture) {\n  if (typeof node.removeEventListener == 'function') {\n    node.removeEventListener(event, fn, opt_useCapture || false);\n  }\n  else if (typeof node.detatchEvent == 'function') {\n    node.detatchEvent('on' + event, fn);\n  }\n}\n\n\n/**\n * Returns the intersection between two rect objects.\n * @param {Object} rect1 The first rect.\n * @param {Object} rect2 The second rect.\n * @return {?Object} The intersection rect or undefined if no intersection\n *     is found.\n */\nfunction computeRectIntersection(rect1, rect2) {\n  var top = Math.max(rect1.top, rect2.top);\n  var bottom = Math.min(rect1.bottom, rect2.bottom);\n  var left = Math.max(rect1.left, rect2.left);\n  var right = Math.min(rect1.right, rect2.right);\n  var width = right - left;\n  var height = bottom - top;\n\n  return (width >= 0 && height >= 0) && {\n    top: top,\n    bottom: bottom,\n    left: left,\n    right: right,\n    width: width,\n    height: height\n  };\n}\n\n\n/**\n * Shims the native getBoundingClientRect for compatibility with older IE.\n * @param {Element} el The element whose bounding rect to get.\n * @return {Object} The (possibly shimmed) rect of the element.\n */\nfunction getBoundingClientRect(el) {\n  var rect;\n\n  try {\n    rect = el.getBoundingClientRect();\n  } catch (err) {\n    // Ignore Windows 7 IE11 \"Unspecified error\"\n    // https://github.com/w3c/IntersectionObserver/pull/205\n  }\n\n  if (!rect) return getEmptyRect();\n\n  // Older IE\n  if (!(rect.width && rect.height)) {\n    rect = {\n      top: rect.top,\n      right: rect.right,\n      bottom: rect.bottom,\n      left: rect.left,\n      width: rect.right - rect.left,\n      height: rect.bottom - rect.top\n    };\n  }\n  return rect;\n}\n\n\n/**\n * Returns an empty rect object. An empty rect is returned when an element\n * is not in the DOM.\n * @return {Object} The empty rect.\n */\nfunction getEmptyRect() {\n  return {\n    top: 0,\n    bottom: 0,\n    left: 0,\n    right: 0,\n    width: 0,\n    height: 0\n  };\n}\n\n/**\n * Checks to see if a parent element contains a child element (including inside\n * shadow DOM).\n * @param {Node} parent The parent element.\n * @param {Node} child The child element.\n * @return {boolean} True if the parent node contains the child node.\n */\nfunction containsDeep(parent, child) {\n  var node = child;\n  while (node) {\n    if (node == parent) return true;\n\n    node = getParentNode(node);\n  }\n  return false;\n}\n\n\n/**\n * Gets the parent node of an element or its host element if the parent node\n * is a shadow root.\n * @param {Node} node The node whose parent to get.\n * @return {Node|null} The parent node or null if no parent exists.\n */\nfunction getParentNode(node) {\n  var parent = node.parentNode;\n\n  if (parent && parent.nodeType == 11 && parent.host) {\n    // If the parent is a shadow root, return the host element.\n    return parent.host;\n  }\n\n  if (parent && parent.assignedSlot) {\n    // If the parent is distributed in a <slot>, return the parent of a slot.\n    return parent.assignedSlot.parentNode;\n  }\n\n  return parent;\n}\n\n\n// Exposes the constructors globally.\nwindow.IntersectionObserver = IntersectionObserver;\nwindow.IntersectionObserverEntry = IntersectionObserverEntry;\n\n}());\n","export default class lazyloadPicturefillBackground {\r\n  constructor(options) {\r\n    this.options = lazyloadPicturefillBackground.updateDefaultSettings(options);\r\n    this.init();\r\n  }\r\n\r\n  static updateDefaultSettings(userSettings) {\r\n    const defaultSettings = {\r\n      pictureFillBackgroundSelector: \".picturefill-background\",\r\n      lazySelector: \".is-lazy\",\r\n      pictureFillBackgroundSourceSelector: \".picturefill-background-source\"\r\n    };\r\n\r\n    for (const attrName in userSettings) {\r\n      defaultSettings[attrName] = userSettings[attrName];\r\n    }\r\n\r\n    defaultSettings.pictureFillBackgroundSelector =\r\n      typeof defaultSettings.pictureFillBackgroundSelector === \"string\"\r\n        ? document.querySelectorAll(\r\n            defaultSettings.pictureFillBackgroundSelector\r\n          )\r\n        : defaultSettings.pictureFillBackgroundSelector;\r\n\r\n    return defaultSettings;\r\n  }\r\n\r\n  init() {\r\n    if (this.options.pictureFillBackgroundSelector.length) {\r\n      Array.prototype.forEach.call(\r\n        this.options.pictureFillBackgroundSelector,\r\n        el => {\r\n          let matches = [];\r\n          let mqMatches = [];\r\n          const sources = el.querySelectorAll(\r\n            this.options.pictureFillBackgroundSourceSelector\r\n          );\r\n\r\n          matches = this.getSources(sources);\r\n\r\n          for (let i = 0; i < matches.length; i++) {\r\n            const mq = window.matchMedia(matches[i].media);\r\n\r\n            if (window.matchMedia && mq.matches) {\r\n              mqMatches.push(matches[i].src);\r\n            }\r\n\r\n            mq.addListener(() => {\r\n              if (mq.matches) {\r\n                const exp = new RegExp(this.escapeRegExp(matches[i].src));\r\n                if (!exp.test(el.style.backgroundImage)) {\r\n                  el.style.backgroundImage = \"url('\" + matches[i].src + \"')\";\r\n                }\r\n              } else {\r\n                const exp = new RegExp(this.escapeRegExp(matches[i - 1].src));\r\n                if (!exp.test(el.style.backgroundImage)) {\r\n                  el.style.backgroundImage =\r\n                    \"url('\" + matches[i - 1].src + \"')\";\r\n                }\r\n              }\r\n            });\r\n          }\r\n\r\n          if (el.classList.contains(this.options.lazySelector.substring(1))) {\r\n            this.createObserver(el, mqMatches, matches);\r\n          } else {\r\n            let src = mqMatches.length ? mqMatches.pop() : matches[0].src;\r\n            el.style.backgroundImage = \"url('\" + src + \"')\";\r\n          }\r\n        }\r\n      );\r\n    }\r\n  }\r\n\r\n  getSources(sourcesEls) {\r\n    let matches = [];\r\n\r\n    Array.prototype.forEach.call(sourcesEls, source => {\r\n      const sourceObj = {\r\n        src: source.getAttribute(\"data-src\"),\r\n        media: source.getAttribute(\"data-media\")\r\n      };\r\n\r\n      matches.push(sourceObj);\r\n    });\r\n\r\n    return matches;\r\n  }\r\n\r\n  createObserver(pictureFillBackgroundSelector, mqMatches, matches) {\r\n    const that = this;\r\n    const observer = new IntersectionObserver(entries => {\r\n      entries.forEach(function(entry) {\r\n        if (entry.isIntersecting) {\r\n          const lazyImage = entry.target;\r\n          lazyImage.classList.remove(that.options.lazySelector.substring(1));\r\n          observer.unobserve(lazyImage);\r\n\r\n          let src = mqMatches.length ? mqMatches.pop() : matches[0].src;\r\n          lazyImage.style.backgroundImage = \"url('\" + src + \"')\";\r\n        }\r\n      });\r\n    });\r\n    observer.observe(pictureFillBackgroundSelector);\r\n  }\r\n\r\n  escapeRegExp(string) {\r\n    return string.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\r\n  }\r\n}\r\n","/*! npm.im/object-fit-images 3.2.4 */\n'use strict';\n\nvar OFI = 'bfred-it:object-fit-images';\nvar propRegex = /(object-fit|object-position)\\s*:\\s*([-.\\w\\s%]+)/g;\nvar testImg = typeof Image === 'undefined' ? {style: {'object-position': 1}} : new Image();\nvar supportsObjectFit = 'object-fit' in testImg.style;\nvar supportsObjectPosition = 'object-position' in testImg.style;\nvar supportsOFI = 'background-size' in testImg.style;\nvar supportsCurrentSrc = typeof testImg.currentSrc === 'string';\nvar nativeGetAttribute = testImg.getAttribute;\nvar nativeSetAttribute = testImg.setAttribute;\nvar autoModeEnabled = false;\n\nfunction createPlaceholder(w, h) {\n\treturn (\"data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='\" + w + \"' height='\" + h + \"'%3E%3C/svg%3E\");\n}\n\nfunction polyfillCurrentSrc(el) {\n\tif (el.srcset && !supportsCurrentSrc && window.picturefill) {\n\t\tvar pf = window.picturefill._;\n\t\t// parse srcset with picturefill where currentSrc isn't available\n\t\tif (!el[pf.ns] || !el[pf.ns].evaled) {\n\t\t\t// force synchronous srcset parsing\n\t\t\tpf.fillImg(el, {reselect: true});\n\t\t}\n\n\t\tif (!el[pf.ns].curSrc) {\n\t\t\t// force picturefill to parse srcset\n\t\t\tel[pf.ns].supported = false;\n\t\t\tpf.fillImg(el, {reselect: true});\n\t\t}\n\n\t\t// retrieve parsed currentSrc, if any\n\t\tel.currentSrc = el[pf.ns].curSrc || el.src;\n\t}\n}\n\nfunction getStyle(el) {\n\tvar style = getComputedStyle(el).fontFamily;\n\tvar parsed;\n\tvar props = {};\n\twhile ((parsed = propRegex.exec(style)) !== null) {\n\t\tprops[parsed[1]] = parsed[2];\n\t}\n\treturn props;\n}\n\nfunction setPlaceholder(img, width, height) {\n\t// Default: fill width, no height\n\tvar placeholder = createPlaceholder(width || 1, height || 0);\n\n\t// Only set placeholder if it's different\n\tif (nativeGetAttribute.call(img, 'src') !== placeholder) {\n\t\tnativeSetAttribute.call(img, 'src', placeholder);\n\t}\n}\n\nfunction onImageReady(img, callback) {\n\t// naturalWidth is only available when the image headers are loaded,\n\t// this loop will poll it every 100ms.\n\tif (img.naturalWidth) {\n\t\tcallback(img);\n\t} else {\n\t\tsetTimeout(onImageReady, 100, img, callback);\n\t}\n}\n\nfunction fixOne(el) {\n\tvar style = getStyle(el);\n\tvar ofi = el[OFI];\n\tstyle['object-fit'] = style['object-fit'] || 'fill'; // default value\n\n\t// Avoid running where unnecessary, unless OFI had already done its deed\n\tif (!ofi.img) {\n\t\t// fill is the default behavior so no action is necessary\n\t\tif (style['object-fit'] === 'fill') {\n\t\t\treturn;\n\t\t}\n\n\t\t// Where object-fit is supported and object-position isn't (Safari < 10)\n\t\tif (\n\t\t\t!ofi.skipTest && // unless user wants to apply regardless of browser support\n\t\t\tsupportsObjectFit && // if browser already supports object-fit\n\t\t\t!style['object-position'] // unless object-position is used\n\t\t) {\n\t\t\treturn;\n\t\t}\n\t}\n\n\t// keep a clone in memory while resetting the original to a blank\n\tif (!ofi.img) {\n\t\tofi.img = new Image(el.width, el.height);\n\t\tofi.img.srcset = nativeGetAttribute.call(el, \"data-ofi-srcset\") || el.srcset;\n\t\tofi.img.src = nativeGetAttribute.call(el, \"data-ofi-src\") || el.src;\n\n\t\t// preserve for any future cloneNode calls\n\t\t// https://github.com/bfred-it/object-fit-images/issues/53\n\t\tnativeSetAttribute.call(el, \"data-ofi-src\", el.src);\n\t\tif (el.srcset) {\n\t\t\tnativeSetAttribute.call(el, \"data-ofi-srcset\", el.srcset);\n\t\t}\n\n\t\tsetPlaceholder(el, el.naturalWidth || el.width, el.naturalHeight || el.height);\n\n\t\t// remove srcset because it overrides src\n\t\tif (el.srcset) {\n\t\t\tel.srcset = '';\n\t\t}\n\t\ttry {\n\t\t\tkeepSrcUsable(el);\n\t\t} catch (err) {\n\t\t\tif (window.console) {\n\t\t\t\tconsole.warn('https://bit.ly/ofi-old-browser');\n\t\t\t}\n\t\t}\n\t}\n\n\tpolyfillCurrentSrc(ofi.img);\n\n\tel.style.backgroundImage = \"url(\\\"\" + ((ofi.img.currentSrc || ofi.img.src).replace(/\"/g, '\\\\\"')) + \"\\\")\";\n\tel.style.backgroundPosition = style['object-position'] || 'center';\n\tel.style.backgroundRepeat = 'no-repeat';\n\tel.style.backgroundOrigin = 'content-box';\n\n\tif (/scale-down/.test(style['object-fit'])) {\n\t\tonImageReady(ofi.img, function () {\n\t\t\tif (ofi.img.naturalWidth > el.width || ofi.img.naturalHeight > el.height) {\n\t\t\t\tel.style.backgroundSize = 'contain';\n\t\t\t} else {\n\t\t\t\tel.style.backgroundSize = 'auto';\n\t\t\t}\n\t\t});\n\t} else {\n\t\tel.style.backgroundSize = style['object-fit'].replace('none', 'auto').replace('fill', '100% 100%');\n\t}\n\n\tonImageReady(ofi.img, function (img) {\n\t\tsetPlaceholder(el, img.naturalWidth, img.naturalHeight);\n\t});\n}\n\nfunction keepSrcUsable(el) {\n\tvar descriptors = {\n\t\tget: function get(prop) {\n\t\t\treturn el[OFI].img[prop ? prop : 'src'];\n\t\t},\n\t\tset: function set(value, prop) {\n\t\t\tel[OFI].img[prop ? prop : 'src'] = value;\n\t\t\tnativeSetAttribute.call(el, (\"data-ofi-\" + prop), value); // preserve for any future cloneNode\n\t\t\tfixOne(el);\n\t\t\treturn value;\n\t\t}\n\t};\n\tObject.defineProperty(el, 'src', descriptors);\n\tObject.defineProperty(el, 'currentSrc', {\n\t\tget: function () { return descriptors.get('currentSrc'); }\n\t});\n\tObject.defineProperty(el, 'srcset', {\n\t\tget: function () { return descriptors.get('srcset'); },\n\t\tset: function (ss) { return descriptors.set(ss, 'srcset'); }\n\t});\n}\n\nfunction hijackAttributes() {\n\tfunction getOfiImageMaybe(el, name) {\n\t\treturn el[OFI] && el[OFI].img && (name === 'src' || name === 'srcset') ? el[OFI].img : el;\n\t}\n\tif (!supportsObjectPosition) {\n\t\tHTMLImageElement.prototype.getAttribute = function (name) {\n\t\t\treturn nativeGetAttribute.call(getOfiImageMaybe(this, name), name);\n\t\t};\n\n\t\tHTMLImageElement.prototype.setAttribute = function (name, value) {\n\t\t\treturn nativeSetAttribute.call(getOfiImageMaybe(this, name), name, String(value));\n\t\t};\n\t}\n}\n\nfunction fix(imgs, opts) {\n\tvar startAutoMode = !autoModeEnabled && !imgs;\n\topts = opts || {};\n\timgs = imgs || 'img';\n\n\tif ((supportsObjectPosition && !opts.skipTest) || !supportsOFI) {\n\t\treturn false;\n\t}\n\n\t// use imgs as a selector or just select all images\n\tif (imgs === 'img') {\n\t\timgs = document.getElementsByTagName('img');\n\t} else if (typeof imgs === 'string') {\n\t\timgs = document.querySelectorAll(imgs);\n\t} else if (!('length' in imgs)) {\n\t\timgs = [imgs];\n\t}\n\n\t// apply fix to all\n\tfor (var i = 0; i < imgs.length; i++) {\n\t\timgs[i][OFI] = imgs[i][OFI] || {\n\t\t\tskipTest: opts.skipTest\n\t\t};\n\t\tfixOne(imgs[i]);\n\t}\n\n\tif (startAutoMode) {\n\t\tdocument.body.addEventListener('load', function (e) {\n\t\t\tif (e.target.tagName === 'IMG') {\n\t\t\t\tfix(e.target, {\n\t\t\t\t\tskipTest: opts.skipTest\n\t\t\t\t});\n\t\t\t}\n\t\t}, true);\n\t\tautoModeEnabled = true;\n\t\timgs = 'img'; // reset to a generic selector for watchMQ\n\t}\n\n\t// if requested, watch media queries for object-fit change\n\tif (opts.watchMQ) {\n\t\twindow.addEventListener('resize', fix.bind(null, imgs, {\n\t\t\tskipTest: opts.skipTest\n\t\t}));\n\t}\n}\n\nfix.supportsObjectFit = supportsObjectFit;\nfix.supportsObjectPosition = supportsObjectPosition;\n\nhijackAttributes();\n\nmodule.exports = fix;\n","/**\n * Object Fit Videos\n * Polyfill for object-fit and object-position CSS properties on video elements\n * Covers IE9, IE10, IE11, Edge, Safari <10\n *\n * Usage\n * In your CSS, add a special font-family tag for IE/Edge\n * video {\n *   object-fit: cover;\n *   font-family: 'object-fit: cover;';\n * }\n *\n * Before the closing body tag, or whenever the DOM is ready,\n * make the JavaScript call\n * objectFitVideos();\n *\n * All video elements with the special CSS property will be targeted\n *\n * @license  MIT (https://opensource.org/licenses/MIT)\n * @author   Todd Miller <todd.miller@tricomb2b.com>\n * @version  1.0.2\n * @changelog\n * 2016-08-19 - Adds object-position support.\n * 2016-08-19 - Add throttle function for more performant resize events\n * 2016-08-19 - Initial release with object-fit support, and\n *              object-position default 'center'\n * 2016-10-14 - No longer relies on window load event, instead requires a specific\n *              function call to initialize the videos for object fit and position.\n * 2016-11-28 - Support CommonJS environment, courtesy of @msorensson\n * 2016-12-05 - Refactors the throttling function to support IE\n * 2017-09-26 - Fix an issue with autplay not working on polyfilled videos\n *            - Adds the capability to specify elements to polyfill,\n *              instead of just checking every video element for the\n *              CSS property. Slight performance gain in most usecases,\n *              and a bigger gain in a few usecases.\n * 2017-10-24 - Add user agent check to enable polyfill for all Edge browsers.\n *              object-fit is supported on Edge >= 16, but currently just for images.\n */\nvar objectFitVideos = function (videos) {\n  'use strict';\n\n  var isEdge = navigator.userAgent.indexOf('Edge/') >= 0;\n\n  var testImg                = new Image(),\n      supportsObjectFit      = 'object-fit' in testImg.style && !isEdge,\n      supportsObjectPosition = 'object-position' in testImg.style && !isEdge,\n      propRegex              = /(object-fit|object-position)\\s*:\\s*([-\\w\\s%]+)/g;\n\n  if (!supportsObjectFit || !supportsObjectPosition) {\n    initialize(videos);\n    throttle('resize', 'optimizedResize');\n  }\n\n  /**\n   * Parse the style and look for the special font-family tag\n   * @param  {object} $el The element to parse\n   * @return {object}     The font-family properties we're interested in\n   */\n  function getStyle ($el) {\n    var style  = getComputedStyle($el).fontFamily,\n        parsed = null,\n        props  = {};\n\n      while ((parsed = propRegex.exec(style)) !== null) {\n        props[parsed[1]] = parsed[2];\n      }\n\n      if (props['object-position'])\n        return parsePosition(props);\n\n      return props;\n  }\n\n  /**\n   * Initialize all the relevant video elements and get them fitted\n   */\n  function initialize (videos) {\n    var index = -1;\n\n    if (!videos) {\n      // if no videos given, query all video elements\n      videos = document.querySelectorAll('video');\n    } else if (!('length' in videos)) {\n      // convert to an array for proper looping if an array or NodeList\n      // was not given\n      videos = [videos];\n    }\n\n    while (videos[++index]) {\n      var style = getStyle(videos[index]);\n\n      // only do work if the property is on the element\n      if (style['object-fit'] || style['object-position']) {\n        // set the default values\n        style['object-fit'] = style['object-fit'] || 'fill';\n        fitIt(videos[index], style);\n      }\n    }\n  }\n\n  /**\n   * Object Fit\n   * @param  {object} $el Element to fit\n   * @return {object}     The element's relevant properties\n   */\n  function fitIt ($el, style) {\n    // fill is the default behavior, no action is necessary\n    if (style['object-fit'] === 'fill')\n      return;\n\n    // convenience style properties on the source element\n    var setCss = $el.style,\n        getCss = window.getComputedStyle($el);\n\n    // create and insert a wrapper element\n    var $wrap = document.createElement('object-fit');\n    $wrap.appendChild($el.parentNode.replaceChild($wrap, $el));\n\n    // style the wrapper element to mostly match the source element\n    var wrapCss = {\n      height:    '100%',\n      width:     '100%',\n      boxSizing: 'content-box',\n      display:   'inline-block',\n      overflow:  'hidden'\n    };\n\n    'backgroundColor backgroundImage borderColor borderStyle borderWidth bottom fontSize lineHeight left opacity margin position right top visibility'.replace(/\\w+/g, function (key) {\n      wrapCss[key] = getCss[key];\n    });\n\n    for (var key in wrapCss)\n      $wrap.style[key] = wrapCss[key];\n\n    // give the source element some saner styles\n    setCss.border  = setCss.margin = setCss.padding = 0;\n    setCss.display = 'block';\n    setCss.opacity = 1;\n\n    // set up the event handlers\n    $el.addEventListener('loadedmetadata', doWork);\n    window.addEventListener('optimizedResize', doWork);\n\n    // we may have missed the loadedmetadata event, so if the video has loaded\n    // enough data, just drop the event listener and execute\n    if ($el.readyState >= 1) {\n      $el.removeEventListener('loadedmetadata', doWork);\n      doWork();\n    }\n\n    /**\n     * Do the actual sizing. Math.\n     * @methodOf fitIt\n     */\n    function doWork () {\n      // the actual size and ratio of the video\n      // we do this here, even though it doesn't change, because\n      // at this point we can be sure the metadata has loaded\n      var videoWidth  = $el.videoWidth,\n          videoHeight = $el.videoHeight,\n          videoRatio  = videoWidth / videoHeight;\n\n      var wrapWidth  = $wrap.clientWidth,\n          wrapHeight = $wrap.clientHeight,\n          wrapRatio  = wrapWidth / wrapHeight;\n\n      var newHeight = 0,\n          newWidth  = 0;\n      setCss.marginLeft = setCss.marginTop = 0;\n\n      // basically we do the opposite action for contain and cover,\n      // depending on whether the video aspect ratio is less than or\n      // greater than the wrapper's aspect ratio\n      if (videoRatio < wrapRatio ?\n          style['object-fit'] === 'contain' : style['object-fit'] === 'cover') {\n        newHeight = wrapHeight * videoRatio;\n        newWidth  = wrapWidth / videoRatio;\n\n        setCss.width  = Math.round(newHeight) + 'px';\n        setCss.height = wrapHeight + 'px';\n\n        if (style['object-position-x'] === 'left')\n          setCss.marginLeft = 0;\n        else if (style['object-position-x'] === 'right')\n          setCss.marginLeft = Math.round(wrapWidth - newHeight) + 'px';\n        else\n          setCss.marginLeft = Math.round((wrapWidth - newHeight) / 2) + 'px';\n      } else {\n        newWidth = wrapWidth / videoRatio;\n\n        setCss.width     = wrapWidth + 'px';\n        setCss.height    = Math.round(newWidth) + 'px';\n\n        if (style['object-position-y'] === 'top')\n          setCss.marginTop = 0;\n        else if (style['object-position-y'] === 'bottom')\n          setCss.marginTop = Math.round(wrapHeight - newWidth) + 'px';\n        else\n          setCss.marginTop = Math.round((wrapHeight - newWidth) / 2) + 'px';\n      }\n\n      // play the video if autoplay is set\n      if ($el.autoplay)\n        $el.play();\n    }\n  }\n\n  /**\n   * Split the object-position property into x and y position properties\n   * @param  {object} style Relevant element styles\n   * @return {object}       The style object with the added x and y props\n   */\n  function parsePosition (style) {\n    if (~style['object-position'].indexOf('left'))\n      style['object-position-x'] = 'left';\n    else if (~style['object-position'].indexOf('right'))\n      style['object-position-x'] = 'right';\n    else\n      style['object-position-x'] = 'center';\n\n    if (~style['object-position'].indexOf('top'))\n      style['object-position-y'] = 'top';\n    else if (~style['object-position'].indexOf('bottom'))\n      style['object-position-y'] = 'bottom';\n    else\n      style['object-position-y'] = 'center';\n\n    return style;\n  }\n\n  /**\n   * Throttle an event with RequestAnimationFrame API for better performance\n   * @param  {string} type The event to throttle\n   * @param  {string} name Custom event name to listen for\n   * @param  {object} obj  Optional object to attach the event to\n   */\n  function throttle (type, name, obj) {\n    obj = obj || window;\n    var running = false,\n        evt     = null;\n\n    // IE does not support the CustomEvent constructor\n    // so if that fails do it the old way\n    try {\n      evt = new CustomEvent(name);\n    } catch (e) {\n      evt = document.createEvent('Event');\n      evt.initEvent(name, true, true);\n    }\n\n    var func = function () {\n      if (running) return;\n\n      running = true;\n      requestAnimationFrame(function () {\n        obj.dispatchEvent(evt);\n        running = false;\n      });\n    };\n\n    obj.addEventListener(type, func);\n  }\n};\n\nif (typeof module !== 'undefined' && typeof module.exports !== 'undefined')\n  module.exports = objectFitVideos;\n","/*! picturefill - v3.0.2 - 2016-02-12\n * https://scottjehl.github.io/picturefill/\n * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT\n */\n/*! Gecko-Picture - v1.0\n * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture\n * Firefox's early picture implementation (prior to FF41) is static and does\n * not react to viewport changes. This tiny module fixes this.\n */\n(function(window) {\n\t/*jshint eqnull:true */\n\tvar ua = navigator.userAgent;\n\n\tif ( window.HTMLPictureElement && ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 < 45) ) {\n\t\taddEventListener(\"resize\", (function() {\n\t\t\tvar timer;\n\n\t\t\tvar dummySrc = document.createElement(\"source\");\n\n\t\t\tvar fixRespimg = function(img) {\n\t\t\t\tvar source, sizes;\n\t\t\t\tvar picture = img.parentNode;\n\n\t\t\t\tif (picture.nodeName.toUpperCase() === \"PICTURE\") {\n\t\t\t\t\tsource = dummySrc.cloneNode();\n\n\t\t\t\t\tpicture.insertBefore(source, picture.firstElementChild);\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\tpicture.removeChild(source);\n\t\t\t\t\t});\n\t\t\t\t} else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) {\n\t\t\t\t\timg._pfLastSize = img.offsetWidth;\n\t\t\t\t\tsizes = img.sizes;\n\t\t\t\t\timg.sizes += \",100vw\";\n\t\t\t\t\tsetTimeout(function() {\n\t\t\t\t\t\timg.sizes = sizes;\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar findPictureImgs = function() {\n\t\t\t\tvar i;\n\t\t\t\tvar imgs = document.querySelectorAll(\"picture > img, img[srcset][sizes]\");\n\t\t\t\tfor (i = 0; i < imgs.length; i++) {\n\t\t\t\t\tfixRespimg(imgs[i]);\n\t\t\t\t}\n\t\t\t};\n\t\t\tvar onResize = function() {\n\t\t\t\tclearTimeout(timer);\n\t\t\t\ttimer = setTimeout(findPictureImgs, 99);\n\t\t\t};\n\t\t\tvar mq = window.matchMedia && matchMedia(\"(orientation: landscape)\");\n\t\t\tvar init = function() {\n\t\t\t\tonResize();\n\n\t\t\t\tif (mq && mq.addListener) {\n\t\t\t\t\tmq.addListener(onResize);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tdummySrc.srcset = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\n\t\t\tif (/^[c|i]|d$/.test(document.readyState || \"\")) {\n\t\t\t\tinit();\n\t\t\t} else {\n\t\t\t\tdocument.addEventListener(\"DOMContentLoaded\", init);\n\t\t\t}\n\n\t\t\treturn onResize;\n\t\t})());\n\t}\n})(window);\n\n/*! Picturefill - v3.0.2\n * http://scottjehl.github.io/picturefill\n * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt;\n *  License: MIT\n */\n\n(function( window, document, undefined ) {\n\t// Enable strict mode\n\t\"use strict\";\n\n\t// HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround)\n\tdocument.createElement( \"picture\" );\n\n\tvar warn, eminpx, alwaysCheckWDescriptor, evalId;\n\t// local object for method references and testing exposure\n\tvar pf = {};\n\tvar isSupportTestReady = false;\n\tvar noop = function() {};\n\tvar image = document.createElement( \"img\" );\n\tvar getImgAttr = image.getAttribute;\n\tvar setImgAttr = image.setAttribute;\n\tvar removeImgAttr = image.removeAttribute;\n\tvar docElem = document.documentElement;\n\tvar types = {};\n\tvar cfg = {\n\t\t//resource selection:\n\t\talgorithm: \"\"\n\t};\n\tvar srcAttr = \"data-pfsrc\";\n\tvar srcsetAttr = srcAttr + \"set\";\n\t// ua sniffing is done for undetectable img loading features,\n\t// to do some non crucial perf optimizations\n\tvar ua = navigator.userAgent;\n\tvar supportAbort = (/rident/).test(ua) || ((/ecko/).test(ua) && ua.match(/rv\\:(\\d+)/) && RegExp.$1 > 35 );\n\tvar curSrcProp = \"currentSrc\";\n\tvar regWDesc = /\\s+\\+?\\d+(e\\d+)?w/;\n\tvar regSize = /(\\([^)]+\\))?\\s*(.+)/;\n\tvar setOptions = window.picturefillCFG;\n\t/**\n\t * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests )\n\t */\n\t// baseStyle also used by getEmValue (i.e.: width: 1em is important)\n\tvar baseStyle = \"position:absolute;left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)\";\n\tvar fsCss = \"font-size:100%!important;\";\n\tvar isVwDirty = true;\n\n\tvar cssCache = {};\n\tvar sizeLengthCache = {};\n\tvar DPR = window.devicePixelRatio;\n\tvar units = {\n\t\tpx: 1,\n\t\t\"in\": 96\n\t};\n\tvar anchor = document.createElement( \"a\" );\n\t/**\n\t * alreadyRun flag used for setOptions. is it true setOptions will reevaluate\n\t * @type {boolean}\n\t */\n\tvar alreadyRun = false;\n\n\t// Reusable, non-\"g\" Regexes\n\n\t// (Don't use \\s, to avoid matching non-breaking space.)\n\tvar regexLeadingSpaces = /^[ \\t\\n\\r\\u000c]+/,\n\t    regexLeadingCommasOrSpaces = /^[, \\t\\n\\r\\u000c]+/,\n\t    regexLeadingNotSpaces = /^[^ \\t\\n\\r\\u000c]+/,\n\t    regexTrailingCommas = /[,]+$/,\n\t    regexNonNegativeInteger = /^\\d+$/,\n\n\t    // ( Positive or negative or unsigned integers or decimals, without or without exponents.\n\t    // Must include at least one digit.\n\t    // According to spec tests any decimal point must be followed by a digit.\n\t    // No leading plus sign is allowed.)\n\t    // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number\n\t    regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/;\n\n\tvar on = function(obj, evt, fn, capture) {\n\t\tif ( obj.addEventListener ) {\n\t\t\tobj.addEventListener(evt, fn, capture || false);\n\t\t} else if ( obj.attachEvent ) {\n\t\t\tobj.attachEvent( \"on\" + evt, fn);\n\t\t}\n\t};\n\n\t/**\n\t * simple memoize function:\n\t */\n\n\tvar memoize = function(fn) {\n\t\tvar cache = {};\n\t\treturn function(input) {\n\t\t\tif ( !(input in cache) ) {\n\t\t\t\tcache[ input ] = fn(input);\n\t\t\t}\n\t\t\treturn cache[ input ];\n\t\t};\n\t};\n\n\t// UTILITY FUNCTIONS\n\n\t// Manual is faster than RegEx\n\t// http://jsperf.com/whitespace-character/5\n\tfunction isSpace(c) {\n\t\treturn (c === \"\\u0020\" || // space\n\t\t        c === \"\\u0009\" || // horizontal tab\n\t\t        c === \"\\u000A\" || // new line\n\t\t        c === \"\\u000C\" || // form feed\n\t\t        c === \"\\u000D\");  // carriage return\n\t}\n\n\t/**\n\t * gets a mediaquery and returns a boolean or gets a css length and returns a number\n\t * @param css mediaqueries or css length\n\t * @returns {boolean|number}\n\t *\n\t * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738\n\t */\n\tvar evalCSS = (function() {\n\n\t\tvar regLength = /^([\\d\\.]+)(em|vw|px)$/;\n\t\tvar replace = function() {\n\t\t\tvar args = arguments, index = 0, string = args[0];\n\t\t\twhile (++index in args) {\n\t\t\t\tstring = string.replace(args[index], args[++index]);\n\t\t\t}\n\t\t\treturn string;\n\t\t};\n\n\t\tvar buildStr = memoize(function(css) {\n\n\t\t\treturn \"return \" + replace((css || \"\").toLowerCase(),\n\t\t\t\t// interpret `and`\n\t\t\t\t/\\band\\b/g, \"&&\",\n\n\t\t\t\t// interpret `,`\n\t\t\t\t/,/g, \"||\",\n\n\t\t\t\t// interpret `min-` as >=\n\t\t\t\t/min-([a-z-\\s]+):/g, \"e.$1>=\",\n\n\t\t\t\t// interpret `max-` as <=\n\t\t\t\t/max-([a-z-\\s]+):/g, \"e.$1<=\",\n\n\t\t\t\t//calc value\n\t\t\t\t/calc([^)]+)/g, \"($1)\",\n\n\t\t\t\t// interpret css values\n\t\t\t\t/(\\d+[\\.]*[\\d]*)([a-z]+)/g, \"($1 * e.$2)\",\n\t\t\t\t//make eval less evil\n\t\t\t\t/^(?!(e.[a-z]|[0-9\\.&=|><\\+\\-\\*\\(\\)\\/])).*/ig, \"\"\n\t\t\t) + \";\";\n\t\t});\n\n\t\treturn function(css, length) {\n\t\t\tvar parsedLength;\n\t\t\tif (!(css in cssCache)) {\n\t\t\t\tcssCache[css] = false;\n\t\t\t\tif (length && (parsedLength = css.match( regLength ))) {\n\t\t\t\t\tcssCache[css] = parsedLength[ 1 ] * units[parsedLength[ 2 ]];\n\t\t\t\t} else {\n\t\t\t\t\t/*jshint evil:true */\n\t\t\t\t\ttry{\n\t\t\t\t\t\tcssCache[css] = new Function(\"e\", buildStr(css))(units);\n\t\t\t\t\t} catch(e) {}\n\t\t\t\t\t/*jshint evil:false */\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn cssCache[css];\n\t\t};\n\t})();\n\n\tvar setResolution = function( candidate, sizesattr ) {\n\t\tif ( candidate.w ) { // h = means height: || descriptor.type === 'h' do not handle yet...\n\t\t\tcandidate.cWidth = pf.calcListLength( sizesattr || \"100vw\" );\n\t\t\tcandidate.res = candidate.w / candidate.cWidth ;\n\t\t} else {\n\t\t\tcandidate.res = candidate.d;\n\t\t}\n\t\treturn candidate;\n\t};\n\n\t/**\n\t *\n\t * @param opt\n\t */\n\tvar picturefill = function( opt ) {\n\n\t\tif (!isSupportTestReady) {return;}\n\n\t\tvar elements, i, plen;\n\n\t\tvar options = opt || {};\n\n\t\tif ( options.elements && options.elements.nodeType === 1 ) {\n\t\t\tif ( options.elements.nodeName.toUpperCase() === \"IMG\" ) {\n\t\t\t\toptions.elements =  [ options.elements ];\n\t\t\t} else {\n\t\t\t\toptions.context = options.elements;\n\t\t\t\toptions.elements =  null;\n\t\t\t}\n\t\t}\n\n\t\telements = options.elements || pf.qsa( (options.context || document), ( options.reevaluate || options.reselect ) ? pf.sel : pf.selShort );\n\n\t\tif ( (plen = elements.length) ) {\n\n\t\t\tpf.setupRun( options );\n\t\t\talreadyRun = true;\n\n\t\t\t// Loop through all elements\n\t\t\tfor ( i = 0; i < plen; i++ ) {\n\t\t\t\tpf.fillImg(elements[ i ], options);\n\t\t\t}\n\n\t\t\tpf.teardownRun( options );\n\t\t}\n\t};\n\n\t/**\n\t * outputs a warning for the developer\n\t * @param {message}\n\t * @type {Function}\n\t */\n\twarn = ( window.console && console.warn ) ?\n\t\tfunction( message ) {\n\t\t\tconsole.warn( message );\n\t\t} :\n\t\tnoop\n\t;\n\n\tif ( !(curSrcProp in image) ) {\n\t\tcurSrcProp = \"src\";\n\t}\n\n\t// Add support for standard mime types.\n\ttypes[ \"image/jpeg\" ] = true;\n\ttypes[ \"image/gif\" ] = true;\n\ttypes[ \"image/png\" ] = true;\n\n\tfunction detectTypeSupport( type, typeUri ) {\n\t\t// based on Modernizr's lossless img-webp test\n\t\t// note: asynchronous\n\t\tvar image = new window.Image();\n\t\timage.onerror = function() {\n\t\t\ttypes[ type ] = false;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.onload = function() {\n\t\t\ttypes[ type ] = image.width === 1;\n\t\t\tpicturefill();\n\t\t};\n\t\timage.src = typeUri;\n\t\treturn \"pending\";\n\t}\n\n\t// test svg support\n\ttypes[ \"image/svg+xml\" ] = document.implementation.hasFeature( \"http://www.w3.org/TR/SVG11/feature#Image\", \"1.1\" );\n\n\t/**\n\t * updates the internal vW property with the current viewport width in px\n\t */\n\tfunction updateMetrics() {\n\n\t\tisVwDirty = false;\n\t\tDPR = window.devicePixelRatio;\n\t\tcssCache = {};\n\t\tsizeLengthCache = {};\n\n\t\tpf.DPR = DPR || 1;\n\n\t\tunits.width = Math.max(window.innerWidth || 0, docElem.clientWidth);\n\t\tunits.height = Math.max(window.innerHeight || 0, docElem.clientHeight);\n\n\t\tunits.vw = units.width / 100;\n\t\tunits.vh = units.height / 100;\n\n\t\tevalId = [ units.height, units.width, DPR ].join(\"-\");\n\n\t\tunits.em = pf.getEmValue();\n\t\tunits.rem = units.em;\n\t}\n\n\tfunction chooseLowRes( lowerValue, higherValue, dprValue, isCached ) {\n\t\tvar bonusFactor, tooMuch, bonus, meanDensity;\n\n\t\t//experimental\n\t\tif (cfg.algorithm === \"saveData\" ){\n\t\t\tif ( lowerValue > 2.7 ) {\n\t\t\t\tmeanDensity = dprValue + 1;\n\t\t\t} else {\n\t\t\t\ttooMuch = higherValue - dprValue;\n\t\t\t\tbonusFactor = Math.pow(lowerValue - 0.6, 1.5);\n\n\t\t\t\tbonus = tooMuch * bonusFactor;\n\n\t\t\t\tif (isCached) {\n\t\t\t\t\tbonus += 0.1 * bonusFactor;\n\t\t\t\t}\n\n\t\t\t\tmeanDensity = lowerValue + bonus;\n\t\t\t}\n\t\t} else {\n\t\t\tmeanDensity = (dprValue > 1) ?\n\t\t\t\tMath.sqrt(lowerValue * higherValue) :\n\t\t\t\tlowerValue;\n\t\t}\n\n\t\treturn meanDensity > dprValue;\n\t}\n\n\tfunction applyBestCandidate( img ) {\n\t\tvar srcSetCandidates;\n\t\tvar matchingSet = pf.getSet( img );\n\t\tvar evaluated = false;\n\t\tif ( matchingSet !== \"pending\" ) {\n\t\t\tevaluated = evalId;\n\t\t\tif ( matchingSet ) {\n\t\t\t\tsrcSetCandidates = pf.setRes( matchingSet );\n\t\t\t\tpf.applySetCandidate( srcSetCandidates, img );\n\t\t\t}\n\t\t}\n\t\timg[ pf.ns ].evaled = evaluated;\n\t}\n\n\tfunction ascendingSort( a, b ) {\n\t\treturn a.res - b.res;\n\t}\n\n\tfunction setSrcToCur( img, src, set ) {\n\t\tvar candidate;\n\t\tif ( !set && src ) {\n\t\t\tset = img[ pf.ns ].sets;\n\t\t\tset = set && set[set.length - 1];\n\t\t}\n\n\t\tcandidate = getCandidateForSrc(src, set);\n\n\t\tif ( candidate ) {\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\timg[ pf.ns ].curSrc = src;\n\t\t\timg[ pf.ns ].curCan = candidate;\n\n\t\t\tif ( !candidate.res ) {\n\t\t\t\tsetResolution( candidate, candidate.set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getCandidateForSrc( src, set ) {\n\t\tvar i, candidate, candidates;\n\t\tif ( src && set ) {\n\t\t\tcandidates = pf.parseSet( set );\n\t\t\tsrc = pf.makeUrl(src);\n\t\t\tfor ( i = 0; i < candidates.length; i++ ) {\n\t\t\t\tif ( src === pf.makeUrl(candidates[ i ].url) ) {\n\t\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn candidate;\n\t}\n\n\tfunction getAllSourceElements( picture, candidates ) {\n\t\tvar i, len, source, srcset;\n\n\t\t// SPEC mismatch intended for size and perf:\n\t\t// actually only source elements preceding the img should be used\n\t\t// also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector\n\t\tvar sources = picture.getElementsByTagName( \"source\" );\n\n\t\tfor ( i = 0, len = sources.length; i < len; i++ ) {\n\t\t\tsource = sources[ i ];\n\t\t\tsource[ pf.ns ] = true;\n\t\t\tsrcset = source.getAttribute( \"srcset\" );\n\n\t\t\t// if source does not have a srcset attribute, skip\n\t\t\tif ( srcset ) {\n\t\t\t\tcandidates.push( {\n\t\t\t\t\tsrcset: srcset,\n\t\t\t\t\tmedia: source.getAttribute( \"media\" ),\n\t\t\t\t\ttype: source.getAttribute( \"type\" ),\n\t\t\t\t\tsizes: source.getAttribute( \"sizes\" )\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Srcset Parser\n\t * By Alex Bell |  MIT License\n\t *\n\t * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...]\n\t *\n\t * Based super duper closely on the reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute\n\t */\n\n\t// 1. Let input be the value passed to this algorithm.\n\t// (TO-DO : Explain what \"set\" argument is here. Maybe choose a more\n\t// descriptive & more searchable name.  Since passing the \"set\" in really has\n\t// nothing to do with parsing proper, I would prefer this assignment eventually\n\t// go in an external fn.)\n\tfunction parseSrcset(input, set) {\n\n\t\tfunction collectCharacters(regEx) {\n\t\t\tvar chars,\n\t\t\t    match = regEx.exec(input.substring(pos));\n\t\t\tif (match) {\n\t\t\t\tchars = match[ 0 ];\n\t\t\t\tpos += chars.length;\n\t\t\t\treturn chars;\n\t\t\t}\n\t\t}\n\n\t\tvar inputLength = input.length,\n\t\t    url,\n\t\t    descriptors,\n\t\t    currentDescriptor,\n\t\t    state,\n\t\t    c,\n\n\t\t    // 2. Let position be a pointer into input, initially pointing at the start\n\t\t    //    of the string.\n\t\t    pos = 0,\n\n\t\t    // 3. Let candidates be an initially empty source set.\n\t\t    candidates = [];\n\n\t\t/**\n\t\t* Adds descriptor properties to a candidate, pushes to the candidates array\n\t\t* @return undefined\n\t\t*/\n\t\t// (Declared outside of the while loop so that it's only created once.\n\t\t// (This fn is defined before it is used, in order to pass JSHINT.\n\t\t// Unfortunately this breaks the sequencing of the spec comments. :/ )\n\t\tfunction parseDescriptors() {\n\n\t\t\t// 9. Descriptor parser: Let error be no.\n\t\t\tvar pError = false,\n\n\t\t\t// 10. Let width be absent.\n\t\t\t// 11. Let density be absent.\n\t\t\t// 12. Let future-compat-h be absent. (We're implementing it now as h)\n\t\t\t    w, d, h, i,\n\t\t\t    candidate = {},\n\t\t\t    desc, lastChar, value, intVal, floatVal;\n\n\t\t\t// 13. For each descriptor in descriptors, run the appropriate set of steps\n\t\t\t// from the following list:\n\t\t\tfor (i = 0 ; i < descriptors.length; i++) {\n\t\t\t\tdesc = descriptors[ i ];\n\n\t\t\t\tlastChar = desc[ desc.length - 1 ];\n\t\t\t\tvalue = desc.substring(0, desc.length - 1);\n\t\t\t\tintVal = parseInt(value, 10);\n\t\t\t\tfloatVal = parseFloat(value);\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0077 LATIN SMALL LETTER W character\n\t\t\t\tif (regexNonNegativeInteger.test(value) && (lastChar === \"w\")) {\n\n\t\t\t\t\t// If width and density are not both absent, then let error be yes.\n\t\t\t\t\tif (w || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes.\n\t\t\t\t\t// Otherwise, let width be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {w = intVal;}\n\n\t\t\t\t// If the descriptor consists of a valid floating-point number followed by\n\t\t\t\t// a U+0078 LATIN SMALL LETTER X character\n\t\t\t\t} else if (regexFloatingPoint.test(value) && (lastChar === \"x\")) {\n\n\t\t\t\t\t// If width, density and future-compat-h are not all absent, then let error\n\t\t\t\t\t// be yes.\n\t\t\t\t\tif (w || d || h) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing floating-point number values to the descriptor.\n\t\t\t\t\t// If the result is less than zero, let error be yes. Otherwise, let density\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (floatVal < 0) {pError = true;} else {d = floatVal;}\n\n\t\t\t\t// If the descriptor consists of a valid non-negative integer followed by\n\t\t\t\t// a U+0068 LATIN SMALL LETTER H character\n\t\t\t\t} else if (regexNonNegativeInteger.test(value) && (lastChar === \"h\")) {\n\n\t\t\t\t\t// If height and density are not both absent, then let error be yes.\n\t\t\t\t\tif (h || d) {pError = true;}\n\n\t\t\t\t\t// Apply the rules for parsing non-negative integers to the descriptor.\n\t\t\t\t\t// If the result is zero, let error be yes. Otherwise, let future-compat-h\n\t\t\t\t\t// be the result.\n\t\t\t\t\tif (intVal === 0) {pError = true;} else {h = intVal;}\n\n\t\t\t\t// Anything else, Let error be yes.\n\t\t\t\t} else {pError = true;}\n\t\t\t} // (close step 13 for loop)\n\n\t\t\t// 15. If error is still no, then append a new image source to candidates whose\n\t\t\t// URL is url, associated with a width width if not absent and a pixel\n\t\t\t// density density if not absent. Otherwise, there is a parse error.\n\t\t\tif (!pError) {\n\t\t\t\tcandidate.url = url;\n\n\t\t\t\tif (w) { candidate.w = w;}\n\t\t\t\tif (d) { candidate.d = d;}\n\t\t\t\tif (h) { candidate.h = h;}\n\t\t\t\tif (!h && !d && !w) {candidate.d = 1;}\n\t\t\t\tif (candidate.d === 1) {set.has1x = true;}\n\t\t\t\tcandidate.set = set;\n\n\t\t\t\tcandidates.push(candidate);\n\t\t\t}\n\t\t} // (close parseDescriptors fn)\n\n\t\t/**\n\t\t* Tokenizes descriptor properties prior to parsing\n\t\t* Returns undefined.\n\t\t* (Again, this fn is defined before it is used, in order to pass JSHINT.\n\t\t* Unfortunately this breaks the logical sequencing of the spec comments. :/ )\n\t\t*/\n\t\tfunction tokenize() {\n\n\t\t\t// 8.1. Descriptor tokeniser: Skip whitespace\n\t\t\tcollectCharacters(regexLeadingSpaces);\n\n\t\t\t// 8.2. Let current descriptor be the empty string.\n\t\t\tcurrentDescriptor = \"\";\n\n\t\t\t// 8.3. Let state be in descriptor.\n\t\t\tstate = \"in descriptor\";\n\n\t\t\twhile (true) {\n\n\t\t\t\t// 8.4. Let c be the character at position.\n\t\t\t\tc = input.charAt(pos);\n\n\t\t\t\t//  Do the following depending on the value of state.\n\t\t\t\t//  For the purpose of this step, \"EOF\" is a special character representing\n\t\t\t\t//  that position is past the end of input.\n\n\t\t\t\t// In descriptor\n\t\t\t\tif (state === \"in descriptor\") {\n\t\t\t\t\t// Do the following, depending on the value of c:\n\n\t\t\t\t  // Space character\n\t\t\t\t  // If current descriptor is not empty, append current descriptor to\n\t\t\t\t  // descriptors and let current descriptor be the empty string.\n\t\t\t\t  // Set state to after descriptor.\n\t\t\t\t\tif (isSpace(c)) {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t\tcurrentDescriptor = \"\";\n\t\t\t\t\t\t\tstate = \"after descriptor\";\n\t\t\t\t\t\t}\n\n\t\t\t\t\t// U+002C COMMA (,)\n\t\t\t\t\t// Advance position to the next character in input. If current descriptor\n\t\t\t\t\t// is not empty, append current descriptor to descriptors. Jump to the step\n\t\t\t\t\t// labeled descriptor parser.\n\t\t\t\t\t} else if (c === \",\") {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// U+0028 LEFT PARENTHESIS (()\n\t\t\t\t\t// Append c to current descriptor. Set state to in parens.\n\t\t\t\t\t} else if (c === \"\\u0028\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in parens\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// If current descriptor is not empty, append current descriptor to\n\t\t\t\t\t// descriptors. Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tif (currentDescriptor) {\n\t\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\t\t\t\t// (end \"in descriptor\"\n\n\t\t\t\t// In parens\n\t\t\t\t} else if (state === \"in parens\") {\n\n\t\t\t\t\t// U+0029 RIGHT PARENTHESIS ())\n\t\t\t\t\t// Append c to current descriptor. Set state to in descriptor.\n\t\t\t\t\tif (c === \")\") {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t\tstate = \"in descriptor\";\n\n\t\t\t\t\t// EOF\n\t\t\t\t\t// Append current descriptor to descriptors. Jump to the step labeled\n\t\t\t\t\t// descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tdescriptors.push(currentDescriptor);\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Append c to current descriptor.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tcurrentDescriptor = currentDescriptor + c;\n\t\t\t\t\t}\n\n\t\t\t\t// After descriptor\n\t\t\t\t} else if (state === \"after descriptor\") {\n\n\t\t\t\t\t// Do the following, depending on the value of c:\n\t\t\t\t\t// Space character: Stay in this state.\n\t\t\t\t\tif (isSpace(c)) {\n\n\t\t\t\t\t// EOF: Jump to the step labeled descriptor parser.\n\t\t\t\t\t} else if (c === \"\") {\n\t\t\t\t\t\tparseDescriptors();\n\t\t\t\t\t\treturn;\n\n\t\t\t\t\t// Anything else\n\t\t\t\t\t// Set state to in descriptor. Set position to the previous character in input.\n\t\t\t\t\t} else {\n\t\t\t\t\t\tstate = \"in descriptor\";\n\t\t\t\t\t\tpos -= 1;\n\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Advance position to the next character in input.\n\t\t\t\tpos += 1;\n\n\t\t\t// Repeat this step.\n\t\t\t} // (close while true loop)\n\t\t}\n\n\t\t// 4. Splitting loop: Collect a sequence of characters that are space\n\t\t//    characters or U+002C COMMA characters. If any U+002C COMMA characters\n\t\t//    were collected, that is a parse error.\n\t\twhile (true) {\n\t\t\tcollectCharacters(regexLeadingCommasOrSpaces);\n\n\t\t\t// 5. If position is past the end of input, return candidates and abort these steps.\n\t\t\tif (pos >= inputLength) {\n\t\t\t\treturn candidates; // (we're done, this is the sole return path)\n\t\t\t}\n\n\t\t\t// 6. Collect a sequence of characters that are not space characters,\n\t\t\t//    and let that be url.\n\t\t\turl = collectCharacters(regexLeadingNotSpaces);\n\n\t\t\t// 7. Let descriptors be a new empty list.\n\t\t\tdescriptors = [];\n\n\t\t\t// 8. If url ends with a U+002C COMMA character (,), follow these substeps:\n\t\t\t//\t\t(1). Remove all trailing U+002C COMMA characters from url. If this removed\n\t\t\t//         more than one character, that is a parse error.\n\t\t\tif (url.slice(-1) === \",\") {\n\t\t\t\turl = url.replace(regexTrailingCommas, \"\");\n\t\t\t\t// (Jump ahead to step 9 to skip tokenization and just push the candidate).\n\t\t\t\tparseDescriptors();\n\n\t\t\t//\tOtherwise, follow these substeps:\n\t\t\t} else {\n\t\t\t\ttokenize();\n\t\t\t} // (close else of step 8)\n\n\t\t// 16. Return to the step labeled splitting loop.\n\t\t} // (Close of big while loop.)\n\t}\n\n\t/*\n\t * Sizes Parser\n\t *\n\t * By Alex Bell |  MIT License\n\t *\n\t * Non-strict but accurate and lightweight JS Parser for the string value <img sizes=\"here\">\n\t *\n\t * Reference algorithm at:\n\t * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute\n\t *\n\t * Most comments are copied in directly from the spec\n\t * (except for comments in parens).\n\t *\n\t * Grammar is:\n\t * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value>\n\t * <source-size> = <media-condition> <source-size-value>\n\t * <source-size-value> = <length>\n\t * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes\n\t *\n\t * E.g. \"(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw\"\n\t * or \"(min-width: 30em), calc(30vw - 15px)\" or just \"30vw\"\n\t *\n\t * Returns the first valid <css-length> with a media condition that evaluates to true,\n\t * or \"100vw\" if all valid media conditions evaluate to false.\n\t *\n\t */\n\n\tfunction parseSizes(strValue) {\n\n\t\t// (Percentage CSS lengths are not allowed in this case, to avoid confusion:\n\t\t// https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list\n\t\t// CSS allows a single optional plus or minus sign:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#numbers\n\t\t// CSS is ASCII case-insensitive:\n\t\t// http://www.w3.org/TR/CSS2/syndata.html#characters )\n\t\t// Spec allows exponential notation for <number> type:\n\t\t// http://dev.w3.org/csswg/css-values/#numbers\n\t\tvar regexCssLengthWithUnits = /^(?:[+-]?[0-9]+|[0-9]*\\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i;\n\n\t\t// (This is a quick and lenient test. Because of optional unlimited-depth internal\n\t\t// grouping parens and strict spacing rules, this could get very complicated.)\n\t\tvar regexCssCalc = /^calc\\((?:[0-9a-z \\.\\+\\-\\*\\/\\(\\)]+)\\)$/i;\n\n\t\tvar i;\n\t\tvar unparsedSizesList;\n\t\tvar unparsedSizesListLength;\n\t\tvar unparsedSize;\n\t\tvar lastComponentValue;\n\t\tvar size;\n\n\t\t// UTILITY FUNCTIONS\n\n\t\t//  (Toy CSS parser. The goals here are:\n\t\t//  1) expansive test coverage without the weight of a full CSS parser.\n\t\t//  2) Avoiding regex wherever convenient.\n\t\t//  Quick tests: http://jsfiddle.net/gtntL4gr/3/\n\t\t//  Returns an array of arrays.)\n\t\tfunction parseComponentValues(str) {\n\t\t\tvar chrctr;\n\t\t\tvar component = \"\";\n\t\t\tvar componentArray = [];\n\t\t\tvar listArray = [];\n\t\t\tvar parenDepth = 0;\n\t\t\tvar pos = 0;\n\t\t\tvar inComment = false;\n\n\t\t\tfunction pushComponent() {\n\t\t\t\tif (component) {\n\t\t\t\t\tcomponentArray.push(component);\n\t\t\t\t\tcomponent = \"\";\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tfunction pushComponentArray() {\n\t\t\t\tif (componentArray[0]) {\n\t\t\t\t\tlistArray.push(componentArray);\n\t\t\t\t\tcomponentArray = [];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// (Loop forwards from the beginning of the string.)\n\t\t\twhile (true) {\n\t\t\t\tchrctr = str.charAt(pos);\n\n\t\t\t\tif (chrctr === \"\") { // ( End of string reached.)\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\treturn listArray;\n\t\t\t\t} else if (inComment) {\n\t\t\t\t\tif ((chrctr === \"*\") && (str[pos + 1] === \"/\")) { // (At end of a comment.)\n\t\t\t\t\t\tinComment = false;\n\t\t\t\t\t\tpos += 2;\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tpos += 1; // (Skip all characters inside comments.)\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t} else if (isSpace(chrctr)) {\n\t\t\t\t\t// (If previous character in loop was also a space, or if\n\t\t\t\t\t// at the beginning of the string, do not add space char to\n\t\t\t\t\t// component.)\n\t\t\t\t\tif ( (str.charAt(pos - 1) && isSpace( str.charAt(pos - 1) ) ) || !component ) {\n\t\t\t\t\t\tpos += 1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else if (parenDepth === 0) {\n\t\t\t\t\t\tpushComponent();\n\t\t\t\t\t\tpos +=1;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// (Replace any space character with a plain space for legibility.)\n\t\t\t\t\t\tchrctr = \" \";\n\t\t\t\t\t}\n\t\t\t\t} else if (chrctr === \"(\") {\n\t\t\t\t\tparenDepth += 1;\n\t\t\t\t} else if (chrctr === \")\") {\n\t\t\t\t\tparenDepth -= 1;\n\t\t\t\t} else if (chrctr === \",\") {\n\t\t\t\t\tpushComponent();\n\t\t\t\t\tpushComponentArray();\n\t\t\t\t\tpos += 1;\n\t\t\t\t\tcontinue;\n\t\t\t\t} else if ( (chrctr === \"/\") && (str.charAt(pos + 1) === \"*\") ) {\n\t\t\t\t\tinComment = true;\n\t\t\t\t\tpos += 2;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tcomponent = component + chrctr;\n\t\t\t\tpos += 1;\n\t\t\t}\n\t\t}\n\n\t\tfunction isValidNonNegativeSourceSizeValue(s) {\n\t\t\tif (regexCssLengthWithUnits.test(s) && (parseFloat(s) >= 0)) {return true;}\n\t\t\tif (regexCssCalc.test(s)) {return true;}\n\t\t\t// ( http://www.w3.org/TR/CSS2/syndata.html#numbers says:\n\t\t\t// \"-0 is equivalent to 0 and is not a negative number.\" which means that\n\t\t\t// unitless zero and unitless negative zero must be accepted as special cases.)\n\t\t\tif ((s === \"0\") || (s === \"-0\") || (s === \"+0\")) {return true;}\n\t\t\treturn false;\n\t\t}\n\n\t\t// When asked to parse a sizes attribute from an element, parse a\n\t\t// comma-separated list of component values from the value of the element's\n\t\t// sizes attribute (or the empty string, if the attribute is absent), and let\n\t\t// unparsed sizes list be the result.\n\t\t// http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values\n\n\t\tunparsedSizesList = parseComponentValues(strValue);\n\t\tunparsedSizesListLength = unparsedSizesList.length;\n\n\t\t// For each unparsed size in unparsed sizes list:\n\t\tfor (i = 0; i < unparsedSizesListLength; i++) {\n\t\t\tunparsedSize = unparsedSizesList[i];\n\n\t\t\t// 1. Remove all consecutive <whitespace-token>s from the end of unparsed size.\n\t\t\t// ( parseComponentValues() already omits spaces outside of parens. )\n\n\t\t\t// If unparsed size is now empty, that is a parse error; continue to the next\n\t\t\t// iteration of this algorithm.\n\t\t\t// ( parseComponentValues() won't push an empty array. )\n\n\t\t\t// 2. If the last component value in unparsed size is a valid non-negative\n\t\t\t// <source-size-value>, let size be its value and remove the component value\n\t\t\t// from unparsed size. Any CSS function other than the calc() function is\n\t\t\t// invalid. Otherwise, there is a parse error; continue to the next iteration\n\t\t\t// of this algorithm.\n\t\t\t// http://dev.w3.org/csswg/css-syntax/#parse-component-value\n\t\t\tlastComponentValue = unparsedSize[unparsedSize.length - 1];\n\n\t\t\tif (isValidNonNegativeSourceSizeValue(lastComponentValue)) {\n\t\t\t\tsize = lastComponentValue;\n\t\t\t\tunparsedSize.pop();\n\t\t\t} else {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 3. Remove all consecutive <whitespace-token>s from the end of unparsed\n\t\t\t// size. If unparsed size is now empty, return size and exit this algorithm.\n\t\t\t// If this was not the last item in unparsed sizes list, that is a parse error.\n\t\t\tif (unparsedSize.length === 0) {\n\t\t\t\treturn size;\n\t\t\t}\n\n\t\t\t// 4. Parse the remaining component values in unparsed size as a\n\t\t\t// <media-condition>. If it does not parse correctly, or it does parse\n\t\t\t// correctly but the <media-condition> evaluates to false, continue to the\n\t\t\t// next iteration of this algorithm.\n\t\t\t// (Parsing all possible compound media conditions in JS is heavy, complicated,\n\t\t\t// and the payoff is unclear. Is there ever an situation where the\n\t\t\t// media condition parses incorrectly but still somehow evaluates to true?\n\t\t\t// Can we just rely on the browser/polyfill to do it?)\n\t\t\tunparsedSize = unparsedSize.join(\" \");\n\t\t\tif (!(pf.matchesMedia( unparsedSize ) ) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// 5. Return size and exit this algorithm.\n\t\t\treturn size;\n\t\t}\n\n\t\t// If the above algorithm exhausts unparsed sizes list without returning a\n\t\t// size value, return 100vw.\n\t\treturn \"100vw\";\n\t}\n\n\t// namespace\n\tpf.ns = (\"pf\" + new Date().getTime()).substr(0, 9);\n\n\t// srcset support test\n\tpf.supSrcset = \"srcset\" in image;\n\tpf.supSizes = \"sizes\" in image;\n\tpf.supPicture = !!window.HTMLPictureElement;\n\n\t// UC browser does claim to support srcset and picture, but not sizes,\n\t// this extended test reveals the browser does support nothing\n\tif (pf.supSrcset && pf.supPicture && !pf.supSizes) {\n\t\t(function(image2) {\n\t\t\timage.srcset = \"data:,a\";\n\t\t\timage2.src = \"data:,a\";\n\t\t\tpf.supSrcset = image.complete === image2.complete;\n\t\t\tpf.supPicture = pf.supSrcset && pf.supPicture;\n\t\t})(document.createElement(\"img\"));\n\t}\n\n\t// Safari9 has basic support for sizes, but does't expose the `sizes` idl attribute\n\tif (pf.supSrcset && !pf.supSizes) {\n\n\t\t(function() {\n\t\t\tvar width2 = \"data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw==\";\n\t\t\tvar width1 = \"data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==\";\n\t\t\tvar img = document.createElement(\"img\");\n\t\t\tvar test = function() {\n\t\t\t\tvar width = img.width;\n\n\t\t\t\tif (width === 2) {\n\t\t\t\t\tpf.supSizes = true;\n\t\t\t\t}\n\n\t\t\t\talwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes;\n\n\t\t\t\tisSupportTestReady = true;\n\t\t\t\t// force async\n\t\t\t\tsetTimeout(picturefill);\n\t\t\t};\n\n\t\t\timg.onload = test;\n\t\t\timg.onerror = test;\n\t\t\timg.setAttribute(\"sizes\", \"9px\");\n\n\t\t\timg.srcset = width1 + \" 1w,\" + width2 + \" 9w\";\n\t\t\timg.src = width1;\n\t\t})();\n\n\t} else {\n\t\tisSupportTestReady = true;\n\t}\n\n\t// using pf.qsa instead of dom traversing does scale much better,\n\t// especially on sites mixing responsive and non-responsive images\n\tpf.selShort = \"picture>img,img[srcset]\";\n\tpf.sel = pf.selShort;\n\tpf.cfg = cfg;\n\n\t/**\n\t * Shortcut property for `devicePixelRatio` ( for easy overriding in tests )\n\t */\n\tpf.DPR = (DPR  || 1 );\n\tpf.u = units;\n\n\t// container of supported mime types that one might need to qualify before using\n\tpf.types =  types;\n\n\tpf.setSize = noop;\n\n\t/**\n\t * Gets a string and returns the absolute URL\n\t * @param src\n\t * @returns {String} absolute URL\n\t */\n\n\tpf.makeUrl = memoize(function(src) {\n\t\tanchor.href = src;\n\t\treturn anchor.href;\n\t});\n\n\t/**\n\t * Gets a DOM element or document and a selctor and returns the found matches\n\t * Can be extended with jQuery/Sizzle for IE7 support\n\t * @param context\n\t * @param sel\n\t * @returns {NodeList|Array}\n\t */\n\tpf.qsa = function(context, sel) {\n\t\treturn ( \"querySelector\" in context ) ? context.querySelectorAll(sel) : [];\n\t};\n\n\t/**\n\t * Shortcut method for matchMedia ( for easy overriding in tests )\n\t * wether native or pf.mMQ is used will be decided lazy on first call\n\t * @returns {boolean}\n\t */\n\tpf.matchesMedia = function() {\n\t\tif ( window.matchMedia && (matchMedia( \"(min-width: 0.1em)\" ) || {}).matches ) {\n\t\t\tpf.matchesMedia = function( media ) {\n\t\t\t\treturn !media || ( matchMedia( media ).matches );\n\t\t\t};\n\t\t} else {\n\t\t\tpf.matchesMedia = pf.mMQ;\n\t\t}\n\n\t\treturn pf.matchesMedia.apply( this, arguments );\n\t};\n\n\t/**\n\t * A simplified matchMedia implementation for IE8 and IE9\n\t * handles only min-width/max-width with px or em values\n\t * @param media\n\t * @returns {boolean}\n\t */\n\tpf.mMQ = function( media ) {\n\t\treturn media ? evalCSS(media) : true;\n\t};\n\n\t/**\n\t * Returns the calculated length in css pixel from the given sourceSizeValue\n\t * http://dev.w3.org/csswg/css-values-3/#length-value\n\t * intended Spec mismatches:\n\t * * Does not check for invalid use of CSS functions\n\t * * Does handle a computed length of 0 the same as a negative and therefore invalid value\n\t * @param sourceSizeValue\n\t * @returns {Number}\n\t */\n\tpf.calcLength = function( sourceSizeValue ) {\n\n\t\tvar value = evalCSS(sourceSizeValue, true) || false;\n\t\tif (value < 0) {\n\t\t\tvalue = false;\n\t\t}\n\n\t\treturn value;\n\t};\n\n\t/**\n\t * Takes a type string and checks if its supported\n\t */\n\n\tpf.supportsType = function( type ) {\n\t\treturn ( type ) ? types[ type ] : true;\n\t};\n\n\t/**\n\t * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length)\n\t * @param sourceSizeStr\n\t * @returns {*}\n\t */\n\tpf.parseSize = memoize(function( sourceSizeStr ) {\n\t\tvar match = ( sourceSizeStr || \"\" ).match(regSize);\n\t\treturn {\n\t\t\tmedia: match && match[1],\n\t\t\tlength: match && match[2]\n\t\t};\n\t});\n\n\tpf.parseSet = function( set ) {\n\t\tif ( !set.cands ) {\n\t\t\tset.cands = parseSrcset(set.srcset, set);\n\t\t}\n\t\treturn set.cands;\n\t};\n\n\t/**\n\t * returns 1em in css px for html/body default size\n\t * function taken from respondjs\n\t * @returns {*|number}\n\t */\n\tpf.getEmValue = function() {\n\t\tvar body;\n\t\tif ( !eminpx && (body = document.body) ) {\n\t\t\tvar div = document.createElement( \"div\" ),\n\t\t\t\toriginalHTMLCSS = docElem.style.cssText,\n\t\t\t\toriginalBodyCSS = body.style.cssText;\n\n\t\t\tdiv.style.cssText = baseStyle;\n\n\t\t\t// 1em in a media query is the value of the default font size of the browser\n\t\t\t// reset docElem and body to ensure the correct value is returned\n\t\t\tdocElem.style.cssText = fsCss;\n\t\t\tbody.style.cssText = fsCss;\n\n\t\t\tbody.appendChild( div );\n\t\t\teminpx = div.offsetWidth;\n\t\t\tbody.removeChild( div );\n\n\t\t\t//also update eminpx before returning\n\t\t\teminpx = parseFloat( eminpx, 10 );\n\n\t\t\t// restore the original values\n\t\t\tdocElem.style.cssText = originalHTMLCSS;\n\t\t\tbody.style.cssText = originalBodyCSS;\n\n\t\t}\n\t\treturn eminpx || 16;\n\t};\n\n\t/**\n\t * Takes a string of sizes and returns the width in pixels as a number\n\t */\n\tpf.calcListLength = function( sourceSizeListStr ) {\n\t\t// Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33%\n\t\t//\n\t\t//                           or (min-width:30em) calc(30% - 15px)\n\t\tif ( !(sourceSizeListStr in sizeLengthCache) || cfg.uT ) {\n\t\t\tvar winningLength = pf.calcLength( parseSizes( sourceSizeListStr ) );\n\n\t\t\tsizeLengthCache[ sourceSizeListStr ] = !winningLength ? units.width : winningLength;\n\t\t}\n\n\t\treturn sizeLengthCache[ sourceSizeListStr ];\n\t};\n\n\t/**\n\t * Takes a candidate object with a srcset property in the form of url/\n\t * ex. \"images/pic-medium.png 1x, images/pic-medium-2x.png 2x\" or\n\t *     \"images/pic-medium.png 400w, images/pic-medium-2x.png 800w\" or\n\t *     \"images/pic-small.png\"\n\t * Get an array of image candidates in the form of\n\t *      {url: \"/foo/bar.png\", resolution: 1}\n\t * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value\n\t * If sizes is specified, res is calculated\n\t */\n\tpf.setRes = function( set ) {\n\t\tvar candidates;\n\t\tif ( set ) {\n\n\t\t\tcandidates = pf.parseSet( set );\n\n\t\t\tfor ( var i = 0, len = candidates.length; i < len; i++ ) {\n\t\t\t\tsetResolution( candidates[ i ], set.sizes );\n\t\t\t}\n\t\t}\n\t\treturn candidates;\n\t};\n\n\tpf.setRes.res = setResolution;\n\n\tpf.applySetCandidate = function( candidates, img ) {\n\t\tif ( !candidates.length ) {return;}\n\t\tvar candidate,\n\t\t\ti,\n\t\t\tj,\n\t\t\tlength,\n\t\t\tbestCandidate,\n\t\t\tcurSrc,\n\t\t\tcurCan,\n\t\t\tcandidateSrc,\n\t\t\tabortCurSrc;\n\n\t\tvar imageData = img[ pf.ns ];\n\t\tvar dpr = pf.DPR;\n\n\t\tcurSrc = imageData.curSrc || img[curSrcProp];\n\n\t\tcurCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set);\n\n\t\t// if we have a current source, we might either become lazy or give this source some advantage\n\t\tif ( curCan && curCan.set === candidates[ 0 ].set ) {\n\n\t\t\t// if browser can abort image request and the image has a higher pixel density than needed\n\t\t\t// and this image isn't downloaded yet, we skip next part and try to save bandwidth\n\t\t\tabortCurSrc = (supportAbort && !img.complete && curCan.res - 0.1 > dpr);\n\n\t\t\tif ( !abortCurSrc ) {\n\t\t\t\tcurCan.cached = true;\n\n\t\t\t\t// if current candidate is \"best\", \"better\" or \"okay\",\n\t\t\t\t// set it to bestCandidate\n\t\t\t\tif ( curCan.res >= dpr ) {\n\t\t\t\t\tbestCandidate = curCan;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( !bestCandidate ) {\n\n\t\t\tcandidates.sort( ascendingSort );\n\n\t\t\tlength = candidates.length;\n\t\t\tbestCandidate = candidates[ length - 1 ];\n\n\t\t\tfor ( i = 0; i < length; i++ ) {\n\t\t\t\tcandidate = candidates[ i ];\n\t\t\t\tif ( candidate.res >= dpr ) {\n\t\t\t\t\tj = i - 1;\n\n\t\t\t\t\t// we have found the perfect candidate,\n\t\t\t\t\t// but let's improve this a little bit with some assumptions ;-)\n\t\t\t\t\tif (candidates[ j ] &&\n\t\t\t\t\t\t(abortCurSrc || curSrc !== pf.makeUrl( candidate.url )) &&\n\t\t\t\t\t\tchooseLowRes(candidates[ j ].res, candidate.res, dpr, candidates[ j ].cached)) {\n\n\t\t\t\t\t\tbestCandidate = candidates[ j ];\n\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbestCandidate = candidate;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif ( bestCandidate ) {\n\n\t\t\tcandidateSrc = pf.makeUrl( bestCandidate.url );\n\n\t\t\timageData.curSrc = candidateSrc;\n\t\t\timageData.curCan = bestCandidate;\n\n\t\t\tif ( candidateSrc !== curSrc ) {\n\t\t\t\tpf.setSrc( img, bestCandidate );\n\t\t\t}\n\t\t\tpf.setSize( img );\n\t\t}\n\t};\n\n\tpf.setSrc = function( img, bestCandidate ) {\n\t\tvar origWidth;\n\t\timg.src = bestCandidate.url;\n\n\t\t// although this is a specific Safari issue, we don't want to take too much different code paths\n\t\tif ( bestCandidate.set.type === \"image/svg+xml\" ) {\n\t\t\torigWidth = img.style.width;\n\t\t\timg.style.width = (img.offsetWidth + 1) + \"px\";\n\n\t\t\t// next line only should trigger a repaint\n\t\t\t// if... is only done to trick dead code removal\n\t\t\tif ( img.offsetWidth + 1 ) {\n\t\t\t\timg.style.width = origWidth;\n\t\t\t}\n\t\t}\n\t};\n\n\tpf.getSet = function( img ) {\n\t\tvar i, set, supportsType;\n\t\tvar match = false;\n\t\tvar sets = img [ pf.ns ].sets;\n\n\t\tfor ( i = 0; i < sets.length && !match; i++ ) {\n\t\t\tset = sets[i];\n\n\t\t\tif ( !set.srcset || !pf.matchesMedia( set.media ) || !(supportsType = pf.supportsType( set.type )) ) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif ( supportsType === \"pending\" ) {\n\t\t\t\tset = supportsType;\n\t\t\t}\n\n\t\t\tmatch = set;\n\t\t\tbreak;\n\t\t}\n\n\t\treturn match;\n\t};\n\n\tpf.parseSets = function( element, parent, options ) {\n\t\tvar srcsetAttribute, imageSet, isWDescripor, srcsetParsed;\n\n\t\tvar hasPicture = parent && parent.nodeName.toUpperCase() === \"PICTURE\";\n\t\tvar imageData = element[ pf.ns ];\n\n\t\tif ( imageData.src === undefined || options.src ) {\n\t\t\timageData.src = getImgAttr.call( element, \"src\" );\n\t\t\tif ( imageData.src ) {\n\t\t\t\tsetImgAttr.call( element, srcAttr, imageData.src );\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcAttr );\n\t\t\t}\n\t\t}\n\n\t\tif ( imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset ) {\n\t\t\tsrcsetAttribute = getImgAttr.call( element, \"srcset\" );\n\t\t\timageData.srcset = srcsetAttribute;\n\t\t\tsrcsetParsed = true;\n\t\t}\n\n\t\timageData.sets = [];\n\n\t\tif ( hasPicture ) {\n\t\t\timageData.pic = true;\n\t\t\tgetAllSourceElements( parent, imageData.sets );\n\t\t}\n\n\t\tif ( imageData.srcset ) {\n\t\t\timageSet = {\n\t\t\t\tsrcset: imageData.srcset,\n\t\t\t\tsizes: getImgAttr.call( element, \"sizes\" )\n\t\t\t};\n\n\t\t\timageData.sets.push( imageSet );\n\n\t\t\tisWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || \"\");\n\n\t\t\t// add normal src as candidate, if source has no w descriptor\n\t\t\tif ( !isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x ) {\n\t\t\t\timageSet.srcset += \", \" + imageData.src;\n\t\t\t\timageSet.cands.push({\n\t\t\t\t\turl: imageData.src,\n\t\t\t\t\td: 1,\n\t\t\t\t\tset: imageSet\n\t\t\t\t});\n\t\t\t}\n\n\t\t} else if ( imageData.src ) {\n\t\t\timageData.sets.push( {\n\t\t\t\tsrcset: imageData.src,\n\t\t\t\tsizes: null\n\t\t\t} );\n\t\t}\n\n\t\timageData.curCan = null;\n\t\timageData.curSrc = undefined;\n\n\t\t// if img has picture or the srcset was removed or has a srcset and does not support srcset at all\n\t\t// or has a w descriptor (and does not support sizes) set support to false to evaluate\n\t\timageData.supported = !( hasPicture || ( imageSet && !pf.supSrcset ) || (isWDescripor && !pf.supSizes) );\n\n\t\tif ( srcsetParsed && pf.supSrcset && !imageData.supported ) {\n\t\t\tif ( srcsetAttribute ) {\n\t\t\t\tsetImgAttr.call( element, srcsetAttr, srcsetAttribute );\n\t\t\t\telement.srcset = \"\";\n\t\t\t} else {\n\t\t\t\tremoveImgAttr.call( element, srcsetAttr );\n\t\t\t}\n\t\t}\n\n\t\tif (imageData.supported && !imageData.srcset && ((!imageData.src && element.src) ||  element.src !== pf.makeUrl(imageData.src))) {\n\t\t\tif (imageData.src === null) {\n\t\t\t\telement.removeAttribute(\"src\");\n\t\t\t} else {\n\t\t\t\telement.src = imageData.src;\n\t\t\t}\n\t\t}\n\n\t\timageData.parsed = true;\n\t};\n\n\tpf.fillImg = function(element, options) {\n\t\tvar imageData;\n\t\tvar extreme = options.reselect || options.reevaluate;\n\n\t\t// expando for caching data on the img\n\t\tif ( !element[ pf.ns ] ) {\n\t\t\telement[ pf.ns ] = {};\n\t\t}\n\n\t\timageData = element[ pf.ns ];\n\n\t\t// if the element has already been evaluated, skip it\n\t\t// unless `options.reevaluate` is set to true ( this, for example,\n\t\t// is set to true when running `picturefill` on `resize` ).\n\t\tif ( !extreme && imageData.evaled === evalId ) {\n\t\t\treturn;\n\t\t}\n\n\t\tif ( !imageData.parsed || options.reevaluate ) {\n\t\t\tpf.parseSets( element, element.parentNode, options );\n\t\t}\n\n\t\tif ( !imageData.supported ) {\n\t\t\tapplyBestCandidate( element );\n\t\t} else {\n\t\t\timageData.evaled = evalId;\n\t\t}\n\t};\n\n\tpf.setupRun = function() {\n\t\tif ( !alreadyRun || isVwDirty || (DPR !== window.devicePixelRatio) ) {\n\t\t\tupdateMetrics();\n\t\t}\n\t};\n\n\t// If picture is supported, well, that's awesome.\n\tif ( pf.supPicture ) {\n\t\tpicturefill = noop;\n\t\tpf.fillImg = noop;\n\t} else {\n\n\t\t // Set up picture polyfill by polling the document\n\t\t(function() {\n\t\t\tvar isDomReady;\n\t\t\tvar regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/;\n\n\t\t\tvar run = function() {\n\t\t\t\tvar readyState = document.readyState || \"\";\n\n\t\t\t\ttimerId = setTimeout(run, readyState === \"loading\" ? 200 :  999);\n\t\t\t\tif ( document.body ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t\tisDomReady = isDomReady || regReady.test(readyState);\n\t\t\t\t\tif ( isDomReady ) {\n\t\t\t\t\t\tclearTimeout( timerId );\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tvar timerId = setTimeout(run, document.body ? 9 : 99);\n\n\t\t\t// Also attach picturefill on resize and readystatechange\n\t\t\t// http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html\n\t\t\tvar debounce = function(func, wait) {\n\t\t\t\tvar timeout, timestamp;\n\t\t\t\tvar later = function() {\n\t\t\t\t\tvar last = (new Date()) - timestamp;\n\n\t\t\t\t\tif (last < wait) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait - last);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttimeout = null;\n\t\t\t\t\t\tfunc();\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\treturn function() {\n\t\t\t\t\ttimestamp = new Date();\n\n\t\t\t\t\tif (!timeout) {\n\t\t\t\t\t\ttimeout = setTimeout(later, wait);\n\t\t\t\t\t}\n\t\t\t\t};\n\t\t\t};\n\t\t\tvar lastClientWidth = docElem.clientHeight;\n\t\t\tvar onResize = function() {\n\t\t\t\tisVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth;\n\t\t\t\tlastClientWidth = docElem.clientHeight;\n\t\t\t\tif ( isVwDirty ) {\n\t\t\t\t\tpf.fillImgs();\n\t\t\t\t}\n\t\t\t};\n\n\t\t\ton( window, \"resize\", debounce(onResize, 99 ) );\n\t\t\ton( document, \"readystatechange\", run );\n\t\t})();\n\t}\n\n\tpf.picturefill = picturefill;\n\t//use this internally for easy monkey patching/performance testing\n\tpf.fillImgs = picturefill;\n\tpf.teardownRun = noop;\n\n\t/* expose methods for testing */\n\tpicturefill._ = pf;\n\n\twindow.picturefillCFG = {\n\t\tpf: pf,\n\t\tpush: function(args) {\n\t\t\tvar name = args.shift();\n\t\t\tif (typeof pf[name] === \"function\") {\n\t\t\t\tpf[name].apply(pf, args);\n\t\t\t} else {\n\t\t\t\tcfg[name] = args[0];\n\t\t\t\tif (alreadyRun) {\n\t\t\t\t\tpf.fillImgs( { reselect: true } );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t};\n\n\twhile (setOptions && setOptions.length) {\n\t\twindow.picturefillCFG.push(setOptions.shift());\n\t}\n\n\t/* expose picturefill */\n\twindow.picturefill = picturefill;\n\n\t/* expose picturefill */\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\t\t// CommonJS, just export\n\t\tmodule.exports = picturefill;\n\t} else if ( typeof define === \"function\" && define.amd ) {\n\t\t// AMD support\n\t\tdefine( \"picturefill\", function() { return picturefill; } );\n\t}\n\n\t// IE8 evals this sync, so it must be the last thing we do\n\tif ( !pf.supPicture ) {\n\t\ttypes[ \"image/webp\" ] = detectTypeSupport(\"image/webp\", \"data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA==\" );\n\t}\n\n} )( window, document );\n","/*!\n * @copyright Copyright (c) 2017 IcoMoon.io\n * @license   Licensed under MIT license\n *            See https://github.com/Keyamoon/svgxuse\n * @version   1.2.6\n */\n/*jslint browser: true */\n/*global XDomainRequest, MutationObserver, window */\n(function () {\n    \"use strict\";\n    if (typeof window !== \"undefined\" && window.addEventListener) {\n        var cache = Object.create(null); // holds xhr objects to prevent multiple requests\n        var checkUseElems;\n        var tid; // timeout id\n        var debouncedCheck = function () {\n            clearTimeout(tid);\n            tid = setTimeout(checkUseElems, 100);\n        };\n        var unobserveChanges = function () {\n            return;\n        };\n        var observeChanges = function () {\n            var observer;\n            window.addEventListener(\"resize\", debouncedCheck, false);\n            window.addEventListener(\"orientationchange\", debouncedCheck, false);\n            if (window.MutationObserver) {\n                observer = new MutationObserver(debouncedCheck);\n                observer.observe(document.documentElement, {\n                    childList: true,\n                    subtree: true,\n                    attributes: true\n                });\n                unobserveChanges = function () {\n                    try {\n                        observer.disconnect();\n                        window.removeEventListener(\"resize\", debouncedCheck, false);\n                        window.removeEventListener(\"orientationchange\", debouncedCheck, false);\n                    } catch (ignore) {}\n                };\n            } else {\n                document.documentElement.addEventListener(\"DOMSubtreeModified\", debouncedCheck, false);\n                unobserveChanges = function () {\n                    document.documentElement.removeEventListener(\"DOMSubtreeModified\", debouncedCheck, false);\n                    window.removeEventListener(\"resize\", debouncedCheck, false);\n                    window.removeEventListener(\"orientationchange\", debouncedCheck, false);\n                };\n            }\n        };\n        var createRequest = function (url) {\n            // In IE 9, cross origin requests can only be sent using XDomainRequest.\n            // XDomainRequest would fail if CORS headers are not set.\n            // Therefore, XDomainRequest should only be used with cross origin requests.\n            function getOrigin(loc) {\n                var a;\n                if (loc.protocol !== undefined) {\n                    a = loc;\n                } else {\n                    a = document.createElement(\"a\");\n                    a.href = loc;\n                }\n                return a.protocol.replace(/:/g, \"\") + a.host;\n            }\n            var Request;\n            var origin;\n            var origin2;\n            if (window.XMLHttpRequest) {\n                Request = new XMLHttpRequest();\n                origin = getOrigin(location);\n                origin2 = getOrigin(url);\n                if (Request.withCredentials === undefined && origin2 !== \"\" && origin2 !== origin) {\n                    Request = XDomainRequest || undefined;\n                } else {\n                    Request = XMLHttpRequest;\n                }\n            }\n            return Request;\n        };\n        var xlinkNS = \"http://www.w3.org/1999/xlink\";\n        checkUseElems = function () {\n            var base;\n            var bcr;\n            var fallback = \"\"; // optional fallback URL in case no base path to SVG file was given and no symbol definition was found.\n            var hash;\n            var href;\n            var i;\n            var inProgressCount = 0;\n            var isHidden;\n            var Request;\n            var url;\n            var uses;\n            var xhr;\n            function observeIfDone() {\n                // If done with making changes, start watching for chagnes in DOM again\n                inProgressCount -= 1;\n                if (inProgressCount === 0) { // if all xhrs were resolved\n                    unobserveChanges(); // make sure to remove old handlers\n                    observeChanges(); // watch for changes to DOM\n                }\n            }\n            function attrUpdateFunc(spec) {\n                return function () {\n                    if (cache[spec.base] !== true) {\n                        spec.useEl.setAttributeNS(xlinkNS, \"xlink:href\", \"#\" + spec.hash);\n                        if (spec.useEl.hasAttribute(\"href\")) {\n                            spec.useEl.setAttribute(\"href\", \"#\" + spec.hash);\n                        }\n                    }\n                };\n            }\n            function onloadFunc(xhr) {\n                return function () {\n                    var body = document.body;\n                    var x = document.createElement(\"x\");\n                    var svg;\n                    xhr.onload = null;\n                    x.innerHTML = xhr.responseText;\n                    svg = x.getElementsByTagName(\"svg\")[0];\n                    if (svg) {\n                        svg.setAttribute(\"aria-hidden\", \"true\");\n                        svg.style.position = \"absolute\";\n                        svg.style.width = 0;\n                        svg.style.height = 0;\n                        svg.style.overflow = \"hidden\";\n                        body.insertBefore(svg, body.firstChild);\n                    }\n                    observeIfDone();\n                };\n            }\n            function onErrorTimeout(xhr) {\n                return function () {\n                    xhr.onerror = null;\n                    xhr.ontimeout = null;\n                    observeIfDone();\n                };\n            }\n            unobserveChanges(); // stop watching for changes to DOM\n            // find all use elements\n            uses = document.getElementsByTagName(\"use\");\n            for (i = 0; i < uses.length; i += 1) {\n                try {\n                    bcr = uses[i].getBoundingClientRect();\n                } catch (ignore) {\n                    // failed to get bounding rectangle of the use element\n                    bcr = false;\n                }\n                href = uses[i].getAttribute(\"href\")\n                        || uses[i].getAttributeNS(xlinkNS, \"href\")\n                        || uses[i].getAttribute(\"xlink:href\");\n                if (href && href.split) {\n                    url = href.split(\"#\");\n                } else {\n                    url = [\"\", \"\"];\n                }\n                base = url[0];\n                hash = url[1];\n                isHidden = bcr && bcr.left === 0 && bcr.right === 0 && bcr.top === 0 && bcr.bottom === 0;\n                if (bcr && bcr.width === 0 && bcr.height === 0 && !isHidden) {\n                    // the use element is empty\n                    // if there is a reference to an external SVG, try to fetch it\n                    // use the optional fallback URL if there is no reference to an external SVG\n                    if (fallback && !base.length && hash && !document.getElementById(hash)) {\n                        base = fallback;\n                    }\n                    if (uses[i].hasAttribute(\"href\")) {\n                        uses[i].setAttributeNS(xlinkNS, \"xlink:href\", href);\n                    }\n                    if (base.length) {\n                        // schedule updating xlink:href\n                        xhr = cache[base];\n                        if (xhr !== true) {\n                            // true signifies that prepending the SVG was not required\n                            setTimeout(attrUpdateFunc({\n                                useEl: uses[i],\n                                base: base,\n                                hash: hash\n                            }), 0);\n                        }\n                        if (xhr === undefined) {\n                            Request = createRequest(base);\n                            if (Request !== undefined) {\n                                xhr = new Request();\n                                cache[base] = xhr;\n                                xhr.onload = onloadFunc(xhr);\n                                xhr.onerror = onErrorTimeout(xhr);\n                                xhr.ontimeout = onErrorTimeout(xhr);\n                                xhr.open(\"GET\", base);\n                                xhr.send();\n                                inProgressCount += 1;\n                            }\n                        }\n                    }\n                } else {\n                    if (!isHidden) {\n                        if (cache[base] === undefined) {\n                            // remember this URL if the use element was not empty and no request was sent\n                            cache[base] = true;\n                        } else if (cache[base].onload) {\n                            // if it turns out that prepending the SVG is not necessary,\n                            // abort the in-progress xhr.\n                            cache[base].abort();\n                            delete cache[base].onload;\n                            cache[base] = true;\n                        }\n                    } else if (base.length && cache[base]) {\n                        setTimeout(attrUpdateFunc({\n                            useEl: uses[i],\n                            base: base,\n                            hash: hash\n                        }), 0);\n                    }\n                }\n            }\n            uses = \"\";\n            inProgressCount += 1;\n            observeIfDone();\n        };\n        var winLoad;\n        winLoad = function () {\n            window.removeEventListener(\"load\", winLoad, false); // to prevent memory leaks\n            tid = setTimeout(checkUseElems, 0);\n        };\n        if (document.readyState !== \"complete\") {\n            // The load event fires when all resources have finished loading, which allows detecting whether SVG use elements are empty.\n            window.addEventListener(\"load\", winLoad, false);\n        } else {\n            // No need to add a listener if the document is already loaded, initialize immediately.\n            winLoad();\n        }\n    }\n}());\n","/**\n *\n *\n * @author Jerry Bendy <jerry@icewingcc.com>\n * @licence MIT\n *\n */\n\n(function(self) {\n    'use strict';\n\n    var nativeURLSearchParams = (function() {\n            // #41 Fix issue in RN\n            try {\n                if (self.URLSearchParams && (new self.URLSearchParams('foo=bar')).get('foo') === 'bar') {\n                    return self.URLSearchParams;\n                }\n            } catch (e) {}\n            return null;\n        })(),\n        isSupportObjectConstructor = nativeURLSearchParams && (new nativeURLSearchParams({a: 1})).toString() === 'a=1',\n        // There is a bug in safari 10.1 (and earlier) that incorrectly decodes `%2B` as an empty space and not a plus.\n        decodesPlusesCorrectly = nativeURLSearchParams && (new nativeURLSearchParams('s=%2B').get('s') === '+'),\n        __URLSearchParams__ = \"__URLSearchParams__\",\n        // Fix bug in Edge which cannot encode ' &' correctly\n        encodesAmpersandsCorrectly = nativeURLSearchParams ? (function() {\n            var ampersandTest = new nativeURLSearchParams();\n            ampersandTest.append('s', ' &');\n            return ampersandTest.toString() === 's=+%26';\n        })() : true,\n        prototype = URLSearchParamsPolyfill.prototype,\n        iterable = !!(self.Symbol && self.Symbol.iterator);\n\n    if (nativeURLSearchParams && isSupportObjectConstructor && decodesPlusesCorrectly && encodesAmpersandsCorrectly) {\n        return;\n    }\n\n\n    /**\n     * Make a URLSearchParams instance\n     *\n     * @param {object|string|URLSearchParams} search\n     * @constructor\n     */\n    function URLSearchParamsPolyfill(search) {\n        search = search || \"\";\n\n        // support construct object with another URLSearchParams instance\n        if (search instanceof URLSearchParams || search instanceof URLSearchParamsPolyfill) {\n            search = search.toString();\n        }\n        this [__URLSearchParams__] = parseToDict(search);\n    }\n\n\n    /**\n     * Appends a specified key/value pair as a new search parameter.\n     *\n     * @param {string} name\n     * @param {string} value\n     */\n    prototype.append = function(name, value) {\n        appendTo(this [__URLSearchParams__], name, value);\n    };\n\n    /**\n     * Deletes the given search parameter, and its associated value,\n     * from the list of all search parameters.\n     *\n     * @param {string} name\n     */\n    prototype['delete'] = function(name) {\n        delete this [__URLSearchParams__] [name];\n    };\n\n    /**\n     * Returns the first value associated to the given search parameter.\n     *\n     * @param {string} name\n     * @returns {string|null}\n     */\n    prototype.get = function(name) {\n        var dict = this [__URLSearchParams__];\n        return this.has(name) ? dict[name][0] : null;\n    };\n\n    /**\n     * Returns all the values association with a given search parameter.\n     *\n     * @param {string} name\n     * @returns {Array}\n     */\n    prototype.getAll = function(name) {\n        var dict = this [__URLSearchParams__];\n        return this.has(name) ? dict [name].slice(0) : [];\n    };\n\n    /**\n     * Returns a Boolean indicating if such a search parameter exists.\n     *\n     * @param {string} name\n     * @returns {boolean}\n     */\n    prototype.has = function(name) {\n        return hasOwnProperty(this [__URLSearchParams__], name);\n    };\n\n    /**\n     * Sets the value associated to a given search parameter to\n     * the given value. If there were several values, delete the\n     * others.\n     *\n     * @param {string} name\n     * @param {string} value\n     */\n    prototype.set = function set(name, value) {\n        this [__URLSearchParams__][name] = ['' + value];\n    };\n\n    /**\n     * Returns a string containg a query string suitable for use in a URL.\n     *\n     * @returns {string}\n     */\n    prototype.toString = function() {\n        var dict = this[__URLSearchParams__], query = [], i, key, name, value;\n        for (key in dict) {\n            name = encode(key);\n            for (i = 0, value = dict[key]; i < value.length; i++) {\n                query.push(name + '=' + encode(value[i]));\n            }\n        }\n        return query.join('&');\n    };\n\n    // There is a bug in Safari 10.1 and `Proxy`ing it is not enough.\n    var forSureUsePolyfill = !decodesPlusesCorrectly;\n    var useProxy = (!forSureUsePolyfill && nativeURLSearchParams && !isSupportObjectConstructor && self.Proxy);\n    /*\n     * Apply polifill to global object and append other prototype into it\n     */\n    Object.defineProperty(self, 'URLSearchParams', {\n        value: (useProxy ?\n            // Safari 10.0 doesn't support Proxy, so it won't extend URLSearchParams on safari 10.0\n            new Proxy(nativeURLSearchParams, {\n                construct: function(target, args) {\n                    return new target((new URLSearchParamsPolyfill(args[0]).toString()));\n                }\n            }) :\n            URLSearchParamsPolyfill)\n    });\n\n    var USPProto = self.URLSearchParams.prototype;\n\n    USPProto.polyfill = true;\n\n    /**\n     *\n     * @param {function} callback\n     * @param {object} thisArg\n     */\n    USPProto.forEach = USPProto.forEach || function(callback, thisArg) {\n        var dict = parseToDict(this.toString());\n        Object.getOwnPropertyNames(dict).forEach(function(name) {\n            dict[name].forEach(function(value) {\n                callback.call(thisArg, value, name, this);\n            }, this);\n        }, this);\n    };\n\n    /**\n     * Sort all name-value pairs\n     */\n    USPProto.sort = USPProto.sort || function() {\n        var dict = parseToDict(this.toString()), keys = [], k, i, j;\n        for (k in dict) {\n            keys.push(k);\n        }\n        keys.sort();\n\n        for (i = 0; i < keys.length; i++) {\n            this['delete'](keys[i]);\n        }\n        for (i = 0; i < keys.length; i++) {\n            var key = keys[i], values = dict[key];\n            for (j = 0; j < values.length; j++) {\n                this.append(key, values[j]);\n            }\n        }\n    };\n\n    /**\n     * Returns an iterator allowing to go through all keys of\n     * the key/value pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    USPProto.keys = USPProto.keys || function() {\n        var items = [];\n        this.forEach(function(item, name) {\n            items.push(name);\n        });\n        return makeIterator(items);\n    };\n\n    /**\n     * Returns an iterator allowing to go through all values of\n     * the key/value pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    USPProto.values = USPProto.values || function() {\n        var items = [];\n        this.forEach(function(item) {\n            items.push(item);\n        });\n        return makeIterator(items);\n    };\n\n    /**\n     * Returns an iterator allowing to go through all key/value\n     * pairs contained in this object.\n     *\n     * @returns {function}\n     */\n    USPProto.entries = USPProto.entries || function() {\n        var items = [];\n        this.forEach(function(item, name) {\n            items.push([name, item]);\n        });\n        return makeIterator(items);\n    };\n\n\n    if (iterable) {\n        USPProto[self.Symbol.iterator] = USPProto[self.Symbol.iterator] || USPProto.entries;\n    }\n\n\n    function encode(str) {\n        var replace = {\n            '!': '%21',\n            \"'\": '%27',\n            '(': '%28',\n            ')': '%29',\n            '~': '%7E',\n            '%20': '+',\n            '%00': '\\x00'\n        };\n        return encodeURIComponent(str).replace(/[!'\\(\\)~]|%20|%00/g, function(match) {\n            return replace[match];\n        });\n    }\n\n    function decode(str) {\n        return str\n            .replace(/[ +]/g, '%20')\n            .replace(/(%[a-f0-9]{2})+/ig, function(match) {\n                return decodeURIComponent(match);\n            });\n    }\n\n    function makeIterator(arr) {\n        var iterator = {\n            next: function() {\n                var value = arr.shift();\n                return {done: value === undefined, value: value};\n            }\n        };\n\n        if (iterable) {\n            iterator[self.Symbol.iterator] = function() {\n                return iterator;\n            };\n        }\n\n        return iterator;\n    }\n\n    function parseToDict(search) {\n        var dict = {};\n\n        if (typeof search === \"object\") {\n            // if `search` is an array, treat it as a sequence\n            if (isArray(search)) {\n                for (var i = 0; i < search.length; i++) {\n                    var item = search[i];\n                    if (isArray(item) && item.length === 2) {\n                        appendTo(dict, item[0], item[1]);\n                    } else {\n                        throw new TypeError(\"Failed to construct 'URLSearchParams': Sequence initializer must only contain pair elements\");\n                    }\n                }\n\n            } else {\n                for (var key in search) {\n                    if (search.hasOwnProperty(key)) {\n                        appendTo(dict, key, search[key]);\n                    }\n                }\n            }\n\n        } else {\n            // remove first '?'\n            if (search.indexOf(\"?\") === 0) {\n                search = search.slice(1);\n            }\n\n            var pairs = search.split(\"&\");\n            for (var j = 0; j < pairs.length; j++) {\n                var value = pairs [j],\n                    index = value.indexOf('=');\n\n                if (-1 < index) {\n                    appendTo(dict, decode(value.slice(0, index)), decode(value.slice(index + 1)));\n\n                } else {\n                    if (value) {\n                        appendTo(dict, decode(value), '');\n                    }\n                }\n            }\n        }\n\n        return dict;\n    }\n\n    function appendTo(dict, name, value) {\n        var val = typeof value === 'string' ? value : (\n            value !== null && value !== undefined && typeof value.toString === 'function' ? value.toString() : JSON.stringify(value)\n        );\n\n        // #47 Prevent using `hasOwnProperty` as a property name\n        if (hasOwnProperty(dict, name)) {\n            dict[name].push(val);\n        } else {\n            dict[name] = [val];\n        }\n    }\n\n    function isArray(val) {\n        return !!val && '[object Array]' === Object.prototype.toString.call(val);\n    }\n\n    function hasOwnProperty(obj, prop) {\n        return Object.prototype.hasOwnProperty.call(obj, prop);\n    }\n\n})(typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : this));\n","var map = {\n\t\"./ChatBot.js\": [\n\t\t785,\n\t\t727,\n\t\t149,\n\t\t785\n\t],\n\t\"./CountdownTimer.js\": [\n\t\t8007,\n\t\t727,\n\t\t149,\n\t\t7\n\t],\n\t\"./CreditCalculator.js\": [\n\t\t4427,\n\t\t727,\n\t\t149,\n\t\t427\n\t],\n\t\"./FilterIndex.js\": [\n\t\t4161,\n\t\t727,\n\t\t692,\n\t\t728,\n\t\t149,\n\t\t866,\n\t\t161\n\t],\n\t\"./FilterIndexItem.js\": [\n\t\t7074,\n\t\t727,\n\t\t149,\n\t\t74\n\t],\n\t\"./Filters.js\": [\n\t\t3710,\n\t\t727,\n\t\t692,\n\t\t149,\n\t\t710\n\t],\n\t\"./Filtr.js\": [\n\t\t5972,\n\t\t727,\n\t\t149,\n\t\t972\n\t],\n\t\"./LoanCalculator.js\": [\n\t\t4837,\n\t\t727,\n\t\t149,\n\t\t837\n\t],\n\t\"./RealOrNoReal.js\": [\n\t\t9685,\n\t\t727,\n\t\t149,\n\t\t685\n\t],\n\t\"./ResultsList.js\": [\n\t\t8527,\n\t\t727,\n\t\t692,\n\t\t728,\n\t\t149,\n\t\t866,\n\t\t527\n\t],\n\t\"./Roadtrip.js\": [\n\t\t3788,\n\t\t727,\n\t\t523,\n\t\t149,\n\t\t44\n\t],\n\t\"./Search.js\": [\n\t\t4621,\n\t\t727,\n\t\t149,\n\t\t621\n\t],\n\t\"./SearchResults.js\": [\n\t\t7954,\n\t\t727,\n\t\t692,\n\t\t728,\n\t\t149,\n\t\t866,\n\t\t954\n\t],\n\t\"./SearchResultsItem.js\": [\n\t\t2300,\n\t\t727,\n\t\t149,\n\t\t300\n\t],\n\t\"./TravelCalculator.js\": [\n\t\t811,\n\t\t727,\n\t\t149,\n\t\t811\n\t]\n};\nfunction webpackAsyncContext(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\treturn Promise.resolve().then(() => {\n\t\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\t\te.code = 'MODULE_NOT_FOUND';\n\t\t\tthrow e;\n\t\t});\n\t}\n\n\tvar ids = map[req], id = ids[0];\n\treturn Promise.all(ids.slice(1).map(__webpack_require__.e)).then(() => {\n\t\treturn __webpack_require__(id);\n\t});\n}\nwebpackAsyncContext.keys = () => (Object.keys(map));\nwebpackAsyncContext.id = 4871;\nmodule.exports = webpackAsyncContext;","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = (module) => {\n\tvar getter = module && module.__esModule ?\n\t\t() => (module['default']) :\n\t\t() => (module);\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".\" + {\"7\":\"c84180a4f0dd006abcb5\",\"44\":\"bb982a7f17c58d6734e8\",\"74\":\"c390e5773f2a26af18f2\",\"149\":\"c95a48c3f7f165cdc2dd\",\"161\":\"93a97128d68a90944e8d\",\"300\":\"6325453436e65cfcc288\",\"427\":\"ebbaf3c69f98bbe097bb\",\"523\":\"06c98a825f4068e41468\",\"527\":\"af48a9bf3089688b84a4\",\"621\":\"a3bcc9f566ab43eb20a8\",\"685\":\"d3bdb5b0cdfd90f2f343\",\"692\":\"f913f9976356d6b19c20\",\"710\":\"6284718191c3ff96a807\",\"727\":\"f085f2d04db91c6ff782\",\"728\":\"c0224fff938ff0011a43\",\"785\":\"e6c7b483154409952adf\",\"811\":\"9bfbdd0be91f7ea9423f\",\"837\":\"1b8505e04554192869fe\",\"866\":\"6e73b48554d4755acea9\",\"954\":\"b7098688d1ae9d3e16ed\",\"972\":\"405c5240407b7b9297b7\"}[chunkId] + \".js\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","__webpack_require__.b = document.baseURI || self.location.href;\n\n// object to store loaded and loading chunks\n// undefined = chunk not loaded, null = chunk preloaded/prefetched\n// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded\nvar installedChunks = {\n\t284: 0\n};\n\n__webpack_require__.f.j = (chunkId, promises) => {\n\t\t// JSONP chunk loading for javascript\n\t\tvar installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;\n\t\tif(installedChunkData !== 0) { // 0 means \"already installed\".\n\n\t\t\t// a Promise means \"currently loading\".\n\t\t\tif(installedChunkData) {\n\t\t\t\tpromises.push(installedChunkData[2]);\n\t\t\t} else {\n\t\t\t\tif(true) { // all chunks have JS\n\t\t\t\t\t// setup Promise in chunk cache\n\t\t\t\t\tvar promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));\n\t\t\t\t\tpromises.push(installedChunkData[2] = promise);\n\n\t\t\t\t\t// start chunk loading\n\t\t\t\t\tvar url = __webpack_require__.p + __webpack_require__.u(chunkId);\n\t\t\t\t\t// create error before stack unwound to get useful stacktrace later\n\t\t\t\t\tvar error = new Error();\n\t\t\t\t\tvar loadingEnded = (event) => {\n\t\t\t\t\t\tif(__webpack_require__.o(installedChunks, chunkId)) {\n\t\t\t\t\t\t\tinstalledChunkData = installedChunks[chunkId];\n\t\t\t\t\t\t\tif(installedChunkData !== 0) installedChunks[chunkId] = undefined;\n\t\t\t\t\t\t\tif(installedChunkData) {\n\t\t\t\t\t\t\t\tvar errorType = event && (event.type === 'load' ? 'missing' : event.type);\n\t\t\t\t\t\t\t\tvar realSrc = event && event.target && event.target.src;\n\t\t\t\t\t\t\t\terror.message = 'Loading chunk ' + chunkId + ' failed.\\n(' + errorType + ': ' + realSrc + ')';\n\t\t\t\t\t\t\t\terror.name = 'ChunkLoadError';\n\t\t\t\t\t\t\t\terror.type = errorType;\n\t\t\t\t\t\t\t\terror.request = realSrc;\n\t\t\t\t\t\t\t\tinstalledChunkData[1](error);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t};\n\t\t\t\t\t__webpack_require__.l(url, loadingEnded, \"chunk-\" + chunkId, chunkId);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n};\n\n// no prefetching\n\n// no preloaded\n\n// no HMR\n\n// no HMR manifest\n\n// no on chunks loaded\n\n// install a JSONP callback for chunk loading\nvar webpackJsonpCallback = (parentChunkLoadingFunction, data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\t// add \"moreModules\" to the modules object,\n\t// then flag all \"chunkIds\" as loaded and fire callback\n\tvar moduleId, chunkId, i = 0;\n\tif(chunkIds.some((id) => (installedChunks[id] !== 0))) {\n\t\tfor(moduleId in moreModules) {\n\t\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t\t}\n\t\t}\n\t\tif(runtime) var result = runtime(__webpack_require__);\n\t}\n\tif(parentChunkLoadingFunction) parentChunkLoadingFunction(data);\n\tfor(;i < chunkIds.length; i++) {\n\t\tchunkId = chunkIds[i];\n\t\tif(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {\n\t\t\tinstalledChunks[chunkId][0]();\n\t\t}\n\t\tinstalledChunks[chunkId] = 0;\n\t}\n\n}\n\nvar chunkLoadingGlobal = self[\"webpackChunkwls\"] = self[\"webpackChunkwls\"] || [];\nchunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));\nchunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));","import \"intersection-observer\";\r\nimport \"svgxuse\";\r\nimport \"url-search-params-polyfill\";\r\n\r\nimport objectFitImages from \"object-fit-images\";\r\nimport \"picturefill\";\r\nobjectFitImages();\r\n\r\nimport objectFitVideos from \"object-fit-videos\";\r\nobjectFitVideos();\r\n\r\nimport lazyloadPicturefillBackground from \"lazyload-picturefill-background\";\r\nnew lazyloadPicturefillBackground();\r\n","const vueComponents = () => {\r\n  const dataComponents = document.querySelectorAll('[data-vue-component]');\r\n\r\n  for (let i = 0; i < dataComponents.length; i++) {\r\n    const el = dataComponents[i];\r\n    const value = el.dataset.vueComponent;\r\n    const modules = value.split(' ').map((item) => item.trim());\r\n    for (let name = 0; name < modules.length; name++) {\r\n      import(`./imports/${modules[name]}.js`).then((Module) => {\r\n        const module = new Module.default(el);\r\n        module.init();\r\n      });\r\n    }\r\n  }\r\n};\r\n\r\nexport default vueComponents;\r\n","// globals\r\nimport '../globals/webpackPublicPath';\r\n\r\n// polyfills\r\nimport '../polyfills/index';\r\n\r\n// loads vue components async and inits\r\nimport vueComponents from '../vue/_index';\r\nvueComponents();\r\n"],"names":["inProgress","dataWebpackPrefix","__webpack_public_path__","document","querySelector","src","split","slice","join","window","IntersectionObserverEntry","prototype","Object","defineProperty","get","this","intersectionRatio","registry","IntersectionObserver","THROTTLE_TIMEOUT","POLL_INTERVAL","USE_MUTATION_OBSERVER","observe","target","_observationTargets","some","item","element","nodeType","Error","_registerInstance","push","entry","_monitorIntersections","_checkForIntersections","unobserve","filter","length","_unmonitorIntersections","_unregisterInstance","disconnect","takeRecords","records","_queuedEntries","_initThresholds","opt_threshold","threshold","Array","isArray","sort","t","i","a","isNaN","_parseRootMargin","opt_rootMargin","margins","map","margin","parts","exec","value","parseFloat","unit","_monitoringIntersections","_monitoringInterval","setInterval","addEvent","_domObserver","MutationObserver","attributes","childList","characterData","subtree","clearInterval","removeEvent","rootIsInDom","_rootIsInDom","rootRect","_getRootRect","top","bottom","left","right","width","height","forEach","targetRect","getBoundingClientRect","rootContainsTarget","_rootContainsTarget","oldEntry","intersectionRect","_computeTargetAndRootIntersection","newEntry","time","performance","now","boundingClientRect","rootBounds","_hasCrossedThreshold","isIntersecting","_callback","getComputedStyle","display","rect1","rect2","parent","getParentNode","atRoot","parentRect","parentComputedStyle","root","body","documentElement","overflow","Math","max","min","html","clientWidth","clientHeight","_expandRectByRootMargin","rect","_rootMarginValues","newRect","oldRatio","newRatio","thresholds","containsDeep","indexOf","index","splice","targetArea","intersectionArea","Number","toFixed","callback","opt_options","fn","timeout","timer","options","bind","setTimeout","rootMargin","node","event","opt_useCapture","addEventListener","attachEvent","removeEventListener","detatchEvent","el","err","child","parentNode","host","assignedSlot","lazyloadPicturefillBackground","constructor","updateDefaultSettings","init","userSettings","defaultSettings","pictureFillBackgroundSelector","lazySelector","pictureFillBackgroundSourceSelector","attrName","querySelectorAll","call","matches","mqMatches","sources","getSources","mq","matchMedia","media","addListener","RegExp","escapeRegExp","test","style","backgroundImage","classList","contains","substring","createObserver","pop","sourcesEls","source","sourceObj","getAttribute","that","observer","entries","lazyImage","remove","string","replace","OFI","propRegex","testImg","Image","supportsObjectFit","supportsObjectPosition","supportsOFI","supportsCurrentSrc","currentSrc","nativeGetAttribute","nativeSetAttribute","setAttribute","autoModeEnabled","setPlaceholder","img","placeholder","onImageReady","naturalWidth","fixOne","parsed","fontFamily","props","getStyle","ofi","skipTest","srcset","naturalHeight","descriptors","prop","set","ss","keepSrcUsable","console","picturefill","pf","_","ns","evaled","fillImg","reselect","curSrc","supported","polyfillCurrentSrc","backgroundPosition","backgroundRepeat","backgroundOrigin","backgroundSize","fix","imgs","opts","startAutoMode","getElementsByTagName","e","tagName","watchMQ","getOfiImageMaybe","name","HTMLImageElement","String","hijackAttributes","module","exports","videos","isEdge","navigator","userAgent","$el","parsePosition","fitIt","setCss","getCss","$wrap","createElement","appendChild","replaceChild","wrapCss","boxSizing","key","border","padding","opacity","doWork","readyState","videoRatio","videoWidth","videoHeight","wrapWidth","wrapHeight","wrapRatio","newHeight","newWidth","marginLeft","marginTop","round","autoplay","play","initialize","type","obj","running","evt","CustomEvent","createEvent","initEvent","func","requestAnimationFrame","dispatchEvent","throttle","dummySrc","fixRespimg","findPictureImgs","onResize","ua","HTMLPictureElement","match","$1","sizes","picture","nodeName","toUpperCase","cloneNode","insertBefore","firstElementChild","removeChild","_pfLastSize","offsetWidth","clearTimeout","undefined","eminpx","alwaysCheckWDescriptor","evalId","isSupportTestReady","noop","image","getImgAttr","setImgAttr","removeImgAttr","removeAttribute","docElem","types","cfg","algorithm","srcAttr","srcsetAttr","supportAbort","curSrcProp","regWDesc","regSize","setOptions","picturefillCFG","fsCss","isVwDirty","cssCache","sizeLengthCache","DPR","devicePixelRatio","units","px","anchor","alreadyRun","regexLeadingSpaces","regexLeadingCommasOrSpaces","regexLeadingNotSpaces","regexTrailingCommas","regexNonNegativeInteger","regexFloatingPoint","on","capture","memoize","cache","input","isSpace","c","regLength","buildStr","image2","width1","isDomReady","wait","timestamp","later","regReady","run","timerId","lastClientWidth","evalCSS","css","args","arguments","toLowerCase","parsedLength","Function","setResolution","candidate","sizesattr","w","cWidth","calcListLength","res","d","opt","elements","plen","context","qsa","reevaluate","sel","selShort","setupRun","teardownRun","ascendingSort","b","getCandidateForSrc","candidates","parseSet","makeUrl","url","warn","implementation","hasFeature","Date","getTime","substr","supSrcset","supSizes","supPicture","complete","onload","onerror","u","setSize","href","matchesMedia","mMQ","apply","calcLength","sourceSizeValue","supportsType","parseSize","sourceSizeStr","cands","collectCharacters","regEx","chars","pos","currentDescriptor","state","inputLength","parseDescriptors","h","desc","lastChar","intVal","floatVal","pError","parseInt","has1x","tokenize","charAt","parseSrcset","getEmValue","div","originalHTMLCSS","cssText","originalBodyCSS","sourceSizeListStr","uT","winningLength","strValue","unparsedSizesList","unparsedSizesListLength","unparsedSize","lastComponentValue","size","s","regexCssLengthWithUnits","regexCssCalc","str","chrctr","component","componentArray","listArray","parenDepth","inComment","pushComponent","pushComponentArray","parseComponentValues","parseSizes","setRes","len","applySetCandidate","j","bestCandidate","curCan","candidateSrc","abortCurSrc","lowerValue","higherValue","dprValue","isCached","bonusFactor","bonus","meanDensity","imageData","dpr","sets","setSrcToCur","cached","pow","sqrt","setSrc","origWidth","getSet","parseSets","srcsetAttribute","imageSet","isWDescripor","srcsetParsed","hasPicture","pic","getAllSourceElements","extreme","srcSetCandidates","matchingSet","evaluated","applyBestCandidate","innerWidth","innerHeight","vw","vh","em","rem","fillImgs","last","shift","typeUri","detectTypeSupport","checkUseElems","tid","winLoad","create","debouncedCheck","unobserveChanges","createRequest","getOrigin","loc","protocol","Request","origin","origin2","XMLHttpRequest","location","withCredentials","XDomainRequest","xlinkNS","base","bcr","hash","isHidden","uses","xhr","inProgressCount","observeIfDone","ignore","attrUpdateFunc","spec","useEl","setAttributeNS","hasAttribute","onloadFunc","svg","x","innerHTML","responseText","position","firstChild","onErrorTimeout","ontimeout","getAttributeNS","open","send","abort","self","ampersandTest","nativeURLSearchParams","URLSearchParams","isSupportObjectConstructor","toString","decodesPlusesCorrectly","__URLSearchParams__","encodesAmpersandsCorrectly","append","URLSearchParamsPolyfill","iterable","Symbol","iterator","appendTo","dict","has","getAll","hasOwnProperty","query","encode","useProxy","Proxy","construct","USPProto","polyfill","thisArg","parseToDict","getOwnPropertyNames","k","keys","values","items","makeIterator","search","encodeURIComponent","decode","decodeURIComponent","arr","next","done","TypeError","pairs","val","JSON","stringify","g","webpackAsyncContext","req","__webpack_require__","o","Promise","resolve","then","code","ids","id","all","__webpack_module_cache__","moduleId","cachedModule","loaded","__webpack_modules__","m","n","getter","__esModule","definition","enumerable","f","chunkId","reduce","promises","globalThis","l","script","needAttach","scripts","charset","nc","onScriptComplete","prev","doneFns","head","r","toStringTag","nmd","paths","children","scriptUrl","importScripts","currentScript","p","baseURI","installedChunks","installedChunkData","promise","reject","error","errorType","realSrc","message","request","webpackJsonpCallback","parentChunkLoadingFunction","data","chunkIds","moreModules","runtime","chunkLoadingGlobal","objectFitImages","objectFitVideos","vueComponents","dataComponents","_loop","modules","dataset","vueComponent","trim","Module","default"],"sourceRoot":""}