256b551e-1832dd584c826cd29ac8.js.map

{"version":3,"file":"256b551e-1832dd584c826cd29ac8.js","mappings":"qVAyBA,MAAMA,GAKC,MAAMC,EAKEC,wBACP,MAAO,kBACX,CAIWC,qBACP,MAAO,QACX,CAIIC,kBACA,IAAIA,EAAcC,KAAKC,KAAOD,KAAKE,aAInC,OAHIF,KAAKG,MAAMC,wBACXL,GAAe,kCAEZA,CACX,CAIIE,WACA,OAAOD,KAAKK,KAChB,CACIJ,SAAKK,GACLN,KAAKK,MAAQC,CACjB,CAIIC,cACA,OAAOP,KAAKQ,aAChB,CACIC,iBACA,OAAOT,KAAKU,WAChB,CAIWC,+BACP,OAAO,IAAOA,iBAClB,CACWA,6BAAkBL,GACzB,IAAOK,kBAAoBL,CAC/B,CAIAM,oBAAoBC,GAChB,OAAOb,KAAKc,gBAChB,CAKIC,4BACA,OAAOf,KAAKgB,sBAChB,CACID,0BAAsBE,GAClBA,IAAejB,KAAKgB,yBAGxBhB,KAAKgB,uBAAyBC,EAE1BjB,KAAKkB,mBAAmBC,UADxBF,EACoC,IAGA,IAE5C,CAIIG,cACA,OAAOpB,KAAKqB,QAChB,CAKIC,6BACA,OAAOtB,KAAKE,aAAe,IAAMF,KAAKuB,qBAC1C,CAKAC,qBACI,OAAOxB,KAAKyB,gBAChB,CAEIC,oCACA,SAAU1B,KAAKG,MAAMwB,+BAAgC3B,KAAK4B,6BAC9D,CAKIC,sBACA,OAAO7B,KAAKQ,cAAgB,GAAKR,KAAK8B,gBAC1C,CAKIC,wBACA,OAAO/B,KAAKgC,kBAChB,CAKIC,6BACA,OAAOjC,KAAKkC,uBAChB,CACID,2BAAuB3B,GACvBN,KAAKkC,wBAA0B5B,CACnC,CACI6B,wCACA,OAAO,CACX,CAMIC,gCAA4BC,GAC5BrC,KAAKsC,6BAA+BD,CACxC,CAIIE,sBACA,OAAOvC,KAAKwC,eAChB,CAIIC,mBAIA,OAHKzC,KAAK0C,gBACN1C,KAAK0C,cAAgB1C,KAAK2C,iBAAiB,IAAIC,WAAW,GAAI,EAAG,EAAG,GAAG,GAAO,EAAO,IAElF5C,KAAK0C,aAChB,CAIIG,qBAIA,OAHK7C,KAAK8C,kBACN9C,KAAK8C,gBAAkB9C,KAAK+C,mBAAmB,IAAIH,WAAW,GAAI,EAAG,EAAG,EAAG,GAAG,GAAO,EAAO,IAEzF5C,KAAK8C,eAChB,CAIIE,0BAIA,OAHKhD,KAAKiD,uBACNjD,KAAKiD,qBAAuBjD,KAAKkD,wBAAwB,IAAIN,WAAW,GAAI,EAAG,EAAG,EAAG,GAAG,GAAO,EAAO,IAEnG5C,KAAKiD,oBAChB,CAIIE,uBACA,IAAKnD,KAAKoD,kBAAmB,CACzB,MAAMC,EAAW,IAAIT,WAAW,GAC1BU,EAAW,CAACD,EAAUA,EAAUA,EAAUA,EAAUA,EAAUA,GACpErD,KAAKoD,kBAAoBpD,KAAKuD,qBAAqBD,EAAU,EAAG,EAAG,GAAG,GAAO,EAAO,EACxF,CACA,OAAOtD,KAAKoD,iBAChB,CAIII,eACA,OAAOxD,KAAKyD,SAChB,CAIIC,yBACA,OAAO1D,KAAK2D,mBAChB,CAKIC,wBACA,OAAO,CACX,CACIA,sBAAkBC,GAEtB,CAIIC,4BACA,OAAO9D,KAAK+D,sBAChB,CACID,0BAAsBE,GACtBhE,KAAK+D,uBAAyBC,CAClC,CAIAC,yBACIjE,KAAK4D,mBAAoB,CAC7B,CACAM,qBAAqBC,EAAOC,GACxB,GAAwB,oBAAbC,SACP,OAAO,IAAIC,gBAAgBH,EAAOC,GAEtC,MAAMG,EAASF,SAASG,cAAc,UAGtC,OAFAD,EAAOJ,MAAQA,EACfI,EAAOH,OAASA,EACTG,CACX,CAOAE,aAAaN,EAAOC,GAChB,OAAOxE,EAAW8E,cAAcP,EAAOC,EAC3C,CAKAO,oBACI,OAAON,SAASG,cAAc,MAClC,CAQAI,YAAYC,EAAiBC,EAAWC,EAASC,GAC7C,IAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAAIC,EAE5C3F,KAAKK,MAAQ,QACbL,KAAKU,aAAc,EAInBV,KAAK8B,kBAAmB,EAIxB9B,KAAK4F,cAAe,EAKpB5F,KAAK6F,cAAgB,KAIrB7F,KAAK8F,wBAAyB,EAI9B9F,KAAK+F,+BAAgC,EAErC/F,KAAKgG,wBAAyB,EAC9BhG,KAAKgB,wBAAyB,EAI9BhB,KAAKiG,iBAAkB,EAIvBjG,KAAKkG,qBAAsB,EAI3BlG,KAAKuB,uBAAwB,EAI7BvB,KAAKmG,oBAAsB,IAAI,KAC/BnG,KAAKqB,SAAW,EAEhBrB,KAAKoG,gBAAkB,IAAIC,MAE3BrG,KAAKsG,gBAAkB,IAAID,MAE3BrG,KAAKQ,cAAgB,EACrBR,KAAKuG,qBAAsB,EAC3BvG,KAAK4B,8BAA+B,EAEpC5B,KAAKwG,QAAS,EAEdxG,KAAKyG,eAAgB,EACrBzG,KAAK0G,yBAA0B,EAC/B1G,KAAKgC,mBAAqB,IAAIqE,MAK9BrG,KAAK2G,wBAA0B,IAAI,KAInC3G,KAAK4G,4BAA8B,IAAI,KACvC5G,KAAK6G,iBAAkB,EAEvB7G,KAAKkC,yBAA0B,EAI/BlC,KAAK8G,2BAA4B,EAGjC9G,KAAK+G,aAAc,EAEnB/G,KAAKgH,oBAAqB,EAE1BhH,KAAKkB,mBAAqB,IAAI,IAE9BlB,KAAKiH,sBAAwB,IAAI,IAEjCjH,KAAKkH,cAAgB,IAAI,IAEzBlH,KAAKmH,YAAc,IAAI,IAEvBnH,KAAKoH,WAAa,EAElBpH,KAAKqH,eAAiB,EAGtBrH,KAAKsH,uBAAyB,IAAIjB,MAElCrG,KAAKuH,0BAA4B,IAAIlB,MAErCrG,KAAKwH,eAAiB,EACtBxH,KAAKyH,wBAA0B,EAE/BzH,KAAK0H,oBAAsB,CAAC,EAC5B1H,KAAK2H,iBAAmB,CAAC,EACzB3H,KAAK4H,2BAA6B,GAClC5H,KAAK6H,0BAA2B,EAChC7H,KAAK8H,oBAAsB,IAAIzB,MAE/BrG,KAAK+H,oBAAsB,KAE3B/H,KAAKgI,kBAAoB,KACzBhI,KAAKiI,uBAAyB,IAAI5B,MAClCrG,KAAKkI,0BAA4B,IAAI7B,MACrCrG,KAAKmI,wBAA0B,IAAI9B,MACnCrG,KAAKoI,sBAAuB,EAC5BpI,KAAKqI,2BAA4B,EACjCrI,KAAKsI,sBAAwB,IAAIjC,MACjCrG,KAAKuI,yBAA2B,EAChCvI,KAAKwI,wBAA0B,KAC/BxI,KAAKyI,gBAAkB,IAAIpC,MAI3BrG,KAAKgF,oBAAqB,EAE1BhF,KAAK0I,sBAAwB,EAE7B1I,KAAK2I,qBAAuB,KAI5B3I,KAAK4I,gBAAkB,CACnBC,UAAU,GAKd7I,KAAK8I,oBAAqB,EAI1B9I,KAAK+I,8BAAgC,IAAI,KAEzC/I,KAAKyD,WAAY,EACjBzD,KAAK+D,uBAAyB,EAC9B/D,KAAKgJ,gBAAkB,CAAEC,EAAG,EAAGC,EAAG,EAAGC,EAAG,EAAGC,EAAG,GAC9CpJ,KAAKqJ,mBAAqB,KAM1BrJ,KAAKsJ,yBAA0B,EAC/BtJ,KAAKuJ,eAAiB,CAAC,EACvBvJ,KAAKwJ,UAAY,IAAcC,IAC/B,IAAIlF,EAAS,KACbQ,EAAUA,GAAW,CAAC,EACtB/E,KAAKyB,iBAAmBsD,EAExB/E,KAAKgF,mBAAqBA,SAA+DA,EACzFhF,KAAKiH,sBAAsByC,cAAgB1J,KAAKkH,cAChD,IAAwByC,qBAAqB5E,EAAQ6E,wBACrD7E,EAAQD,UAAYA,QAA6CA,EAAYC,EAAQD,UACrFC,EAAQ8E,sBAAiE,QAAxC5E,EAAKF,EAAQ8E,6BAA0C,IAAP5E,GAAgBA,EACjGF,EAAQ+E,iBAAuD,QAAnC5E,EAAKH,EAAQ+E,wBAAqC,IAAP5E,EAAgBA,EAAK,EAC5FH,EAAQgF,SAAuC,QAA3B5E,EAAKJ,EAAQgF,gBAA6B,IAAP5E,EAAgBA,EAAK,EAAI,GAChFJ,EAAQiF,YAA6C,QAA9B5E,EAAKL,EAAQiF,mBAAgC,IAAP5E,GAAgBA,EAC7EL,EAAQkF,QAAqC,QAA1B5E,EAAKN,EAAQkF,eAA4B,IAAP5E,GAAgBA,EACrErF,KAAKkK,cAAkH,QAAjG3E,EAA2C,QAArCD,EAAKP,EAAQoF,0BAAuC,IAAP7E,OAAgB,EAASA,EAAG8E,oBAAiC,IAAP7E,EAAgBA,EAAK,KACpJvF,KAAKqK,kBAA0H,QAArG5E,EAA2C,QAArCD,EAAKT,EAAQoF,0BAAuC,IAAP3E,OAAgB,EAASA,EAAG8E,wBAAqC,IAAP7E,EAAgBA,EAAK,KAC5JzF,KAAK8I,mBAA2D,QAArCpD,EAAKX,EAAQ+D,0BAAuC,IAAPpD,GAAgBA,EACxF1F,KAAKuK,wBAAqE,QAA1C5E,EAAKZ,EAAQwF,+BAA4C,IAAP5E,GAAgBA,EAClG3F,KAAKkC,0BAA4B6C,EAAQ9C,uBACzCjC,KAAKwK,mBAAmBzF,EAAQkF,QAEhCjF,EAAqBA,GAAsBD,EAAQC,qBAAsB,EACzE,MAAMyF,GAAmB,WAAwBC,OAAOD,kBAA0B,EAC5EE,EAAmB5F,EAAQ4F,kBAAoBF,EAGrD,GAFAzK,KAAK4K,sBAAwB5F,EAAqB,EAAM6F,KAAKC,IAAIH,EAAkBF,GAAoB,EACvGzK,KAAK0I,sBAAwB+B,GACxB5F,EACD,OAEJ,GAAIA,EAAgBkG,WAAY,CAU5B,GATAxG,EAASM,EACT7E,KAAKgL,iBAAmBzG,OACc0G,IAAlClG,EAAQmG,wBACRnG,EAAQmG,uBAAwB,QAEPD,IAAzBlG,EAAQoG,eACRpG,EAAQoG,cAAe,GAGvBC,WAAaA,UAAUC,UAAW,CAClCrL,KAAKsL,qBACL,MAAMC,EAAKH,UAAUC,UACrB,IAAK,MAAMG,KAAa5L,EAAW6L,cAAe,CAC9C,MAAMC,EAAMF,EAAUE,IAChBC,EAAUH,EAAUG,QAE1B,GADc,IAAIC,OAAOF,GACfG,KAAKN,GAAK,CAChB,GAAIC,EAAUM,SAAWN,EAAUO,kBAAmB,CAClD,MAAMD,EAAUN,EAAUM,QACpBE,EAAaR,EAAUO,kBAEvBE,EADQ,IAAIL,OAAOE,GACHI,KAAKX,GAC3B,GAAIU,GAAWA,EAAQE,OAAS,EAAG,CAE/B,GADsBC,SAASH,EAAQA,EAAQE,OAAS,KACnCH,EACjB,QAER,CACJ,CACA,IAAK,MAAMK,KAAUV,EACjB,OAAQU,GACJ,IAAK,gBACDrM,KAAKuB,uBAAwB,EAC7B,MACJ,IAAK,MACDvB,KAAK8G,2BAA4B,EACjC,MACJ,IAAK,YACD/B,EAAQD,WAAY,EACpB,MACJ,IAAK,iBACD9E,KAAKwI,wBAA0B,EAI/C,CACJ,CACJ,CAsBA,GApBKxI,KAAKkC,0BACNlC,KAAKsM,eAAkBC,IACnBA,EAAIC,iBACJxM,KAAK6G,iBAAkB,EACvB,IAAO4F,KAAK,uBACZzM,KAAK2G,wBAAwB+F,gBAAgB1M,KAAK,EAEtDA,KAAK2M,mBAAqB,KACtB3M,KAAK4M,+BAA+B5M,KAAK6M,eAAeC,KAAK9M,MAAM,EAEvEuE,EAAOwI,iBAAiB,mBAAoB/M,KAAKsM,gBAAgB,GACjE/H,EAAOwI,iBAAiB,uBAAwB/M,KAAK2M,oBAAoB,GACzE5H,EAAQiI,gBAAkBjI,EAAQiI,iBAAmB,oBAGzDhN,KAAKyG,cAAgB,iCAAiCoF,KAAKT,UAAUC,WACjErL,KAAKyG,gBACL1B,EAAQoG,cAAe,IAGtBpG,EAAQkI,qBACT,IACIjN,KAAKkN,IAAO3I,EAAOwG,WAAW,SAAUhG,IAAYR,EAAOwG,WAAW,sBAAuBhG,GACzF/E,KAAKkN,MACLlN,KAAKQ,cAAgB,EACrBR,KAAK2D,oBAAsB,SAEtB3D,KAAKkN,IAAIC,cACVnN,KAAKQ,cAAgB,EACrBR,KAAK2D,oBAAsB,UAGvC,CACA,MAAOyJ,GAEP,CAEJ,IAAKpN,KAAKkN,IAAK,CACX,IAAK3I,EACD,MAAM,IAAI8I,MAAM,6CAEpB,IACIrN,KAAKkN,IAAO3I,EAAOwG,WAAW,QAAShG,IAAYR,EAAOwG,WAAW,qBAAsBhG,EAC/F,CACA,MAAOqI,GACH,MAAM,IAAIC,MAAM,sBACpB,CACJ,CACA,IAAKrN,KAAKkN,IACN,MAAM,IAAIG,MAAM,sBAExB,KACK,CACDrN,KAAKkN,IAAMrI,EACX7E,KAAKgL,iBAAmBhL,KAAKkN,IAAI3I,OAC7BvE,KAAKkN,IAAII,gCACTtN,KAAKQ,cAAgB,EACrBR,KAAK2D,oBAAsB,UAG3B3D,KAAK2D,oBAAsB,SAE/B,MAAM4J,EAAavN,KAAKkN,IAAIM,uBACxBD,IACAxI,EAAQkF,QAAUsD,EAAWtD,QAErC,CAEAjK,KAAKkN,IAAIO,YAAYzN,KAAKkN,IAAIQ,mCAAoC1N,KAAKkN,IAAIS,WACpC1C,IAAnClG,EAAQ6I,yBACR5N,KAAK4B,6BAA+BmD,EAAQ6I,wBAEhD5N,KAAK6N,SACL7N,KAAK6M,iBACL7M,KAAK8N,gBAEL,IAAK,IAAIC,EAAI,EAAGA,EAAI/N,KAAKG,MAAM6N,iBAAkBD,IAC7C/N,KAAKiI,uBAAuB8F,GAAK,IAAIpO,EAGzCK,KAAKc,iBAAmBd,KAAKE,aAAe,EAAI,IAAI,IAA0B,IAAI,IAElFF,KAAKwG,OAAS,QAAQqF,KAAKT,UAAUC,YAAc,UAAUQ,KAAKT,UAAUC,WAQ5E,MAAM4C,EAAe,eAAerO,EAAWE,UAC/CoO,QAAQC,IAAIF,EAAe,MAAMjO,KAAKD,eAElCC,KAAKgL,kBAAoBhL,KAAKgL,iBAAiBoD,cAC/CpO,KAAKgL,iBAAiBoD,aAAa,cAAeH,EAE1D,CACA3C,qBACUF,WAAaA,UAAUC,YAI7BrL,KAAKqO,gBAAkB,KACnB,MAAMC,EAAYlD,UAAUC,UAC5BrL,KAAK4I,gBAAgBC,UACgB,IAAjCyF,EAAUC,QAAQ,YAEiB,IAA9BD,EAAUC,QAAQ,SAAiB,WAAyB,eAAgBlK,QAAS,EAGlGrE,KAAKqO,mBAED,WACA3D,OAAOqC,iBAAiB,SAAU/M,KAAKqO,iBAE/C,CACAzB,+BAA+B4B,GAE3BC,YAAWC,UACP,IAAIzJ,EACJjF,KAAKgI,kBAAoB,KACzB,MAAM2G,EAAY3O,KAAKkB,mBAAmByN,UACpCxN,EAAYnB,KAAKkB,mBAAmBC,UACpCyN,EAAY5O,KAAKkB,mBAAmB0N,UACpCC,EAAc7O,KAAKkH,cAAc2H,kBAEjCL,IAENxO,KAAK8O,YAAW,GAEhB9O,KAAK+O,kBACkC,QAAtC9J,EAAKjF,KAAKgP,8BAA2C,IAAP/J,GAAyBA,EAAGgK,KAAKjP,MAKhFA,KAAKkP,kBAELlP,KAAKmP,2BAELnP,KAAKoP,+BAELpP,KAAK8O,YAAW,GAChB9O,KAAKkB,mBAAmByN,UAAYA,EACpC3O,KAAKkB,mBAAmBC,UAAYA,EACpCnB,KAAKkB,mBAAmB0N,UAAYA,EACpC5O,KAAKkH,cAAc2H,YAAcA,EACjC,IAAOpC,KAAKzM,KAAKC,KAAO,mCACxBD,KAAK4G,4BAA4B8F,gBAAgB1M,MACjDA,KAAK6G,iBAAkB,CAAK,GAC7B,EACP,CAKAwI,YAAY9K,GACRvE,KAAKgL,iBAAmBzG,CAC5B,CAIA+K,4BAA4BzO,GACxB,OAAO,IACX,CACAsO,2BACI,MAAMI,EAAevP,KAAKsH,uBAAuBkI,QACjD,IAAK,MAAMC,KAAmBF,EAC1BE,EAAgBC,UAExB,CACAN,+BACI,MAAMG,EAAevP,KAAKuH,0BAA0BiI,QACpD,IAAK,MAAMG,KAAuBJ,EAC9BI,EAAoBD,UAE5B,CACAX,kBACI,IAAK,MAAMrD,KAAO1L,KAAK2H,iBAAkB,CACrC,MAAMiI,EAAS5P,KAAK2H,iBAAiB+D,GACrCkE,EAAOC,iBAAmB,KAC1BD,EAAOE,qBAAsB,EAC7BF,EAAOG,gBACX,CACA,IAAOC,YACX,CAKAC,qBACI,IAAK,MAAMvE,KAAO1L,KAAK2H,iBAAkB,CAErC,IADe3H,KAAK2H,iBAAiB+D,GACzBwE,UACR,OAAO,CAEf,CACA,OAAO,CACX,CACAhB,kBAEI,IAAK,MAAMiB,KAAiBnQ,KAAKoG,gBAC7B+J,EAAcT,WAGlB,IAAK,MAAMU,KAAiBpQ,KAAKsG,gBAC7B8J,EAAcV,UAEtB,CACA7C,iBACI,IAAI5H,EAEJjF,KAAKG,MAAQ,CACTkQ,sBAAuBrQ,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIqD,yBACtDC,8BAA+BxQ,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIuD,kCAC9DC,2BAA4B1Q,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIyD,gCAC3DC,eAAgB5Q,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAI2D,kBAC/CC,WAAY9Q,KAAKQ,cAAgB,EAAIR,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAI6D,aAAe,EACnFC,sBAAuBhR,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAI+D,2BACtDC,qBAAsBlR,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIiE,uBACrDnD,iBAAkBhO,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIkE,oBACjDC,kBAAmBrR,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIoE,qBAClDC,0BAA2BvR,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIsE,8BAC1DC,wBAAyBzR,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIwE,4BACxDtR,sBAAuBJ,KAAKkN,IAAIyE,aAAa,qCAAkC1G,EAC/E2G,oBAAqB5R,KAAKQ,cAAgB,GAA2D,OAAtDR,KAAKkN,IAAIyE,aAAa,4BACrEE,cAAe,EACfC,KAAM9R,KAAKkN,IAAIyE,aAAa,kCAAoC3R,KAAKkN,IAAIyE,aAAa,wCACtFI,KAAM/R,KAAKkN,IAAIyE,aAAa,iCAAmC3R,KAAKkN,IAAIyE,aAAa,uCACrFK,KAAMhS,KAAKkN,IAAIyE,aAAa,kCAAoC3R,KAAKkN,IAAIyE,aAAa,wCAEtFM,UAAWjS,KAAKkN,IAAIyE,aAAa,uCAAyC3R,KAAKkN,IAAIyE,aAAa,6CAChGO,MAAOlS,KAAKkN,IAAIyE,aAAa,mCAAqC3R,KAAKkN,IAAIyE,aAAa,yCACxFQ,KAAMnS,KAAKkN,IAAIyE,aAAa,kCAAoC3R,KAAKkN,IAAIyE,aAAa,wCACtFS,KAAMpS,KAAKkN,IAAIyE,aAAa,iCACxB3R,KAAKkN,IAAIyE,aAAa,wCACtB3R,KAAKkN,IAAIyE,aAAa,kCAC1BU,kCAAmCrS,KAAKkN,IAAIyE,aAAa,mCACrD3R,KAAKkN,IAAIyE,aAAa,0CACtB3R,KAAKkN,IAAIyE,aAAa,sCAC1BW,YAAatS,KAAKQ,cAAgB,GAAyD,OAApDR,KAAKkN,IAAIyE,aAAa,0BAC7DY,uBAAwBvS,KAAKQ,cAAgB,GAAiD,OAA5CR,KAAKkN,IAAIyE,aAAa,kBACxEhQ,8BAA8B,EAC9B6Q,WAAYxS,KAAKkN,IAAIyE,aAAa,oCAAsC3R,KAAKkN,IAAIyE,aAAa,4BAC9Fc,sBAAuBzS,KAAKQ,cAAgB,EAC5CkS,8BAA8B,EAC9BC,sBAAsB,EACtBC,eAAgB,EAChBC,oBAAqB7S,KAAKQ,cAAgB,GAAKR,KAAKkN,IAAIyE,aAAa,2BACrEmB,wBAAyB9S,KAAKQ,cAAgB,GAAKR,KAAKkN,IAAIyE,aAAa,gCACzEoB,gBAAc/S,KAAKQ,cAAgB,GAAKR,KAAKkN,IAAIyE,aAAa,sBAC9DqB,oBAAkBhT,KAAKQ,cAAgB,GAAKR,KAAKkN,IAAIyE,aAAa,2BAClEsB,wBAAwB,EACxBC,6BAA6B,EAC7BC,oBAAoB,EACpBC,iCAAiC,EACjCC,mBAAmB,EACnBC,iBAAiB,EACjBC,cAAYvT,KAAKQ,cAAgB,GAAKR,KAAKkN,IAAIyE,aAAa,2BAC5D6B,WAAmC,IAAvBxT,KAAKQ,cACjBiT,aAAa,EACbC,UAAW1T,KAAKkN,IAAIyE,aAAa,kBACjCgC,gBAAiB3T,KAAKkN,IAAIyE,aAAa,oBACvCiC,uBAAuB,EACvBC,mBAAoB7T,KAAKQ,cAAgB,EACzCsT,iBAAkB9T,KAAKQ,cAAgB,EACvCuT,uBAAuB,EACvBC,oBAAoB,EACpBC,0BAA2BjU,KAAKQ,cAAgB,EAChD0T,gBAAiBlU,KAAKQ,cAAgB,EACtC2T,4BAA6BnU,KAAKQ,cAAgB,EAAIR,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIkH,0BAA4B,IACjHC,2BAA2B,GAG/BrU,KAAKsU,WAAatU,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAIqH,SACjD,MAAMC,EAAexU,KAAKkN,IAAIyE,aAAa,6BA+D3C,GA9DoB,MAAhB6C,IACAxU,KAAKyU,YAAczU,KAAKkN,IAAIoD,aAAakE,EAAaE,yBACtD1U,KAAK2U,UAAY3U,KAAKkN,IAAIoD,aAAakE,EAAaI,wBAEnD5U,KAAK2U,YACN3U,KAAK2U,UAAY3U,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAI2H,SAAW,kBAE1D7U,KAAKyU,cACNzU,KAAKyU,YAAczU,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAI4H,WAAa,oBAGnC,QAA5B9U,KAAKkN,IAAI6H,iBACT/U,KAAKkN,IAAI6H,eAAiB,OAEL,QAArB/U,KAAKkN,IAAI8H,UACThV,KAAKkN,IAAI8H,QAAU,OAEE,QAArBhV,KAAKkN,IAAI+H,UACTjV,KAAKkN,IAAI+H,QAAU,OAEW,QAA9BjV,KAAKkN,IAAIgI,mBACTlV,KAAKkN,IAAIgI,iBAAmB,OAG5BlV,KAAKG,MAAMqS,aACgB,IAAvBxS,KAAKQ,gBACLR,KAAKkN,IAAIiI,SAAWnV,KAAKG,MAAMqS,WAAW4C,YAAYtI,KAAK9M,KAAKG,MAAMqS,aAG1ExS,KAAKG,MAAMuS,8BAAgJ,QAA/GzN,EAAKjF,KAAKkN,IAAIiI,SAASnV,KAAKG,MAAMqS,WAAW6C,cAAerV,KAAKG,MAAMqS,WAAW8C,+BAA4C,IAAPrQ,EAAgBA,EAAK,GAAK,GAEjMjF,KAAKG,MAAM0R,cAAgB7R,KAAKG,MAAMkS,kCAChCrS,KAAKkN,IAAIoD,aAAatQ,KAAKG,MAAMkS,kCAAkCkD,gCACnE,EACNvV,KAAKG,MAAM+S,+BAA8BlT,KAAKG,MAAM4S,eAAgB/S,KAAKkN,IAAIyE,aAAa,6BAC1F3R,KAAKG,MAAMgT,sBAAqBnT,KAAKG,MAAM4S,eAAgB/S,KAAKwV,gCAChExV,KAAKG,MAAMiT,mCACPpT,KAAKQ,cAAgB,GAAMR,KAAKG,MAAM6S,kBAAoBhT,KAAKkN,IAAIyE,aAAa,kCAEhF3R,KAAKG,MAAM2R,OACX9R,KAAKkN,IAAIuI,qCAAuCzV,KAAKG,MAAM2R,KAAK2D,sCAEhEzV,KAAKG,MAAM4R,OACX/R,KAAKkN,IAAIwI,qCAAuC1V,KAAKG,MAAM4R,KAAK2D,sCAEhE1V,KAAKG,MAAM8R,YACXjS,KAAKkN,IAAIyI,8BAAgC3V,KAAKG,MAAM8R,UAAU0D,8BAC9D3V,KAAKkN,IAAI0I,oCAAsC5V,KAAKG,MAAM8R,UAAU2D,oCACpE5V,KAAKkN,IAAI2I,oCAAsC7V,KAAKG,MAAM8R,UAAU4D,qCAEpE7V,KAAKG,MAAMiS,OACXpS,KAAKkN,IAAI4I,sBAAwB9V,KAAKG,MAAMiS,KAAK0D,sBACjD9V,KAAKkN,IAAI6I,iCAAmC/V,KAAKG,MAAMiS,KAAK2D,kCAG5D/V,KAAKQ,cAAgB,GACW,OAA5BR,KAAKkN,IAAI6H,iBACT/U,KAAKkN,IAAI6H,eAAiB,MAGlC/U,KAAKG,MAAM8S,uBAAyBjT,KAAKG,MAAM6S,kBAAoBhT,KAAKgW,mCAEpEhW,KAAKQ,cAAgB,EACrBR,KAAKG,MAAMwS,sBAAuB,EAClC3S,KAAKG,MAAMyS,eAAkD,OAAjC5S,KAAKwI,wBAAmCxI,KAAKwI,wBAA0BxI,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAI6D,iBAEjI,CACD,MAAM4B,EAAuB3S,KAAKkN,IAAIyE,aAAa,sBACnD,GAA6B,OAAzBgB,EAA+B,CAC/B3S,KAAKG,MAAMwS,sBAAuB,EAClC3S,KAAKkN,IAAI+I,YAActD,EAAqBuD,iBAAiBpJ,KAAK6F,GAClE3S,KAAKkN,IAAIiJ,iBAAmBnW,KAAKkN,IAAIkJ,YACrC,IAAK,IAAIrI,EAAI,EAAGA,EAAI,GAAIA,IACpB/N,KAAKkN,IAAI,mBAAqBa,EAAI,UAAY4E,EAAqB,mBAAqB5E,EAAI,SAEpG,CACJ,CAEA,GAAI/N,KAAKQ,cAAgB,EACrBR,KAAKG,MAAMyT,uBAAwB,MAElC,CACD,MAAMA,EAAwB5T,KAAKkN,IAAIyE,aAAa,uBACvB,MAAzBiC,IACA5T,KAAKG,MAAMyT,uBAAwB,EACnC5T,KAAKkN,IAAImJ,kBAAoBzC,EAAsB0C,wBAE3D,CAEA,GAAItW,KAAK8G,0BACL9G,KAAKG,MAAMkT,mBAAoB,OAE9B,GAAIrT,KAAKQ,cAAgB,EAC1BR,KAAKG,MAAMkT,mBAAoB,MAE9B,CACD,MAAMkD,EAA6BvW,KAAKkN,IAAIyE,aAAa,2BACvB,MAA9B4E,IACAvW,KAAKG,MAAMkT,mBAAoB,EAC/BrT,KAAKkN,IAAIsJ,kBAAoBD,EAA2BE,qBAAqB3J,KAAKyJ,GAClFvW,KAAKkN,IAAIwJ,gBAAkBH,EAA2BI,mBAAmB7J,KAAKyJ,GAC9EvW,KAAKkN,IAAI0J,kBAAoBL,EAA2BM,qBAAqB/J,KAAKyJ,GAE1F,CAEA,GAAIvW,KAAKQ,cAAgB,EACrBR,KAAKG,MAAMmT,iBAAkB,MAE5B,CACD,MAAMwD,EAAoB9W,KAAKkN,IAAIyE,aAAa,0BACvB,MAArBmF,GACA9W,KAAKG,MAAMmT,iBAAkB,EAC7BtT,KAAKkN,IAAI6J,oBAAsBD,EAAkBE,yBAAyBlK,KAAKgK,GAC/E9W,KAAKkN,IAAI+J,sBAAwBH,EAAkBI,2BAA2BpK,KAAKgK,GACnF9W,KAAKkN,IAAIiK,oBAAsBL,EAAkBM,yBAAyBtK,KAAKgK,IAG/E9W,KAAKG,MAAMmT,iBAAkB,CAErC,CACA,GAAItT,KAAKkN,IAAImK,yBAA0B,CACnC,MAAMC,EAActX,KAAKkN,IAAImK,yBAAyBrX,KAAKkN,IAAIqK,cAAevX,KAAKkN,IAAIsK,YACjFC,EAAgBzX,KAAKkN,IAAImK,yBAAyBrX,KAAKkN,IAAIwK,gBAAiB1X,KAAKkN,IAAIsK,YACvFF,GAAeG,IACfzX,KAAKG,MAAMwB,6BAAyD,IAA1B2V,EAAYK,WAA+C,IAA5BF,EAAcE,UAE/F,CACA,GAAI3X,KAAKQ,cAAgB,EACrBR,KAAKG,MAAMsT,aAAc,MAExB,CACD,MAAMmE,EAAuB5X,KAAKkN,IAAIyE,aAAa,oBACvB,MAAxBiG,IACA5X,KAAKG,MAAMsT,aAAc,EACzBzT,KAAKkN,IAAI2K,IAAMD,EAAqBE,QACpC9X,KAAKkN,IAAI6K,IAAMH,EAAqBI,QAE5C,CAGA,IAAKhY,KAAKG,MAAM6T,mBAAoB,CAChC,GAAIhU,KAAKQ,cAAgB,EACrBR,KAAKG,MAAM6T,oBAAqB,EAChChU,KAAKiY,uBAAyB,CAC1BC,KAAMC,uBAAuBD,KAC7BE,MAAOD,uBAAuBC,MAC9BC,aAAcF,uBAAuBE,kBAGxC,CACD,MAAMC,EAAgBtY,KAAKkN,IAAIyE,aAAa,YACvB,MAAjB2G,IACAtY,KAAKG,MAAM6T,oBAAqB,EAChChU,KAAKiY,uBAAyB,CAC1BC,KAAMI,EAAcC,SACpBH,MAAOE,EAAcE,eACrBH,aAAcC,EAAcE,gBAGxC,CAGAxY,KAAKG,MAAM6T,mBAAqBhU,KAAKG,MAAM6T,uBAAyBhU,KAAKyB,mBAAoBzB,KAAKyB,iBAAiBgX,4BACvH,CAEAzY,KAAKkB,mBAAmByN,WAAY,EACpC3O,KAAKkB,mBAAmBC,UAAYnB,KAAKkN,IAAIwL,OAC7C1Y,KAAKkB,mBAAmB0N,WAAY,EAEpC5O,KAAKuI,yBAA2BvI,KAAKG,MAAMqQ,8BAC3C,IAAK,IAAImI,EAAO,EAAGA,EAAO3Y,KAAKuI,yBAA0BoQ,IACrD3Y,KAAKsI,sBAAsBsQ,KAAKD,GAEX,aAArB3Y,KAAKyU,cAELzU,KAAKG,MAAMkU,2BAA4B,EAE/C,CACAvG,gBACI9N,KAAK6Y,UAAY,CACbC,iCAAiC,EACjCC,0CAAkE,IAAvB/Y,KAAKQ,cAChDwY,2BAAmD,IAAvBhZ,KAAKQ,cACjCyY,sBAA8C,IAAvBjZ,KAAKQ,cAC5B0Y,8BAA8B,EAC9BC,yBAAiD,IAAvBnZ,KAAKQ,cAC/B4Y,kBAAkB,EAClBC,8BAA8B,EAC9BC,WAAmC,IAAvBtZ,KAAKQ,cACjB+Y,cAAsC,IAAvBvZ,KAAKQ,cACpBgZ,kBAA0C,IAAvBxZ,KAAKQ,cACxBiZ,gCAAwD,IAAvBzZ,KAAKQ,cACtCkZ,YAAoC,IAAvB1Z,KAAKQ,cAClBmZ,aAAqC,IAAvB3Z,KAAKQ,cACnBoZ,8BAAsD,IAAvB5Z,KAAKQ,cACpCqZ,0BAAkD,IAAvB7Z,KAAKQ,cAChCsZ,wBAAwB,EACxBC,sBAAsB,EACtBC,oBAAoB,EACpBC,wBAAwB,EACxBC,gCAAgC,EAChCC,qBAAqB,EACrBC,yBAAyB,EACzBC,4BAA4B,EAEpC,CAKIna,mBACA,OAAOF,KAAKQ,aAChB,CAKA8Z,eACI,MAAO,YACX,CAIIC,sBACA,OAAOva,KAAKwK,gBAChB,CAEAgQ,wBACI,GAAIxa,KAAKya,eACL,OAEJza,KAAKya,eAAiBza,KAAKyE,aAAa,EAAG,GAC3C,MAAMiW,EAAU1a,KAAKya,eAAe1P,WAAW,MAC3C2P,IACA1a,KAAK2a,gBAAkBD,EAE/B,CAIAE,oBACI,IAAK,MAAMlP,KAAO1L,KAAK0H,oBACdmT,OAAOC,UAAUC,eAAe9L,KAAKjP,KAAK0H,oBAAqBgE,KAGpE1L,KAAK0H,oBAAoBgE,GAAO,MAEpC1L,KAAKyH,wBAA0B,CACnC,CAKAuT,UACI,OAAOhb,KAAKib,WAChB,CAKAA,YACI,MAAO,CACHC,OAAQlb,KAAK2U,UACbwG,SAAUnb,KAAKyU,YACflU,QAASP,KAAKsU,WAEtB,CAOA8G,wBAAwBC,GACpBrb,KAAK4K,sBAAwByQ,EAC7Brb,KAAK6N,QACT,CAOAyN,0BACI,OAAOtb,KAAK4K,qBAChB,CAKA2Q,yBACI,OAAOvb,KAAKsH,sBAChB,CAKAkU,UACI,OAAOxb,KAAKG,KAChB,CAKAsb,eAAeC,GACX,IAAKA,EAED,YADA1b,KAAKgC,mBAAmBmK,OAAS,GAGrC,MAAMwP,EAAQ3b,KAAKgC,mBAAmBuM,QAAQmN,GAC1CC,GAAS,GACT3b,KAAKgC,mBAAmB4Z,OAAOD,EAAO,EAE9C,CAEAE,cACI,IAAK7b,KAAK6G,gBAAiB,CACvB,IAAIiV,GAAe,EAInB,IAHI9b,KAAKU,cAAiBV,KAAK8F,wBAA0B9F,KAAKuG,uBAC1DuV,GAAe,GAEfA,EAAc,CAEd9b,KAAK+b,aACL,IAAK,IAAIJ,EAAQ,EAAGA,EAAQ3b,KAAKgC,mBAAmBmK,OAAQwP,IAAS,EAEjED,EADuB1b,KAAKgC,mBAAmB2Z,KAEnD,CAEA3b,KAAKgc,UACT,CACJ,CACIhc,KAAKgC,mBAAmBmK,OAAS,EACjCnM,KAAKic,cAAgBjc,KAAKkc,eAAelc,KAAKmc,qBAAsBnc,KAAKoc,iBAGzEpc,KAAK0G,yBAA0B,CAEvC,CAKA2V,qBACI,OAAOrc,KAAKgL,gBAChB,CAKAsR,kBACI,OAAOtc,KAAKkK,aAChB,CAKAqS,sBACI,OAAOvc,KAAKqK,iBAChB,CAKA+R,gBACI,OAAK,UAGDpc,KAAKgL,kBAAoBhL,KAAKgL,iBAAiBwR,eAAiBxc,KAAKgL,iBAAiBwR,cAAcC,YAC7Fzc,KAAKgL,iBAAiBwR,cAAcC,YAExC/R,OALI,IAMf,CAMAgS,eAAeC,GAAY,GACvB,OAAKA,GAAa3c,KAAK4c,qBACZ5c,KAAK4c,qBAAqBzY,MAE9BnE,KAAKsC,6BAA+BtC,KAAKsC,6BAA6Bua,iBAAmB7c,KAAKkN,IAAI4P,kBAC7G,CAMAC,gBAAgBJ,GAAY,GACxB,OAAKA,GAAa3c,KAAK4c,qBACZ5c,KAAK4c,qBAAqBxY,OAE9BpE,KAAKsC,6BAA+BtC,KAAKsC,6BAA6B0a,kBAAoBhd,KAAKkN,IAAI+P,mBAC9G,CAKAf,eAAegB,EAAsBC,GACjC,OAAOvd,EAAWwd,cAAcF,EAAsBC,EAC1D,CAKAE,cAAc3B,IAC+C,IAArD1b,KAAKgC,mBAAmBuM,QAAQmN,KAGpC1b,KAAKgC,mBAAmB4W,KAAK8C,GACxB1b,KAAK0G,0BACN1G,KAAK0G,yBAA0B,EAC/B1G,KAAKmc,qBAAuBnc,KAAK6b,YAAY/O,KAAK9M,MAClDA,KAAKic,cAAgBjc,KAAKkc,eAAelc,KAAKmc,qBAAsBnc,KAAKoc,kBAEjF,CAQAkB,MAAMC,EAAOC,EAAYC,EAAOxT,GAAU,GACtC,MAAMyT,EAAuB1d,KAAK2d,qBAAqBD,qBACvD1d,KAAK2d,qBAAqBD,sBAAuB,EACjD1d,KAAK4d,cACL5d,KAAK2d,qBAAqBD,qBAAuBA,EACjD,IAAI1Z,EAAO,EACPwZ,GAAcD,IACdvd,KAAKkN,IAAI2Q,WAAWN,EAAMO,EAAGP,EAAMQ,EAAGR,EAAMS,OAAe/S,IAAZsS,EAAMU,EAAkBV,EAAMU,EAAI,GACjFja,GAAQhE,KAAKkN,IAAIgR,kBAEjBT,IACIzd,KAAKe,uBACLf,KAAKkB,mBAAmBC,UAAYnB,KAAKkN,IAAIiR,OAC7Cne,KAAKkN,IAAIkR,WAAW,IAGpBpe,KAAKkN,IAAIkR,WAAW,GAExBpa,GAAQhE,KAAKkN,IAAImR,kBAEjBpU,IACAjK,KAAKkN,IAAIoR,aAAa,GACtBta,GAAQhE,KAAKkN,IAAIqR,oBAErBve,KAAKkN,IAAIoQ,MAAMtZ,EACnB,CAIAwa,UAAUvV,EAAGC,EAAG/E,EAAOC,GACf6E,IAAMjJ,KAAKgJ,gBAAgBC,GAAKC,IAAMlJ,KAAKgJ,gBAAgBE,GAAK/E,IAAUnE,KAAKgJ,gBAAgBG,GAAK/E,IAAWpE,KAAKgJ,gBAAgBI,IACpIpJ,KAAKgJ,gBAAgBC,EAAIA,EACzBjJ,KAAKgJ,gBAAgBE,EAAIA,EACzBlJ,KAAKgJ,gBAAgBG,EAAIhF,EACzBnE,KAAKgJ,gBAAgBI,EAAIhF,EACzBpE,KAAKkN,IAAIuR,SAASxV,EAAGC,EAAG/E,EAAOC,GAEvC,CAOAsa,YAAYD,EAAUE,EAAeC,GACjC,MAAMza,EAAQwa,GAAiB3e,KAAK0c,iBAC9BtY,EAASwa,GAAkB5e,KAAK+c,kBAChC9T,EAAIwV,EAASxV,GAAK,EAClBC,EAAIuV,EAASvV,GAAK,EACxBlJ,KAAKwC,gBAAkBic,EACvBze,KAAKwe,UAAUvV,EAAI9E,EAAO+E,EAAI9E,EAAQD,EAAQsa,EAASta,MAAOC,EAASqa,EAASra,OACpF,CAIA2X,aAAe,CAIfC,WAEQhc,KAAKwG,QACLxG,KAAK6e,mBAET7e,KAAKqB,UACT,CAKAwM,OAAOiR,GAAe,GAClB,IAAI3a,EACAC,EAEJ,GAAIpE,KAAKgF,mBAAoB,CACzB,MAAMyF,GAAmB,WAAwBC,OAAOD,kBAA0B,EAC5EsU,EAAc/e,KAAK0I,sBAAwB+B,EACjDzK,KAAK0I,sBAAwB+B,EAC7BzK,KAAK4K,uBAAyBmU,CAClC,CACA,IAAI,YAAyB,UAEzB,GAAI/e,KAAKgL,iBAAkB,CACvB,MAAMgU,EAAehf,KAAKgL,iBAAiBiU,sBACrCjf,KAAKgL,iBAAiBiU,wBACtB,CAEE9a,MAAOnE,KAAKgL,iBAAiB7G,MAAQnE,KAAK4K,sBAC1CxG,OAAQpE,KAAKgL,iBAAiB5G,OAASpE,KAAK4K,uBAEpDzG,EAAQnE,KAAKgL,iBAAiBkU,aAAeF,EAAa7a,OAASnE,KAAKgL,iBAAiB7G,OAAS,IAClGC,EAASpE,KAAKgL,iBAAiBmU,cAAgBH,EAAa5a,QAAUpE,KAAKgL,iBAAiB5G,QAAU,GAC1G,MAEID,EAAQuG,OAAO0U,WACfhb,EAASsG,OAAO2U,iBAIpBlb,EAAQnE,KAAKgL,iBAAmBhL,KAAKgL,iBAAiB7G,MAAQ,IAC9DC,EAASpE,KAAKgL,iBAAmBhL,KAAKgL,iBAAiB5G,OAAS,IAEpEpE,KAAKsf,QAAQnb,EAAQnE,KAAK4K,sBAAuBxG,EAASpE,KAAK4K,sBAAuBkU,EAC1F,CAQAQ,QAAQnb,EAAOC,EAAQ0a,GAAe,GAClC,QAAK9e,KAAKgL,mBAGV7G,GAAgB,EAChBC,GAAkB,KACb0a,GAAgB9e,KAAKgL,iBAAiB7G,QAAUA,GAASnE,KAAKgL,iBAAiB5G,SAAWA,KAG/FpE,KAAKgL,iBAAiB7G,MAAQA,EAC9BnE,KAAKgL,iBAAiB5G,OAASA,GACxB,GACX,CAWAmb,gBAAgBC,EAAWC,EAAY,EAAGd,EAAeC,EAAgBc,EAAyBC,EAAW,EAAGC,EAAQ,GACpH,IAAI3a,EAAIC,EAAIC,EAAIC,EAAIC,EACpB,MAAMwa,EAAiBL,EACnBxf,KAAK4c,sBACL5c,KAAK8f,kBAAkB9f,KAAK4c,sBAEhC5c,KAAK4c,qBAAuB4C,EAC5Bxf,KAAK+f,wBAAwBF,EAAeG,iBAAmBH,EAAeG,iBAAmBH,EAAeI,cAChH,MAAMC,EAAKlgB,KAAKkN,IACXsS,EAAUW,UACPX,EAAUY,UACVF,EAAGG,wBAAwBH,EAAG9J,YAAa8J,EAAGI,kBAAiE,QAA7Crb,EAAKua,EAAUe,QAAQC,wBAAqC,IAAPvb,OAAgB,EAASA,EAAGwb,mBAAoBd,EAAUC,GAE5KJ,EAAUkB,QACfR,EAAGS,qBAAqBT,EAAG9J,YAAa8J,EAAGI,kBAAmBJ,EAAGU,4BAA8BnB,EAAyD,QAA7Cva,EAAKsa,EAAUe,QAAQC,wBAAqC,IAAPtb,OAAgB,EAASA,EAAGub,mBAAoBd,IAGxN,MAAMkB,EAAsBrB,EAAUsB,qBACtC,GAAID,EAAqB,CACrB,MAAME,EAAavB,EAAUwB,gCAAkCd,EAAGe,yBAA2Bf,EAAGgB,iBAC5F1B,EAAUY,UACVF,EAAGG,wBAAwBH,EAAG9J,YAAa2K,EAA4D,QAA/C5b,EAAK0b,EAAoBL,wBAAqC,IAAPrb,OAAgB,EAASA,EAAGsb,mBAAoBd,EAAUC,GAEpKJ,EAAUkB,OACfR,EAAGS,qBAAqBT,EAAG9J,YAAa2K,EAAYb,EAAGU,4BAA8BnB,EAA2D,QAA/Cra,EAAKyb,EAAoBL,wBAAqC,IAAPpb,OAAgB,EAASA,EAAGqb,mBAAoBd,GAGxMO,EAAGS,qBAAqBT,EAAG9J,YAAa2K,EAAYb,EAAGiB,WAA4D,QAA/C9b,EAAKwb,EAAoBL,wBAAqC,IAAPnb,OAAgB,EAASA,EAAGob,mBAAoBd,EAEnL,CACI3f,KAAKwC,kBAAoBkd,EACzB1f,KAAK0e,YAAY1e,KAAKwC,gBAAiBmc,EAAeC,IAGjDD,IACDA,EAAgBa,EAAUrb,MACtBwb,IACAhB,GAAgC9T,KAAKuW,IAAI,EAAGzB,KAG/Cf,IACDA,EAAiBY,EAAUpb,OACvBub,IACAf,GAAkC/T,KAAKuW,IAAI,EAAGzB,KAGtD3f,KAAKwe,UAAU,EAAG,EAAGG,EAAeC,IAExC5e,KAAK8O,YACT,CAWAuS,SAASC,EAASC,EAAU,EAAGC,EAAOC,GAAc,EAAO5b,EAAeoE,EAASyX,EAAe,GAC9F,IAAIzc,EAAIC,GAEJlF,KAAKkB,mBAAmBygB,OAASL,GAAWE,KAC5CxhB,KAAKkB,mBAAmBygB,KAAOL,GAGnC,MAAMM,EAAgG,QAAnF1c,EAAmC,QAA7BD,EAAKjF,KAAK6F,qBAAkC,IAAPZ,EAAgBA,EAAKY,SAAkC,IAAPX,GAAgBA,EAAalF,KAAKkN,IAAI2U,KAAO7hB,KAAKkN,IAAI4U,OAChK9hB,KAAKkB,mBAAmB0gB,WAAaA,GAAYJ,KACjDxhB,KAAKkB,mBAAmB0gB,SAAWA,GAGvC5hB,KAAK+hB,WAAWR,GAChBvhB,KAAKgiB,gBAAgBN,GAErB,MAAMO,EAAYR,EAAczhB,KAAKkN,IAAIgV,GAAKliB,KAAKkN,IAAIiV,KACnDniB,KAAKkB,mBAAmB+gB,YAAcA,GAAaT,KACnDxhB,KAAKkB,mBAAmB+gB,UAAYA,GAExCjiB,KAAKiH,sBAAsBmb,gBAAkBnY,CACjD,CAKAoY,iBACI,OAAOriB,KAAKkB,mBAAmByN,SACnC,CAKA2T,eAAeC,GACXviB,KAAKkB,mBAAmByN,UAAY4T,CACxC,CAKAR,WAAWzhB,GACPN,KAAKkB,mBAAmBqgB,QAAUvhB,KAAKe,uBAAyBT,EAAQA,CAC5E,CAKAkiB,aACI,MAAMjB,EAAUvhB,KAAKkB,mBAAmBqgB,QACxC,OAAOvhB,KAAKe,uBAAyBwgB,EAAUA,CACnD,CAKAS,gBAAgB1hB,GACZN,KAAKkB,mBAAmBwgB,aAAe1hB,KAAKe,uBAAyBT,EAAQA,CACjF,CAKAmiB,kBACI,MAAMf,EAAe1hB,KAAKkB,mBAAmBwgB,aAC7C,OAAO1hB,KAAKe,uBAAyB2gB,EAAeA,CACxD,CAIA3B,wBAAwB2C,GAChB1iB,KAAK+H,sBAAwB2a,IAC7B1iB,KAAKkN,IAAIqS,gBAAgBvf,KAAKkN,IAAIkJ,YAAasM,GAC/C1iB,KAAK+H,oBAAsB2a,EAEnC,CAEAC,0CACI,OAAoC,OAA7B3iB,KAAK+H,mBAChB,CAKA6a,gBAAgBrC,GACZvgB,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIiU,WAAYZ,GAAS,GACxDvgB,KAAKkN,IAAI4V,eAAe9iB,KAAKkN,IAAIiU,YACjCnhB,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIiU,WAAY,KACnD,CAOArB,kBAAkBS,EAASwC,GAAyB,EAAOC,GACvD,IAAI/d,EACJ,MAAM4a,EAAiBU,EACvBvgB,KAAK4c,qBAAuB,KAE5B,MAAMsD,EAAKlgB,KAAKkN,IAChB,GAAI2S,EAAeG,iBAAkB,CACjC,GAAIO,EAAQJ,QAGR,YADAngB,KAAKijB,sCAAsC1C,EAASwC,EAAwBC,GAGhF9C,EAAGX,gBAAgBW,EAAGgD,iBAAkBrD,EAAeG,kBACvDE,EAAGX,gBAAgBW,EAAG/J,iBAAkB0J,EAAeI,cACvDC,EAAGiD,gBAAgB,EAAG,EAAG5C,EAAQpc,MAAOoc,EAAQnc,OAAQ,EAAG,EAAGmc,EAAQpc,MAAOoc,EAAQnc,OAAQ8b,EAAGhC,iBAAkBgC,EAAGkD,QACzH,GACgC,QAA1Bne,EAAKsb,EAAQA,eAA4B,IAAPtb,OAAgB,EAASA,EAAGoe,kBAAqBN,GAA2BxC,EAAQG,QACxH1gB,KAAK4iB,gBAAgBrC,EAAQA,SAE7ByC,IACInD,EAAeG,kBAEfhgB,KAAK+f,wBAAwBF,EAAeI,cAEhD+C,KAEJhjB,KAAK+f,wBAAwB,KACjC,CAIAlB,mBACI7e,KAAKkN,IAAIoW,OACb,CAIAC,4BACQvjB,KAAK4c,qBACL5c,KAAK8f,kBAAkB9f,KAAK4c,sBAG5B5c,KAAK+f,wBAAwB,MAE7B/f,KAAKwC,iBACLxC,KAAK0e,YAAY1e,KAAKwC,iBAE1BxC,KAAK8O,YACT,CAGA0U,4BACIxjB,KAAKyjB,gBAAgB,MACrBzjB,KAAK0jB,qBAAuB,IAChC,CAMAC,mBAAmBC,GACf,OAAO5jB,KAAK6jB,oBAAoBD,EAAM5jB,KAAKkN,IAAI4W,YACnD,CACAD,oBAAoBD,EAAMG,GACtB,MAAMC,EAAMhkB,KAAKkN,IAAI+W,eACrB,IAAKD,EACD,MAAM,IAAI3W,MAAM,kCAEpB,MAAM6W,EAAa,IAAI,IAAgBF,GAUvC,OATAhkB,KAAKyjB,gBAAgBS,GACjBN,aAAgBvd,MAChBrG,KAAKkN,IAAIiX,WAAWnkB,KAAKkN,IAAIkX,aAAc,IAAIC,aAAaT,GAAOG,GAGnE/jB,KAAKkN,IAAIiX,WAAWnkB,KAAKkN,IAAIkX,aAAcR,EAAMG,GAErD/jB,KAAKwjB,4BACLU,EAAWI,WAAa,EACjBJ,CACX,CAMAK,0BAA0BX,GACtB,OAAO5jB,KAAK6jB,oBAAoBD,EAAM5jB,KAAKkN,IAAIsX,aACnD,CACAC,2BACIzkB,KAAK0kB,gBAAgB,MACrB1kB,KAAK2kB,mBAAqB,IAC9B,CAOAC,kBAAkBC,EAASC,GACvB,MAAMd,EAAMhkB,KAAKkN,IAAI+W,eACfC,EAAa,IAAI,IAAgBF,GACvC,IAAKA,EACD,MAAM,IAAI3W,MAAM,iCAEpBrN,KAAK0kB,gBAAgBR,GACrB,MAAMN,EAAO5jB,KAAK+kB,oBAAoBF,GAKtC,OAJA7kB,KAAKkN,IAAIiX,WAAWnkB,KAAKkN,IAAI8X,qBAAsBpB,EAAMkB,EAAY9kB,KAAKkN,IAAIsX,aAAexkB,KAAKkN,IAAI4W,aACtG9jB,KAAKykB,2BACLP,EAAWI,WAAa,EACxBJ,EAAWe,SAAsC,IAA3BrB,EAAKsB,kBACpBhB,CACX,CACAa,oBAAoBF,GAEhB,GAAwB,IADAA,EAAQK,kBAE5B,OAAOL,EAGX,GAAI7kB,KAAKG,MAAMmS,YAAa,CACxB,GAAIuS,aAAmBM,YACnB,OAAON,EAIP,IAAK,IAAIlJ,EAAQ,EAAGA,EAAQkJ,EAAQ1Y,OAAQwP,IACxC,GAAIkJ,EAAQlJ,IAAU,MAClB,OAAO,IAAIwJ,YAAYN,GAG/B,OAAO,IAAIO,YAAYP,EAE/B,CAEA,OAAO,IAAIO,YAAYP,EAC3B,CAKApB,gBAAgB4B,GACPrlB,KAAKoI,sBACNpI,KAAKslB,2BAETtlB,KAAKulB,YAAYF,EAAQrlB,KAAKkN,IAAIkX,aACtC,CAOAoB,iBAAiBC,EAAiBC,EAAW/J,GACzC,MAAMgK,EAAUF,EAAgBE,QAC1BC,EAAkB5lB,KAAKkN,IAAI2Y,qBAAqBF,EAASD,GAC/D1lB,KAAKkN,IAAI4Y,oBAAoBH,EAASC,EAAiBjK,EAC3D,CAEA+I,gBAAgBW,GACPrlB,KAAKoI,sBACNpI,KAAKslB,2BAETtlB,KAAKulB,YAAYF,EAAQrlB,KAAKkN,IAAI8X,qBACtC,CACAO,YAAYF,EAAQhZ,IACZrM,KAAKoI,sBAAwBpI,KAAK8H,oBAAoBuE,KAAYgZ,KAClErlB,KAAKkN,IAAI6Y,WAAW1Z,EAAQgZ,EAASA,EAAO5E,mBAAqB,MACjEzgB,KAAK8H,oBAAoBuE,GAAUgZ,EAE3C,CAKAW,kBAAkBpC,GACd5jB,KAAKkN,IAAI+Y,cAAcjmB,KAAKkN,IAAIkX,aAAc,EAAGR,EACrD,CACAsC,qBAAqBb,EAAQc,EAAMC,EAAMC,EAAMC,EAAYC,EAAQC,GAC/D,MAAMC,EAAUzmB,KAAKiI,uBAAuBke,GAC5C,IAAKM,EACD,OAEJ,IAAIC,GAAU,EACTD,EAAQE,QAYLF,EAAQpB,SAAWA,IACnBoB,EAAQpB,OAASA,EACjBqB,GAAU,GAEVD,EAAQL,OAASA,IACjBK,EAAQL,KAAOA,EACfM,GAAU,GAEVD,EAAQJ,OAASA,IACjBI,EAAQJ,KAAOA,EACfK,GAAU,GAEVD,EAAQH,aAAeA,IACvBG,EAAQH,WAAaA,EACrBI,GAAU,GAEVD,EAAQF,SAAWA,IACnBE,EAAQF,OAASA,EACjBG,GAAU,GAEVD,EAAQD,SAAWA,IACnBC,EAAQD,OAASA,EACjBE,GAAU,KAjCdA,GAAU,EACVD,EAAQE,QAAS,EACjBF,EAAQ9K,MAAQwK,EAChBM,EAAQL,KAAOA,EACfK,EAAQJ,KAAOA,EACfI,EAAQH,WAAaA,EACrBG,EAAQF,OAASA,EACjBE,EAAQD,OAASA,EACjBC,EAAQpB,OAASA,IA4BjBqB,GAAW1mB,KAAKoI,wBAChBpI,KAAKyjB,gBAAgB4B,GACjBgB,IAASrmB,KAAKkN,IAAI0Z,cAAgBP,IAASrmB,KAAKkN,IAAI2Z,IACpD7mB,KAAKkN,IAAI4Z,qBAAqBX,EAAMC,EAAMC,EAAME,EAAQC,GAGxDxmB,KAAKkN,IAAI6Z,oBAAoBZ,EAAMC,EAAMC,EAAMC,EAAYC,EAAQC,GAG/E,CAIAQ,0BAA0BC,GACH,MAAfA,GAGAjnB,KAAK2kB,qBAAuBsC,IAC5BjnB,KAAK2kB,mBAAqBsC,EAC1BjnB,KAAK0kB,gBAAgBuC,GACrBjnB,KAAK6H,yBAA2Bof,EAAYhC,SAEpD,CACAiC,6BAA6BC,EAAevX,EAAQwX,GAChD,MAAM7Z,EAAaqC,EAAOyX,qBACrBrnB,KAAKoI,sBACNpI,KAAKslB,2BAETtlB,KAAKsnB,sBACL,IAAK,IAAI3L,EAAQ,EAAGA,EAAQpO,EAAWpB,OAAQwP,IAAS,CACpD,MAAM4L,EAAQ3X,EAAO4X,qBAAqB7L,GAC1C,GAAI4L,GAAS,EAAG,CACZ,MAAME,EAAKla,EAAWoO,GACtB,IAAI+L,EAAe,KAOnB,GANIN,IACAM,EAAeN,EAAsBK,IAEpCC,IACDA,EAAeP,EAAcM,KAE5BC,EACD,SAEJ1nB,KAAKkN,IAAIya,wBAAwBJ,GAC5BvnB,KAAKoI,uBACNpI,KAAK4H,2BAA2B2f,IAAS,GAE7C,MAAMlC,EAASqC,EAAaE,YACxBvC,IACArlB,KAAKkmB,qBAAqBb,EAAQkC,EAAOG,EAAaG,UAAWH,EAAarB,KAAMqB,EAAapB,WAAYoB,EAAaI,WAAYJ,EAAaK,YAC/IL,EAAaM,mBACbhoB,KAAKkN,IAAIiK,oBAAoBoQ,EAAOG,EAAaO,sBAC5CjoB,KAAKoI,uBACNpI,KAAKkI,0BAA0B0Q,KAAK2O,GACpCvnB,KAAKmI,wBAAwByQ,KAAKyM,KAIlD,CACJ,CACJ,CAUA6C,wBAAwBf,EAAeF,EAAarX,EAAQwX,GACxD,MAAMe,EAAMnoB,KAAKkN,IAAIsJ,oBACrB,IAAK2R,EACD,MAAM,IAAI9a,MAAM,wBASpB,OAPArN,KAAKoI,sBAAuB,EAC5BpI,KAAKkN,IAAIwJ,gBAAgByR,GACzBnoB,KAAKqI,2BAA4B,EACjCrI,KAAKknB,6BAA6BC,EAAevX,EAAQwX,GACzDpnB,KAAK0kB,gBAAgBuC,GACrBjnB,KAAKoI,sBAAuB,EAC5BpI,KAAKkN,IAAIwJ,gBAAgB,MAClByR,CACX,CAOAC,sBAAsB/U,EAAmB4T,GACjCjnB,KAAKqoB,2BAA6BhV,IAClCrT,KAAKqoB,yBAA2BhV,EAChCrT,KAAKkN,IAAIwJ,gBAAgBrD,GACzBrT,KAAK0jB,qBAAuB,KAC5B1jB,KAAK2kB,mBAAqB,KAC1B3kB,KAAK6H,yBAA0C,MAAfof,GAAuBA,EAAYhC,SACnEjlB,KAAKqI,2BAA4B,EAEzC,CASAigB,oBAAoBZ,EAAcT,EAAasB,EAAmBC,EAAkB5Y,GAChF,GAAI5P,KAAK0jB,uBAAyBgE,GAAgB1nB,KAAKyoB,gCAAkC7Y,EAAQ,CAC7F5P,KAAK0jB,qBAAuBgE,EAC5B1nB,KAAKyoB,8BAAgC7Y,EACrC,MAAM8Y,EAAkB9Y,EAAO+Y,qBAC/B3oB,KAAKslB,2BACLtlB,KAAKsnB,sBACL,IAAId,EAAS,EACb,IAAK,IAAI7K,EAAQ,EAAGA,EAAQ+M,EAAiB/M,IACzC,GAAIA,EAAQ4M,EAAkBpc,OAAQ,CAClC,MAAMob,EAAQ3X,EAAO4X,qBAAqB7L,GACtC4L,GAAS,IACTvnB,KAAKkN,IAAIya,wBAAwBJ,GACjCvnB,KAAK4H,2BAA2B2f,IAAS,EACzCvnB,KAAKkmB,qBAAqBwB,EAAcH,EAAOgB,EAAkB5M,GAAQ3b,KAAKkN,IAAI0b,OAAO,EAAOJ,EAAkBhC,IAEtHA,GAAqC,EAA3B+B,EAAkB5M,EAChC,CAER,CACA3b,KAAKgnB,0BAA0BC,EACnC,CACA3B,2BACStlB,KAAKqoB,2BAGVroB,KAAKqoB,yBAA2B,KAChCroB,KAAKkN,IAAIwJ,gBAAgB,MAC7B,CAQAmS,YAAY1B,EAAeF,EAAarX,EAAQwX,GACxCpnB,KAAK0jB,uBAAyByD,GAAiBnnB,KAAKyoB,gCAAkC7Y,IACtF5P,KAAK0jB,qBAAuByD,EAC5BnnB,KAAKyoB,8BAAgC7Y,EACrC5P,KAAKknB,6BAA6BC,EAAevX,EAAQwX,IAE7DpnB,KAAKgnB,0BAA0BC,EACnC,CAIA6B,2BACI,IAAIC,EACJ,IAAK,IAAIhb,EAAI,EAAGib,EAAKhpB,KAAKkI,0BAA0BiE,OAAQ4B,EAAIib,EAAIjb,IAAK,CACrE,MAAMkb,EAAkBjpB,KAAKmI,wBAAwB4F,GACjDgb,GAAeE,GAAmBA,EAAgB3E,aAClDyE,EAAcE,EACdjpB,KAAKyjB,gBAAgBwF,IAEzB,MAAMC,EAAiBlpB,KAAKkI,0BAA0B6F,GACtD/N,KAAKkN,IAAIiK,oBAAoB+R,EAAgB,EACjD,CACAlpB,KAAKmI,wBAAwBgE,OAAS,EACtCnM,KAAKkI,0BAA0BiE,OAAS,CAC5C,CAKAgd,yBAAyBhB,GACrBnoB,KAAKkN,IAAI0J,kBAAkBuR,EAC/B,CAIAiB,eAAe/D,GAEX,OADAA,EAAOf,aACmB,IAAtBe,EAAOf,aACPtkB,KAAKqpB,cAAchE,IACZ,EAGf,CACAgE,cAAchE,GACVrlB,KAAKkN,IAAIoc,aAAajE,EAAO5E,mBACjC,CAOA8I,6BAA6BN,EAAiBrF,EAAM4F,GAKhD,GAJAxpB,KAAKyjB,gBAAgBwF,GACjBrF,GACA5jB,KAAKkN,IAAI+Y,cAAcjmB,KAAKkN,IAAIkX,aAAc,EAAGR,QAEpB3Y,IAA7Bue,EAAgB,GAAG7N,MACnB3b,KAAKypB,oBAAoBR,EAAiBO,GAAiB,QAG3D,IAAK,IAAI7N,EAAQ,EAAGA,EAAQ,EAAGA,IAAS,CACpC,MAAMuN,EAAiBM,EAAgB7N,GAClC3b,KAAK4H,2BAA2BshB,KACjClpB,KAAKkN,IAAIya,wBAAwBuB,GACjClpB,KAAK4H,2BAA2BshB,IAAkB,GAEtDlpB,KAAKkmB,qBAAqB+C,EAAiBC,EAAgB,EAAGlpB,KAAKkN,IAAI0b,OAAO,EAAO,GAAY,GAARjN,GACzF3b,KAAKkN,IAAIiK,oBAAoB+R,EAAgB,GAC7ClpB,KAAKkI,0BAA0B0Q,KAAKsQ,GACpClpB,KAAKmI,wBAAwByQ,KAAKqQ,EACtC,CAER,CAOAQ,oBAAoBR,EAAiBS,EAAgBC,GAAgB,GACjE3pB,KAAKyjB,gBAAgBwF,GACrB,IAAI1C,EAAS,EACb,GAAIoD,EACA,IAAK,IAAI5b,EAAI,EAAGA,EAAI2b,EAAevd,OAAQ4B,IAAK,CAE5CwY,GAA6B,EADlBmD,EAAe3b,GACb6b,aACjB,CAEJ,IAAK,IAAI7b,EAAI,EAAGA,EAAI2b,EAAevd,OAAQ4B,IAAK,CAC5C,MAAM0Z,EAAKiC,EAAe3b,QACT9C,IAAbwc,EAAG9L,QACH8L,EAAG9L,MAAQ3b,KAAK6pB,eAAeC,2BAA2BrC,EAAGsC,gBAE7DtC,EAAG9L,MAAQ,IAGV3b,KAAK4H,2BAA2B6f,EAAG9L,SACpC3b,KAAKkN,IAAIya,wBAAwBF,EAAG9L,OACpC3b,KAAK4H,2BAA2B6f,EAAG9L,QAAS,GAEhD3b,KAAKkmB,qBAAqB+C,EAAiBxB,EAAG9L,MAAO8L,EAAGmC,cAAenC,EAAGuC,eAAiBhqB,KAAKkN,IAAI0b,MAAOnB,EAAGnB,aAAc,EAAOC,EAAQkB,EAAGjB,QAC9IxmB,KAAKkN,IAAIiK,oBAAoBsQ,EAAG9L,WAAsB1Q,IAAfwc,EAAGwC,QAAwB,EAAIxC,EAAGwC,SACzEjqB,KAAKkI,0BAA0B0Q,KAAK6O,EAAG9L,OACvC3b,KAAKmI,wBAAwByQ,KAAKqQ,GACtC,CACJ,CAKAiB,+BAA+BjqB,GAC3B,IAAKD,KAAK6pB,eACN,OAEJ,MAAMM,EAAoBnqB,KAAK6pB,eAAeC,2BAA2B7pB,GACzED,KAAKoqB,yBAAyBD,EAClC,CAKAC,yBAAyBD,GACrB,IACIxO,EADA0O,GAAc,EAElB,MAAgF,KAAxE1O,EAAQ3b,KAAKkI,0BAA0BqG,QAAQ4b,KACnDnqB,KAAKkI,0BAA0B0T,OAAOD,EAAO,GAC7C3b,KAAKmI,wBAAwByT,OAAOD,EAAO,GAC3C0O,GAAc,EACd1O,EAAQ3b,KAAKkI,0BAA0BqG,QAAQ4b,GAE/CE,IACArqB,KAAKkN,IAAIiK,oBAAoBgT,EAAmB,GAChDnqB,KAAKsqB,wBAAwBH,GAErC,CAKAG,wBAAwBH,GACpBnqB,KAAKkN,IAAIqd,yBAAyBJ,GAClCnqB,KAAK4H,2BAA2BuiB,IAAqB,EACrDnqB,KAAKiI,uBAAuBkiB,GAAmBxD,QAAS,CAC5D,CAQA6D,KAAKC,EAAcC,EAAYC,EAAYC,GACvC5qB,KAAK6qB,iBAAiBJ,EAAe,EAAI,EAAGC,EAAYC,EAAYC,EACxE,CAOAE,gBAAgBC,EAAeC,EAAeJ,GAC1C5qB,KAAKirB,eAAe,EAAGF,EAAeC,EAAeJ,EACzD,CAQAM,cAAcT,EAAcM,EAAeC,EAAeJ,GACtD5qB,KAAKirB,eAAeR,EAAe,EAAI,EAAGM,EAAeC,EAAeJ,EAC5E,CAQAC,iBAAiBM,EAAUT,EAAYC,EAAYC,GAE/C5qB,KAAK4d,cACL5d,KAAKorB,kBAEL,MAAMC,EAAWrrB,KAAKsrB,UAAUH,GAC1BI,EAAcvrB,KAAK6H,yBAA2B7H,KAAKkN,IAAI0Z,aAAe5mB,KAAKkN,IAAIse,eAC/EC,EAAOzrB,KAAK6H,yBAA2B,EAAI,EAC7C+iB,EACA5qB,KAAKkN,IAAI+J,sBAAsBoU,EAAUV,EAAYY,EAAab,EAAae,EAAMb,GAGrF5qB,KAAKkN,IAAIwe,aAAaL,EAAUV,EAAYY,EAAab,EAAae,EAE9E,CAQAR,eAAeE,EAAUJ,EAAeC,EAAeJ,GAEnD5qB,KAAK4d,cACL5d,KAAKorB,kBACL,MAAMC,EAAWrrB,KAAKsrB,UAAUH,GAC5BP,EACA5qB,KAAKkN,IAAI6J,oBAAoBsU,EAAUN,EAAeC,EAAeJ,GAGrE5qB,KAAKkN,IAAIye,WAAWN,EAAUN,EAAeC,EAErD,CACAM,UAAUH,GACN,OAAQA,GAEJ,KAAK,EAmBL,QACI,OAAOnrB,KAAKkN,IAAI0e,UAlBpB,KAAK,EAKL,KAAK,EACD,OAAO5rB,KAAKkN,IAAI2e,OAJpB,KAAK,EAKL,KAAK,EACD,OAAO7rB,KAAKkN,IAAI4e,MACpB,KAAK,EACD,OAAO9rB,KAAKkN,IAAI6e,UACpB,KAAK,EACD,OAAO/rB,KAAKkN,IAAI8e,WACpB,KAAK,EACD,OAAOhsB,KAAKkN,IAAI+e,eACpB,KAAK,EACD,OAAOjsB,KAAKkN,IAAIgf,aAI5B,CAEAd,kBAEA,CAKAe,eAAevc,GACP5P,KAAK2H,iBAAiBiI,EAAOwc,cACtBpsB,KAAK2H,iBAAiBiI,EAAOwc,MAExC,MAAM3G,EAAkB7V,EAAOyc,qBAC3B5G,GACAzlB,KAAKssB,uBAAuB7G,EAEpC,CAIA6G,uBAAuB7G,GACnB,MAAM8G,EAAuB9G,EACzB8G,GAAwBA,EAAqB5G,UAC7C4G,EAAqB5G,QAAQ6G,yBAA2B,KACxDxsB,KAAKkN,IAAIuf,cAAcF,EAAqB5G,SAEpD,CAEA+G,kBAAkBC,GACd,GAAIA,EAmBA,OAlBI3sB,KAAKiG,gBACL0mB,EAA4B,mBAAI,UAGzBA,EAA4B,mBAEnC3sB,KAAKe,sBACL4rB,EAAiC,wBAAI,UAG9BA,EAAiC,6BAExC3sB,KAAKuK,wBACLoiB,EAAoC,2BAAI,UAGjCA,EAAoC,4BAI9C,CACD,IAAIC,EAAI,GAgBR,OAfI5sB,KAAKiG,kBACL2mB,GAAK,8BAEL5sB,KAAKe,wBACD6rB,IACAA,GAAK,MAETA,GAAK,mCAEL5sB,KAAKuK,0BACDqiB,IACAA,GAAK,MAETA,GAAK,sCAEFA,CACX,CACJ,CAeAC,aAAaC,EAAUC,EAA0BC,EAAuBC,EAAUN,EAASO,EAAWC,EAAYC,EAASC,EAAiBxsB,EAAiB,IAAeysB,MACxK,IAAIroB,EACJ,MAAMsoB,EAAST,EAASU,eAAiBV,EAASS,QAAUT,EAASW,aAAeX,EAASY,cAAgBZ,EACvGa,EAAWb,EAASc,iBAAmBd,EAASa,UAAYb,EAASe,eAAiBf,EAASgB,gBAAkBhB,EACjHiB,EAAgB/tB,KAAK0sB,oBAC3B,IAAIsB,EAA6G,QAA9F/oB,EAAK0nB,QAAyCA,EAAUI,EAAyBJ,eAA4B,IAAP1nB,EAAgBA,EAAK,GAC1I8oB,IACAC,GAAeD,GAEnB,MAAM9tB,EAAOstB,EAAS,IAAMI,EAAW,IAAMK,EAC7C,GAAIhuB,KAAK2H,iBAAiB1H,GAAO,CAC7B,MAAMguB,EAAiBjuB,KAAK2H,iBAAiB1H,GAI7C,OAHIktB,GAAcc,EAAe/d,WAC7Bid,EAAWc,GAERA,CACX,CACA,MAAMre,EAAS,IAAI,IAAOkd,EAAUC,EAA0BC,EAAuBC,EAAUjtB,KAAM2sB,EAASO,EAAWC,EAAYC,EAASC,EAAiBptB,EAAMY,GAErK,OADAb,KAAK2H,iBAAiB1H,GAAQ2P,EACvBA,CACX,CAEA1L,0BAA0BgqB,EAAQvB,EAASwB,EAAgB,IACvD,OAAOA,GAAiBxB,EAAUA,EAAU,KAAO,IAAMuB,CAC7D,CACAE,eAAeF,EAAQ7H,EAAMsG,EAASwB,GAClC,OAAOnuB,KAAKquB,kBAAkBzuB,EAAW0uB,mBAAmBJ,EAAQvB,EAASwB,GAAgB9H,EACjG,CACAgI,kBAAkBH,EAAQ7H,GACtB,MAAMnG,EAAKlgB,KAAKkN,IACVqhB,EAASrO,EAAGsO,aAAsB,WAATnI,EAAoBnG,EAAG3I,cAAgB2I,EAAGxI,iBACzE,IAAK6W,EAAQ,CACT,IAAIE,EAAQvO,EAAGwO,SACXC,EAAYzO,EAAGwO,SACnB,MAAQC,EAAYzO,EAAG0O,cAAgB1O,EAAGwO,UACtCD,EAAQE,EAEZ,MAAM,IAAIthB,MAAM,4CAA4CgZ,6BAAgCoI,uBAA2BvO,EAAG2O,oCAAoC7uB,KAAK6G,kBACvK,CAGA,OAFAqZ,EAAG4O,aAAaP,EAAQL,GACxBhO,EAAG6O,cAAcR,GACVA,CACX,CAIAS,iBAAiBT,GACb,OAAOvuB,KAAKkN,IAAI+hB,gBAAgBV,EACpC,CAUAW,uBAAuBzJ,EAAiB0J,EAAYC,EAAc1U,EAAS2U,EAA4B,MACnG3U,EAAUA,GAAW1a,KAAKkN,IAC1B,MAAMoiB,EAAetvB,KAAKquB,kBAAkBc,EAAY,UAClDI,EAAiBvvB,KAAKquB,kBAAkBe,EAAc,YAC5D,OAAOpvB,KAAKwvB,qBAAqB/J,EAAiB6J,EAAcC,EAAgB7U,EAAS2U,EAC7F,CAWAI,oBAAoBhK,EAAiB0J,EAAYC,EAAczC,EAASjS,EAAS2U,EAA4B,MACzG3U,EAAUA,GAAW1a,KAAKkN,IAC1B,MAAMihB,EAAgBnuB,KAAKQ,cAAgB,EAAI,qCAAuC,GAChF8uB,EAAetvB,KAAKouB,eAAee,EAAY,SAAUxC,EAASwB,GAClEoB,EAAiBvvB,KAAKouB,eAAegB,EAAc,WAAYzC,EAASwB,GAC9E,OAAOnuB,KAAKwvB,qBAAqB/J,EAAiB6J,EAAcC,EAAgB7U,EAAS2U,EAC7F,CAMAK,iBAAiBC,GAEb,OAAOA,CACX,CAMAC,sBAAsBC,GAClB,MAAMpK,EAAkB,IAAI,IAK5B,OAJAA,EAAgBqK,OAAS9vB,KACrBA,KAAKG,MAAMC,wBACXqlB,EAAgBsK,oBAAqB,GAElCtK,CACX,CAKAuK,wBAEA,CAKAC,oBAEA,CACAT,qBAAqB/J,EAAiB6J,EAAcC,EAAgB7U,EAAS2U,EAA4B,MACrG,MAAMa,EAAgBxV,EAAQyV,gBAE9B,GADA1K,EAAgBE,QAAUuK,GACrBA,EACD,MAAM,IAAI7iB,MAAM,4BAWpB,OATAqN,EAAQ0V,aAAaF,EAAeZ,GACpC5U,EAAQ0V,aAAaF,EAAeX,GACpC7U,EAAQ2V,YAAYH,GACpBzK,EAAgB/K,QAAUA,EAC1B+K,EAAgB6J,aAAeA,EAC/B7J,EAAgB8J,eAAiBA,EAC5B9J,EAAgBsK,oBACjB/vB,KAAKswB,yBAAyB7K,GAE3ByK,CACX,CACAI,yBAAyB7K,GACrB,MAAM/K,EAAU+K,EAAgB/K,QAC1B4U,EAAe7J,EAAgB6J,aAC/BC,EAAiB9J,EAAgB8J,eACjC5J,EAAUF,EAAgBE,QAEhC,IADejL,EAAQ6V,oBAAoB5K,EAASjL,EAAQ8V,aAC/C,CAGT,IAAKxwB,KAAKkN,IAAIujB,mBAAmBnB,EAActvB,KAAKkN,IAAIwjB,gBAAiB,CACrE,MAAMviB,EAAMnO,KAAKkN,IAAIyjB,iBAAiBrB,GACtC,GAAInhB,EAEA,MADAsX,EAAgBmL,uBAAyBziB,EACnC,IAAId,MAAM,iBAAmBc,EAE3C,CAEA,IAAKnO,KAAKkN,IAAIujB,mBAAmBlB,EAAgBvvB,KAAKkN,IAAIwjB,gBAAiB,CACvE,MAAMviB,EAAMnO,KAAKkN,IAAIyjB,iBAAiBpB,GACtC,GAAIphB,EAEA,MADAsX,EAAgBoL,yBAA2B1iB,EACrC,IAAId,MAAM,mBAAqBc,EAE7C,CACA,MAAMsgB,EAAQ/T,EAAQoW,kBAAkBnL,GACxC,GAAI8I,EAEA,MADAhJ,EAAgBsL,iBAAmBtC,EAC7B,IAAIphB,MAAMohB,EAExB,CACA,GAAIzuB,KAAKgG,uBAAwB,CAC7B0U,EAAQsW,gBAAgBrL,GAExB,IADkBjL,EAAQ6V,oBAAoB5K,EAASjL,EAAQuW,iBAC/C,CACZ,MAAMxC,EAAQ/T,EAAQoW,kBAAkBnL,GACxC,GAAI8I,EAEA,MADAhJ,EAAgByL,uBAAyBzC,EACnC,IAAIphB,MAAMohB,EAExB,CACJ,CACA/T,EAAQyW,aAAa7B,GACrB5U,EAAQyW,aAAa5B,GACrB9J,EAAgB6J,kBAAerkB,EAC/Bwa,EAAgB8J,oBAAiBtkB,EAC7Bwa,EAAgB0H,aAChB1H,EAAgB0H,aAChB1H,EAAgB0H,gBAAaliB,EAErC,CAIAmmB,wBAAwB3L,EAAiB4L,EAAkBC,EAAoBC,EAAaC,EAAqBC,EAAuBC,EAAe/E,EAAS0C,EAA2B3jB,GACvL,MAAMimB,EAAsBlM,EAExBkM,EAAoBhM,QADpB4L,EAC8BvxB,KAAKkvB,uBAAuByC,EAAqBN,EAAkBC,OAAoBrmB,EAAWokB,GAGlGrvB,KAAKyvB,oBAAoBkC,EAAqBN,EAAkBC,EAAoB3E,OAAS1hB,EAAWokB,GAE1IsC,EAAoBhM,QAAQ6G,yBAA2BkF,CAC3D,CAIAE,0BAA0BnM,GACtB,MAAM8G,EAAuB9G,EAC7B,QAAIzlB,KAAKkN,IAAIqjB,oBAAoBhE,EAAqB5G,QAAS3lB,KAAKG,MAAMC,sBAAsByxB,yBAC5F7xB,KAAKswB,yBAAyB/D,IACvB,EAGf,CAIAuF,qCAAqCrM,EAAiBsM,GAClD,MAAMxF,EAAuB9G,EAC7B,IAAK8G,EAAqBwD,mBAEtB,YADAgC,IAGJ,MAAMC,EAAazF,EAAqBY,WAEpCZ,EAAqBY,WADrB6E,EACkC,KAC9BA,IACAD,GAAQ,EAIsBA,CAE1C,CAOAE,YAAYxM,EAAiByM,GACzB,MAAMC,EAAU,IAAI9rB,MACdkmB,EAAuB9G,EAC7B,IAAK,IAAI9J,EAAQ,EAAGA,EAAQuW,EAAc/lB,OAAQwP,IAC9CwW,EAAQvZ,KAAK5Y,KAAKkN,IAAIklB,mBAAmB7F,EAAqB5G,QAASuM,EAAcvW,KAEzF,OAAOwW,CACX,CAOAE,cAAc5M,EAAiB6M,GAC3B,MAAMH,EAAU,GACV5F,EAAuB9G,EAC7B,IAAK,IAAI9J,EAAQ,EAAGA,EAAQ2W,EAAgBnmB,OAAQwP,IAChD,IACIwW,EAAQvZ,KAAK5Y,KAAKkN,IAAIqlB,kBAAkBhG,EAAqB5G,QAAS2M,EAAgB3W,IAC1F,CACA,MAAOvO,GACH+kB,EAAQvZ,MAAM,EAClB,CAEJ,OAAOuZ,CACX,CAKAK,aAAa5iB,IACTA,EAAoB,OAAXA,GAAmB,IAAY6iB,UAAU7iB,GAAUA,EAAOA,OAASA,IAC7DA,IAAW5P,KAAK6pB,iBAG/B7pB,KAAKiH,sBAAsBmb,qBAAkBnX,EAG7CjL,KAAK0yB,aAAa9iB,GAClB5P,KAAK6pB,eAAiBja,EAClBA,EAAO+iB,QACP/iB,EAAO+iB,OAAO/iB,GAEdA,EAAOgjB,mBACPhjB,EAAOgjB,kBAAkBlmB,gBAAgBkD,GAEjD,CAOAijB,OAAOC,EAASxyB,GACZ,QAAKwyB,IAGL9yB,KAAKkN,IAAI6lB,UAAUD,EAASxyB,IACrB,EACX,CAQA0yB,QAAQF,EAAS7pB,EAAGC,GAChB,QAAK4pB,IAGL9yB,KAAKkN,IAAI+lB,UAAUH,EAAS7pB,EAAGC,IACxB,EACX,CASAgqB,QAAQJ,EAAS7pB,EAAGC,EAAGC,GACnB,QAAK2pB,IAGL9yB,KAAKkN,IAAIimB,UAAUL,EAAS7pB,EAAGC,EAAGC,IAC3B,EACX,CAUAiqB,QAAQN,EAAS7pB,EAAGC,EAAGC,EAAGC,GACtB,QAAK0pB,IAGL9yB,KAAKkN,IAAImmB,UAAUP,EAAS7pB,EAAGC,EAAGC,EAAGC,IAC9B,EACX,CAOAkqB,YAAYR,EAASS,GACjB,QAAKT,IAGL9yB,KAAKkN,IAAIsmB,WAAWV,EAASS,IACtB,EACX,CAOAE,aAAaX,EAASS,GAClB,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAIwmB,WAAWZ,EAASS,IACtB,EACX,CAOAI,aAAab,EAASS,GAClB,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAI0mB,WAAWd,EAASS,IACtB,EACX,CAOAM,aAAaf,EAASS,GAClB,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAI4mB,WAAWhB,EAASS,IACtB,EACX,CAOAQ,QAAQjB,EAASxyB,GACb,QAAKwyB,IAGL9yB,KAAKkN,IAAI8mB,WAAWlB,EAASxyB,IACtB,EACX,CAQA2zB,SAASnB,EAAS7pB,EAAGC,GACjB,QAAK4pB,IAGL9yB,KAAKkN,IAAIgnB,WAAWpB,EAAS7pB,EAAGC,IACzB,EACX,CASAirB,SAASrB,EAAS7pB,EAAGC,EAAGC,GACpB,QAAK2pB,IAGL9yB,KAAKkN,IAAIknB,WAAWtB,EAAS7pB,EAAGC,EAAGC,IAC5B,EACX,CAUAkrB,SAASvB,EAAS7pB,EAAGC,EAAGC,EAAGC,GACvB,QAAK0pB,IAGL9yB,KAAKkN,IAAIonB,WAAWxB,EAAS7pB,EAAGC,EAAGC,EAAGC,IAC/B,EACX,CAOAmrB,aAAazB,EAASS,GAClB,QAAKT,IAGL9yB,KAAKkN,IAAIsnB,YAAY1B,EAASS,IACvB,EACX,CAOAkB,cAAc3B,EAASS,GACnB,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAIwnB,YAAY5B,EAASS,IACvB,EACX,CAOAoB,cAAc7B,EAASS,GACnB,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAI0nB,YAAY9B,EAASS,IACvB,EACX,CAOAsB,cAAc/B,EAASS,GACnB,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAI4nB,YAAYhC,EAASS,IACvB,EACX,CAOAwB,SAASjC,EAASS,GACd,QAAKT,MAGDS,EAAMpnB,OAAS,KAGnBnM,KAAKkN,IAAI8nB,WAAWlC,EAASS,IACtB,GACX,CAOA0B,UAAUnC,EAASS,GACf,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAIgoB,WAAWpC,EAASS,IACtB,EACX,CAOA4B,UAAUrC,EAASS,GACf,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAIkoB,WAAWtC,EAASS,IACtB,EACX,CAOA8B,UAAUvC,EAASS,GACf,SAAKT,GAAWS,EAAMpnB,OAAS,GAAM,KAGrCnM,KAAKkN,IAAIooB,WAAWxC,EAASS,IACtB,EACX,CAOAgC,YAAYzC,EAAS0C,GACjB,QAAK1C,IAGL9yB,KAAKkN,IAAIuoB,iBAAiB3C,GAAS,EAAO0C,IACnC,EACX,CAOAE,aAAa5C,EAAS6C,GAClB,QAAK7C,IAGL9yB,KAAKkN,IAAI0oB,iBAAiB9C,GAAS,EAAO6C,IACnC,EACX,CAOAE,aAAa/C,EAAS6C,GAClB,QAAK7C,IAGL9yB,KAAKkN,IAAI4oB,iBAAiBhD,GAAS,EAAO6C,IACnC,EACX,CAOAI,SAASjD,EAASxyB,GACd,QAAKwyB,IAGL9yB,KAAKkN,IAAI8oB,UAAUlD,EAASxyB,IACrB,EACX,CAQA21B,UAAUnD,EAAS7pB,EAAGC,GAClB,QAAK4pB,IAGL9yB,KAAKkN,IAAIgpB,UAAUpD,EAAS7pB,EAAGC,IACxB,EACX,CASAitB,UAAUrD,EAAS7pB,EAAGC,EAAGC,GACrB,QAAK2pB,IAGL9yB,KAAKkN,IAAIkpB,UAAUtD,EAAS7pB,EAAGC,EAAGC,IAC3B,EACX,CAUAktB,UAAUvD,EAAS7pB,EAAGC,EAAGC,EAAGC,GACxB,QAAK0pB,IAGL9yB,KAAKkN,IAAIopB,UAAUxD,EAAS7pB,EAAGC,EAAGC,EAAGC,IAC9B,EACX,CAKAwU,cAII,GAHA5d,KAAKkB,mBAAmBq1B,MAAMv2B,KAAKkN,KACnClN,KAAKiH,sBAAsBsvB,MAAMv2B,KAAKkN,KACtClN,KAAKmH,YAAYovB,MAAMv2B,KAAKkN,KACxBlN,KAAKgH,mBAAoB,CACzBhH,KAAKgH,oBAAqB,EAC1B,MAAMub,EAASviB,KAAK+G,YACpB/G,KAAKkN,IAAIspB,UAAUjU,EAAQA,EAAQA,EAAQA,EAC/C,CACJ,CAKAkU,cAAclU,GACNA,IAAWviB,KAAK+G,cAChB/G,KAAKgH,oBAAqB,EAC1BhH,KAAK+G,YAAcwb,EAE3B,CAKAmU,gBACI,OAAO12B,KAAK+G,WAChB,CAII4vB,wBACA,OAAO32B,KAAKkB,kBAChB,CAII01B,iBACA,OAAO52B,KAAKmH,WAChB,CAII0vB,mBACA,OAAO72B,KAAKkH,aAChB,CAIIyW,2BACA,OAAO3d,KAAKiH,qBAChB,CAMA6vB,6BACI92B,KAAKsH,uBAAuB6E,OAAS,CACzC,CAMA2C,WAAWioB,GACH/2B,KAAK+F,gCAAkCgxB,IAG3C/2B,KAAK6pB,eAAiB,KACtB7pB,KAAKgJ,gBAAgBC,EAAI,EACzBjJ,KAAKgJ,gBAAgBE,EAAI,EACzBlJ,KAAKgJ,gBAAgBG,EAAI,EACzBnJ,KAAKgJ,gBAAgBI,EAAI,EAEzBpJ,KAAKslB,2BACDyR,IACA/2B,KAAKg3B,gBAAkB,KACvBh3B,KAAK4a,oBACL5a,KAAKiH,sBAAsBgwB,QAC3Bj3B,KAAKkB,mBAAmB+1B,QACxBj3B,KAAKkB,mBAAmBC,UAAYnB,KAAKkN,IAAIwL,OAC7C1Y,KAAKmH,YAAY8vB,QACjBj3B,KAAKoH,WAAa,EAClBpH,KAAKqH,eAAiB,EACtBrH,KAAK+G,aAAc,EACnB/G,KAAKgH,oBAAqB,EAC1BhH,KAAKqJ,mBAAqB,KAC1BrJ,KAAKkN,IAAIO,YAAYzN,KAAKkN,IAAIQ,mCAAoC1N,KAAKkN,IAAIS,MAC3E3N,KAAKkN,IAAIO,YAAYzN,KAAKkN,IAAIgqB,+BAAgC,GAC9Dl3B,KAAKqI,2BAA4B,EACjCrI,KAAKsnB,uBAETtnB,KAAKwjB,4BACLxjB,KAAK2kB,mBAAqB,KAC1B3kB,KAAKyoB,8BAAgC,KACrCzoB,KAAK0kB,gBAAgB,MACzB,CAIAyS,uBAAuBC,EAAc/T,GACjC,MAAMnD,EAAKlgB,KAAKkN,IAChB,IAAImqB,EAAYnX,EAAGkD,QACfkU,EAAYpX,EAAGkD,QACnB,OAAQgU,GACJ,KAAK,GACDC,EAAYnX,EAAGqX,OAEXD,EADAjU,EACYnD,EAAGsX,sBAGHtX,EAAGqX,OAEnB,MACJ,KAAK,EACDF,EAAYnX,EAAGqX,OAEXD,EADAjU,EACYnD,EAAGuX,qBAGHvX,EAAGqX,OAEnB,MACJ,KAAK,EACDF,EAAYnX,EAAGkD,QAEXkU,EADAjU,EACYnD,EAAGwX,sBAGHxX,EAAGkD,QAEnB,MACJ,KAAK,EACDiU,EAAYnX,EAAGkD,QAEXkU,EADAjU,EACYnD,EAAGyX,uBAGHzX,EAAGkD,QAEnB,MACJ,KAAK,EACDiU,EAAYnX,EAAGkD,QAEXkU,EADAjU,EACYnD,EAAGsX,sBAGHtX,EAAGqX,OAEnB,MACJ,KAAK,EACDF,EAAYnX,EAAGkD,QAEXkU,EADAjU,EACYnD,EAAGuX,qBAGHvX,EAAGqX,OAEnB,MACJ,KAAK,EACDF,EAAYnX,EAAGkD,QACfkU,EAAYpX,EAAGqX,OACf,MACJ,KAAK,EACDF,EAAYnX,EAAGkD,QACfkU,EAAYpX,EAAGkD,QACf,MACJ,KAAK,EACDiU,EAAYnX,EAAGqX,OAEXD,EADAjU,EACYnD,EAAGyX,uBAGHzX,EAAGkD,QAEnB,MACJ,KAAK,GACDiU,EAAYnX,EAAGqX,OAEXD,EADAjU,EACYnD,EAAGwX,sBAGHxX,EAAGkD,QAEnB,MACJ,KAAK,EACDiU,EAAYnX,EAAGqX,OACfD,EAAYpX,EAAGqX,OACf,MACJ,KAAK,GACDF,EAAYnX,EAAGqX,OACfD,EAAYpX,EAAGkD,QAGvB,MAAO,CACHtY,IAAKwsB,EACLM,IAAKP,EAEb,CAEAQ,iBACI,MAAMtX,EAAUvgB,KAAKkN,IAAI4qB,gBACzB,IAAKvX,EACD,MAAM,IAAIlT,MAAM,4BAEpB,OAAOkT,CACX,CAEAwX,yBACI,OAAO,IAAI,IAAqB/3B,KAAK63B,iBAAkB73B,KAAKkN,IAChE,CAUA8qB,uBAAuB5R,EAAMrhB,EAASkzB,GAA0B,EAAM/J,EAAS,IAAsBgK,SACjG,IAAIjzB,EACJ,IAMIkzB,EANA9U,GAAkB,EAClBgD,EAAO,EACP+Q,EAAe,EACfgB,EAAS,EACTC,GAAgB,EAChBC,EAAU,OAEErtB,IAAZlG,GAA4C,iBAAZA,GAChCse,IAAoBte,EAAQse,gBAC5BgD,OAAwBpb,IAAjBlG,EAAQshB,KAAqB,EAAIthB,EAAQshB,KAChD+Q,OAAwCnsB,IAAzBlG,EAAQqyB,aAA6B,EAAIryB,EAAQqyB,aAChEgB,OAA4BntB,IAAnBlG,EAAQqzB,OAAuB,EAAIrzB,EAAQqzB,OACpDC,OAA0CptB,IAA1BlG,EAAQszB,eAAsCtzB,EAAQszB,cACtEC,EAAqC,QAA1BrzB,EAAKF,EAAQuzB,eAA4B,IAAPrzB,EAAgBA,EAAK,EAClEkzB,EAAQpzB,EAAQozB,OAGhB9U,IAAoBte,EAExBszB,IAAkBA,EAAgBr4B,KAAKG,MAAM6T,qBAAuBhU,KAAKE,aAAe,GAAKF,KAAKwD,YACrF,IAAT6iB,GAAermB,KAAKG,MAAM+S,+BAIZ,IAATmT,GAAermB,KAAKG,MAAMiT,mCAF/BgkB,EAAe,GAMN,IAAT/Q,GAAermB,KAAKG,MAAM4S,eAC1BsT,EAAO,EACP,IAAO5Z,KAAK,+EAEhB,MAAMyT,EAAKlgB,KAAKkN,IACVqT,EAAU,IAAI,IAAgBvgB,KAAMkuB,GACpC/pB,EAAQiiB,EAAKjiB,OAASiiB,EACtBhiB,EAASgiB,EAAKhiB,QAAUgiB,EACxBmS,EAASnS,EAAKmS,QAAU,EACxBC,EAAUx4B,KAAKm3B,uBAAuBC,EAAc/T,GACpDhX,EAAoB,IAAXksB,EAAerY,EAAGuY,iBAAmBvY,EAAGiB,WACjDuX,EAAc14B,KAAK24B,kCAAkCtS,EAAM+R,EAAQC,GACnEO,EAAiB54B,KAAK64B,mBAAmBT,GACzCU,EAAc94B,KAAK+4B,qBAAqB1S,GAiC9C,OA/BArmB,KAAK6iB,qBAAqBxW,EAAQkU,GACnB,IAAXgY,GACAhY,EAAQH,WAAY,EACpBF,EAAG8Y,WAAW3sB,EAAQ,EAAGqsB,EAAav0B,EAAOC,EAAQm0B,EAAQ,EAAGK,EAAgBE,EAAa,OAG7F5Y,EAAG+Y,WAAW5sB,EAAQ,EAAGqsB,EAAav0B,EAAOC,EAAQ,EAAGw0B,EAAgBE,EAAa,MAEzF5Y,EAAGgZ,cAAc7sB,EAAQ6T,EAAGiZ,mBAAoBX,EAAQZ,KACxD1X,EAAGgZ,cAAc7sB,EAAQ6T,EAAGkZ,mBAAoBZ,EAAQ1tB,KACxDoV,EAAGgZ,cAAc7sB,EAAQ6T,EAAGmZ,eAAgBnZ,EAAGoZ,eAC/CpZ,EAAGgZ,cAAc7sB,EAAQ6T,EAAGqZ,eAAgBrZ,EAAGoZ,eAE3CjW,GACArjB,KAAKkN,IAAI4V,eAAezW,GAE5BrM,KAAK6iB,qBAAqBxW,EAAQ,MAClCkU,EAAQiZ,eAAiBnB,EACzB9X,EAAQkZ,UAAYt1B,EACpBoc,EAAQmZ,WAAat1B,EACrBmc,EAAQpc,MAAQA,EAChBoc,EAAQnc,OAASA,EACjBmc,EAAQ9C,MAAQ8a,EAChBhY,EAAQrQ,SAAU,EAClBqQ,EAAQ+X,QAAUA,EAClB/X,EAAQ8C,gBAAkBA,EAC1B9C,EAAQ6W,aAAeA,EACvB7W,EAAQ8F,KAAOA,EACf9F,EAAQ6X,OAASA,EACjB7X,EAAQ4X,MAAQA,EAChBn4B,KAAKsH,uBAAuBsR,KAAK2H,GAC1BA,CACX,CAIAoZ,kBAAkBtB,EAAeuB,GAE7B,OAAOvB,GAAiBr4B,KAAKG,MAAM6T,qBAAuBhU,KAAKE,aAAe,GAAKF,KAAKwD,UAAYo2B,EACxG,CACAC,mBAAmBC,EAAKF,EAAUG,EAASC,EAAO5C,EAAe,EAAG6C,EAAS,KAAM7M,EAAU,KAAM8M,EAAgBC,EAA+B9U,EAAS,KAAM+U,EAAW,KAAMhC,EAAS,KAAMiC,EAAkB,KAAMC,EAAUC,EAAelC,GAE9O,MAAMmC,EAAgC,WADtCV,EAAMA,GAAO,IACQW,OAAO,EAAG,GACzBC,EAAgC,UAArBZ,EAAIW,OAAO,EAAG,GACzBE,EAAWH,IAAyC,IAA7BV,EAAIvrB,QAAQ,YACnCgS,EAAU6Z,GAAsB,IAAI,IAAgBp6B,KAAM,IAAsB46B,KAClFra,IAAY6Z,IACZ7Z,EAAQ4X,MAAQ2B,EAAIe,UAAU,EAAG,KAErC,MAAMC,EAAchB,GAChB95B,KAAK2I,sBAAyBgyB,GAAaP,GAAa/U,IACxDyU,EAAM95B,KAAK2I,qBAAqBmxB,IAEhCgB,IAAgBhB,IAChBvZ,EAAQwa,aAAeD,GAG3B,MAAME,EAAUlB,EAAImB,YAAY,KAChC,IAAIC,EAAYb,IAAoCW,GAAW,EAAIlB,EAAIe,UAAUG,GAASG,cAAgB,IACtGC,EAAS,KAEYF,EAAU3sB,QAAQ,MACnB,IACpB2sB,EAAYA,EAAUG,MAAM,KAAK,IAErC,IAAK,MAAMC,KAAmB17B,EAAW27B,gBACrC,GAAID,EAAgBE,QAAQN,EAAWZ,GAAW,CAC9Cc,EAASE,EACT,KACJ,CAEAtB,GACAA,EAAMyB,eAAelb,GAEzBA,EAAQuZ,IAAMA,EACdvZ,EAAQ8C,iBAAmBuW,EAC3BrZ,EAAQ6W,aAAeA,EACvB7W,EAAQwZ,QAAUA,EAClBxZ,EAAQiZ,eAAiBx5B,KAAK25B,oBAAoBtB,EAAeuB,GAC5D55B,KAAKkC,0BAENqe,EAAQmb,QAAUrW,GAEtB,IAAIsW,EAAiB,KACjB1B,IAAWG,IACXuB,EAAiBpb,EAAQqb,mBAAmBC,IAAI5B,IAE/CG,GACDp6B,KAAKsH,uBAAuBsR,KAAK2H,GAErC,MAAMub,EAAkB,CAACC,EAASvwB,KAC1BwuB,GACAA,EAAMgC,kBAAkBzb,GAExBuZ,IAAQgB,GACJa,GACApb,EAAQqb,mBAAmBK,OAAON,GAElC,IAAYO,oBACZl8B,KAAK65B,mBAAmB,IAAYsC,gBAAiBvC,EAAUrZ,EAAQwZ,QAASC,EAAO5C,EAAc,KAAMhK,EAAS8M,EAAgBC,EAA+B9U,EAAQ9E,GAE/Kwb,GAAWA,GAAW,kBAAoB,IAAYG,mBAAqB,+BAAiC,IAC5G3b,EAAQ6b,kBAAkB1vB,gBAAgB,CAAEqvB,UAASvwB,cACjD4hB,GACAA,EAAQ2O,EAASvwB,KAKrB,IAAOiB,KAAK,kBAAkBqtB,sBAAwBgB,KACtD96B,KAAK65B,mBAAmBiB,EAAalB,EAAUrZ,EAAQwZ,QAASC,EAAO5C,EAAc6C,EAAQ7M,EAAS8M,EAAgBC,EAA+B9U,EAAQ9E,EAAS6X,EAAQiC,EAAiBC,EAAUC,EAAelC,GAC5N,EAGJ,GAAI+C,EAAQ,CACR,MAAMiB,EAAYzY,IACdwX,EAAOkB,SAAS1Y,EAAMrD,GAAS,CAACpc,EAAOC,EAAQm4B,EAAYC,EAAcC,EAAMC,KACvEA,EACAZ,EAAgB,qCAGhB5B,EAAe3Z,EAAS2a,EAAWlB,EAAO,CAAE71B,QAAOC,UAAUmc,EAAQwZ,SAAUwC,EAAYC,GAAc,KACrGC,KACO,IACRrF,EACP,GACDmD,EAAc,EAEhBlV,EAMGA,aAAkBsX,YAClBN,EAAS,IAAIz5B,WAAWyiB,IAEnBsX,YAAYC,OAAOvX,GACxBgX,EAAShX,GAGL+H,GACAA,EAAQ,mEAAoE,MAbpFptB,KAAK68B,UAAU/C,GAAMlW,GAASyY,EAAS,IAAIz5B,WAAWghB,UAAQ3Y,EAAW+uB,EAAQA,EAAM8C,qBAAkB7xB,GAAW,GAAM,CAAC8xB,EAASvxB,KAChIswB,EAAgB,mBAAqBiB,GAAUA,EAAQC,YAAmBxxB,GAAW,GAgBjG,KACK,CACD,MAAMyxB,EAAUC,IACRxC,IAAa16B,KAAKkC,0BAGlBqe,EAAQmb,QAAUwB,GAEtBhD,EAAe3Z,EAAS2a,EAAWlB,EAAOkD,EAAK3c,EAAQwZ,QAASH,GAAU,EAAOO,EAA+B/C,EAAa,GAI5HoD,GAAYG,EACTtV,IAAsC,iBAApBA,EAAO8X,UAAyB9X,EAAO+X,OACzDH,EAAO5X,GAGPzlB,EAAWy9B,oBAAoBvD,EAAKmD,EAAQnB,EAAiB9B,EAAQA,EAAM8C,gBAAkB,KAAMxC,EAAU/Z,EAAQwZ,SAAW/5B,KAAK6Y,UAAUkB,qBAAuB,CAAEujB,iBAAkB,cAAYryB,GAGnL,iBAAXoa,GAAuBA,aAAkBsX,aAAeA,YAAYC,OAAOvX,IAAWA,aAAkBkY,KACpH39B,EAAWy9B,oBAAoBhY,EAAQ4X,EAAQnB,EAAiB9B,EAAQA,EAAM8C,gBAAkB,KAAMxC,EAAU/Z,EAAQwZ,SAAW/5B,KAAK6Y,UAAUkB,qBAAuB,CAAEujB,iBAAkB,cAAYryB,GAEpMoa,GACL4X,EAAO5X,EAEf,CACA,OAAO9E,CACX,CAwBAuX,cAAcgC,EAAKF,EAAUG,EAASC,EAAO5C,EAAe,EAAG6C,EAAS,KAAM7M,EAAU,KAAM/H,EAAS,KAAM+U,EAAW,KAAMhC,EAAS,KAAMiC,EAAkB,KAAMC,EAAUC,EAAeiD,EAAenF,GACzM,OAAOr4B,KAAK65B,mBAAmBC,EAAKF,EAAUG,EAASC,EAAO5C,EAAc6C,EAAQ7M,EAASptB,KAAKy9B,qBAAqB3wB,KAAK9M,OAAO,CAAC09B,EAAUC,EAAWT,EAAKhC,EAAW3a,EAASqd,KAC9K,MAAM1d,EAAKlgB,KAAKkN,IACV2wB,EAAQX,EAAI/4B,QAAUu5B,GAAYR,EAAI94B,SAAWu5B,EACjD/E,EAAiBR,EACjBp4B,KAAK64B,mBAAmBT,EAAQ7X,EAAQiZ,gBAC1B,SAAd0B,GAAyB3a,EAAQiZ,eAE7BjZ,EAAQiZ,eACJx5B,KAAKiY,uBAAuBI,aAC5B6H,EAAG4d,KAHP5d,EAAG6d,IAIb,IAAIC,EAAc5F,EAASp4B,KAAK64B,mBAAmBT,GAAwB,SAAd8C,GAAyB3a,EAAQiZ,eAA0BtZ,EAAG4d,KAAZ5d,EAAG6d,IAIlH,GAHIxd,EAAQiZ,gBAAwC,IAAtBx5B,KAAKE,eAC/B89B,EAAcpF,GAEdiF,EAEA,OADA3d,EAAG+Y,WAAW/Y,EAAGiB,WAAY,EAAGyX,EAAgBoF,EAAa9d,EAAG+d,cAAef,IACxE,EAEX,MAAMtsB,EAAiB5Q,KAAKG,MAAMyQ,eAClC,GAAIssB,EAAI/4B,MAAQyM,GAAkBssB,EAAI94B,OAASwM,IAAmB5Q,KAAKmC,kCAEnE,OADAnC,KAAKwa,2BACAxa,KAAKya,iBAAmBza,KAAK2a,mBAGlC3a,KAAKya,eAAetW,MAAQu5B,EAC5B19B,KAAKya,eAAerW,OAASu5B,EAC7B39B,KAAK2a,gBAAgBujB,UAAUhB,EAAK,EAAG,EAAGA,EAAI/4B,MAAO+4B,EAAI94B,OAAQ,EAAG,EAAGs5B,EAAUC,GACjFzd,EAAG+Y,WAAW/Y,EAAGiB,WAAY,EAAGyX,EAAgBoF,EAAa9d,EAAG+d,cAAej+B,KAAKya,gBACpF8F,EAAQpc,MAAQu5B,EAChBnd,EAAQnc,OAASu5B,GACV,GAEN,CAED,MAAMzP,EAAS,IAAI,IAAgBluB,KAAM,IAAsBm+B,MAC/Dn+B,KAAK6iB,qBAAqB3C,EAAGiB,WAAY+M,GAAQ,GACjDhO,EAAG+Y,WAAW/Y,EAAGiB,WAAY,EAAGyX,EAAgBoF,EAAa9d,EAAG+d,cAAef,GAC/El9B,KAAKo+B,gBAAgBlQ,EAAQ3N,EAASyZ,EAAOpB,GAAgB,KACzD54B,KAAKq+B,gBAAgBnQ,GACrBluB,KAAK6iB,qBAAqB3C,EAAGiB,WAAYZ,GAAS,GAClDqd,GAAsB,GAE9B,CACA,OAAO,CAAI,GACZvY,EAAQ+U,EAAUhC,EAAQiC,EAAiBC,EAAUC,EAAelC,EAC3E,CAYAn0B,2BAA2Bo6B,EAAOrE,EAAQ7M,EAAS0P,EAAiBxC,EAAUiE,GAC1E,MAAM,OAAY,YACtB,CAIAH,gBAAgBlQ,EAAQsQ,EAAaxE,EAAOpB,EAAgB6F,GAAc,CAgB1E97B,iBAAiBihB,EAAMzf,EAAOC,EAAQg0B,EAAQ/U,EAAiB0W,EAAS3C,EAAcsH,EAAc,KAAMrY,EAAO,EAAGmX,EAAgB,EAAGnF,GAAgB,GACnJ,MAAM,OAAY,oBACtB,CAaA90B,qBAAqBqgB,EAAMwC,EAAMgS,EAAQ/R,EAAMhD,EAAiB0W,EAAS3C,EAAcsH,EAAc,MACjG,MAAM,OAAY,oBACtB,CAeA37B,mBAAmB6gB,EAAMzf,EAAOC,EAAQqZ,EAAO2a,EAAQ/U,EAAiB0W,EAAS3C,EAAcsH,EAAc,KAAM5F,EAAc,GAC7H,MAAM,OAAY,oBACtB,CAeA51B,wBAAwB0gB,EAAMzf,EAAOC,EAAQqZ,EAAO2a,EAAQ/U,EAAiB0W,EAAS3C,EAAcsH,EAAc,KAAM5F,EAAc,GAClI,MAAM,OAAY,oBACtB,CAIA6F,aAAar+B,GACLN,KAAKqJ,qBAAuB/I,IAC5BN,KAAKkN,IAAIO,YAAYzN,KAAKkN,IAAI0xB,oBAAqBt+B,EAAQ,EAAI,GAC3DN,KAAKsJ,0BACLtJ,KAAKqJ,mBAAqB/I,GAGtC,CAEAu+B,uBACI,OAAO7+B,KAAKkN,IAAIoD,aAAatQ,KAAKkN,IAAI4xB,iBAC1C,CACAC,kBAAkBxe,GACd,OAAIA,EAAQG,OACD1gB,KAAKkN,IAAI8xB,iBAEXze,EAAQ0e,KACNj/B,KAAKkN,IAAIgyB,WAEX3e,EAAQH,WAAaG,EAAQ4e,YAC3Bn/B,KAAKkN,IAAIurB,iBAEbz4B,KAAKkN,IAAIiU,UACpB,CAOAie,0BAA0BhI,EAAc7W,EAAS8C,GAAkB,GAC/D,MAAMhX,EAASrM,KAAK++B,kBAAkBxe,GAChCiY,EAAUx4B,KAAKm3B,uBAAuBC,EAAc7W,EAAQ8e,YAAchc,GAChFrjB,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAIisB,mBAAoBX,EAAQZ,IAAKrX,GACnFvgB,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAIksB,mBAAoBZ,EAAQ1tB,KAC1EuY,IACA9C,EAAQ8C,iBAAkB,EAC1BrjB,KAAKkN,IAAI4V,eAAezW,IAE5BrM,KAAK6iB,qBAAqBxW,EAAQ,MAClCkU,EAAQ6W,aAAeA,CAC3B,CAQAmI,wBAAwBhf,EAASpc,EAAOC,EAAQqZ,EAAQ,GAAK,CAQ7D+hB,0BAA0Bjf,EAASkf,EAAOC,EAAQ,KAAMC,EAAQ,MAC5D,MAAMtzB,EAASrM,KAAK++B,kBAAkBxe,GACxB,OAAVkf,IACAz/B,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAImsB,eAAgBr5B,KAAK4/B,oBAAoBH,GAAQlf,GACnGA,EAAQsf,aAAeJ,GAEb,OAAVC,IACA1/B,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAIqsB,eAAgBv5B,KAAK4/B,oBAAoBF,GAAQnf,GACnGA,EAAQuf,aAAeJ,IAEtBnf,EAAQH,WAAaG,EAAQ0e,OAAmB,OAAVU,IACvC3/B,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAI6yB,eAAgB//B,KAAK4/B,oBAAoBD,GAAQpf,GACnGA,EAAQyf,aAAeL,GAE3B3/B,KAAK6iB,qBAAqBxW,EAAQ,KACtC,CAIA4zB,0BAA0BxwB,EAAiB2W,EAAM8Z,EAAiBC,EAAmBC,EAAoB9H,EAAU,GAC/G,MAAMn0B,EAAQiiB,EAAKjiB,OAASiiB,EACtBhiB,EAASgiB,EAAKhiB,QAAUgiB,EACxBmS,EAASnS,EAAKmS,QAAU,EAC9B9oB,EAAgBgqB,UAAYt1B,EAC5BsL,EAAgBiqB,WAAat1B,EAC7BqL,EAAgBtL,MAAQA,EACxBsL,EAAgBrL,OAASA,EACzBqL,EAAgB2Q,UAAYmY,EAAS,EACrC9oB,EAAgBgO,MAAQ8a,EACxB9oB,EAAgBS,SAAU,EAC1BT,EAAgB6oB,QAAUA,EAC1B7oB,EAAgB4T,iBAAkB,EAClC5T,EAAgB2nB,aAAe+I,EAAoB,EAAI,EACvD1wB,EAAgB4W,KAAO,EACvB5W,EAAgB4wB,oBAAsBD,EACtC,MAAMlgB,EAAKlgB,KAAKkN,IACVb,EAASrM,KAAK++B,kBAAkBtvB,GAChC6wB,EAAqBtgC,KAAKm3B,uBAAuB1nB,EAAgB2nB,cAAc,GACrFlX,EAAGgZ,cAAc7sB,EAAQ6T,EAAGiZ,mBAAoBmH,EAAmB1I,KACnE1X,EAAGgZ,cAAc7sB,EAAQ6T,EAAGkZ,mBAAoBkH,EAAmBx1B,KACnEoV,EAAGgZ,cAAc7sB,EAAQ6T,EAAGmZ,eAAgBnZ,EAAGoZ,eAC/CpZ,EAAGgZ,cAAc7sB,EAAQ6T,EAAGqZ,eAAgBrZ,EAAGoZ,eAE3Ct5B,KAAKE,aAAe,IACO,IAAvBkgC,GACAlgB,EAAGgZ,cAAc7sB,EAAQ6T,EAAGqgB,qBAAsB,KAClDrgB,EAAGgZ,cAAc7sB,EAAQ6T,EAAGsgB,qBAAsBtgB,EAAGvS,QAGrDuS,EAAGgZ,cAAc7sB,EAAQ6T,EAAGqgB,qBAAsBH,GAClDlgB,EAAGgZ,cAAc7sB,EAAQ6T,EAAGsgB,qBAAsBtgB,EAAGugB,yBAGjE,CAIAC,uCAAuCngB,EAASqY,EAAgBz0B,EAAOC,EAAQwf,EAAMnE,EAAY,EAAGkhB,EAAM,GACtG,MAAMzgB,EAAKlgB,KAAKkN,IAChB,IAAIb,EAAS6T,EAAGiB,WAIhB,GAHIZ,EAAQG,SACRrU,EAAS6T,EAAGU,4BAA8BnB,GAE1Cc,EAAQiZ,eACR,OAAQZ,GACJ,KAAK,MACL,KAAK,MAEG54B,KAAKG,MAAMiS,KACXwmB,EAAiB1Y,EAAGpK,sBAGpByK,EAAQiZ,gBAAiB,EAE7B,MACJ,KAAK,MACGx5B,KAAKG,MAAMiS,KACXwmB,EAAiB1Y,EAAGnK,iCAGpBwK,EAAQiZ,gBAAiB,EAE7B,MACJ,KAAK,MACDZ,EAAiB1Y,EAAGxK,qCACpB,MACJ,KAAK,MACDkjB,EAAiB1Y,EAAGzK,qCACpB,MACJ,KAAK,MACGzV,KAAKG,MAAM8R,UACX2mB,EAAiB1Y,EAAGvK,8BAIpB4K,EAAQiZ,gBAAiB,EAE7B,MACJ,KAAK,MACGx5B,KAAKG,MAAM8R,UACX2mB,EAAiB1Y,EAAGtK,oCAIpB2K,EAAQiZ,gBAAiB,EAE7B,MACJ,KAAK,MACGx5B,KAAKG,MAAM8R,UACX2mB,EAAiB1Y,EAAGrK,oCAIpB0K,EAAQiZ,gBAAiB,EAE7B,MACJ,QAEIjZ,EAAQiZ,gBAAiB,EAIrCx5B,KAAKkN,IAAI0zB,qBAAqBv0B,EAAQs0B,EAAK/H,EAAgBz0B,EAAOC,EAAQ,EAAGwf,EACjF,CAIAid,6BAA6BtgB,EAASugB,EAAWrhB,EAAY,EAAGkhB,EAAM,EAAGI,EAAuBC,GAA2B,GACvH,MAAM9gB,EAAKlgB,KAAKkN,IACV4rB,EAAc94B,KAAK+4B,qBAAqBxY,EAAQ8F,MAChD+R,EAASp4B,KAAK64B,mBAAmBtY,EAAQ6X,QACzCQ,OAA2C3tB,IAA1B81B,EACjB/gC,KAAK24B,kCAAkCpY,EAAQ8F,KAAM9F,EAAQ6X,OAAQ7X,EAAQiZ,gBAC7Ex5B,KAAK64B,mBAAmBkI,EAAuBxgB,EAAQiZ,gBAC7Dx5B,KAAK2+B,aAAape,EAAQwZ,SAC1B,IAAI1tB,EAAS6T,EAAGiB,WACZZ,EAAQG,SACRrU,EAAS6T,EAAGU,4BAA8BnB,GAE9C,MAAMwhB,EAAcp2B,KAAKq2B,MAAMr2B,KAAKsD,IAAIoS,EAAQpc,OAAS0G,KAAKs2B,OACxDC,EAAev2B,KAAKq2B,MAAMr2B,KAAKsD,IAAIoS,EAAQnc,QAAUyG,KAAKs2B,OAC1Dh9B,EAAQ68B,EAA2BzgB,EAAQpc,MAAQ0G,KAAKuW,IAAI,EAAGvW,KAAKw2B,IAAIJ,EAAcN,EAAK,IAC3Fv8B,EAAS48B,EAA2BzgB,EAAQnc,OAASyG,KAAKuW,IAAI,EAAGvW,KAAKw2B,IAAID,EAAeT,EAAK,IACpGzgB,EAAG+Y,WAAW5sB,EAAQs0B,EAAK/H,EAAgBz0B,EAAOC,EAAQ,EAAGg0B,EAAQU,EAAagI,EACtF,CAaAQ,kBAAkB/gB,EAASugB,EAAWS,EAASC,EAASr9B,EAAOC,EAAQqb,EAAY,EAAGkhB,EAAM,EAAGtd,GAAkB,GAC7G,MAAMnD,EAAKlgB,KAAKkN,IACV4rB,EAAc94B,KAAK+4B,qBAAqBxY,EAAQ8F,MAChD+R,EAASp4B,KAAK64B,mBAAmBtY,EAAQ6X,QAC/Cp4B,KAAK2+B,aAAape,EAAQwZ,SAC1B,IAAI0H,EAAmBvhB,EAAGiB,WACtB9U,EAAS6T,EAAGiB,WACZZ,EAAQG,SACRrU,EAAS6T,EAAGU,4BAA8BnB,EAC1CgiB,EAAmBvhB,EAAG8e,kBAE1Bh/B,KAAK6iB,qBAAqB4e,EAAkBlhB,GAAS,GACrDL,EAAGwhB,cAAcr1B,EAAQs0B,EAAKY,EAASC,EAASr9B,EAAOC,EAAQg0B,EAAQU,EAAagI,GAChFzd,GACArjB,KAAKkN,IAAI4V,eAAezW,GAE5BrM,KAAK6iB,qBAAqB4e,EAAkB,KAChD,CAIAE,gCAAgCphB,EAASugB,EAAWrhB,EAAY,EAAGkhB,EAAM,GACrE,MAAMzgB,EAAKlgB,KAAKkN,IACV00B,EAAarhB,EAAQG,OAASR,EAAG8e,iBAAmB9e,EAAGiB,WAC7DnhB,KAAK6iB,qBAAqB+e,EAAYrhB,GAAS,GAC/CvgB,KAAK6gC,6BAA6BtgB,EAASugB,EAAWrhB,EAAWkhB,GACjE3gC,KAAK6iB,qBAAqB+e,EAAY,MAAM,EAChD,CACAC,iCAAiCthB,EAASyZ,EAAOJ,EAAU4C,EAAcpF,GACrE,MAAMlX,EAAKlgB,KAAKkN,IAChB,IAAKgT,EACD,OAEJ,MAAMsY,EAAUx4B,KAAKm3B,uBAAuBC,GAAewC,GAC3D1Z,EAAGgZ,cAAchZ,EAAGiB,WAAYjB,EAAGiZ,mBAAoBX,EAAQZ,KAC/D1X,EAAGgZ,cAAchZ,EAAGiB,WAAYjB,EAAGkZ,mBAAoBZ,EAAQ1tB,KAC1D8uB,GAAa4C,GACdtc,EAAG4C,eAAe5C,EAAGiB,YAEzBnhB,KAAK6iB,qBAAqB3C,EAAGiB,WAAY,MAErC6Y,GACAA,EAAMgC,kBAAkBzb,GAE5BA,EAAQqb,mBAAmBlvB,gBAAgB6T,GAC3CA,EAAQqb,mBAAmBte,OAC/B,CACAmgB,qBAAqBld,EAAS2a,EAAWlB,EAAOkD,EAAKnD,EAASH,EAAU4C,EAAcsF,EAAiB1K,EAAe,GAClH,MAAMxmB,EAAiB5Q,KAAKwb,UAAU5K,eAChC8sB,EAAW7yB,KAAKC,IAAI8F,EAAgB5Q,KAAK6B,gBAAkBjC,EAAWmiC,iBAAiB7E,EAAI/4B,MAAOyM,GAAkBssB,EAAI/4B,OACxHw5B,EAAY9yB,KAAKC,IAAI8F,EAAgB5Q,KAAK6B,gBAAkBjC,EAAWmiC,iBAAiB7E,EAAI94B,OAAQwM,GAAkBssB,EAAI94B,QAC1H8b,EAAKlgB,KAAKkN,IACXgT,IAGAK,EAAQC,kBAObxgB,KAAK6iB,qBAAqB3C,EAAGiB,WAAYZ,GAAS,GAClDvgB,KAAK2+B,kBAAyB1zB,IAAZ8uB,KAA+BA,GACjDxZ,EAAQkZ,UAAYyD,EAAI/4B,MACxBoc,EAAQmZ,WAAawD,EAAI94B,OACzBmc,EAAQpc,MAAQu5B,EAChBnd,EAAQnc,OAASu5B,EACjBpd,EAAQrQ,SAAU,EACd4xB,EAAgBpE,EAAUC,EAAWT,EAAKhC,EAAW3a,GAAS,KAC9DvgB,KAAK6hC,iCAAiCthB,EAASyZ,EAAOJ,EAAU4C,EAAcpF,EAAa,KAK/Fp3B,KAAK6hC,iCAAiCthB,EAASyZ,EAAOJ,EAAU4C,EAAcpF,IAlBtE4C,GACAA,EAAMgC,kBAAkBzb,GAkBpC,CAIAyhB,kCAAkCC,EAAuBC,EAAqB/9B,EAAOC,EAAQk0B,EAAU,GACnG,MAAMpY,EAAKlgB,KAAKkN,IAEhB,GAAI+0B,GAAyBC,EACzB,OAAOliC,KAAKmiC,oBAAoBh+B,EAAOC,EAAQk0B,EAASpY,EAAGkiB,cAAeliB,EAAGhL,iBAAkBgL,EAAGe,0BAEtG,GAAIihB,EAAqB,CACrB,IAAIG,EAAcniB,EAAGoiB,kBAIrB,OAHItiC,KAAKQ,cAAgB,IACrB6hC,EAAcniB,EAAGqiB,oBAEdviC,KAAKmiC,oBAAoBh+B,EAAOC,EAAQk0B,EAAS+J,EAAaA,EAAaniB,EAAGgB,iBACzF,CACA,OAAI+gB,EACOjiC,KAAKmiC,oBAAoBh+B,EAAOC,EAAQk0B,EAASpY,EAAGsiB,eAAgBtiB,EAAGsiB,eAAgBtiB,EAAGuiB,oBAE9F,IACX,CAIAN,oBAAoBh+B,EAAOC,EAAQk0B,EAASM,EAAgB8J,EAAkB3hB,EAAY4hB,GAAe,GACrG,MACMC,EADK5iC,KAAKkN,IACQ21B,qBACxB,OAAO7iC,KAAK8iC,oBAAoBF,EAAcz+B,EAAOC,EAAQk0B,EAASM,EAAgB8J,EAAkB3hB,EAAY4hB,EACxH,CACAG,oBAAoBF,EAAcz+B,EAAOC,EAAQk0B,EAASM,EAAgB8J,EAAkB3hB,EAAY4hB,GAAe,GACnH,MAAMziB,EAAKlgB,KAAKkN,IAYhB,OAXAgT,EAAG6iB,iBAAiB7iB,EAAG8iB,aAAcJ,GACjCtK,EAAU,GAAKpY,EAAG5S,+BAClB4S,EAAG5S,+BAA+B4S,EAAG8iB,aAAc1K,EAASoK,EAAkBv+B,EAAOC,GAGrF8b,EAAG+iB,oBAAoB/iB,EAAG8iB,aAAcpK,EAAgBz0B,EAAOC,GAEnE8b,EAAGgjB,wBAAwBhjB,EAAG9J,YAAa2K,EAAYb,EAAG8iB,aAAcJ,GACpED,GACAziB,EAAG6iB,iBAAiB7iB,EAAG8iB,aAAc,MAElCJ,CACX,CAIAvE,gBAAgB9d,GACZ,IAAItb,EACJjF,KAAKmjC,eAAmD,QAAnCl+B,EAAKsb,EAAQC,wBAAqC,IAAPvb,OAAgB,EAASA,EAAGwb,oBAE5FzgB,KAAKojC,oBACL,MAAMznB,EAAQ3b,KAAKsH,uBAAuBiH,QAAQgS,IACnC,IAAX5E,GACA3b,KAAKsH,uBAAuBsU,OAAOD,EAAO,GAG1C4E,EAAQ8iB,iBACR9iB,EAAQ8iB,gBAAgBC,UAExB/iB,EAAQgjB,gBACRhjB,EAAQgjB,eAAeD,UAEvB/iB,EAAQijB,gBACRjjB,EAAQijB,eAAeF,UAGvB/iB,EAAQkjB,oBACRljB,EAAQkjB,mBAAmBH,SAEnC,CAIAI,4BAA4BlkB,GACxB,MAAM7D,EAAQ3b,KAAKuH,0BAA0BgH,QAAQiR,IACtC,IAAX7D,GACA3b,KAAKuH,0BAA0BqU,OAAOD,EAAO,EAErD,CACAwnB,eAAe5iB,GACPA,GACAvgB,KAAKkN,IAAIy2B,cAAcpjB,EAE/B,CACAqjB,YAAYje,GACJ3lB,KAAKg3B,kBAAoBrR,IACzB3lB,KAAKkN,IAAI22B,WAAWle,GACpB3lB,KAAKg3B,gBAAkBrR,EAE/B,CAKA+M,aAAa9iB,GACT,MAAM2c,EAAuB3c,EAAOyc,qBACpCrsB,KAAK4jC,YAAYrX,EAAqB5G,SACtC,MAAMsH,EAAWrd,EAAOk0B,cACxB,IAAK,IAAInoB,EAAQ,EAAGA,EAAQsR,EAAS9gB,OAAQwP,IAAS,CAClD,MAAMmX,EAAUljB,EAAOm0B,WAAW9W,EAAStR,IACvCmX,IACA9yB,KAAKuJ,eAAeoS,GAASmX,EAErC,CACA9yB,KAAK6pB,eAAiB,IAC1B,CACAma,0BACQhkC,KAAKyH,yBAA2BzH,KAAKwH,iBACrCxH,KAAKkN,IAAI+2B,cAAcjkC,KAAKkN,IAAIg3B,SAAWlkC,KAAKwH,gBAChDxH,KAAKyH,uBAAyBzH,KAAKwH,eAE3C,CAIAqb,qBAAqBxW,EAAQkU,EAAS4jB,GAAuB,EAAO3iB,GAAQ,GACxE,IAAIvc,EAAIC,EACR,IAAIk/B,GAAqB,EACzB,MAAMC,EAAwB9jB,GAAWA,EAAQ+jB,oBAAsB,EACnEH,GAAwBE,IACxBrkC,KAAKwH,eAAiB+Y,EAAQ+jB,oBAGlC,GAD4BtkC,KAAK0H,oBAAoB1H,KAAKwH,kBAC9B+Y,GAAWiB,EAAO,CAE1C,GADAxhB,KAAKgkC,0BACDzjB,GAAWA,EAAQ4e,YAGnB,MADAjxB,QAAQugB,MAAMpiB,EAAQkU,GAChB,wDAGNvgB,KAAKkN,IAAIq3B,YAAYl4B,EAAgK,QAAvJnH,EAA2F,QAArFD,EAAKsb,aAAyC,EAASA,EAAQC,wBAAqC,IAAPvb,OAAgB,EAASA,EAAGwb,0BAAuC,IAAPvb,EAAgBA,EAAK,MAEtNlF,KAAK0H,oBAAoB1H,KAAKwH,gBAAkB+Y,EAC5CA,IACAA,EAAQ+jB,mBAAqBtkC,KAAKwH,eAE1C,MACS28B,IACLC,GAAqB,EACrBpkC,KAAKgkC,2BAKT,OAHIK,IAA0BF,GAC1BnkC,KAAKwkC,6BAA6BjkB,EAAQ+jB,mBAAoBtkC,KAAKwH,gBAEhE48B,CACX,CAIAK,aAAaC,EAASnkB,EAAStgB,GAC3B,QAAgBgL,IAAZy5B,EACA,OAEAnkB,IACAA,EAAQ+jB,mBAAqBI,GAEjC1kC,KAAKwH,eAAiBk9B,EACtB,MAAMr4B,EAASkU,EAAUvgB,KAAK++B,kBAAkBxe,GAAWvgB,KAAKkN,IAAIiU,WACpEnhB,KAAK6iB,qBAAqBxW,EAAQkU,EACtC,CAIA6iB,oBACI,IAAK,IAAIsB,EAAU,EAAGA,EAAU1kC,KAAKuI,yBAA0Bm8B,IAC3D1kC,KAAKwH,eAAiBk9B,EACtB1kC,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIiU,WAAY,MAC/CnhB,KAAK6iB,qBAAqB7iB,KAAKkN,IAAI8xB,iBAAkB,MACjDh/B,KAAKE,aAAe,IACpBF,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIgyB,WAAY,MAC/Cl/B,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIurB,iBAAkB,MAGjE,CAQAkM,WAAWD,EAAS5R,EAASvS,EAAStgB,QAClBgL,IAAZy5B,IAGA5R,IACA9yB,KAAKuJ,eAAem7B,GAAW5R,GAEnC9yB,KAAK4kC,YAAYF,EAASnkB,GAC9B,CACAikB,6BAA6BK,EAAYrG,GACrC,MAAM1L,EAAU9yB,KAAKuJ,eAAes7B,GAC/B/R,GAAWA,EAAQgS,gBAAkBtG,IAG1Cx+B,KAAKkN,IAAI6lB,UAAUD,EAAS0L,GAC5B1L,EAAQgS,cAAgBtG,EAC5B,CACAoB,oBAAoB57B,GAChB,OAAQA,GACJ,KAAK,EACD,OAAOhE,KAAKkN,IAAI63B,OACpB,KAAK,EACD,OAAO/kC,KAAKkN,IAAIosB,cACpB,KAAK,EACD,OAAOt5B,KAAKkN,IAAI83B,gBAExB,OAAOhlC,KAAKkN,IAAI63B,MACpB,CACAH,YAAYF,EAASnkB,EAAS0kB,GAAuB,EAAOpkB,GAAsB,EAAO5gB,EAAO,IAE5F,IAAKsgB,EAUD,OATyC,MAArCvgB,KAAK0H,oBAAoBg9B,KACzB1kC,KAAKwH,eAAiBk9B,EACtB1kC,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIiU,WAAY,MAC/CnhB,KAAK6iB,qBAAqB7iB,KAAKkN,IAAI8xB,iBAAkB,MACjDh/B,KAAKE,aAAe,IACpBF,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIgyB,WAAY,MAC/Cl/B,KAAK6iB,qBAAqB7iB,KAAKkN,IAAIurB,iBAAkB,SAGtD,EAGX,GAAIlY,EAAQ2kB,MAAO,CACfllC,KAAKwH,eAAiBk9B,EACtB,MAAMS,EAAuB5kB,EAAQ6kB,qBACjCD,IACAA,EAAqBb,mBAAqBI,GAE9CnkB,EAAQ8kB,QACZ,MACK,GAA+B,IAA3B9kB,EAAQ+kB,eAGb,OADA/kB,EAAQglB,aACD,EAEX,IAAI91B,EAEAA,EADAoR,EACkBN,EAAQM,oBAErBN,EAAQrQ,UACKqQ,EAAQ6kB,qBAErB7kB,EAAQG,OACK1gB,KAAKmD,iBAElBod,EAAQ0e,KACKj/B,KAAK6C,eAElB0d,EAAQH,UACKpgB,KAAKgD,oBAGLhD,KAAKyC,cAEtBwiC,GAAwBx1B,IACzBA,EAAgB60B,mBAAqBI,GAEzC,IAAIc,GAAa,EACbxlC,KAAK0H,oBAAoBg9B,KAAaj1B,IACjCw1B,GACDjlC,KAAKwkC,6BAA6B/0B,EAAgB60B,mBAAoBI,GAE1Ec,GAAa,GAEjBxlC,KAAKwH,eAAiBk9B,EACtB,MAAMr4B,EAASrM,KAAK++B,kBAAkBtvB,GAItC,GAHI+1B,GACAxlC,KAAK6iB,qBAAqBxW,EAAQoD,EAAiBw1B,GAEnDx1B,IAAoBA,EAAgB0vB,YAAa,CAEjD,GAAI1vB,EAAgBiR,QAAUjR,EAAgBg2B,yBAA2BllB,EAAQmlB,gBAAiB,CAC9Fj2B,EAAgBg2B,uBAAyBllB,EAAQmlB,gBACjD,MAAMC,EAA8C,IAA5BplB,EAAQmlB,iBAAqD,IAA5BnlB,EAAQmlB,gBAC3D,EACA,EACNnlB,EAAQkf,MAAQkG,EAChBplB,EAAQmf,MAAQiG,CACpB,CACIl2B,EAAgBowB,eAAiBtf,EAAQkf,QACzChwB,EAAgBowB,aAAetf,EAAQkf,MACvCz/B,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAImsB,eAAgBr5B,KAAK4/B,oBAAoBrf,EAAQkf,OAAQhwB,IAE3GA,EAAgBqwB,eAAiBvf,EAAQmf,QACzCjwB,EAAgBqwB,aAAevf,EAAQmf,MACvC1/B,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAIqsB,eAAgBv5B,KAAK4/B,oBAAoBrf,EAAQmf,OAAQjwB,IAE3GA,EAAgBwvB,MAAQxvB,EAAgBuwB,eAAiBzf,EAAQof,QACjElwB,EAAgBuwB,aAAezf,EAAQof,MACvC3/B,KAAKs/B,4BAA4BjzB,EAAQrM,KAAKkN,IAAI6yB,eAAgB//B,KAAK4/B,oBAAoBrf,EAAQof,OAAQlwB,IAE/GzP,KAAK4lC,qBAAqBv5B,EAAQoD,EAAiB8Q,EAAQslB,0BAC/D,CACA,OAAO,CACX,CAQAC,gBAAgBpB,EAAS5R,EAASiT,EAAU9lC,GACxC,QAAgBgL,IAAZy5B,GAA0B5R,EAA9B,CAGK9yB,KAAKgmC,eAAiBhmC,KAAKgmC,cAAc75B,SAAW45B,EAAS55B,SAC9DnM,KAAKgmC,cAAgB,IAAIC,WAAWF,EAAS55B,SAEjD,IAAK,IAAI4B,EAAI,EAAGA,EAAIg4B,EAAS55B,OAAQ4B,IAAK,CACtC,MAAMwS,EAAUwlB,EAASh4B,GAAGq3B,qBACxB7kB,GACAvgB,KAAKgmC,cAAcj4B,GAAK22B,EAAU32B,EAClCwS,EAAQ+jB,mBAAqBI,EAAU32B,GAGvC/N,KAAKgmC,cAAcj4B,IAAM,CAEjC,CACA/N,KAAKkN,IAAIsmB,WAAWV,EAAS9yB,KAAKgmC,eAClC,IAAK,IAAIrqB,EAAQ,EAAGA,EAAQoqB,EAAS55B,OAAQwP,IACzC3b,KAAK4kC,YAAY5kC,KAAKgmC,cAAcrqB,GAAQoqB,EAASpqB,IAAQ,EAhBjE,CAkBJ,CAIAiqB,qBAAqBv5B,EAAQoD,EAAiBo2B,GAC1C,MAAMK,EAA6BlmC,KAAKG,MAAMkS,kCACT,KAAjC5C,EAAgB2nB,cACiB,IAAjC3nB,EAAgB2nB,cACiB,IAAjC3nB,EAAgB2nB,eAChByO,EAA4B,GAE5BK,GAA8Bz2B,EAAgB02B,mCAAqCN,IACnF7lC,KAAKomC,0BAA0B/5B,EAAQ65B,EAA2BG,2BAA4Bx7B,KAAKC,IAAI+6B,EAA2B7lC,KAAKG,MAAM0R,eAAgBpC,GAC7JA,EAAgB02B,iCAAmCN,EAE3D,CACAO,0BAA0B/5B,EAAQi6B,EAAWhmC,EAAOigB,GAChDvgB,KAAK6iB,qBAAqBxW,EAAQkU,GAAS,GAAM,GACjDvgB,KAAKkN,IAAIq5B,cAAcl6B,EAAQi6B,EAAWhmC,EAC9C,CACAg/B,4BAA4BjzB,EAAQi6B,EAAWhmC,EAAOigB,GAC9CA,GACAvgB,KAAK6iB,qBAAqBxW,EAAQkU,GAAS,GAAM,GAErDvgB,KAAKkN,IAAIgsB,cAAc7sB,EAAQi6B,EAAWhmC,EAC9C,CAIAgnB,sBACI,GAAItnB,KAAKqI,0BAAT,CACIrI,KAAKqI,2BAA4B,EACjC,IAAK,IAAI0F,EAAI,EAAGA,EAAI/N,KAAKG,MAAM6N,iBAAkBD,IAC7C/N,KAAKsqB,wBAAwBvc,EAGrC,MACA,IAAK,IAAIA,EAAI,EAAGib,EAAKhpB,KAAK4H,2BAA2BuE,OAAQ4B,EAAIib,EAAIjb,IAC7DA,GAAK/N,KAAKG,MAAM6N,mBAAqBhO,KAAK4H,2BAA2BmG,IAGzE/N,KAAKsqB,wBAAwBvc,EAErC,CAIAy4B,iBACI,IAAK,MAAMvmC,KAAQD,KAAK2H,iBAAkB,CACtC,MAAM4kB,EAAuBvsB,KAAK2H,iBAAiB1H,GAAMosB,qBACzDrsB,KAAKssB,uBAAuBC,EAChC,CACAvsB,KAAK2H,iBAAmB,CAAC,CAC7B,CAIA27B,UACI,IAAIr+B,EACJjF,KAAKU,aAAc,EACnBV,KAAKyb,iBAEDzb,KAAK+I,+BACL/I,KAAK+I,8BAA8BuU,QAGnCtd,KAAK0C,gBACL1C,KAAKq+B,gBAAgBr+B,KAAK0C,eAC1B1C,KAAK0C,cAAgB,MAErB1C,KAAKoD,oBACLpD,KAAKq+B,gBAAgBr+B,KAAKoD,mBAC1BpD,KAAKoD,kBAAoB,MAEzBpD,KAAKgI,mBACLhI,KAAKkN,IAAIu5B,kBAAkBzmC,KAAKgI,mBAGpChI,KAAKwmC,iBACiC,QAArCvhC,EAAKjF,KAAK0mC,6BAA0C,IAAPzhC,GAAyBA,EAAGgK,KAAKjP,MAE/EA,KAAKsnB,sBACLtnB,KAAKuJ,eAAiB,CAAC,GAEnB,WACIvJ,KAAKgL,mBACAhL,KAAKkC,0BACNlC,KAAKgL,iBAAiB27B,oBAAoB,mBAAoB3mC,KAAKsM,gBACnEtM,KAAKgL,iBAAiB27B,oBAAoB,uBAAwB3mC,KAAK2M,qBAE3EjC,OAAOi8B,oBAAoB,SAAU3mC,KAAKqO,kBAGlDrO,KAAKya,eAAiB,KACtBza,KAAK2a,gBAAkB,KACvB3a,KAAKiI,uBAAuBkE,OAAS,EACrCnM,KAAKgL,iBAAmB,KACxBhL,KAAKg3B,gBAAkB,KACvBh3B,KAAKmc,qBAAuB,KAC5B,IAAOnM,aAEP,IAAK,MAAM+sB,KAAW/8B,KAAKyI,gBACvBs0B,EAAQ6J,QAEZ5mC,KAAKmG,oBAAoBuG,gBAAgB1M,MACzCA,KAAKmG,oBAAoBmX,OAC7B,CAKAupB,uBAAuBxK,GACfr8B,KAAKgL,kBACLhL,KAAKgL,iBAAiB+B,iBAAiB,mBAAoBsvB,GAAU,EAE7E,CAKAyK,2BAA2BzK,GACnBr8B,KAAKgL,kBACLhL,KAAKgL,iBAAiB+B,iBAAiB,uBAAwBsvB,GAAU,EAEjF,CAMAzN,WACI,OAAO5uB,KAAKkN,IAAI0hB,UACpB,CACApZ,+BACI,OAAIxV,KAAKQ,cAAgB,EACdR,KAAKG,MAAM0S,iBAEf7S,KAAK+mC,wBAAwB,EACxC,CACA/wB,mCACI,OAAIhW,KAAKQ,cAAgB,EACdR,KAAKG,MAAM0S,iBAEf7S,KAAK+mC,wBAAwB,EACxC,CAEAA,wBAAwB1gB,GACpB,MAAMnG,EAAKlgB,KAAKkN,IAGhB,KAAOgT,EAAG0O,aAAe1O,EAAGwO,WAC5B,IAAIsY,GAAa,EACjB,MAAMzmB,EAAUL,EAAG4X,gBACnB5X,EAAGqkB,YAAYrkB,EAAGiB,WAAYZ,GAC9BL,EAAG+Y,WAAW/Y,EAAGiB,WAAY,EAAGnhB,KAAK24B,kCAAkCtS,GAAO,EAAG,EAAG,EAAGnG,EAAG4d,KAAM99B,KAAK+4B,qBAAqB1S,GAAO,MACjInG,EAAGgZ,cAAchZ,EAAGiB,WAAYjB,EAAGkZ,mBAAoBlZ,EAAGkD,SAC1DlD,EAAGgZ,cAAchZ,EAAGiB,WAAYjB,EAAGiZ,mBAAoBjZ,EAAGkD,SAC1D,MAAM6jB,EAAK/mB,EAAGgnB,oBACdhnB,EAAGX,gBAAgBW,EAAG9J,YAAa6wB,GACnC/mB,EAAGS,qBAAqBT,EAAG9J,YAAa8J,EAAGI,kBAAmBJ,EAAGiB,WAAYZ,EAAS,GACtF,MAAM4mB,EAASjnB,EAAGknB,uBAAuBlnB,EAAG9J,aAS5C,GARA4wB,EAAaA,GAAcG,IAAWjnB,EAAGmnB,qBACzCL,EAAaA,GAAc9mB,EAAG0O,aAAe1O,EAAGwO,SAE5CsY,IACA9mB,EAAG5C,MAAM4C,EAAGhC,kBACZ8oB,EAAaA,GAAc9mB,EAAG0O,aAAe1O,EAAGwO,UAGhDsY,EAAY,CAEZ9mB,EAAGX,gBAAgBW,EAAG9J,YAAa,MACnC,MAAMkxB,EAAapnB,EAAG4d,KAChByJ,EAAWrnB,EAAG+d,cACd5Y,EAAS,IAAIziB,WAAW,GAC9Bsd,EAAGsnB,WAAW,EAAG,EAAG,EAAG,EAAGF,EAAYC,EAAUliB,GAChD2hB,EAAaA,GAAc9mB,EAAG0O,aAAe1O,EAAGwO,QACpD,CAOA,IALAxO,EAAGyjB,cAAcpjB,GACjBL,EAAGumB,kBAAkBQ,GACrB/mB,EAAGX,gBAAgBW,EAAG9J,YAAa,OAG3B4wB,GAAc9mB,EAAG0O,aAAe1O,EAAGwO,WAC3C,OAAOsY,CACX,CAIAjO,qBAAqB1S,GACjB,GAA2B,IAAvBrmB,KAAKQ,cAAqB,CAC1B,OAAQ6lB,GACJ,KAAK,EACD,OAAOrmB,KAAKkN,IAAI0b,MACpB,KAAK,EACD,OAAO5oB,KAAKkN,IAAI6H,eACpB,KAAK,EACD,OAAO/U,KAAKkN,IAAI+wB,cACpB,KAAK,EACD,OAAOj+B,KAAKkN,IAAIu6B,uBACpB,KAAK,EACD,OAAOznC,KAAKkN,IAAIw6B,uBACpB,KAAK,GACD,OAAO1nC,KAAKkN,IAAIy6B,qBAExB,OAAO3nC,KAAKkN,IAAI+wB,aACpB,CACA,OAAQ5X,GACJ,KAAK,EACD,OAAOrmB,KAAKkN,IAAI06B,KACpB,KAAK,EACD,OAAO5nC,KAAKkN,IAAI+wB,cACpB,KAAK,EACD,OAAOj+B,KAAKkN,IAAI26B,MACpB,KAAK,EACD,OAAO7nC,KAAKkN,IAAIse,eACpB,KAAK,EACD,OAAOxrB,KAAKkN,IAAI2Z,IACpB,KAAK,EACD,OAAO7mB,KAAKkN,IAAI0Z,aACpB,KAAK,EACD,OAAO5mB,KAAKkN,IAAI0b,MACpB,KAAK,EACD,OAAO5oB,KAAKkN,IAAI46B,WACpB,KAAK,EACD,OAAO9nC,KAAKkN,IAAIu6B,uBACpB,KAAK,EACD,OAAOznC,KAAKkN,IAAIw6B,uBACpB,KAAK,GACD,OAAO1nC,KAAKkN,IAAIy6B,qBACpB,KAAK,GACD,OAAO3nC,KAAKkN,IAAI66B,4BACpB,KAAK,GACD,OAAO/nC,KAAKkN,IAAImJ,kBACpB,KAAK,GACD,OAAOrW,KAAKkN,IAAI86B,6BACpB,KAAK,GACD,OAAOhoC,KAAKkN,IAAI+6B,yBACpB,KAAK,GACD,OAAOjoC,KAAKkN,IAAIg7B,+BAExB,OAAOloC,KAAKkN,IAAI+wB,aACpB,CAIApF,mBAAmBT,EAAQC,GAAgB,GACvC,IAAIO,EAAiBP,EAAgBr4B,KAAKiY,uBAAuBI,aAAerY,KAAKkN,IAAI4wB,KACzF,OAAQ1F,GACJ,KAAK,EACDQ,EAAiB54B,KAAKkN,IAAIi7B,MAC1B,MACJ,KAAK,EACDvP,EAAiB54B,KAAKkN,IAAIk7B,UAC1B,MACJ,KAAK,EACDxP,EAAiB54B,KAAKkN,IAAIm7B,gBAC1B,MACJ,KAAK,EACDzP,EAAiB54B,KAAKkN,IAAIo7B,IAC1B,MACJ,KAAK,EACD1P,EAAiB54B,KAAKkN,IAAIq7B,GAC1B,MACJ,KAAK,EACD3P,EAAiBP,EAAgBr4B,KAAKiY,uBAAuBC,KAAOlY,KAAKkN,IAAI6wB,IAC7E,MACJ,KAAK,EACDnF,EAAiBP,EAAgBr4B,KAAKiY,uBAAuBI,aAAerY,KAAKkN,IAAI4wB,KAG7F,GAAI99B,KAAKQ,cAAgB,EACrB,OAAQ43B,GACJ,KAAK,EACDQ,EAAiB54B,KAAKkN,IAAIs7B,YAC1B,MACJ,KAAK,EACD5P,EAAiB54B,KAAKkN,IAAIu7B,WAC1B,MACJ,KAAK,GACD7P,EAAiB54B,KAAKkN,IAAIw7B,YAC1B,MACJ,KAAK,GACD9P,EAAiB54B,KAAKkN,IAAIy7B,aAItC,OAAO/P,CACX,CAIAD,kCAAkCtS,EAAM+R,EAAQC,GAAgB,GAC5D,GAA2B,IAAvBr4B,KAAKQ,cAAqB,CAC1B,QAAeyK,IAAXmtB,EACA,OAAQA,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAIi7B,MACpB,KAAK,EACD,OAAOnoC,KAAKkN,IAAIk7B,UACpB,KAAK,EACD,OAAOpoC,KAAKkN,IAAIm7B,gBACpB,KAAK,EACD,OAAOhQ,EAAgBr4B,KAAKiY,uBAAuBC,KAAOlY,KAAKkN,IAAI6wB,IAG/E,OAAO/9B,KAAKkN,IAAI4wB,IACpB,CACA,OAAQzX,GACJ,KAAK,EACD,OAAQ+R,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAI07B,SACpB,KAAK,EACD,OAAO5oC,KAAKkN,IAAI27B,UACpB,KAAK,EACD,OAAO7oC,KAAKkN,IAAI47B,WACpB,KAAK,EACD,OAAO9oC,KAAKkN,IAAI67B,IACpB,KAAK,EACD,OAAO/oC,KAAKkN,IAAI87B,KACpB,KAAK,GACD,OAAOhpC,KAAKkN,IAAI+7B,MACpB,KAAK,GACD,OAAOjpC,KAAKkN,IAAIg8B,OACpB,QACI,OAAOlpC,KAAKkN,IAAIi8B,YAE5B,KAAK,EACD,OAAQ/Q,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAIk8B,GACpB,KAAK,EACD,OAAOppC,KAAKkN,IAAIm8B,IACpB,KAAK,EACD,OAAOhR,EAAgBr4B,KAAKiY,uBAAuBG,MAAQpY,KAAKkN,IAAIo8B,KACxE,KAAK,EACD,OAAOjR,EAAgBr4B,KAAKiY,uBAAuBI,aAAerY,KAAKkN,IAAIq8B,MAC/E,KAAK,EACD,OAAOvpC,KAAKkN,IAAIs8B,KACpB,KAAK,EACD,OAAOxpC,KAAKkN,IAAIu8B,MACpB,KAAK,GACD,OAAOzpC,KAAKkN,IAAIw8B,OACpB,KAAK,GACD,OAAO1pC,KAAKkN,IAAIy8B,QACpB,KAAK,EACD,OAAO3pC,KAAKkN,IAAIi7B,MACpB,KAAK,EACD,OAAOnoC,KAAKkN,IAAIk7B,UACpB,KAAK,EACD,OAAOpoC,KAAKkN,IAAIm7B,gBACpB,QACI,OAAOroC,KAAKkN,IAAIq8B,MAE5B,KAAK,EACD,OAAQnR,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAI08B,KACpB,KAAK,EACD,OAAO5pC,KAAKkN,IAAI28B,MACpB,KAAK,GACD,OAAO7pC,KAAKkN,IAAI48B,OAGpB,QACI,OAAO9pC,KAAKkN,IAAI68B,QAE5B,KAAK,EACD,OAAQ3R,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAI88B,MACpB,KAAK,EACD,OAAOhqC,KAAKkN,IAAI+8B,OACpB,KAAK,GACD,OAAOjqC,KAAKkN,IAAIg9B,QAGpB,QACI,OAAOlqC,KAAKkN,IAAIi9B,SAE5B,KAAK,EACD,OAAQ/R,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAIk9B,KACpB,KAAK,EACD,OAAOpqC,KAAKkN,IAAIm9B,MACpB,KAAK,GACD,OAAOrqC,KAAKkN,IAAIo9B,OAGpB,QACI,OAAOtqC,KAAKkN,IAAIq9B,QAE5B,KAAK,EACD,OAAQnS,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAIs9B,MACpB,KAAK,EACD,OAAOxqC,KAAKkN,IAAIu9B,OACpB,KAAK,GACD,OAAOzqC,KAAKkN,IAAIw9B,QAGpB,QACI,OAAO1qC,KAAKkN,IAAIy9B,SAE5B,KAAK,EACD,OAAQvS,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAI09B,KACpB,KAAK,EACD,OAAO5qC,KAAKkN,IAAI29B,MACpB,KAAK,EACD,OAAO7qC,KAAKkN,IAAI49B,OAGpB,QACI,OAAO9qC,KAAKkN,IAAI+H,QAE5B,KAAK,EACD,OAAQmjB,GACJ,KAAK,EACD,OAAOp4B,KAAKkN,IAAI69B,KACpB,KAAK,EACD,OAAO/qC,KAAKkN,IAAI89B,MACpB,KAAK,EACD,OAAOhrC,KAAKkN,IAAI+9B,OAGpB,QACI,OAAOjrC,KAAKkN,IAAI8H,QAE5B,KAAK,GACD,OAAOhV,KAAKkN,IAAIg+B,OACpB,KAAK,GACD,OAAOlrC,KAAKkN,IAAIi+B,eACpB,KAAK,GACD,OAAOnrC,KAAKkN,IAAIk+B,QACpB,KAAK,EACD,OAAOprC,KAAKkN,IAAIm+B,MACpB,KAAK,EACD,OAAOrrC,KAAKkN,IAAIo+B,QACpB,KAAK,GACD,OAAQlT,GACJ,KAAK,EAIL,QACI,OAAOp4B,KAAKkN,IAAIq+B,SAHpB,KAAK,GACD,OAAOvrC,KAAKkN,IAAIs+B,YAKhC,OAAOnT,EAAgBr4B,KAAKiY,uBAAuBI,aAAerY,KAAKkN,IAAIq8B,KAC/E,CAIAkC,gCAAgCplB,EAAM+R,EAAS,GAC3C,OAAQ/R,GACJ,KAAK,EACD,OACS,IADD+R,EAEOp4B,KAAKkN,IAAI09B,KAET5qC,KAAKkN,IAAI+H,QAE5B,KAAK,EACD,OACS,IADDmjB,EAEOp4B,KAAKkN,IAAI69B,KAET/qC,KAAKkN,IAAI8H,QAGhC,OAAOhV,KAAKkN,IAAIq8B,KACpB,CAIA1M,UAAU/C,EAAK4R,EAAWC,EAAY7O,EAAiB8O,EAAgBxe,GACnE,MAAM2P,EAAUn9B,EAAWisC,mBAAmB/R,EAAK4R,EAAWC,EAAY7O,EAAiB8O,EAAgBxe,GAK3G,OAJAptB,KAAKyI,gBAAgBmQ,KAAKmkB,GAC1BA,EAAQ+O,qBAAqBjQ,KAAKkB,IAC9B/8B,KAAKyI,gBAAgBmT,OAAO5b,KAAKyI,gBAAgB8F,QAAQwuB,GAAU,EAAE,IAElEA,CACX,CAYA74B,0BAA0B41B,EAAK4R,EAAWC,EAAY7O,EAAiB8O,EAAgBxe,GACnF,MAAM,OAAY,YACtB,CAWAoa,WAAWv+B,EAAGC,EAAG/E,EAAOC,EAAQ2nC,GAAW,EAAMC,GAAgB,GAC7D,MAAMC,EAAcF,EAAW,EAAI,EAC7B3T,EAAS2T,EAAW/rC,KAAKkN,IAAI4wB,KAAO99B,KAAKkN,IAAI6wB,IAC7Cna,EAAO,IAAIhhB,WAAWwB,EAASD,EAAQ8nC,GAK7C,OAJID,GACAhsC,KAAK6e,mBAET7e,KAAKkN,IAAIs6B,WAAWv+B,EAAGC,EAAG/E,EAAOC,EAAQg0B,EAAQp4B,KAAKkN,IAAI+wB,cAAera,GAClEsoB,QAAQC,QAAQvoB,EAC3B,CAIWwoB,8BACP,OAAOF,QAAQC,QAAQnsC,KAAKqsC,cAChC,CAIWC,yBACP,OAAOtsC,KAAKqsC,aAChB,CAOAnoC,qBACI,GAAwC,OAApClE,KAAKusC,2BACL,OAAQvsC,KAAKusC,2BAEjB,GAA0B,OAAtBvsC,KAAKwsC,aACL,IACI,MAAMC,EAAazsC,KAAK0E,cAAc,EAAG,GACnCwb,EAAKusB,EAAW1hC,WAAW,UAAY0hC,EAAW1hC,WAAW,sBACnE/K,KAAKwsC,aAAqB,MAANtsB,KAAgBxV,OAAOgiC,qBAC/C,CACA,MAAOt/B,GACHpN,KAAKwsC,cAAe,CACxB,CAEJ,OAAOxsC,KAAKwsC,YAChB,CAIWG,uCACP,GAAwC,OAApC3sC,KAAKusC,2BACL,IACI,MAAME,EAAazsC,KAAK0E,cAAc,EAAG,GACnCwb,EAAKusB,EAAW1hC,WAAW,QAAS,CAAE6hC,8BAA8B,KACtEH,EAAW1hC,WAAW,qBAAsB,CAAE6hC,8BAA8B,IAChF5sC,KAAKusC,4BAA8BrsB,CACvC,CACA,MAAO9S,GACHpN,KAAKusC,4BAA6B,CACtC,CAEJ,OAAOvsC,KAAKusC,0BAChB,CAMAroC,kBAAkB+E,GAQd,OAPAA,IACAA,GAAKA,GAAK,EACVA,GAAKA,GAAK,EACVA,GAAKA,GAAK,EACVA,GAAKA,GAAK,EACVA,GAAKA,GAAK,KACVA,CAEJ,CAMA/E,gBAAgB+E,GAMZ,OALAA,GAASA,GAAK,EACdA,GAASA,GAAK,EACdA,GAASA,GAAK,EACdA,GAASA,GAAK,GACdA,GAASA,GAAK,KACFA,GAAK,EACrB,CAMA/E,kBAAkB+E,GACd,MAAM4jC,EAAIjtC,EAAWktC,WAAW7jC,GAC1B8jC,EAAIntC,EAAWotC,SAAS/jC,GAC9B,OAAO4jC,EAAI5jC,EAAIA,EAAI8jC,EAAIA,EAAIF,CAC/B,CAQA3oC,wBAAwB5D,EAAO+gC,EAAKr9B,EAAO,GACvC,IAAIipC,EACJ,OAAQjpC,GACJ,KAAK,EACDipC,EAAMrtC,EAAWotC,SAAS1sC,GAC1B,MACJ,KAAK,EACD2sC,EAAMrtC,EAAWstC,WAAW5sC,GAC5B,MAEJ,QACI2sC,EAAMrtC,EAAWktC,WAAWxsC,GAGpC,OAAOuK,KAAKC,IAAImiC,EAAK5L,EACzB,CAOAn9B,qBAAqBipC,EAAMhwB,GAIvB,IAAK,UAKA,CACD,MAAM,0BAAEiwB,EAAyB,sBAAEC,GAA0BlwB,GAAazS,OAC1E,GAAyC,mBAA9B0iC,EACP,OAAOA,EAA0BD,GAErC,GAAqC,mBAA1BE,EACP,OAAOA,EAAsBF,EAErC,MAZI,GAAqC,mBAA1BE,sBACP,OAAOA,sBAAsBF,GAcrC,OAAO1+B,WAAW0+B,EAAM,GAC5B,CAKAG,kBACI,OAAIttC,KAAKgL,kBAAoBhL,KAAKgL,iBAAiBwR,cACxCxc,KAAKgL,iBAAiBwR,eAE1B,UAAwBnY,SAAW,IAC9C,EAGJzE,EAAW6L,cAAgB,CACvB,CAAEC,IAAK,cAAeI,QAAS,yBAA0BC,kBAAmB,IAAKJ,QAAS,CAAC,kBAC3F,CAAED,IAAK,aAAcI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,kBACvE,CAAED,IAAK,aAAcI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,kBACvE,CAAED,IAAK,qBAAsBI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,QAC/E,CAAED,IAAK,qBAAsBI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,QAC/E,CAAED,IAAK,qBAAsBI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,QAC/E,CAAED,IAAK,oBAAqBI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,QAC9E,CAAED,IAAK,oBAAqBI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,QAC9E,CAAED,IAAK,iBAAkBI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,kBAE3E,CAAED,IAAK,gCAAiCI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,YAAa,mBAEvG,CAAED,IAAK,gCAAiCI,QAAS,KAAMC,kBAAmB,KAAMJ,QAAS,CAAC,YAAa,oBAG3G/L,EAAW27B,gBAAkB,GAK7B37B,EAAW2tC,kBAAoB,KAE/B3tC,EAAW4sC,aAAe,KAC1B5sC,EAAW2sC,2BAA6B,I","sources":["webpack://code-cave/./node_modules/@babylonjs/core/Engines/thinEngine.js"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\nimport { EngineStore } from \"./engineStore.js\";\nimport { Effect } from \"../Materials/effect.js\";\nimport { _WarnImport } from \"../Misc/devTools.js\";\nimport { Observable } from \"../Misc/observable.js\";\nimport { DepthCullingState } from \"../States/depthCullingState.js\";\nimport { StencilState } from \"../States/stencilState.js\";\nimport { AlphaState } from \"../States/alphaCullingState.js\";\n\nimport { InternalTexture, InternalTextureSource } from \"../Materials/Textures/internalTexture.js\";\nimport { Logger } from \"../Misc/logger.js\";\nimport { IsDocumentAvailable, IsWindowObjectExist } from \"../Misc/domManagement.js\";\nimport { WebGLShaderProcessor } from \"./WebGL/webGLShaderProcessors.js\";\nimport { WebGL2ShaderProcessor } from \"./WebGL/webGL2ShaderProcessors.js\";\nimport { WebGLDataBuffer } from \"../Meshes/WebGL/webGLDataBuffer.js\";\nimport { WebGLPipelineContext } from \"./WebGL/webGLPipelineContext.js\";\nimport { PerformanceConfigurator } from \"./performanceConfigurator.js\";\nimport { WebGLHardwareTexture } from \"./WebGL/webGLHardwareTexture.js\";\nimport { DrawWrapper } from \"../Materials/drawWrapper.js\";\nimport { StencilStateComposer } from \"../States/stencilStateComposer.js\";\nimport { ShaderLanguage } from \"../Materials/shaderLanguage.js\";\nimport { PrecisionDate } from \"../Misc/precisionDate.js\";\n/**\n * Keeps track of all the buffer info used in engine.\n */\nclass BufferPointer {\n}\n/**\n * The base engine class (root of all engines)\n */\nexport class ThinEngine {\n    /**\n     * Returns the current npm package of the sdk\n     */\n    // Not mixed with Version for tooling purpose.\n    static get NpmPackage() {\n        return \"babylonjs@6.10.0\";\n    }\n    /**\n     * Returns the current version of the framework\n     */\n    static get Version() {\n        return \"6.10.0\";\n    }\n    /**\n     * Returns a string describing the current engine\n     */\n    get description() {\n        let description = this.name + this.webGLVersion;\n        if (this._caps.parallelShaderCompile) {\n            description += \" - Parallel shader compilation\";\n        }\n        return description;\n    }\n    /**\n     * Gets or sets the name of the engine\n     */\n    get name() {\n        return this._name;\n    }\n    set name(value) {\n        this._name = value;\n    }\n    /**\n     * Returns the version of the engine\n     */\n    get version() {\n        return this._webGLVersion;\n    }\n    get isDisposed() {\n        return this._isDisposed;\n    }\n    /**\n     * Gets or sets the relative url used to load shaders if using the engine in non-minified mode\n     */\n    static get ShadersRepository() {\n        return Effect.ShadersRepository;\n    }\n    static set ShadersRepository(value) {\n        Effect.ShadersRepository = value;\n    }\n    /**\n     * @internal\n     */\n    _getShaderProcessor(shaderLanguage) {\n        return this._shaderProcessor;\n    }\n    /**\n     * Gets or sets a boolean indicating if depth buffer should be reverse, going from far to near.\n     * This can provide greater z depth for distant objects.\n     */\n    get useReverseDepthBuffer() {\n        return this._useReverseDepthBuffer;\n    }\n    set useReverseDepthBuffer(useReverse) {\n        if (useReverse === this._useReverseDepthBuffer) {\n            return;\n        }\n        this._useReverseDepthBuffer = useReverse;\n        if (useReverse) {\n            this._depthCullingState.depthFunc = 518;\n        }\n        else {\n            this._depthCullingState.depthFunc = 515;\n        }\n    }\n    /**\n     * Gets the current frame id\n     */\n    get frameId() {\n        return this._frameId;\n    }\n    /**\n     * Gets a boolean indicating that the engine supports uniform buffers\n     * @see https://doc.babylonjs.com/setup/support/webGL2#uniform-buffer-objets\n     */\n    get supportsUniformBuffers() {\n        return this.webGLVersion > 1 && !this.disableUniformBuffers;\n    }\n    /**\n     * Gets the options used for engine creation\n     * @returns EngineOptions object\n     */\n    getCreationOptions() {\n        return this._creationOptions;\n    }\n    /** @internal */\n    get _shouldUseHighPrecisionShader() {\n        return !!(this._caps.highPrecisionShaderSupported && this._highPrecisionShadersAllowed);\n    }\n    /**\n     * Gets a boolean indicating that only power of 2 textures are supported\n     * Please note that you can still use non power of 2 textures but in this case the engine will forcefully convert them\n     */\n    get needPOTTextures() {\n        return this._webGLVersion < 2 || this.forcePOTTextures;\n    }\n    /**\n     * Gets the list of current active render loop functions\n     * @returns an array with the current render loop functions\n     */\n    get activeRenderLoops() {\n        return this._activeRenderLoops;\n    }\n    /**\n     * Gets or sets a boolean indicating if resources should be retained to be able to handle context lost events\n     * @see https://doc.babylonjs.com/features/featuresDeepDive/scene/optimize_your_scene#handling-webgl-context-lost\n     */\n    get doNotHandleContextLost() {\n        return this._doNotHandleContextLost;\n    }\n    set doNotHandleContextLost(value) {\n        this._doNotHandleContextLost = value;\n    }\n    get _supportsHardwareTextureRescaling() {\n        return false;\n    }\n    /**\n     * sets the object from which width and height will be taken from when getting render width and height\n     * Will fallback to the gl object\n     * @param dimensions the framebuffer width and height that will be used.\n     */\n    set framebufferDimensionsObject(dimensions) {\n        this._framebufferDimensionsObject = dimensions;\n    }\n    /**\n     * Gets the current viewport\n     */\n    get currentViewport() {\n        return this._cachedViewport;\n    }\n    /**\n     * Gets the default empty texture\n     */\n    get emptyTexture() {\n        if (!this._emptyTexture) {\n            this._emptyTexture = this.createRawTexture(new Uint8Array(4), 1, 1, 5, false, false, 1);\n        }\n        return this._emptyTexture;\n    }\n    /**\n     * Gets the default empty 3D texture\n     */\n    get emptyTexture3D() {\n        if (!this._emptyTexture3D) {\n            this._emptyTexture3D = this.createRawTexture3D(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);\n        }\n        return this._emptyTexture3D;\n    }\n    /**\n     * Gets the default empty 2D array texture\n     */\n    get emptyTexture2DArray() {\n        if (!this._emptyTexture2DArray) {\n            this._emptyTexture2DArray = this.createRawTexture2DArray(new Uint8Array(4), 1, 1, 1, 5, false, false, 1);\n        }\n        return this._emptyTexture2DArray;\n    }\n    /**\n     * Gets the default empty cube texture\n     */\n    get emptyCubeTexture() {\n        if (!this._emptyCubeTexture) {\n            const faceData = new Uint8Array(4);\n            const cubeData = [faceData, faceData, faceData, faceData, faceData, faceData];\n            this._emptyCubeTexture = this.createRawCubeTexture(cubeData, 1, 5, 0, false, false, 1);\n        }\n        return this._emptyCubeTexture;\n    }\n    /**\n     * Gets a boolean indicating if the engine runs in WebGPU or not.\n     */\n    get isWebGPU() {\n        return this._isWebGPU;\n    }\n    /**\n     * Gets the shader platform name used by the effects.\n     */\n    get shaderPlatformName() {\n        return this._shaderPlatformName;\n    }\n    /**\n     * Enables or disables the snapshot rendering mode\n     * Note that the WebGL engine does not support snapshot rendering so setting the value won't have any effect for this engine\n     */\n    get snapshotRendering() {\n        return false;\n    }\n    set snapshotRendering(activate) {\n        // WebGL engine does not support snapshot rendering\n    }\n    /**\n     * Gets or sets the snapshot rendering mode\n     */\n    get snapshotRenderingMode() {\n        return this._snapshotRenderingMode;\n    }\n    set snapshotRenderingMode(mode) {\n        this._snapshotRenderingMode = mode;\n    }\n    /**\n     * Creates a new snapshot at the next frame using the current snapshotRenderingMode\n     */\n    snapshotRenderingReset() {\n        this.snapshotRendering = false;\n    }\n    static _CreateCanvas(width, height) {\n        if (typeof document === \"undefined\") {\n            return new OffscreenCanvas(width, height);\n        }\n        const canvas = document.createElement(\"canvas\");\n        canvas.width = width;\n        canvas.height = height;\n        return canvas;\n    }\n    /**\n     * Create a canvas. This method is overridden by other engines\n     * @param width width\n     * @param height height\n     * @returns ICanvas interface\n     */\n    createCanvas(width, height) {\n        return ThinEngine._CreateCanvas(width, height);\n    }\n    /**\n     * Create an image to use with canvas\n     * @returns IImage interface\n     */\n    createCanvasImage() {\n        return document.createElement(\"img\");\n    }\n    /**\n     * Creates a new engine\n     * @param canvasOrContext defines the canvas or WebGL context to use for rendering. If you provide a WebGL context, Babylon.js will not hook events on the canvas (like pointers, keyboards, etc...) so no event observables will be available. This is mostly used when Babylon.js is used as a plugin on a system which already used the WebGL context\n     * @param antialias defines enable antialiasing (default: false)\n     * @param options defines further options to be sent to the getContext() function\n     * @param adaptToDeviceRatio defines whether to adapt to the device's viewport characteristics (default: false)\n     */\n    constructor(canvasOrContext, antialias, options, adaptToDeviceRatio) {\n        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;\n        /** @internal */\n        this._name = \"WebGL\";\n        this._isDisposed = false;\n        /**\n         * Gets or sets a boolean that indicates if textures must be forced to power of 2 size even if not required\n         */\n        this.forcePOTTextures = false;\n        /**\n         * Gets a boolean indicating if the engine is currently rendering in fullscreen mode\n         */\n        this.isFullscreen = false;\n        /**\n         * Gets or sets a boolean indicating if back faces must be culled. If false, front faces are culled instead (true by default)\n         * If non null, this takes precedence over the value from the material\n         */\n        this.cullBackFaces = null;\n        /**\n         * Gets or sets a boolean indicating if the engine must keep rendering even if the window is not in foreground\n         */\n        this.renderEvenInBackground = true;\n        /**\n         * Gets or sets a boolean indicating that cache can be kept between frames\n         */\n        this.preventCacheWipeBetweenFrames = false;\n        /** Gets or sets a boolean indicating if the engine should validate programs after compilation */\n        this.validateShaderPrograms = false;\n        this._useReverseDepthBuffer = false;\n        /**\n         * Indicates if the z range in NDC space is 0..1 (value: true) or -1..1 (value: false)\n         */\n        this.isNDCHalfZRange = false;\n        /**\n         * Indicates that the origin of the texture/framebuffer space is the bottom left corner. If false, the origin is top left\n         */\n        this.hasOriginBottomLeft = true;\n        /**\n         * Gets or sets a boolean indicating that uniform buffers must be disabled even if they are supported\n         */\n        this.disableUniformBuffers = false;\n        /**\n         * An event triggered when the engine is disposed.\n         */\n        this.onDisposeObservable = new Observable();\n        this._frameId = 0;\n        /** @internal */\n        this._uniformBuffers = new Array();\n        /** @internal */\n        this._storageBuffers = new Array();\n        /** @internal */\n        this._webGLVersion = 1.0;\n        this._windowIsBackground = false;\n        this._highPrecisionShadersAllowed = true;\n        /** @internal */\n        this._badOS = false;\n        /** @internal */\n        this._badDesktopOS = false;\n        this._renderingQueueLaunched = false;\n        this._activeRenderLoops = new Array();\n        // Lost context\n        /**\n         * Observable signaled when a context lost event is raised\n         */\n        this.onContextLostObservable = new Observable();\n        /**\n         * Observable signaled when a context restored event is raised\n         */\n        this.onContextRestoredObservable = new Observable();\n        this._contextWasLost = false;\n        /** @internal */\n        this._doNotHandleContextLost = false;\n        /**\n         * Gets or sets a boolean indicating that vertex array object must be disabled even if they are supported\n         */\n        this.disableVertexArrayObjects = false;\n        // States\n        /** @internal */\n        this._colorWrite = true;\n        /** @internal */\n        this._colorWriteChanged = true;\n        /** @internal */\n        this._depthCullingState = new DepthCullingState();\n        /** @internal */\n        this._stencilStateComposer = new StencilStateComposer();\n        /** @internal */\n        this._stencilState = new StencilState();\n        /** @internal */\n        this._alphaState = new AlphaState();\n        /** @internal */\n        this._alphaMode = 1;\n        /** @internal */\n        this._alphaEquation = 0;\n        // Cache\n        /** @internal */\n        this._internalTexturesCache = new Array();\n        /** @internal */\n        this._renderTargetWrapperCache = new Array();\n        /** @internal */\n        this._activeChannel = 0;\n        this._currentTextureChannel = -1;\n        /** @internal */\n        this._boundTexturesCache = {};\n        this._compiledEffects = {};\n        this._vertexAttribArraysEnabled = [];\n        this._uintIndicesCurrentlySet = false;\n        this._currentBoundBuffer = new Array();\n        /** @internal */\n        this._currentFramebuffer = null;\n        /** @internal */\n        this._dummyFramebuffer = null;\n        this._currentBufferPointers = new Array();\n        this._currentInstanceLocations = new Array();\n        this._currentInstanceBuffers = new Array();\n        this._vaoRecordInProgress = false;\n        this._mustWipeVertexAttributes = false;\n        this._nextFreeTextureSlots = new Array();\n        this._maxSimultaneousTextures = 0;\n        this._maxMSAASamplesOverride = null;\n        this._activeRequests = new Array();\n        /**\n         * If set to true zooming in and out in the browser will rescale the hardware-scaling correctly.\n         */\n        this.adaptToDeviceRatio = false;\n        /** @internal */\n        this._lastDevicePixelRatio = 1.0;\n        /** @internal */\n        this._transformTextureUrl = null;\n        /**\n         * Gets information about the current host\n         */\n        this.hostInformation = {\n            isMobile: false,\n        };\n        /**\n         * Defines whether the engine has been created with the premultipliedAlpha option on or not.\n         */\n        this.premultipliedAlpha = true;\n        /**\n         * Observable event triggered before each texture is initialized\n         */\n        this.onBeforeTextureInitObservable = new Observable();\n        /** @internal */\n        this._isWebGPU = false;\n        this._snapshotRenderingMode = 0;\n        this._viewportCached = { x: 0, y: 0, z: 0, w: 0 };\n        this._unpackFlipYCached = null;\n        /**\n         * In case you are sharing the context with other applications, it might\n         * be interested to not cache the unpack flip y state to ensure a consistent\n         * value would be set.\n         */\n        this.enableUnpackFlipYCached = true;\n        this._boundUniforms = {};\n        this.startTime = PrecisionDate.Now;\n        let canvas = null;\n        options = options || {};\n        this._creationOptions = options;\n        // Save this off for use in resize().\n        this.adaptToDeviceRatio = adaptToDeviceRatio !== null && adaptToDeviceRatio !== void 0 ? adaptToDeviceRatio : false;\n        this._stencilStateComposer.stencilGlobal = this._stencilState;\n        PerformanceConfigurator.SetMatrixPrecision(!!options.useHighPrecisionMatrix);\n        options.antialias = antialias !== null && antialias !== void 0 ? antialias : options.antialias;\n        options.deterministicLockstep = (_a = options.deterministicLockstep) !== null && _a !== void 0 ? _a : false;\n        options.lockstepMaxSteps = (_b = options.lockstepMaxSteps) !== null && _b !== void 0 ? _b : 4;\n        options.timeStep = (_c = options.timeStep) !== null && _c !== void 0 ? _c : 1 / 60;\n        options.audioEngine = (_d = options.audioEngine) !== null && _d !== void 0 ? _d : true;\n        options.stencil = (_e = options.stencil) !== null && _e !== void 0 ? _e : true;\n        this._audioContext = (_g = (_f = options.audioEngineOptions) === null || _f === void 0 ? void 0 : _f.audioContext) !== null && _g !== void 0 ? _g : null;\n        this._audioDestination = (_j = (_h = options.audioEngineOptions) === null || _h === void 0 ? void 0 : _h.audioDestination) !== null && _j !== void 0 ? _j : null;\n        this.premultipliedAlpha = (_k = options.premultipliedAlpha) !== null && _k !== void 0 ? _k : true;\n        this.useExactSrgbConversions = (_l = options.useExactSrgbConversions) !== null && _l !== void 0 ? _l : false;\n        this._doNotHandleContextLost = !!options.doNotHandleContextLost;\n        this._isStencilEnable = options.stencil ? true : false;\n        // Viewport\n        adaptToDeviceRatio = adaptToDeviceRatio || options.adaptToDeviceRatio || false;\n        const devicePixelRatio = IsWindowObjectExist() ? window.devicePixelRatio || 1.0 : 1.0;\n        const limitDeviceRatio = options.limitDeviceRatio || devicePixelRatio;\n        this._hardwareScalingLevel = adaptToDeviceRatio ? 1.0 / Math.min(limitDeviceRatio, devicePixelRatio) : 1.0;\n        this._lastDevicePixelRatio = devicePixelRatio;\n        if (!canvasOrContext) {\n            return;\n        }\n        if (canvasOrContext.getContext) {\n            canvas = canvasOrContext;\n            this._renderingCanvas = canvas;\n            if (options.preserveDrawingBuffer === undefined) {\n                options.preserveDrawingBuffer = false;\n            }\n            if (options.xrCompatible === undefined) {\n                options.xrCompatible = true;\n            }\n            // Exceptions\n            if (navigator && navigator.userAgent) {\n                this._setupMobileChecks();\n                const ua = navigator.userAgent;\n                for (const exception of ThinEngine.ExceptionList) {\n                    const key = exception.key;\n                    const targets = exception.targets;\n                    const check = new RegExp(key);\n                    if (check.test(ua)) {\n                        if (exception.capture && exception.captureConstraint) {\n                            const capture = exception.capture;\n                            const constraint = exception.captureConstraint;\n                            const regex = new RegExp(capture);\n                            const matches = regex.exec(ua);\n                            if (matches && matches.length > 0) {\n                                const capturedValue = parseInt(matches[matches.length - 1]);\n                                if (capturedValue >= constraint) {\n                                    continue;\n                                }\n                            }\n                        }\n                        for (const target of targets) {\n                            switch (target) {\n                                case \"uniformBuffer\":\n                                    this.disableUniformBuffers = true;\n                                    break;\n                                case \"vao\":\n                                    this.disableVertexArrayObjects = true;\n                                    break;\n                                case \"antialias\":\n                                    options.antialias = false;\n                                    break;\n                                case \"maxMSAASamples\":\n                                    this._maxMSAASamplesOverride = 1;\n                                    break;\n                            }\n                        }\n                    }\n                }\n            }\n            // Context lost\n            if (!this._doNotHandleContextLost) {\n                this._onContextLost = (evt) => {\n                    evt.preventDefault();\n                    this._contextWasLost = true;\n                    Logger.Warn(\"WebGL context lost.\");\n                    this.onContextLostObservable.notifyObservers(this);\n                };\n                this._onContextRestored = () => {\n                    this._restoreEngineAfterContextLost(this._initGLContext.bind(this));\n                };\n                canvas.addEventListener(\"webglcontextlost\", this._onContextLost, false);\n                canvas.addEventListener(\"webglcontextrestored\", this._onContextRestored, false);\n                options.powerPreference = options.powerPreference || \"high-performance\";\n            }\n            // Detect if we are running on a faulty buggy desktop OS.\n            this._badDesktopOS = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);\n            if (this._badDesktopOS) {\n                options.xrCompatible = false;\n            }\n            // GL\n            if (!options.disableWebGL2Support) {\n                try {\n                    this._gl = (canvas.getContext(\"webgl2\", options) || canvas.getContext(\"experimental-webgl2\", options));\n                    if (this._gl) {\n                        this._webGLVersion = 2.0;\n                        this._shaderPlatformName = \"WEBGL2\";\n                        // Prevent weird browsers to lie (yeah that happens!)\n                        if (!this._gl.deleteQuery) {\n                            this._webGLVersion = 1.0;\n                            this._shaderPlatformName = \"WEBGL1\";\n                        }\n                    }\n                }\n                catch (e) {\n                    // Do nothing\n                }\n            }\n            if (!this._gl) {\n                if (!canvas) {\n                    throw new Error(\"The provided canvas is null or undefined.\");\n                }\n                try {\n                    this._gl = (canvas.getContext(\"webgl\", options) || canvas.getContext(\"experimental-webgl\", options));\n                }\n                catch (e) {\n                    throw new Error(\"WebGL not supported\");\n                }\n            }\n            if (!this._gl) {\n                throw new Error(\"WebGL not supported\");\n            }\n        }\n        else {\n            this._gl = canvasOrContext;\n            this._renderingCanvas = this._gl.canvas;\n            if (this._gl.renderbufferStorageMultisample) {\n                this._webGLVersion = 2.0;\n                this._shaderPlatformName = \"WEBGL2\";\n            }\n            else {\n                this._shaderPlatformName = \"WEBGL1\";\n            }\n            const attributes = this._gl.getContextAttributes();\n            if (attributes) {\n                options.stencil = attributes.stencil;\n            }\n        }\n        // Ensures a consistent color space unpacking of textures cross browser.\n        this._gl.pixelStorei(this._gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, this._gl.NONE);\n        if (options.useHighPrecisionFloats !== undefined) {\n            this._highPrecisionShadersAllowed = options.useHighPrecisionFloats;\n        }\n        this.resize();\n        this._initGLContext();\n        this._initFeatures();\n        // Prepare buffer pointers\n        for (let i = 0; i < this._caps.maxVertexAttribs; i++) {\n            this._currentBufferPointers[i] = new BufferPointer();\n        }\n        // Shader processor\n        this._shaderProcessor = this.webGLVersion > 1 ? new WebGL2ShaderProcessor() : new WebGLShaderProcessor();\n        // Detect if we are running on a faulty buggy OS.\n        this._badOS = /iPad/i.test(navigator.userAgent) || /iPhone/i.test(navigator.userAgent);\n        // Starting with iOS 14, we can trust the browser\n        // let matches = navigator.userAgent.match(/Version\\/(\\d+)/);\n        // if (matches && matches.length === 2) {\n        //     if (parseInt(matches[1]) >= 14) {\n        //         this._badOS = false;\n        //     }\n        // }\n        const versionToLog = `Babylon.js v${ThinEngine.Version}`;\n        console.log(versionToLog + ` - ${this.description}`);\n        // Check setAttribute in case of workers\n        if (this._renderingCanvas && this._renderingCanvas.setAttribute) {\n            this._renderingCanvas.setAttribute(\"data-engine\", versionToLog);\n        }\n    }\n    _setupMobileChecks() {\n        if (!(navigator && navigator.userAgent)) {\n            return;\n        }\n        // Function to check if running on mobile device\n        this._checkForMobile = () => {\n            const currentUA = navigator.userAgent;\n            this.hostInformation.isMobile =\n                currentUA.indexOf(\"Mobile\") !== -1 ||\n                    // Needed for iOS 13+ detection on iPad (inspired by solution from https://stackoverflow.com/questions/9038625/detect-if-device-is-ios)\n                    (currentUA.indexOf(\"Mac\") !== -1 && IsDocumentAvailable() && \"ontouchend\" in document);\n        };\n        // Set initial isMobile value\n        this._checkForMobile();\n        // Set up event listener to check when window is resized (used to get emulator activation to work properly)\n        if (IsWindowObjectExist()) {\n            window.addEventListener(\"resize\", this._checkForMobile);\n        }\n    }\n    _restoreEngineAfterContextLost(initEngine) {\n        // Adding a timeout to avoid race condition at browser level\n        setTimeout(async () => {\n            var _a;\n            this._dummyFramebuffer = null;\n            const depthTest = this._depthCullingState.depthTest; // backup those values because the call to initEngine / wipeCaches will reset them\n            const depthFunc = this._depthCullingState.depthFunc;\n            const depthMask = this._depthCullingState.depthMask;\n            const stencilTest = this._stencilState.stencilTest;\n            // Rebuild context\n            await initEngine();\n            // Ensure webgl and engine states are matching\n            this.wipeCaches(true);\n            // Rebuild effects\n            this._rebuildEffects();\n            (_a = this._rebuildComputeEffects) === null || _a === void 0 ? void 0 : _a.call(this);\n            // Note:\n            //  The call to _rebuildBuffers must be made before the call to _rebuildInternalTextures because in the process of _rebuildBuffers the buffers used by the post process managers will be rebuilt\n            //  and we may need to use the post process manager of the scene during _rebuildInternalTextures (in WebGL1, non-POT textures are rescaled using a post process + post process manager of the scene)\n            // Rebuild buffers\n            this._rebuildBuffers();\n            // Rebuild textures\n            this._rebuildInternalTextures();\n            // Rebuild textures\n            this._rebuildRenderTargetWrappers();\n            // Reset engine states after all the buffer/textures/... have been rebuilt\n            this.wipeCaches(true);\n            this._depthCullingState.depthTest = depthTest;\n            this._depthCullingState.depthFunc = depthFunc;\n            this._depthCullingState.depthMask = depthMask;\n            this._stencilState.stencilTest = stencilTest;\n            Logger.Warn(this.name + \" context successfully restored.\");\n            this.onContextRestoredObservable.notifyObservers(this);\n            this._contextWasLost = false;\n        }, 0);\n    }\n    /**\n     * Shared initialization across engines types.\n     * @param canvas The canvas associated with this instance of the engine.\n     */\n    _sharedInit(canvas) {\n        this._renderingCanvas = canvas;\n    }\n    /**\n     * @internal\n     */\n    _getShaderProcessingContext(shaderLanguage) {\n        return null;\n    }\n    _rebuildInternalTextures() {\n        const currentState = this._internalTexturesCache.slice(); // Do a copy because the rebuild will add proxies\n        for (const internalTexture of currentState) {\n            internalTexture._rebuild();\n        }\n    }\n    _rebuildRenderTargetWrappers() {\n        const currentState = this._renderTargetWrapperCache.slice(); // Do a copy because the rebuild will add proxies\n        for (const renderTargetWrapper of currentState) {\n            renderTargetWrapper._rebuild();\n        }\n    }\n    _rebuildEffects() {\n        for (const key in this._compiledEffects) {\n            const effect = this._compiledEffects[key];\n            effect._pipelineContext = null; // because _prepareEffect will try to dispose this pipeline before recreating it and that would lead to webgl errors\n            effect._wasPreviouslyReady = false;\n            effect._prepareEffect();\n        }\n        Effect.ResetCache();\n    }\n    /**\n     * Gets a boolean indicating if all created effects are ready\n     * @returns true if all effects are ready\n     */\n    areAllEffectsReady() {\n        for (const key in this._compiledEffects) {\n            const effect = this._compiledEffects[key];\n            if (!effect.isReady()) {\n                return false;\n            }\n        }\n        return true;\n    }\n    _rebuildBuffers() {\n        // Uniforms\n        for (const uniformBuffer of this._uniformBuffers) {\n            uniformBuffer._rebuild();\n        }\n        // Storage buffers\n        for (const storageBuffer of this._storageBuffers) {\n            storageBuffer._rebuild();\n        }\n    }\n    _initGLContext() {\n        var _a;\n        // Caps\n        this._caps = {\n            maxTexturesImageUnits: this._gl.getParameter(this._gl.MAX_TEXTURE_IMAGE_UNITS),\n            maxCombinedTexturesImageUnits: this._gl.getParameter(this._gl.MAX_COMBINED_TEXTURE_IMAGE_UNITS),\n            maxVertexTextureImageUnits: this._gl.getParameter(this._gl.MAX_VERTEX_TEXTURE_IMAGE_UNITS),\n            maxTextureSize: this._gl.getParameter(this._gl.MAX_TEXTURE_SIZE),\n            maxSamples: this._webGLVersion > 1 ? this._gl.getParameter(this._gl.MAX_SAMPLES) : 1,\n            maxCubemapTextureSize: this._gl.getParameter(this._gl.MAX_CUBE_MAP_TEXTURE_SIZE),\n            maxRenderTextureSize: this._gl.getParameter(this._gl.MAX_RENDERBUFFER_SIZE),\n            maxVertexAttribs: this._gl.getParameter(this._gl.MAX_VERTEX_ATTRIBS),\n            maxVaryingVectors: this._gl.getParameter(this._gl.MAX_VARYING_VECTORS),\n            maxFragmentUniformVectors: this._gl.getParameter(this._gl.MAX_FRAGMENT_UNIFORM_VECTORS),\n            maxVertexUniformVectors: this._gl.getParameter(this._gl.MAX_VERTEX_UNIFORM_VECTORS),\n            parallelShaderCompile: this._gl.getExtension(\"KHR_parallel_shader_compile\") || undefined,\n            standardDerivatives: this._webGLVersion > 1 || this._gl.getExtension(\"OES_standard_derivatives\") !== null,\n            maxAnisotropy: 1,\n            astc: this._gl.getExtension(\"WEBGL_compressed_texture_astc\") || this._gl.getExtension(\"WEBKIT_WEBGL_compressed_texture_astc\"),\n            bptc: this._gl.getExtension(\"EXT_texture_compression_bptc\") || this._gl.getExtension(\"WEBKIT_EXT_texture_compression_bptc\"),\n            s3tc: this._gl.getExtension(\"WEBGL_compressed_texture_s3tc\") || this._gl.getExtension(\"WEBKIT_WEBGL_compressed_texture_s3tc\"),\n            // eslint-disable-next-line @typescript-eslint/naming-convention\n            s3tc_srgb: this._gl.getExtension(\"WEBGL_compressed_texture_s3tc_srgb\") || this._gl.getExtension(\"WEBKIT_WEBGL_compressed_texture_s3tc_srgb\"),\n            pvrtc: this._gl.getExtension(\"WEBGL_compressed_texture_pvrtc\") || this._gl.getExtension(\"WEBKIT_WEBGL_compressed_texture_pvrtc\"),\n            etc1: this._gl.getExtension(\"WEBGL_compressed_texture_etc1\") || this._gl.getExtension(\"WEBKIT_WEBGL_compressed_texture_etc1\"),\n            etc2: this._gl.getExtension(\"WEBGL_compressed_texture_etc\") ||\n                this._gl.getExtension(\"WEBKIT_WEBGL_compressed_texture_etc\") ||\n                this._gl.getExtension(\"WEBGL_compressed_texture_es3_0\"),\n            textureAnisotropicFilterExtension: this._gl.getExtension(\"EXT_texture_filter_anisotropic\") ||\n                this._gl.getExtension(\"WEBKIT_EXT_texture_filter_anisotropic\") ||\n                this._gl.getExtension(\"MOZ_EXT_texture_filter_anisotropic\"),\n            uintIndices: this._webGLVersion > 1 || this._gl.getExtension(\"OES_element_index_uint\") !== null,\n            fragmentDepthSupported: this._webGLVersion > 1 || this._gl.getExtension(\"EXT_frag_depth\") !== null,\n            highPrecisionShaderSupported: false,\n            timerQuery: this._gl.getExtension(\"EXT_disjoint_timer_query_webgl2\") || this._gl.getExtension(\"EXT_disjoint_timer_query\"),\n            supportOcclusionQuery: this._webGLVersion > 1,\n            canUseTimestampForTimerQuery: false,\n            drawBuffersExtension: false,\n            maxMSAASamples: 1,\n            colorBufferFloat: !!(this._webGLVersion > 1 && this._gl.getExtension(\"EXT_color_buffer_float\")),\n            colorBufferHalfFloat: !!(this._webGLVersion > 1 && this._gl.getExtension(\"EXT_color_buffer_half_float\")),\n            textureFloat: this._webGLVersion > 1 || this._gl.getExtension(\"OES_texture_float\") ? true : false,\n            textureHalfFloat: this._webGLVersion > 1 || this._gl.getExtension(\"OES_texture_half_float\") ? true : false,\n            textureHalfFloatRender: false,\n            textureFloatLinearFiltering: false,\n            textureFloatRender: false,\n            textureHalfFloatLinearFiltering: false,\n            vertexArrayObject: false,\n            instancedArrays: false,\n            textureLOD: this._webGLVersion > 1 || this._gl.getExtension(\"EXT_shader_texture_lod\") ? true : false,\n            texelFetch: this._webGLVersion !== 1,\n            blendMinMax: false,\n            multiview: this._gl.getExtension(\"OVR_multiview2\"),\n            oculusMultiview: this._gl.getExtension(\"OCULUS_multiview\"),\n            depthTextureExtension: false,\n            canUseGLInstanceID: this._webGLVersion > 1,\n            canUseGLVertexID: this._webGLVersion > 1,\n            supportComputeShaders: false,\n            supportSRGBBuffers: false,\n            supportTransformFeedbacks: this._webGLVersion > 1,\n            textureMaxLevel: this._webGLVersion > 1,\n            texture2DArrayMaxLayerCount: this._webGLVersion > 1 ? this._gl.getParameter(this._gl.MAX_ARRAY_TEXTURE_LAYERS) : 128,\n            disableMorphTargetTexture: false,\n        };\n        // Infos\n        this._glVersion = this._gl.getParameter(this._gl.VERSION);\n        const rendererInfo = this._gl.getExtension(\"WEBGL_debug_renderer_info\");\n        if (rendererInfo != null) {\n            this._glRenderer = this._gl.getParameter(rendererInfo.UNMASKED_RENDERER_WEBGL);\n            this._glVendor = this._gl.getParameter(rendererInfo.UNMASKED_VENDOR_WEBGL);\n        }\n        if (!this._glVendor) {\n            this._glVendor = this._gl.getParameter(this._gl.VENDOR) || \"Unknown vendor\";\n        }\n        if (!this._glRenderer) {\n            this._glRenderer = this._gl.getParameter(this._gl.RENDERER) || \"Unknown renderer\";\n        }\n        // Constants\n        if (this._gl.HALF_FLOAT_OES !== 0x8d61) {\n            this._gl.HALF_FLOAT_OES = 0x8d61; // Half floating-point type (16-bit).\n        }\n        if (this._gl.RGBA16F !== 0x881a) {\n            this._gl.RGBA16F = 0x881a; // RGBA 16-bit floating-point color-renderable internal sized format.\n        }\n        if (this._gl.RGBA32F !== 0x8814) {\n            this._gl.RGBA32F = 0x8814; // RGBA 32-bit floating-point color-renderable internal sized format.\n        }\n        if (this._gl.DEPTH24_STENCIL8 !== 35056) {\n            this._gl.DEPTH24_STENCIL8 = 35056;\n        }\n        // Extensions\n        if (this._caps.timerQuery) {\n            if (this._webGLVersion === 1) {\n                this._gl.getQuery = this._caps.timerQuery.getQueryEXT.bind(this._caps.timerQuery);\n            }\n            // WebGLQuery casted to number to avoid TS error\n            this._caps.canUseTimestampForTimerQuery = ((_a = this._gl.getQuery(this._caps.timerQuery.TIMESTAMP_EXT, this._caps.timerQuery.QUERY_COUNTER_BITS_EXT)) !== null && _a !== void 0 ? _a : 0) > 0;\n        }\n        this._caps.maxAnisotropy = this._caps.textureAnisotropicFilterExtension\n            ? this._gl.getParameter(this._caps.textureAnisotropicFilterExtension.MAX_TEXTURE_MAX_ANISOTROPY_EXT)\n            : 0;\n        this._caps.textureFloatLinearFiltering = this._caps.textureFloat && this._gl.getExtension(\"OES_texture_float_linear\") ? true : false;\n        this._caps.textureFloatRender = this._caps.textureFloat && this._canRenderToFloatFramebuffer() ? true : false;\n        this._caps.textureHalfFloatLinearFiltering =\n            this._webGLVersion > 1 || (this._caps.textureHalfFloat && this._gl.getExtension(\"OES_texture_half_float_linear\")) ? true : false;\n        // Compressed formats\n        if (this._caps.astc) {\n            this._gl.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = this._caps.astc.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;\n        }\n        if (this._caps.bptc) {\n            this._gl.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT = this._caps.bptc.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT;\n        }\n        if (this._caps.s3tc_srgb) {\n            this._gl.COMPRESSED_SRGB_S3TC_DXT1_EXT = this._caps.s3tc_srgb.COMPRESSED_SRGB_S3TC_DXT1_EXT;\n            this._gl.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = this._caps.s3tc_srgb.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;\n            this._gl.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = this._caps.s3tc_srgb.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;\n        }\n        if (this._caps.etc2) {\n            this._gl.COMPRESSED_SRGB8_ETC2 = this._caps.etc2.COMPRESSED_SRGB8_ETC2;\n            this._gl.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = this._caps.etc2.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;\n        }\n        // Checks if some of the format renders first to allow the use of webgl inspector.\n        if (this._webGLVersion > 1) {\n            if (this._gl.HALF_FLOAT_OES !== 0x140b) {\n                this._gl.HALF_FLOAT_OES = 0x140b;\n            }\n        }\n        this._caps.textureHalfFloatRender = this._caps.textureHalfFloat && this._canRenderToHalfFloatFramebuffer();\n        // Draw buffers\n        if (this._webGLVersion > 1) {\n            this._caps.drawBuffersExtension = true;\n            this._caps.maxMSAASamples = this._maxMSAASamplesOverride !== null ? this._maxMSAASamplesOverride : this._gl.getParameter(this._gl.MAX_SAMPLES);\n        }\n        else {\n            const drawBuffersExtension = this._gl.getExtension(\"WEBGL_draw_buffers\");\n            if (drawBuffersExtension !== null) {\n                this._caps.drawBuffersExtension = true;\n                this._gl.drawBuffers = drawBuffersExtension.drawBuffersWEBGL.bind(drawBuffersExtension);\n                this._gl.DRAW_FRAMEBUFFER = this._gl.FRAMEBUFFER;\n                for (let i = 0; i < 16; i++) {\n                    this._gl[\"COLOR_ATTACHMENT\" + i + \"_WEBGL\"] = drawBuffersExtension[\"COLOR_ATTACHMENT\" + i + \"_WEBGL\"];\n                }\n            }\n        }\n        // Depth Texture\n        if (this._webGLVersion > 1) {\n            this._caps.depthTextureExtension = true;\n        }\n        else {\n            const depthTextureExtension = this._gl.getExtension(\"WEBGL_depth_texture\");\n            if (depthTextureExtension != null) {\n                this._caps.depthTextureExtension = true;\n                this._gl.UNSIGNED_INT_24_8 = depthTextureExtension.UNSIGNED_INT_24_8_WEBGL;\n            }\n        }\n        // Vertex array object\n        if (this.disableVertexArrayObjects) {\n            this._caps.vertexArrayObject = false;\n        }\n        else if (this._webGLVersion > 1) {\n            this._caps.vertexArrayObject = true;\n        }\n        else {\n            const vertexArrayObjectExtension = this._gl.getExtension(\"OES_vertex_array_object\");\n            if (vertexArrayObjectExtension != null) {\n                this._caps.vertexArrayObject = true;\n                this._gl.createVertexArray = vertexArrayObjectExtension.createVertexArrayOES.bind(vertexArrayObjectExtension);\n                this._gl.bindVertexArray = vertexArrayObjectExtension.bindVertexArrayOES.bind(vertexArrayObjectExtension);\n                this._gl.deleteVertexArray = vertexArrayObjectExtension.deleteVertexArrayOES.bind(vertexArrayObjectExtension);\n            }\n        }\n        // Instances count\n        if (this._webGLVersion > 1) {\n            this._caps.instancedArrays = true;\n        }\n        else {\n            const instanceExtension = this._gl.getExtension(\"ANGLE_instanced_arrays\");\n            if (instanceExtension != null) {\n                this._caps.instancedArrays = true;\n                this._gl.drawArraysInstanced = instanceExtension.drawArraysInstancedANGLE.bind(instanceExtension);\n                this._gl.drawElementsInstanced = instanceExtension.drawElementsInstancedANGLE.bind(instanceExtension);\n                this._gl.vertexAttribDivisor = instanceExtension.vertexAttribDivisorANGLE.bind(instanceExtension);\n            }\n            else {\n                this._caps.instancedArrays = false;\n            }\n        }\n        if (this._gl.getShaderPrecisionFormat) {\n            const vertexhighp = this._gl.getShaderPrecisionFormat(this._gl.VERTEX_SHADER, this._gl.HIGH_FLOAT);\n            const fragmenthighp = this._gl.getShaderPrecisionFormat(this._gl.FRAGMENT_SHADER, this._gl.HIGH_FLOAT);\n            if (vertexhighp && fragmenthighp) {\n                this._caps.highPrecisionShaderSupported = vertexhighp.precision !== 0 && fragmenthighp.precision !== 0;\n            }\n        }\n        if (this._webGLVersion > 1) {\n            this._caps.blendMinMax = true;\n        }\n        else {\n            const blendMinMaxExtension = this._gl.getExtension(\"EXT_blend_minmax\");\n            if (blendMinMaxExtension != null) {\n                this._caps.blendMinMax = true;\n                this._gl.MAX = blendMinMaxExtension.MAX_EXT;\n                this._gl.MIN = blendMinMaxExtension.MIN_EXT;\n            }\n        }\n        // sRGB buffers\n        // only run this if not already set to true (in the constructor, for example)\n        if (!this._caps.supportSRGBBuffers) {\n            if (this._webGLVersion > 1) {\n                this._caps.supportSRGBBuffers = true;\n                this._glSRGBExtensionValues = {\n                    SRGB: WebGL2RenderingContext.SRGB,\n                    SRGB8: WebGL2RenderingContext.SRGB8,\n                    SRGB8_ALPHA8: WebGL2RenderingContext.SRGB8_ALPHA8,\n                };\n            }\n            else {\n                const sRGBExtension = this._gl.getExtension(\"EXT_sRGB\");\n                if (sRGBExtension != null) {\n                    this._caps.supportSRGBBuffers = true;\n                    this._glSRGBExtensionValues = {\n                        SRGB: sRGBExtension.SRGB_EXT,\n                        SRGB8: sRGBExtension.SRGB_ALPHA_EXT,\n                        SRGB8_ALPHA8: sRGBExtension.SRGB_ALPHA_EXT,\n                    };\n                }\n            }\n            // take into account the forced state that was provided in options\n            // When the issue in angle/chrome is fixed the flag should be taken into account only when it is explicitly defined\n            this._caps.supportSRGBBuffers = this._caps.supportSRGBBuffers && !!(this._creationOptions && this._creationOptions.forceSRGBBufferSupportState);\n        }\n        // Depth buffer\n        this._depthCullingState.depthTest = true;\n        this._depthCullingState.depthFunc = this._gl.LEQUAL;\n        this._depthCullingState.depthMask = true;\n        // Texture maps\n        this._maxSimultaneousTextures = this._caps.maxCombinedTexturesImageUnits;\n        for (let slot = 0; slot < this._maxSimultaneousTextures; slot++) {\n            this._nextFreeTextureSlots.push(slot);\n        }\n        if (this._glRenderer === \"Mali-G72\") {\n            // Overcome a bug when using a texture to store morph targets on Mali-G72\n            this._caps.disableMorphTargetTexture = true;\n        }\n    }\n    _initFeatures() {\n        this._features = {\n            forceBitmapOverHTMLImageElement: false,\n            supportRenderAndCopyToLodForFloatTextures: this._webGLVersion !== 1,\n            supportDepthStencilTexture: this._webGLVersion !== 1,\n            supportShadowSamplers: this._webGLVersion !== 1,\n            uniformBufferHardCheckMatrix: false,\n            allowTexturePrefiltering: this._webGLVersion !== 1,\n            trackUbosInFrame: false,\n            checkUbosContentBeforeUpload: false,\n            supportCSM: this._webGLVersion !== 1,\n            basisNeedsPOT: this._webGLVersion === 1,\n            support3DTextures: this._webGLVersion !== 1,\n            needTypeSuffixInShaderConstants: this._webGLVersion !== 1,\n            supportMSAA: this._webGLVersion !== 1,\n            supportSSAO2: this._webGLVersion !== 1,\n            supportExtendedTextureFormats: this._webGLVersion !== 1,\n            supportSwitchCaseInShader: this._webGLVersion !== 1,\n            supportSyncTextureRead: true,\n            needsInvertingBitmap: true,\n            useUBOBindingCache: true,\n            needShaderCodeInlining: false,\n            needToAlwaysBindUniformBuffers: false,\n            supportRenderPasses: false,\n            supportSpriteInstancing: true,\n            _collectUbosUpdatedInFrame: false,\n        };\n    }\n    /**\n     * Gets version of the current webGL context\n     * Keep it for back compat - use version instead\n     */\n    get webGLVersion() {\n        return this._webGLVersion;\n    }\n    /**\n     * Gets a string identifying the name of the class\n     * @returns \"Engine\" string\n     */\n    getClassName() {\n        return \"ThinEngine\";\n    }\n    /**\n     * Returns true if the stencil buffer has been enabled through the creation option of the context.\n     */\n    get isStencilEnable() {\n        return this._isStencilEnable;\n    }\n    /** @internal */\n    _prepareWorkingCanvas() {\n        if (this._workingCanvas) {\n            return;\n        }\n        this._workingCanvas = this.createCanvas(1, 1);\n        const context = this._workingCanvas.getContext(\"2d\");\n        if (context) {\n            this._workingContext = context;\n        }\n    }\n    /**\n     * Reset the texture cache to empty state\n     */\n    resetTextureCache() {\n        for (const key in this._boundTexturesCache) {\n            if (!Object.prototype.hasOwnProperty.call(this._boundTexturesCache, key)) {\n                continue;\n            }\n            this._boundTexturesCache[key] = null;\n        }\n        this._currentTextureChannel = -1;\n    }\n    /**\n     * Gets an object containing information about the current engine context\n     * @returns an object containing the vendor, the renderer and the version of the current engine context\n     */\n    getInfo() {\n        return this.getGlInfo();\n    }\n    /**\n     * Gets an object containing information about the current webGL context\n     * @returns an object containing the vendor, the renderer and the version of the current webGL context\n     */\n    getGlInfo() {\n        return {\n            vendor: this._glVendor,\n            renderer: this._glRenderer,\n            version: this._glVersion,\n        };\n    }\n    /**\n     * Defines the hardware scaling level.\n     * By default the hardware scaling level is computed from the window device ratio.\n     * if level = 1 then the engine will render at the exact resolution of the canvas. If level = 0.5 then the engine will render at twice the size of the canvas.\n     * @param level defines the level to use\n     */\n    setHardwareScalingLevel(level) {\n        this._hardwareScalingLevel = level;\n        this.resize();\n    }\n    /**\n     * Gets the current hardware scaling level.\n     * By default the hardware scaling level is computed from the window device ratio.\n     * if level = 1 then the engine will render at the exact resolution of the canvas. If level = 0.5 then the engine will render at twice the size of the canvas.\n     * @returns a number indicating the current hardware scaling level\n     */\n    getHardwareScalingLevel() {\n        return this._hardwareScalingLevel;\n    }\n    /**\n     * Gets the list of loaded textures\n     * @returns an array containing all loaded textures\n     */\n    getLoadedTexturesCache() {\n        return this._internalTexturesCache;\n    }\n    /**\n     * Gets the object containing all engine capabilities\n     * @returns the EngineCapabilities object\n     */\n    getCaps() {\n        return this._caps;\n    }\n    /**\n     * stop executing a render loop function and remove it from the execution array\n     * @param renderFunction defines the function to be removed. If not provided all functions will be removed.\n     */\n    stopRenderLoop(renderFunction) {\n        if (!renderFunction) {\n            this._activeRenderLoops.length = 0;\n            return;\n        }\n        const index = this._activeRenderLoops.indexOf(renderFunction);\n        if (index >= 0) {\n            this._activeRenderLoops.splice(index, 1);\n        }\n    }\n    /** @internal */\n    _renderLoop() {\n        if (!this._contextWasLost) {\n            let shouldRender = true;\n            if (this._isDisposed || (!this.renderEvenInBackground && this._windowIsBackground)) {\n                shouldRender = false;\n            }\n            if (shouldRender) {\n                // Start new frame\n                this.beginFrame();\n                for (let index = 0; index < this._activeRenderLoops.length; index++) {\n                    const renderFunction = this._activeRenderLoops[index];\n                    renderFunction();\n                }\n                // Present\n                this.endFrame();\n            }\n        }\n        if (this._activeRenderLoops.length > 0) {\n            this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());\n        }\n        else {\n            this._renderingQueueLaunched = false;\n        }\n    }\n    /**\n     * Gets the HTML canvas attached with the current webGL context\n     * @returns a HTML canvas\n     */\n    getRenderingCanvas() {\n        return this._renderingCanvas;\n    }\n    /**\n     * Gets the audio context specified in engine initialization options\n     * @returns an Audio Context\n     */\n    getAudioContext() {\n        return this._audioContext;\n    }\n    /**\n     * Gets the audio destination specified in engine initialization options\n     * @returns an audio destination node\n     */\n    getAudioDestination() {\n        return this._audioDestination;\n    }\n    /**\n     * Gets host window\n     * @returns the host window object\n     */\n    getHostWindow() {\n        if (!IsWindowObjectExist()) {\n            return null;\n        }\n        if (this._renderingCanvas && this._renderingCanvas.ownerDocument && this._renderingCanvas.ownerDocument.defaultView) {\n            return this._renderingCanvas.ownerDocument.defaultView;\n        }\n        return window;\n    }\n    /**\n     * Gets the current render width\n     * @param useScreen defines if screen size must be used (or the current render target if any)\n     * @returns a number defining the current render width\n     */\n    getRenderWidth(useScreen = false) {\n        if (!useScreen && this._currentRenderTarget) {\n            return this._currentRenderTarget.width;\n        }\n        return this._framebufferDimensionsObject ? this._framebufferDimensionsObject.framebufferWidth : this._gl.drawingBufferWidth;\n    }\n    /**\n     * Gets the current render height\n     * @param useScreen defines if screen size must be used (or the current render target if any)\n     * @returns a number defining the current render height\n     */\n    getRenderHeight(useScreen = false) {\n        if (!useScreen && this._currentRenderTarget) {\n            return this._currentRenderTarget.height;\n        }\n        return this._framebufferDimensionsObject ? this._framebufferDimensionsObject.framebufferHeight : this._gl.drawingBufferHeight;\n    }\n    /**\n     * Can be used to override the current requestAnimationFrame requester.\n     * @internal\n     */\n    _queueNewFrame(bindedRenderFunction, requester) {\n        return ThinEngine.QueueNewFrame(bindedRenderFunction, requester);\n    }\n    /**\n     * Register and execute a render loop. The engine can have more than one render function\n     * @param renderFunction defines the function to continuously execute\n     */\n    runRenderLoop(renderFunction) {\n        if (this._activeRenderLoops.indexOf(renderFunction) !== -1) {\n            return;\n        }\n        this._activeRenderLoops.push(renderFunction);\n        if (!this._renderingQueueLaunched) {\n            this._renderingQueueLaunched = true;\n            this._boundRenderFunction = this._renderLoop.bind(this);\n            this._frameHandler = this._queueNewFrame(this._boundRenderFunction, this.getHostWindow());\n        }\n    }\n    /**\n     * Clear the current render buffer or the current render target (if any is set up)\n     * @param color defines the color to use\n     * @param backBuffer defines if the back buffer must be cleared\n     * @param depth defines if the depth buffer must be cleared\n     * @param stencil defines if the stencil buffer must be cleared\n     */\n    clear(color, backBuffer, depth, stencil = false) {\n        const useStencilGlobalOnly = this.stencilStateComposer.useStencilGlobalOnly;\n        this.stencilStateComposer.useStencilGlobalOnly = true; // make sure the stencil mask is coming from the global stencil and not from a material (effect) which would currently be in effect\n        this.applyStates();\n        this.stencilStateComposer.useStencilGlobalOnly = useStencilGlobalOnly;\n        let mode = 0;\n        if (backBuffer && color) {\n            this._gl.clearColor(color.r, color.g, color.b, color.a !== undefined ? color.a : 1.0);\n            mode |= this._gl.COLOR_BUFFER_BIT;\n        }\n        if (depth) {\n            if (this.useReverseDepthBuffer) {\n                this._depthCullingState.depthFunc = this._gl.GEQUAL;\n                this._gl.clearDepth(0.0);\n            }\n            else {\n                this._gl.clearDepth(1.0);\n            }\n            mode |= this._gl.DEPTH_BUFFER_BIT;\n        }\n        if (stencil) {\n            this._gl.clearStencil(0);\n            mode |= this._gl.STENCIL_BUFFER_BIT;\n        }\n        this._gl.clear(mode);\n    }\n    /**\n     * @internal\n     */\n    _viewport(x, y, width, height) {\n        if (x !== this._viewportCached.x || y !== this._viewportCached.y || width !== this._viewportCached.z || height !== this._viewportCached.w) {\n            this._viewportCached.x = x;\n            this._viewportCached.y = y;\n            this._viewportCached.z = width;\n            this._viewportCached.w = height;\n            this._gl.viewport(x, y, width, height);\n        }\n    }\n    /**\n     * Set the WebGL's viewport\n     * @param viewport defines the viewport element to be used\n     * @param requiredWidth defines the width required for rendering. If not provided the rendering canvas' width is used\n     * @param requiredHeight defines the height required for rendering. If not provided the rendering canvas' height is used\n     */\n    setViewport(viewport, requiredWidth, requiredHeight) {\n        const width = requiredWidth || this.getRenderWidth();\n        const height = requiredHeight || this.getRenderHeight();\n        const x = viewport.x || 0;\n        const y = viewport.y || 0;\n        this._cachedViewport = viewport;\n        this._viewport(x * width, y * height, width * viewport.width, height * viewport.height);\n    }\n    /**\n     * Begin a new frame\n     */\n    beginFrame() { }\n    /**\n     * Enf the current frame\n     */\n    endFrame() {\n        // Force a flush in case we are using a bad OS.\n        if (this._badOS) {\n            this.flushFramebuffer();\n        }\n        this._frameId++;\n    }\n    /**\n     * Resize the view according to the canvas' size\n     * @param forceSetSize true to force setting the sizes of the underlying canvas\n     */\n    resize(forceSetSize = false) {\n        let width;\n        let height;\n        // Re-query hardware scaling level to handle zoomed-in resizing.\n        if (this.adaptToDeviceRatio) {\n            const devicePixelRatio = IsWindowObjectExist() ? window.devicePixelRatio || 1.0 : 1.0;\n            const changeRatio = this._lastDevicePixelRatio / devicePixelRatio;\n            this._lastDevicePixelRatio = devicePixelRatio;\n            this._hardwareScalingLevel *= changeRatio;\n        }\n        if (IsWindowObjectExist() && IsDocumentAvailable()) {\n            // make sure it is a Node object, and is a part of the document.\n            if (this._renderingCanvas) {\n                const boundingRect = this._renderingCanvas.getBoundingClientRect\n                    ? this._renderingCanvas.getBoundingClientRect()\n                    : {\n                        // fallback to last solution in case the function doesn't exist\n                        width: this._renderingCanvas.width * this._hardwareScalingLevel,\n                        height: this._renderingCanvas.height * this._hardwareScalingLevel,\n                    };\n                width = this._renderingCanvas.clientWidth || boundingRect.width || this._renderingCanvas.width || 100;\n                height = this._renderingCanvas.clientHeight || boundingRect.height || this._renderingCanvas.height || 100;\n            }\n            else {\n                width = window.innerWidth;\n                height = window.innerHeight;\n            }\n        }\n        else {\n            width = this._renderingCanvas ? this._renderingCanvas.width : 100;\n            height = this._renderingCanvas ? this._renderingCanvas.height : 100;\n        }\n        this.setSize(width / this._hardwareScalingLevel, height / this._hardwareScalingLevel, forceSetSize);\n    }\n    /**\n     * Force a specific size of the canvas\n     * @param width defines the new canvas' width\n     * @param height defines the new canvas' height\n     * @param forceSetSize true to force setting the sizes of the underlying canvas\n     * @returns true if the size was changed\n     */\n    setSize(width, height, forceSetSize = false) {\n        if (!this._renderingCanvas) {\n            return false;\n        }\n        width = width | 0;\n        height = height | 0;\n        if (!forceSetSize && this._renderingCanvas.width === width && this._renderingCanvas.height === height) {\n            return false;\n        }\n        this._renderingCanvas.width = width;\n        this._renderingCanvas.height = height;\n        return true;\n    }\n    /**\n     * Binds the frame buffer to the specified texture.\n     * @param rtWrapper The render target wrapper to render to\n     * @param faceIndex The face of the texture to render to in case of cube texture and if the render target wrapper is not a multi render target\n     * @param requiredWidth The width of the target to render to\n     * @param requiredHeight The height of the target to render to\n     * @param forceFullscreenViewport Forces the viewport to be the entire texture/screen if true\n     * @param lodLevel Defines the lod level to bind to the frame buffer\n     * @param layer Defines the 2d array index to bind to the frame buffer if the render target wrapper is not a multi render target\n     */\n    bindFramebuffer(rtWrapper, faceIndex = 0, requiredWidth, requiredHeight, forceFullscreenViewport, lodLevel = 0, layer = 0) {\n        var _a, _b, _c, _d, _e;\n        const webglRTWrapper = rtWrapper;\n        if (this._currentRenderTarget) {\n            this.unBindFramebuffer(this._currentRenderTarget);\n        }\n        this._currentRenderTarget = rtWrapper;\n        this._bindUnboundFramebuffer(webglRTWrapper._MSAAFramebuffer ? webglRTWrapper._MSAAFramebuffer : webglRTWrapper._framebuffer);\n        const gl = this._gl;\n        if (!rtWrapper.isMulti) {\n            if (rtWrapper.is2DArray) {\n                gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, (_a = rtWrapper.texture._hardwareTexture) === null || _a === void 0 ? void 0 : _a.underlyingResource, lodLevel, layer);\n            }\n            else if (rtWrapper.isCube) {\n                gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, (_b = rtWrapper.texture._hardwareTexture) === null || _b === void 0 ? void 0 : _b.underlyingResource, lodLevel);\n            }\n        }\n        const depthStencilTexture = rtWrapper._depthStencilTexture;\n        if (depthStencilTexture) {\n            const attachment = rtWrapper._depthStencilTextureWithStencil ? gl.DEPTH_STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;\n            if (rtWrapper.is2DArray) {\n                gl.framebufferTextureLayer(gl.FRAMEBUFFER, attachment, (_c = depthStencilTexture._hardwareTexture) === null || _c === void 0 ? void 0 : _c.underlyingResource, lodLevel, layer);\n            }\n            else if (rtWrapper.isCube) {\n                gl.framebufferTexture2D(gl.FRAMEBUFFER, attachment, gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex, (_d = depthStencilTexture._hardwareTexture) === null || _d === void 0 ? void 0 : _d.underlyingResource, lodLevel);\n            }\n            else {\n                gl.framebufferTexture2D(gl.FRAMEBUFFER, attachment, gl.TEXTURE_2D, (_e = depthStencilTexture._hardwareTexture) === null || _e === void 0 ? void 0 : _e.underlyingResource, lodLevel);\n            }\n        }\n        if (this._cachedViewport && !forceFullscreenViewport) {\n            this.setViewport(this._cachedViewport, requiredWidth, requiredHeight);\n        }\n        else {\n            if (!requiredWidth) {\n                requiredWidth = rtWrapper.width;\n                if (lodLevel) {\n                    requiredWidth = requiredWidth / Math.pow(2, lodLevel);\n                }\n            }\n            if (!requiredHeight) {\n                requiredHeight = rtWrapper.height;\n                if (lodLevel) {\n                    requiredHeight = requiredHeight / Math.pow(2, lodLevel);\n                }\n            }\n            this._viewport(0, 0, requiredWidth, requiredHeight);\n        }\n        this.wipeCaches();\n    }\n    /**\n     * Set various states to the webGL context\n     * @param culling defines culling state: true to enable culling, false to disable it\n     * @param zOffset defines the value to apply to zOffset (0 by default)\n     * @param force defines if states must be applied even if cache is up to date\n     * @param reverseSide defines if culling must be reversed (CCW if false, CW if true)\n     * @param cullBackFaces true to cull back faces, false to cull front faces (if culling is enabled)\n     * @param stencil stencil states to set\n     * @param zOffsetUnits defines the value to apply to zOffsetUnits (0 by default)\n     */\n    setState(culling, zOffset = 0, force, reverseSide = false, cullBackFaces, stencil, zOffsetUnits = 0) {\n        var _a, _b;\n        // Culling\n        if (this._depthCullingState.cull !== culling || force) {\n            this._depthCullingState.cull = culling;\n        }\n        // Cull face\n        const cullFace = ((_b = (_a = this.cullBackFaces) !== null && _a !== void 0 ? _a : cullBackFaces) !== null && _b !== void 0 ? _b : true) ? this._gl.BACK : this._gl.FRONT;\n        if (this._depthCullingState.cullFace !== cullFace || force) {\n            this._depthCullingState.cullFace = cullFace;\n        }\n        // Z offset\n        this.setZOffset(zOffset);\n        this.setZOffsetUnits(zOffsetUnits);\n        // Front face\n        const frontFace = reverseSide ? this._gl.CW : this._gl.CCW;\n        if (this._depthCullingState.frontFace !== frontFace || force) {\n            this._depthCullingState.frontFace = frontFace;\n        }\n        this._stencilStateComposer.stencilMaterial = stencil;\n    }\n    /**\n     * Gets a boolean indicating if depth testing is enabled\n     * @returns the current state\n     */\n    getDepthBuffer() {\n        return this._depthCullingState.depthTest;\n    }\n    /**\n     * Enable or disable depth buffering\n     * @param enable defines the state to set\n     */\n    setDepthBuffer(enable) {\n        this._depthCullingState.depthTest = enable;\n    }\n    /**\n     * Set the z offset Factor to apply to current rendering\n     * @param value defines the offset to apply\n     */\n    setZOffset(value) {\n        this._depthCullingState.zOffset = this.useReverseDepthBuffer ? -value : value;\n    }\n    /**\n     * Gets the current value of the zOffset Factor\n     * @returns the current zOffset Factor state\n     */\n    getZOffset() {\n        const zOffset = this._depthCullingState.zOffset;\n        return this.useReverseDepthBuffer ? -zOffset : zOffset;\n    }\n    /**\n     * Set the z offset Units to apply to current rendering\n     * @param value defines the offset to apply\n     */\n    setZOffsetUnits(value) {\n        this._depthCullingState.zOffsetUnits = this.useReverseDepthBuffer ? -value : value;\n    }\n    /**\n     * Gets the current value of the zOffset Units\n     * @returns the current zOffset Units state\n     */\n    getZOffsetUnits() {\n        const zOffsetUnits = this._depthCullingState.zOffsetUnits;\n        return this.useReverseDepthBuffer ? -zOffsetUnits : zOffsetUnits;\n    }\n    /**\n     * @internal\n     */\n    _bindUnboundFramebuffer(framebuffer) {\n        if (this._currentFramebuffer !== framebuffer) {\n            this._gl.bindFramebuffer(this._gl.FRAMEBUFFER, framebuffer);\n            this._currentFramebuffer = framebuffer;\n        }\n    }\n    /** @internal */\n    _currentFrameBufferIsDefaultFrameBuffer() {\n        return this._currentFramebuffer === null;\n    }\n    /**\n     * Generates the mipmaps for a texture\n     * @param texture texture to generate the mipmaps for\n     */\n    generateMipmaps(texture) {\n        this._bindTextureDirectly(this._gl.TEXTURE_2D, texture, true);\n        this._gl.generateMipmap(this._gl.TEXTURE_2D);\n        this._bindTextureDirectly(this._gl.TEXTURE_2D, null);\n    }\n    /**\n     * Unbind the current render target texture from the webGL context\n     * @param texture defines the render target wrapper to unbind\n     * @param disableGenerateMipMaps defines a boolean indicating that mipmaps must not be generated\n     * @param onBeforeUnbind defines a function which will be called before the effective unbind\n     */\n    unBindFramebuffer(texture, disableGenerateMipMaps = false, onBeforeUnbind) {\n        var _a;\n        const webglRTWrapper = texture;\n        this._currentRenderTarget = null;\n        // If MSAA, we need to bitblt back to main texture\n        const gl = this._gl;\n        if (webglRTWrapper._MSAAFramebuffer) {\n            if (texture.isMulti) {\n                // This texture is part of a MRT texture, we need to treat all attachments\n                this.unBindMultiColorAttachmentFramebuffer(texture, disableGenerateMipMaps, onBeforeUnbind);\n                return;\n            }\n            gl.bindFramebuffer(gl.READ_FRAMEBUFFER, webglRTWrapper._MSAAFramebuffer);\n            gl.bindFramebuffer(gl.DRAW_FRAMEBUFFER, webglRTWrapper._framebuffer);\n            gl.blitFramebuffer(0, 0, texture.width, texture.height, 0, 0, texture.width, texture.height, gl.COLOR_BUFFER_BIT, gl.NEAREST);\n        }\n        if (((_a = texture.texture) === null || _a === void 0 ? void 0 : _a.generateMipMaps) && !disableGenerateMipMaps && !texture.isCube) {\n            this.generateMipmaps(texture.texture);\n        }\n        if (onBeforeUnbind) {\n            if (webglRTWrapper._MSAAFramebuffer) {\n                // Bind the correct framebuffer\n                this._bindUnboundFramebuffer(webglRTWrapper._framebuffer);\n            }\n            onBeforeUnbind();\n        }\n        this._bindUnboundFramebuffer(null);\n    }\n    /**\n     * Force a webGL flush (ie. a flush of all waiting webGL commands)\n     */\n    flushFramebuffer() {\n        this._gl.flush();\n    }\n    /**\n     * Unbind the current render target and bind the default framebuffer\n     */\n    restoreDefaultFramebuffer() {\n        if (this._currentRenderTarget) {\n            this.unBindFramebuffer(this._currentRenderTarget);\n        }\n        else {\n            this._bindUnboundFramebuffer(null);\n        }\n        if (this._cachedViewport) {\n            this.setViewport(this._cachedViewport);\n        }\n        this.wipeCaches();\n    }\n    // VBOs\n    /** @internal */\n    _resetVertexBufferBinding() {\n        this.bindArrayBuffer(null);\n        this._cachedVertexBuffers = null;\n    }\n    /**\n     * Creates a vertex buffer\n     * @param data the data for the vertex buffer\n     * @returns the new WebGL static buffer\n     */\n    createVertexBuffer(data) {\n        return this._createVertexBuffer(data, this._gl.STATIC_DRAW);\n    }\n    _createVertexBuffer(data, usage) {\n        const vbo = this._gl.createBuffer();\n        if (!vbo) {\n            throw new Error(\"Unable to create vertex buffer\");\n        }\n        const dataBuffer = new WebGLDataBuffer(vbo);\n        this.bindArrayBuffer(dataBuffer);\n        if (data instanceof Array) {\n            this._gl.bufferData(this._gl.ARRAY_BUFFER, new Float32Array(data), usage);\n        }\n        else {\n            this._gl.bufferData(this._gl.ARRAY_BUFFER, data, usage);\n        }\n        this._resetVertexBufferBinding();\n        dataBuffer.references = 1;\n        return dataBuffer;\n    }\n    /**\n     * Creates a dynamic vertex buffer\n     * @param data the data for the dynamic vertex buffer\n     * @returns the new WebGL dynamic buffer\n     */\n    createDynamicVertexBuffer(data) {\n        return this._createVertexBuffer(data, this._gl.DYNAMIC_DRAW);\n    }\n    _resetIndexBufferBinding() {\n        this.bindIndexBuffer(null);\n        this._cachedIndexBuffer = null;\n    }\n    /**\n     * Creates a new index buffer\n     * @param indices defines the content of the index buffer\n     * @param updatable defines if the index buffer must be updatable\n     * @returns a new webGL buffer\n     */\n    createIndexBuffer(indices, updatable) {\n        const vbo = this._gl.createBuffer();\n        const dataBuffer = new WebGLDataBuffer(vbo);\n        if (!vbo) {\n            throw new Error(\"Unable to create index buffer\");\n        }\n        this.bindIndexBuffer(dataBuffer);\n        const data = this._normalizeIndexData(indices);\n        this._gl.bufferData(this._gl.ELEMENT_ARRAY_BUFFER, data, updatable ? this._gl.DYNAMIC_DRAW : this._gl.STATIC_DRAW);\n        this._resetIndexBufferBinding();\n        dataBuffer.references = 1;\n        dataBuffer.is32Bits = data.BYTES_PER_ELEMENT === 4;\n        return dataBuffer;\n    }\n    _normalizeIndexData(indices) {\n        const bytesPerElement = indices.BYTES_PER_ELEMENT;\n        if (bytesPerElement === 2) {\n            return indices;\n        }\n        // Check 32 bit support\n        if (this._caps.uintIndices) {\n            if (indices instanceof Uint32Array) {\n                return indices;\n            }\n            else {\n                // number[] or Int32Array, check if 32 bit is necessary\n                for (let index = 0; index < indices.length; index++) {\n                    if (indices[index] >= 65535) {\n                        return new Uint32Array(indices);\n                    }\n                }\n                return new Uint16Array(indices);\n            }\n        }\n        // No 32 bit support, force conversion to 16 bit (values greater 16 bit are lost)\n        return new Uint16Array(indices);\n    }\n    /**\n     * Bind a webGL buffer to the webGL context\n     * @param buffer defines the buffer to bind\n     */\n    bindArrayBuffer(buffer) {\n        if (!this._vaoRecordInProgress) {\n            this._unbindVertexArrayObject();\n        }\n        this._bindBuffer(buffer, this._gl.ARRAY_BUFFER);\n    }\n    /**\n     * Bind a specific block at a given index in a specific shader program\n     * @param pipelineContext defines the pipeline context to use\n     * @param blockName defines the block name\n     * @param index defines the index where to bind the block\n     */\n    bindUniformBlock(pipelineContext, blockName, index) {\n        const program = pipelineContext.program;\n        const uniformLocation = this._gl.getUniformBlockIndex(program, blockName);\n        this._gl.uniformBlockBinding(program, uniformLocation, index);\n    }\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    bindIndexBuffer(buffer) {\n        if (!this._vaoRecordInProgress) {\n            this._unbindVertexArrayObject();\n        }\n        this._bindBuffer(buffer, this._gl.ELEMENT_ARRAY_BUFFER);\n    }\n    _bindBuffer(buffer, target) {\n        if (this._vaoRecordInProgress || this._currentBoundBuffer[target] !== buffer) {\n            this._gl.bindBuffer(target, buffer ? buffer.underlyingResource : null);\n            this._currentBoundBuffer[target] = buffer;\n        }\n    }\n    /**\n     * update the bound buffer with the given data\n     * @param data defines the data to update\n     */\n    updateArrayBuffer(data) {\n        this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, data);\n    }\n    _vertexAttribPointer(buffer, indx, size, type, normalized, stride, offset) {\n        const pointer = this._currentBufferPointers[indx];\n        if (!pointer) {\n            return;\n        }\n        let changed = false;\n        if (!pointer.active) {\n            changed = true;\n            pointer.active = true;\n            pointer.index = indx;\n            pointer.size = size;\n            pointer.type = type;\n            pointer.normalized = normalized;\n            pointer.stride = stride;\n            pointer.offset = offset;\n            pointer.buffer = buffer;\n        }\n        else {\n            if (pointer.buffer !== buffer) {\n                pointer.buffer = buffer;\n                changed = true;\n            }\n            if (pointer.size !== size) {\n                pointer.size = size;\n                changed = true;\n            }\n            if (pointer.type !== type) {\n                pointer.type = type;\n                changed = true;\n            }\n            if (pointer.normalized !== normalized) {\n                pointer.normalized = normalized;\n                changed = true;\n            }\n            if (pointer.stride !== stride) {\n                pointer.stride = stride;\n                changed = true;\n            }\n            if (pointer.offset !== offset) {\n                pointer.offset = offset;\n                changed = true;\n            }\n        }\n        if (changed || this._vaoRecordInProgress) {\n            this.bindArrayBuffer(buffer);\n            if (type === this._gl.UNSIGNED_INT || type === this._gl.INT) {\n                this._gl.vertexAttribIPointer(indx, size, type, stride, offset);\n            }\n            else {\n                this._gl.vertexAttribPointer(indx, size, type, normalized, stride, offset);\n            }\n        }\n    }\n    /**\n     * @internal\n     */\n    _bindIndexBufferWithCache(indexBuffer) {\n        if (indexBuffer == null) {\n            return;\n        }\n        if (this._cachedIndexBuffer !== indexBuffer) {\n            this._cachedIndexBuffer = indexBuffer;\n            this.bindIndexBuffer(indexBuffer);\n            this._uintIndicesCurrentlySet = indexBuffer.is32Bits;\n        }\n    }\n    _bindVertexBuffersAttributes(vertexBuffers, effect, overrideVertexBuffers) {\n        const attributes = effect.getAttributesNames();\n        if (!this._vaoRecordInProgress) {\n            this._unbindVertexArrayObject();\n        }\n        this.unbindAllAttributes();\n        for (let index = 0; index < attributes.length; index++) {\n            const order = effect.getAttributeLocation(index);\n            if (order >= 0) {\n                const ai = attributes[index];\n                let vertexBuffer = null;\n                if (overrideVertexBuffers) {\n                    vertexBuffer = overrideVertexBuffers[ai];\n                }\n                if (!vertexBuffer) {\n                    vertexBuffer = vertexBuffers[ai];\n                }\n                if (!vertexBuffer) {\n                    continue;\n                }\n                this._gl.enableVertexAttribArray(order);\n                if (!this._vaoRecordInProgress) {\n                    this._vertexAttribArraysEnabled[order] = true;\n                }\n                const buffer = vertexBuffer.getBuffer();\n                if (buffer) {\n                    this._vertexAttribPointer(buffer, order, vertexBuffer.getSize(), vertexBuffer.type, vertexBuffer.normalized, vertexBuffer.byteStride, vertexBuffer.byteOffset);\n                    if (vertexBuffer.getIsInstanced()) {\n                        this._gl.vertexAttribDivisor(order, vertexBuffer.getInstanceDivisor());\n                        if (!this._vaoRecordInProgress) {\n                            this._currentInstanceLocations.push(order);\n                            this._currentInstanceBuffers.push(buffer);\n                        }\n                    }\n                }\n            }\n        }\n    }\n    /**\n     * Records a vertex array object\n     * @see https://doc.babylonjs.com/setup/support/webGL2#vertex-array-objects\n     * @param vertexBuffers defines the list of vertex buffers to store\n     * @param indexBuffer defines the index buffer to store\n     * @param effect defines the effect to store\n     * @param overrideVertexBuffers defines optional list of avertex buffers that overrides the entries in vertexBuffers\n     * @returns the new vertex array object\n     */\n    recordVertexArrayObject(vertexBuffers, indexBuffer, effect, overrideVertexBuffers) {\n        const vao = this._gl.createVertexArray();\n        if (!vao) {\n            throw new Error(\"Unable to create VAO\");\n        }\n        this._vaoRecordInProgress = true;\n        this._gl.bindVertexArray(vao);\n        this._mustWipeVertexAttributes = true;\n        this._bindVertexBuffersAttributes(vertexBuffers, effect, overrideVertexBuffers);\n        this.bindIndexBuffer(indexBuffer);\n        this._vaoRecordInProgress = false;\n        this._gl.bindVertexArray(null);\n        return vao;\n    }\n    /**\n     * Bind a specific vertex array object\n     * @see https://doc.babylonjs.com/setup/support/webGL2#vertex-array-objects\n     * @param vertexArrayObject defines the vertex array object to bind\n     * @param indexBuffer defines the index buffer to bind\n     */\n    bindVertexArrayObject(vertexArrayObject, indexBuffer) {\n        if (this._cachedVertexArrayObject !== vertexArrayObject) {\n            this._cachedVertexArrayObject = vertexArrayObject;\n            this._gl.bindVertexArray(vertexArrayObject);\n            this._cachedVertexBuffers = null;\n            this._cachedIndexBuffer = null;\n            this._uintIndicesCurrentlySet = indexBuffer != null && indexBuffer.is32Bits;\n            this._mustWipeVertexAttributes = true;\n        }\n    }\n    /**\n     * Bind webGl buffers directly to the webGL context\n     * @param vertexBuffer defines the vertex buffer to bind\n     * @param indexBuffer defines the index buffer to bind\n     * @param vertexDeclaration defines the vertex declaration to use with the vertex buffer\n     * @param vertexStrideSize defines the vertex stride of the vertex buffer\n     * @param effect defines the effect associated with the vertex buffer\n     */\n    bindBuffersDirectly(vertexBuffer, indexBuffer, vertexDeclaration, vertexStrideSize, effect) {\n        if (this._cachedVertexBuffers !== vertexBuffer || this._cachedEffectForVertexBuffers !== effect) {\n            this._cachedVertexBuffers = vertexBuffer;\n            this._cachedEffectForVertexBuffers = effect;\n            const attributesCount = effect.getAttributesCount();\n            this._unbindVertexArrayObject();\n            this.unbindAllAttributes();\n            let offset = 0;\n            for (let index = 0; index < attributesCount; index++) {\n                if (index < vertexDeclaration.length) {\n                    const order = effect.getAttributeLocation(index);\n                    if (order >= 0) {\n                        this._gl.enableVertexAttribArray(order);\n                        this._vertexAttribArraysEnabled[order] = true;\n                        this._vertexAttribPointer(vertexBuffer, order, vertexDeclaration[index], this._gl.FLOAT, false, vertexStrideSize, offset);\n                    }\n                    offset += vertexDeclaration[index] * 4;\n                }\n            }\n        }\n        this._bindIndexBufferWithCache(indexBuffer);\n    }\n    _unbindVertexArrayObject() {\n        if (!this._cachedVertexArrayObject) {\n            return;\n        }\n        this._cachedVertexArrayObject = null;\n        this._gl.bindVertexArray(null);\n    }\n    /**\n     * Bind a list of vertex buffers to the webGL context\n     * @param vertexBuffers defines the list of vertex buffers to bind\n     * @param indexBuffer defines the index buffer to bind\n     * @param effect defines the effect associated with the vertex buffers\n     * @param overrideVertexBuffers defines optional list of avertex buffers that overrides the entries in vertexBuffers\n     */\n    bindBuffers(vertexBuffers, indexBuffer, effect, overrideVertexBuffers) {\n        if (this._cachedVertexBuffers !== vertexBuffers || this._cachedEffectForVertexBuffers !== effect) {\n            this._cachedVertexBuffers = vertexBuffers;\n            this._cachedEffectForVertexBuffers = effect;\n            this._bindVertexBuffersAttributes(vertexBuffers, effect, overrideVertexBuffers);\n        }\n        this._bindIndexBufferWithCache(indexBuffer);\n    }\n    /**\n     * Unbind all instance attributes\n     */\n    unbindInstanceAttributes() {\n        let boundBuffer;\n        for (let i = 0, ul = this._currentInstanceLocations.length; i < ul; i++) {\n            const instancesBuffer = this._currentInstanceBuffers[i];\n            if (boundBuffer != instancesBuffer && instancesBuffer.references) {\n                boundBuffer = instancesBuffer;\n                this.bindArrayBuffer(instancesBuffer);\n            }\n            const offsetLocation = this._currentInstanceLocations[i];\n            this._gl.vertexAttribDivisor(offsetLocation, 0);\n        }\n        this._currentInstanceBuffers.length = 0;\n        this._currentInstanceLocations.length = 0;\n    }\n    /**\n     * Release and free the memory of a vertex array object\n     * @param vao defines the vertex array object to delete\n     */\n    releaseVertexArrayObject(vao) {\n        this._gl.deleteVertexArray(vao);\n    }\n    /**\n     * @internal\n     */\n    _releaseBuffer(buffer) {\n        buffer.references--;\n        if (buffer.references === 0) {\n            this._deleteBuffer(buffer);\n            return true;\n        }\n        return false;\n    }\n    _deleteBuffer(buffer) {\n        this._gl.deleteBuffer(buffer.underlyingResource);\n    }\n    /**\n     * Update the content of a webGL buffer used with instantiation and bind it to the webGL context\n     * @param instancesBuffer defines the webGL buffer to update and bind\n     * @param data defines the data to store in the buffer\n     * @param offsetLocations defines the offsets or attributes information used to determine where data must be stored in the buffer\n     */\n    updateAndBindInstancesBuffer(instancesBuffer, data, offsetLocations) {\n        this.bindArrayBuffer(instancesBuffer);\n        if (data) {\n            this._gl.bufferSubData(this._gl.ARRAY_BUFFER, 0, data);\n        }\n        if (offsetLocations[0].index !== undefined) {\n            this.bindInstancesBuffer(instancesBuffer, offsetLocations, true);\n        }\n        else {\n            for (let index = 0; index < 4; index++) {\n                const offsetLocation = offsetLocations[index];\n                if (!this._vertexAttribArraysEnabled[offsetLocation]) {\n                    this._gl.enableVertexAttribArray(offsetLocation);\n                    this._vertexAttribArraysEnabled[offsetLocation] = true;\n                }\n                this._vertexAttribPointer(instancesBuffer, offsetLocation, 4, this._gl.FLOAT, false, 64, index * 16);\n                this._gl.vertexAttribDivisor(offsetLocation, 1);\n                this._currentInstanceLocations.push(offsetLocation);\n                this._currentInstanceBuffers.push(instancesBuffer);\n            }\n        }\n    }\n    /**\n     * Bind the content of a webGL buffer used with instantiation\n     * @param instancesBuffer defines the webGL buffer to bind\n     * @param attributesInfo defines the offsets or attributes information used to determine where data must be stored in the buffer\n     * @param computeStride defines Whether to compute the strides from the info or use the default 0\n     */\n    bindInstancesBuffer(instancesBuffer, attributesInfo, computeStride = true) {\n        this.bindArrayBuffer(instancesBuffer);\n        let stride = 0;\n        if (computeStride) {\n            for (let i = 0; i < attributesInfo.length; i++) {\n                const ai = attributesInfo[i];\n                stride += ai.attributeSize * 4;\n            }\n        }\n        for (let i = 0; i < attributesInfo.length; i++) {\n            const ai = attributesInfo[i];\n            if (ai.index === undefined) {\n                ai.index = this._currentEffect.getAttributeLocationByName(ai.attributeName);\n            }\n            if (ai.index < 0) {\n                continue;\n            }\n            if (!this._vertexAttribArraysEnabled[ai.index]) {\n                this._gl.enableVertexAttribArray(ai.index);\n                this._vertexAttribArraysEnabled[ai.index] = true;\n            }\n            this._vertexAttribPointer(instancesBuffer, ai.index, ai.attributeSize, ai.attributeType || this._gl.FLOAT, ai.normalized || false, stride, ai.offset);\n            this._gl.vertexAttribDivisor(ai.index, ai.divisor === undefined ? 1 : ai.divisor);\n            this._currentInstanceLocations.push(ai.index);\n            this._currentInstanceBuffers.push(instancesBuffer);\n        }\n    }\n    /**\n     * Disable the instance attribute corresponding to the name in parameter\n     * @param name defines the name of the attribute to disable\n     */\n    disableInstanceAttributeByName(name) {\n        if (!this._currentEffect) {\n            return;\n        }\n        const attributeLocation = this._currentEffect.getAttributeLocationByName(name);\n        this.disableInstanceAttribute(attributeLocation);\n    }\n    /**\n     * Disable the instance attribute corresponding to the location in parameter\n     * @param attributeLocation defines the attribute location of the attribute to disable\n     */\n    disableInstanceAttribute(attributeLocation) {\n        let shouldClean = false;\n        let index;\n        while ((index = this._currentInstanceLocations.indexOf(attributeLocation)) !== -1) {\n            this._currentInstanceLocations.splice(index, 1);\n            this._currentInstanceBuffers.splice(index, 1);\n            shouldClean = true;\n            index = this._currentInstanceLocations.indexOf(attributeLocation);\n        }\n        if (shouldClean) {\n            this._gl.vertexAttribDivisor(attributeLocation, 0);\n            this.disableAttributeByIndex(attributeLocation);\n        }\n    }\n    /**\n     * Disable the attribute corresponding to the location in parameter\n     * @param attributeLocation defines the attribute location of the attribute to disable\n     */\n    disableAttributeByIndex(attributeLocation) {\n        this._gl.disableVertexAttribArray(attributeLocation);\n        this._vertexAttribArraysEnabled[attributeLocation] = false;\n        this._currentBufferPointers[attributeLocation].active = false;\n    }\n    /**\n     * Send a draw order\n     * @param useTriangles defines if triangles must be used to draw (else wireframe will be used)\n     * @param indexStart defines the starting index\n     * @param indexCount defines the number of index to draw\n     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)\n     */\n    draw(useTriangles, indexStart, indexCount, instancesCount) {\n        this.drawElementsType(useTriangles ? 0 : 1, indexStart, indexCount, instancesCount);\n    }\n    /**\n     * Draw a list of points\n     * @param verticesStart defines the index of first vertex to draw\n     * @param verticesCount defines the count of vertices to draw\n     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)\n     */\n    drawPointClouds(verticesStart, verticesCount, instancesCount) {\n        this.drawArraysType(2, verticesStart, verticesCount, instancesCount);\n    }\n    /**\n     * Draw a list of unindexed primitives\n     * @param useTriangles defines if triangles must be used to draw (else wireframe will be used)\n     * @param verticesStart defines the index of first vertex to draw\n     * @param verticesCount defines the count of vertices to draw\n     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)\n     */\n    drawUnIndexed(useTriangles, verticesStart, verticesCount, instancesCount) {\n        this.drawArraysType(useTriangles ? 0 : 1, verticesStart, verticesCount, instancesCount);\n    }\n    /**\n     * Draw a list of indexed primitives\n     * @param fillMode defines the primitive to use\n     * @param indexStart defines the starting index\n     * @param indexCount defines the number of index to draw\n     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)\n     */\n    drawElementsType(fillMode, indexStart, indexCount, instancesCount) {\n        // Apply states\n        this.applyStates();\n        this._reportDrawCall();\n        // Render\n        const drawMode = this._drawMode(fillMode);\n        const indexFormat = this._uintIndicesCurrentlySet ? this._gl.UNSIGNED_INT : this._gl.UNSIGNED_SHORT;\n        const mult = this._uintIndicesCurrentlySet ? 4 : 2;\n        if (instancesCount) {\n            this._gl.drawElementsInstanced(drawMode, indexCount, indexFormat, indexStart * mult, instancesCount);\n        }\n        else {\n            this._gl.drawElements(drawMode, indexCount, indexFormat, indexStart * mult);\n        }\n    }\n    /**\n     * Draw a list of unindexed primitives\n     * @param fillMode defines the primitive to use\n     * @param verticesStart defines the index of first vertex to draw\n     * @param verticesCount defines the count of vertices to draw\n     * @param instancesCount defines the number of instances to draw (if instantiation is enabled)\n     */\n    drawArraysType(fillMode, verticesStart, verticesCount, instancesCount) {\n        // Apply states\n        this.applyStates();\n        this._reportDrawCall();\n        const drawMode = this._drawMode(fillMode);\n        if (instancesCount) {\n            this._gl.drawArraysInstanced(drawMode, verticesStart, verticesCount, instancesCount);\n        }\n        else {\n            this._gl.drawArrays(drawMode, verticesStart, verticesCount);\n        }\n    }\n    _drawMode(fillMode) {\n        switch (fillMode) {\n            // Triangle views\n            case 0:\n                return this._gl.TRIANGLES;\n            case 2:\n                return this._gl.POINTS;\n            case 1:\n                return this._gl.LINES;\n            // Draw modes\n            case 3:\n                return this._gl.POINTS;\n            case 4:\n                return this._gl.LINES;\n            case 5:\n                return this._gl.LINE_LOOP;\n            case 6:\n                return this._gl.LINE_STRIP;\n            case 7:\n                return this._gl.TRIANGLE_STRIP;\n            case 8:\n                return this._gl.TRIANGLE_FAN;\n            default:\n                return this._gl.TRIANGLES;\n        }\n    }\n    /** @internal */\n    _reportDrawCall() {\n        // Will be implemented by children\n    }\n    // Shaders\n    /**\n     * @internal\n     */\n    _releaseEffect(effect) {\n        if (this._compiledEffects[effect._key]) {\n            delete this._compiledEffects[effect._key];\n        }\n        const pipelineContext = effect.getPipelineContext();\n        if (pipelineContext) {\n            this._deletePipelineContext(pipelineContext);\n        }\n    }\n    /**\n     * @internal\n     */\n    _deletePipelineContext(pipelineContext) {\n        const webGLPipelineContext = pipelineContext;\n        if (webGLPipelineContext && webGLPipelineContext.program) {\n            webGLPipelineContext.program.__SPECTOR_rebuildProgram = null;\n            this._gl.deleteProgram(webGLPipelineContext.program);\n        }\n    }\n    /** @internal */\n    _getGlobalDefines(defines) {\n        if (defines) {\n            if (this.isNDCHalfZRange) {\n                defines[\"IS_NDC_HALF_ZRANGE\"] = \"\";\n            }\n            else {\n                delete defines[\"IS_NDC_HALF_ZRANGE\"];\n            }\n            if (this.useReverseDepthBuffer) {\n                defines[\"USE_REVERSE_DEPTHBUFFER\"] = \"\";\n            }\n            else {\n                delete defines[\"USE_REVERSE_DEPTHBUFFER\"];\n            }\n            if (this.useExactSrgbConversions) {\n                defines[\"USE_EXACT_SRGB_CONVERSIONS\"] = \"\";\n            }\n            else {\n                delete defines[\"USE_EXACT_SRGB_CONVERSIONS\"];\n            }\n            return;\n        }\n        else {\n            let s = \"\";\n            if (this.isNDCHalfZRange) {\n                s += \"#define IS_NDC_HALF_ZRANGE\";\n            }\n            if (this.useReverseDepthBuffer) {\n                if (s) {\n                    s += \"\\n\";\n                }\n                s += \"#define USE_REVERSE_DEPTHBUFFER\";\n            }\n            if (this.useExactSrgbConversions) {\n                if (s) {\n                    s += \"\\n\";\n                }\n                s += \"#define USE_EXACT_SRGB_CONVERSIONS\";\n            }\n            return s;\n        }\n    }\n    /**\n     * Create a new effect (used to store vertex/fragment shaders)\n     * @param baseName defines the base name of the effect (The name of file without .fragment.fx or .vertex.fx)\n     * @param attributesNamesOrOptions defines either a list of attribute names or an IEffectCreationOptions object\n     * @param uniformsNamesOrEngine defines either a list of uniform names or the engine to use\n     * @param samplers defines an array of string used to represent textures\n     * @param defines defines the string containing the defines to use to compile the shaders\n     * @param fallbacks defines the list of potential fallbacks to use if shader compilation fails\n     * @param onCompiled defines a function to call when the effect creation is successful\n     * @param onError defines a function to call when the effect creation has failed\n     * @param indexParameters defines an object containing the index values to use to compile shaders (like the maximum number of simultaneous lights)\n     * @param shaderLanguage the language the shader is written in (default: GLSL)\n     * @returns the new Effect\n     */\n    createEffect(baseName, attributesNamesOrOptions, uniformsNamesOrEngine, samplers, defines, fallbacks, onCompiled, onError, indexParameters, shaderLanguage = ShaderLanguage.GLSL) {\n        var _a;\n        const vertex = baseName.vertexElement || baseName.vertex || baseName.vertexToken || baseName.vertexSource || baseName;\n        const fragment = baseName.fragmentElement || baseName.fragment || baseName.fragmentToken || baseName.fragmentSource || baseName;\n        const globalDefines = this._getGlobalDefines();\n        let fullDefines = (_a = defines !== null && defines !== void 0 ? defines : attributesNamesOrOptions.defines) !== null && _a !== void 0 ? _a : \"\";\n        if (globalDefines) {\n            fullDefines += globalDefines;\n        }\n        const name = vertex + \"+\" + fragment + \"@\" + fullDefines;\n        if (this._compiledEffects[name]) {\n            const compiledEffect = this._compiledEffects[name];\n            if (onCompiled && compiledEffect.isReady()) {\n                onCompiled(compiledEffect);\n            }\n            return compiledEffect;\n        }\n        const effect = new Effect(baseName, attributesNamesOrOptions, uniformsNamesOrEngine, samplers, this, defines, fallbacks, onCompiled, onError, indexParameters, name, shaderLanguage);\n        this._compiledEffects[name] = effect;\n        return effect;\n    }\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    static _ConcatenateShader(source, defines, shaderVersion = \"\") {\n        return shaderVersion + (defines ? defines + \"\\n\" : \"\") + source;\n    }\n    _compileShader(source, type, defines, shaderVersion) {\n        return this._compileRawShader(ThinEngine._ConcatenateShader(source, defines, shaderVersion), type);\n    }\n    _compileRawShader(source, type) {\n        const gl = this._gl;\n        const shader = gl.createShader(type === \"vertex\" ? gl.VERTEX_SHADER : gl.FRAGMENT_SHADER);\n        if (!shader) {\n            let error = gl.NO_ERROR;\n            let tempError = gl.NO_ERROR;\n            while ((tempError = gl.getError()) !== gl.NO_ERROR) {\n                error = tempError;\n            }\n            throw new Error(`Something went wrong while creating a gl ${type} shader object. gl error=${error}, gl isContextLost=${gl.isContextLost()}, _contextWasLost=${this._contextWasLost}`);\n        }\n        gl.shaderSource(shader, source);\n        gl.compileShader(shader);\n        return shader;\n    }\n    /**\n     * @internal\n     */\n    _getShaderSource(shader) {\n        return this._gl.getShaderSource(shader);\n    }\n    /**\n     * Directly creates a webGL program\n     * @param pipelineContext  defines the pipeline context to attach to\n     * @param vertexCode defines the vertex shader code to use\n     * @param fragmentCode defines the fragment shader code to use\n     * @param context defines the webGL context to use (if not set, the current one will be used)\n     * @param transformFeedbackVaryings defines the list of transform feedback varyings to use\n     * @returns the new webGL program\n     */\n    createRawShaderProgram(pipelineContext, vertexCode, fragmentCode, context, transformFeedbackVaryings = null) {\n        context = context || this._gl;\n        const vertexShader = this._compileRawShader(vertexCode, \"vertex\");\n        const fragmentShader = this._compileRawShader(fragmentCode, \"fragment\");\n        return this._createShaderProgram(pipelineContext, vertexShader, fragmentShader, context, transformFeedbackVaryings);\n    }\n    /**\n     * Creates a webGL program\n     * @param pipelineContext  defines the pipeline context to attach to\n     * @param vertexCode  defines the vertex shader code to use\n     * @param fragmentCode defines the fragment shader code to use\n     * @param defines defines the string containing the defines to use to compile the shaders\n     * @param context defines the webGL context to use (if not set, the current one will be used)\n     * @param transformFeedbackVaryings defines the list of transform feedback varyings to use\n     * @returns the new webGL program\n     */\n    createShaderProgram(pipelineContext, vertexCode, fragmentCode, defines, context, transformFeedbackVaryings = null) {\n        context = context || this._gl;\n        const shaderVersion = this._webGLVersion > 1 ? \"#version 300 es\\n#define WEBGL2 \\n\" : \"\";\n        const vertexShader = this._compileShader(vertexCode, \"vertex\", defines, shaderVersion);\n        const fragmentShader = this._compileShader(fragmentCode, \"fragment\", defines, shaderVersion);\n        return this._createShaderProgram(pipelineContext, vertexShader, fragmentShader, context, transformFeedbackVaryings);\n    }\n    /**\n     * Inline functions in shader code that are marked to be inlined\n     * @param code code to inline\n     * @returns inlined code\n     */\n    inlineShaderCode(code) {\n        // no inlining needed in the WebGL engine\n        return code;\n    }\n    /**\n     * Creates a new pipeline context\n     * @param shaderProcessingContext defines the shader processing context used during the processing if available\n     * @returns the new pipeline\n     */\n    createPipelineContext(shaderProcessingContext) {\n        const pipelineContext = new WebGLPipelineContext();\n        pipelineContext.engine = this;\n        if (this._caps.parallelShaderCompile) {\n            pipelineContext.isParallelCompiled = true;\n        }\n        return pipelineContext;\n    }\n    /**\n     * Creates a new material context\n     * @returns the new context\n     */\n    createMaterialContext() {\n        return undefined;\n    }\n    /**\n     * Creates a new draw context\n     * @returns the new context\n     */\n    createDrawContext() {\n        return undefined;\n    }\n    _createShaderProgram(pipelineContext, vertexShader, fragmentShader, context, transformFeedbackVaryings = null) {\n        const shaderProgram = context.createProgram();\n        pipelineContext.program = shaderProgram;\n        if (!shaderProgram) {\n            throw new Error(\"Unable to create program\");\n        }\n        context.attachShader(shaderProgram, vertexShader);\n        context.attachShader(shaderProgram, fragmentShader);\n        context.linkProgram(shaderProgram);\n        pipelineContext.context = context;\n        pipelineContext.vertexShader = vertexShader;\n        pipelineContext.fragmentShader = fragmentShader;\n        if (!pipelineContext.isParallelCompiled) {\n            this._finalizePipelineContext(pipelineContext);\n        }\n        return shaderProgram;\n    }\n    _finalizePipelineContext(pipelineContext) {\n        const context = pipelineContext.context;\n        const vertexShader = pipelineContext.vertexShader;\n        const fragmentShader = pipelineContext.fragmentShader;\n        const program = pipelineContext.program;\n        const linked = context.getProgramParameter(program, context.LINK_STATUS);\n        if (!linked) {\n            // Get more info\n            // Vertex\n            if (!this._gl.getShaderParameter(vertexShader, this._gl.COMPILE_STATUS)) {\n                const log = this._gl.getShaderInfoLog(vertexShader);\n                if (log) {\n                    pipelineContext.vertexCompilationError = log;\n                    throw new Error(\"VERTEX SHADER \" + log);\n                }\n            }\n            // Fragment\n            if (!this._gl.getShaderParameter(fragmentShader, this._gl.COMPILE_STATUS)) {\n                const log = this._gl.getShaderInfoLog(fragmentShader);\n                if (log) {\n                    pipelineContext.fragmentCompilationError = log;\n                    throw new Error(\"FRAGMENT SHADER \" + log);\n                }\n            }\n            const error = context.getProgramInfoLog(program);\n            if (error) {\n                pipelineContext.programLinkError = error;\n                throw new Error(error);\n            }\n        }\n        if (this.validateShaderPrograms) {\n            context.validateProgram(program);\n            const validated = context.getProgramParameter(program, context.VALIDATE_STATUS);\n            if (!validated) {\n                const error = context.getProgramInfoLog(program);\n                if (error) {\n                    pipelineContext.programValidationError = error;\n                    throw new Error(error);\n                }\n            }\n        }\n        context.deleteShader(vertexShader);\n        context.deleteShader(fragmentShader);\n        pipelineContext.vertexShader = undefined;\n        pipelineContext.fragmentShader = undefined;\n        if (pipelineContext.onCompiled) {\n            pipelineContext.onCompiled();\n            pipelineContext.onCompiled = undefined;\n        }\n    }\n    /**\n     * @internal\n     */\n    _preparePipelineContext(pipelineContext, vertexSourceCode, fragmentSourceCode, createAsRaw, rawVertexSourceCode, rawFragmentSourceCode, rebuildRebind, defines, transformFeedbackVaryings, key) {\n        const webGLRenderingState = pipelineContext;\n        if (createAsRaw) {\n            webGLRenderingState.program = this.createRawShaderProgram(webGLRenderingState, vertexSourceCode, fragmentSourceCode, undefined, transformFeedbackVaryings);\n        }\n        else {\n            webGLRenderingState.program = this.createShaderProgram(webGLRenderingState, vertexSourceCode, fragmentSourceCode, defines, undefined, transformFeedbackVaryings);\n        }\n        webGLRenderingState.program.__SPECTOR_rebuildProgram = rebuildRebind;\n    }\n    /**\n     * @internal\n     */\n    _isRenderingStateCompiled(pipelineContext) {\n        const webGLPipelineContext = pipelineContext;\n        if (this._gl.getProgramParameter(webGLPipelineContext.program, this._caps.parallelShaderCompile.COMPLETION_STATUS_KHR)) {\n            this._finalizePipelineContext(webGLPipelineContext);\n            return true;\n        }\n        return false;\n    }\n    /**\n     * @internal\n     */\n    _executeWhenRenderingStateIsCompiled(pipelineContext, action) {\n        const webGLPipelineContext = pipelineContext;\n        if (!webGLPipelineContext.isParallelCompiled) {\n            action();\n            return;\n        }\n        const oldHandler = webGLPipelineContext.onCompiled;\n        if (oldHandler) {\n            webGLPipelineContext.onCompiled = () => {\n                oldHandler();\n                action();\n            };\n        }\n        else {\n            webGLPipelineContext.onCompiled = action;\n        }\n    }\n    /**\n     * Gets the list of webGL uniform locations associated with a specific program based on a list of uniform names\n     * @param pipelineContext defines the pipeline context to use\n     * @param uniformsNames defines the list of uniform names\n     * @returns an array of webGL uniform locations\n     */\n    getUniforms(pipelineContext, uniformsNames) {\n        const results = new Array();\n        const webGLPipelineContext = pipelineContext;\n        for (let index = 0; index < uniformsNames.length; index++) {\n            results.push(this._gl.getUniformLocation(webGLPipelineContext.program, uniformsNames[index]));\n        }\n        return results;\n    }\n    /**\n     * Gets the list of active attributes for a given webGL program\n     * @param pipelineContext defines the pipeline context to use\n     * @param attributesNames defines the list of attribute names to get\n     * @returns an array of indices indicating the offset of each attribute\n     */\n    getAttributes(pipelineContext, attributesNames) {\n        const results = [];\n        const webGLPipelineContext = pipelineContext;\n        for (let index = 0; index < attributesNames.length; index++) {\n            try {\n                results.push(this._gl.getAttribLocation(webGLPipelineContext.program, attributesNames[index]));\n            }\n            catch (e) {\n                results.push(-1);\n            }\n        }\n        return results;\n    }\n    /**\n     * Activates an effect, making it the current one (ie. the one used for rendering)\n     * @param effect defines the effect to activate\n     */\n    enableEffect(effect) {\n        effect = effect !== null && DrawWrapper.IsWrapper(effect) ? effect.effect : effect; // get only the effect, we don't need a Wrapper in the WebGL engine\n        if (!effect || effect === this._currentEffect) {\n            return;\n        }\n        this._stencilStateComposer.stencilMaterial = undefined;\n        effect = effect;\n        // Use program\n        this.bindSamplers(effect);\n        this._currentEffect = effect;\n        if (effect.onBind) {\n            effect.onBind(effect);\n        }\n        if (effect._onBindObservable) {\n            effect._onBindObservable.notifyObservers(effect);\n        }\n    }\n    /**\n     * Set the value of an uniform to a number (int)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param value defines the int number to store\n     * @returns true if the value was set\n     */\n    setInt(uniform, value) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform1i(uniform, value);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a int2\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @returns true if the value was set\n     */\n    setInt2(uniform, x, y) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform2i(uniform, x, y);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a int3\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @param z defines the 3rd component of the value\n     * @returns true if the value was set\n     */\n    setInt3(uniform, x, y, z) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform3i(uniform, x, y, z);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a int4\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @param z defines the 3rd component of the value\n     * @param w defines the 4th component of the value\n     * @returns true if the value was set\n     */\n    setInt4(uniform, x, y, z, w) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform4i(uniform, x, y, z, w);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of int32\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of int32 to store\n     * @returns true if the value was set\n     */\n    setIntArray(uniform, array) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform1iv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of int32 (stored as vec2)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of int32 to store\n     * @returns true if the value was set\n     */\n    setIntArray2(uniform, array) {\n        if (!uniform || array.length % 2 !== 0) {\n            return false;\n        }\n        this._gl.uniform2iv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of int32 (stored as vec3)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of int32 to store\n     * @returns true if the value was set\n     */\n    setIntArray3(uniform, array) {\n        if (!uniform || array.length % 3 !== 0) {\n            return false;\n        }\n        this._gl.uniform3iv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of int32 (stored as vec4)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of int32 to store\n     * @returns true if the value was set\n     */\n    setIntArray4(uniform, array) {\n        if (!uniform || array.length % 4 !== 0) {\n            return false;\n        }\n        this._gl.uniform4iv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a number (unsigned int)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param value defines the unsigned int number to store\n     * @returns true if the value was set\n     */\n    setUInt(uniform, value) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform1ui(uniform, value);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a unsigned int2\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @returns true if the value was set\n     */\n    setUInt2(uniform, x, y) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform2ui(uniform, x, y);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a unsigned int3\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @param z defines the 3rd component of the value\n     * @returns true if the value was set\n     */\n    setUInt3(uniform, x, y, z) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform3ui(uniform, x, y, z);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a unsigned int4\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @param z defines the 3rd component of the value\n     * @param w defines the 4th component of the value\n     * @returns true if the value was set\n     */\n    setUInt4(uniform, x, y, z, w) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform4ui(uniform, x, y, z, w);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of unsigned int32\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of unsigned int32 to store\n     * @returns true if the value was set\n     */\n    setUIntArray(uniform, array) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform1uiv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of unsigned int32 (stored as vec2)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of unsigned int32 to store\n     * @returns true if the value was set\n     */\n    setUIntArray2(uniform, array) {\n        if (!uniform || array.length % 2 !== 0) {\n            return false;\n        }\n        this._gl.uniform2uiv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of unsigned int32 (stored as vec3)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of unsigned int32 to store\n     * @returns true if the value was set\n     */\n    setUIntArray3(uniform, array) {\n        if (!uniform || array.length % 3 !== 0) {\n            return false;\n        }\n        this._gl.uniform3uiv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of unsigned int32 (stored as vec4)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of unsigned int32 to store\n     * @returns true if the value was set\n     */\n    setUIntArray4(uniform, array) {\n        if (!uniform || array.length % 4 !== 0) {\n            return false;\n        }\n        this._gl.uniform4uiv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of number\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of number to store\n     * @returns true if the value was set\n     */\n    setArray(uniform, array) {\n        if (!uniform) {\n            return false;\n        }\n        if (array.length < 1) {\n            return false;\n        }\n        this._gl.uniform1fv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of number (stored as vec2)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of number to store\n     * @returns true if the value was set\n     */\n    setArray2(uniform, array) {\n        if (!uniform || array.length % 2 !== 0) {\n            return false;\n        }\n        this._gl.uniform2fv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of number (stored as vec3)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of number to store\n     * @returns true if the value was set\n     */\n    setArray3(uniform, array) {\n        if (!uniform || array.length % 3 !== 0) {\n            return false;\n        }\n        this._gl.uniform3fv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of number (stored as vec4)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param array defines the array of number to store\n     * @returns true if the value was set\n     */\n    setArray4(uniform, array) {\n        if (!uniform || array.length % 4 !== 0) {\n            return false;\n        }\n        this._gl.uniform4fv(uniform, array);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to an array of float32 (stored as matrices)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param matrices defines the array of float32 to store\n     * @returns true if the value was set\n     */\n    setMatrices(uniform, matrices) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniformMatrix4fv(uniform, false, matrices);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a matrix (3x3)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param matrix defines the Float32Array representing the 3x3 matrix to store\n     * @returns true if the value was set\n     */\n    setMatrix3x3(uniform, matrix) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniformMatrix3fv(uniform, false, matrix);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a matrix (2x2)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param matrix defines the Float32Array representing the 2x2 matrix to store\n     * @returns true if the value was set\n     */\n    setMatrix2x2(uniform, matrix) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniformMatrix2fv(uniform, false, matrix);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a number (float)\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param value defines the float number to store\n     * @returns true if the value was transferred\n     */\n    setFloat(uniform, value) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform1f(uniform, value);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a vec2\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @returns true if the value was set\n     */\n    setFloat2(uniform, x, y) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform2f(uniform, x, y);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a vec3\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @param z defines the 3rd component of the value\n     * @returns true if the value was set\n     */\n    setFloat3(uniform, x, y, z) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform3f(uniform, x, y, z);\n        return true;\n    }\n    /**\n     * Set the value of an uniform to a vec4\n     * @param uniform defines the webGL uniform location where to store the value\n     * @param x defines the 1st component of the value\n     * @param y defines the 2nd component of the value\n     * @param z defines the 3rd component of the value\n     * @param w defines the 4th component of the value\n     * @returns true if the value was set\n     */\n    setFloat4(uniform, x, y, z, w) {\n        if (!uniform) {\n            return false;\n        }\n        this._gl.uniform4f(uniform, x, y, z, w);\n        return true;\n    }\n    // States\n    /**\n     * Apply all cached states (depth, culling, stencil and alpha)\n     */\n    applyStates() {\n        this._depthCullingState.apply(this._gl);\n        this._stencilStateComposer.apply(this._gl);\n        this._alphaState.apply(this._gl);\n        if (this._colorWriteChanged) {\n            this._colorWriteChanged = false;\n            const enable = this._colorWrite;\n            this._gl.colorMask(enable, enable, enable, enable);\n        }\n    }\n    /**\n     * Enable or disable color writing\n     * @param enable defines the state to set\n     */\n    setColorWrite(enable) {\n        if (enable !== this._colorWrite) {\n            this._colorWriteChanged = true;\n            this._colorWrite = enable;\n        }\n    }\n    /**\n     * Gets a boolean indicating if color writing is enabled\n     * @returns the current color writing state\n     */\n    getColorWrite() {\n        return this._colorWrite;\n    }\n    /**\n     * Gets the depth culling state manager\n     */\n    get depthCullingState() {\n        return this._depthCullingState;\n    }\n    /**\n     * Gets the alpha state manager\n     */\n    get alphaState() {\n        return this._alphaState;\n    }\n    /**\n     * Gets the stencil state manager\n     */\n    get stencilState() {\n        return this._stencilState;\n    }\n    /**\n     * Gets the stencil state composer\n     */\n    get stencilStateComposer() {\n        return this._stencilStateComposer;\n    }\n    // Textures\n    /**\n     * Clears the list of texture accessible through engine.\n     * This can help preventing texture load conflict due to name collision.\n     */\n    clearInternalTexturesCache() {\n        this._internalTexturesCache.length = 0;\n    }\n    /**\n     * Force the entire cache to be cleared\n     * You should not have to use this function unless your engine needs to share the webGL context with another engine\n     * @param bruteForce defines a boolean to force clearing ALL caches (including stencil, detoh and alpha states)\n     */\n    wipeCaches(bruteForce) {\n        if (this.preventCacheWipeBetweenFrames && !bruteForce) {\n            return;\n        }\n        this._currentEffect = null;\n        this._viewportCached.x = 0;\n        this._viewportCached.y = 0;\n        this._viewportCached.z = 0;\n        this._viewportCached.w = 0;\n        // Done before in case we clean the attributes\n        this._unbindVertexArrayObject();\n        if (bruteForce) {\n            this._currentProgram = null;\n            this.resetTextureCache();\n            this._stencilStateComposer.reset();\n            this._depthCullingState.reset();\n            this._depthCullingState.depthFunc = this._gl.LEQUAL;\n            this._alphaState.reset();\n            this._alphaMode = 1;\n            this._alphaEquation = 0;\n            this._colorWrite = true;\n            this._colorWriteChanged = true;\n            this._unpackFlipYCached = null;\n            this._gl.pixelStorei(this._gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, this._gl.NONE);\n            this._gl.pixelStorei(this._gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, 0);\n            this._mustWipeVertexAttributes = true;\n            this.unbindAllAttributes();\n        }\n        this._resetVertexBufferBinding();\n        this._cachedIndexBuffer = null;\n        this._cachedEffectForVertexBuffers = null;\n        this.bindIndexBuffer(null);\n    }\n    /**\n     * @internal\n     */\n    _getSamplingParameters(samplingMode, generateMipMaps) {\n        const gl = this._gl;\n        let magFilter = gl.NEAREST;\n        let minFilter = gl.NEAREST;\n        switch (samplingMode) {\n            case 11:\n                magFilter = gl.LINEAR;\n                if (generateMipMaps) {\n                    minFilter = gl.LINEAR_MIPMAP_NEAREST;\n                }\n                else {\n                    minFilter = gl.LINEAR;\n                }\n                break;\n            case 3:\n                magFilter = gl.LINEAR;\n                if (generateMipMaps) {\n                    minFilter = gl.LINEAR_MIPMAP_LINEAR;\n                }\n                else {\n                    minFilter = gl.LINEAR;\n                }\n                break;\n            case 8:\n                magFilter = gl.NEAREST;\n                if (generateMipMaps) {\n                    minFilter = gl.NEAREST_MIPMAP_LINEAR;\n                }\n                else {\n                    minFilter = gl.NEAREST;\n                }\n                break;\n            case 4:\n                magFilter = gl.NEAREST;\n                if (generateMipMaps) {\n                    minFilter = gl.NEAREST_MIPMAP_NEAREST;\n                }\n                else {\n                    minFilter = gl.NEAREST;\n                }\n                break;\n            case 5:\n                magFilter = gl.NEAREST;\n                if (generateMipMaps) {\n                    minFilter = gl.LINEAR_MIPMAP_NEAREST;\n                }\n                else {\n                    minFilter = gl.LINEAR;\n                }\n                break;\n            case 6:\n                magFilter = gl.NEAREST;\n                if (generateMipMaps) {\n                    minFilter = gl.LINEAR_MIPMAP_LINEAR;\n                }\n                else {\n                    minFilter = gl.LINEAR;\n                }\n                break;\n            case 7:\n                magFilter = gl.NEAREST;\n                minFilter = gl.LINEAR;\n                break;\n            case 1:\n                magFilter = gl.NEAREST;\n                minFilter = gl.NEAREST;\n                break;\n            case 9:\n                magFilter = gl.LINEAR;\n                if (generateMipMaps) {\n                    minFilter = gl.NEAREST_MIPMAP_NEAREST;\n                }\n                else {\n                    minFilter = gl.NEAREST;\n                }\n                break;\n            case 10:\n                magFilter = gl.LINEAR;\n                if (generateMipMaps) {\n                    minFilter = gl.NEAREST_MIPMAP_LINEAR;\n                }\n                else {\n                    minFilter = gl.NEAREST;\n                }\n                break;\n            case 2:\n                magFilter = gl.LINEAR;\n                minFilter = gl.LINEAR;\n                break;\n            case 12:\n                magFilter = gl.LINEAR;\n                minFilter = gl.NEAREST;\n                break;\n        }\n        return {\n            min: minFilter,\n            mag: magFilter,\n        };\n    }\n    /** @internal */\n    _createTexture() {\n        const texture = this._gl.createTexture();\n        if (!texture) {\n            throw new Error(\"Unable to create texture\");\n        }\n        return texture;\n    }\n    /** @internal */\n    _createHardwareTexture() {\n        return new WebGLHardwareTexture(this._createTexture(), this._gl);\n    }\n    /**\n     * Creates an internal texture without binding it to a framebuffer\n     * @internal\n     * @param size defines the size of the texture\n     * @param options defines the options used to create the texture\n     * @param delayGPUTextureCreation true to delay the texture creation the first time it is really needed. false to create it right away\n     * @param source source type of the texture\n     * @returns a new internal texture\n     */\n    _createInternalTexture(size, options, delayGPUTextureCreation = true, source = InternalTextureSource.Unknown) {\n        var _a;\n        let generateMipMaps = false;\n        let type = 0;\n        let samplingMode = 3;\n        let format = 5;\n        let useSRGBBuffer = false;\n        let samples = 1;\n        let label;\n        if (options !== undefined && typeof options === \"object\") {\n            generateMipMaps = !!options.generateMipMaps;\n            type = options.type === undefined ? 0 : options.type;\n            samplingMode = options.samplingMode === undefined ? 3 : options.samplingMode;\n            format = options.format === undefined ? 5 : options.format;\n            useSRGBBuffer = options.useSRGBBuffer === undefined ? false : options.useSRGBBuffer;\n            samples = (_a = options.samples) !== null && _a !== void 0 ? _a : 1;\n            label = options.label;\n        }\n        else {\n            generateMipMaps = !!options;\n        }\n        useSRGBBuffer && (useSRGBBuffer = this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU));\n        if (type === 1 && !this._caps.textureFloatLinearFiltering) {\n            // if floating point linear (gl.FLOAT) then force to NEAREST_SAMPLINGMODE\n            samplingMode = 1;\n        }\n        else if (type === 2 && !this._caps.textureHalfFloatLinearFiltering) {\n            // if floating point linear (HALF_FLOAT) then force to NEAREST_SAMPLINGMODE\n            samplingMode = 1;\n        }\n        if (type === 1 && !this._caps.textureFloat) {\n            type = 0;\n            Logger.Warn(\"Float textures are not supported. Type forced to TEXTURETYPE_UNSIGNED_BYTE\");\n        }\n        const gl = this._gl;\n        const texture = new InternalTexture(this, source);\n        const width = size.width || size;\n        const height = size.height || size;\n        const layers = size.layers || 0;\n        const filters = this._getSamplingParameters(samplingMode, generateMipMaps);\n        const target = layers !== 0 ? gl.TEXTURE_2D_ARRAY : gl.TEXTURE_2D;\n        const sizedFormat = this._getRGBABufferInternalSizedFormat(type, format, useSRGBBuffer);\n        const internalFormat = this._getInternalFormat(format);\n        const textureType = this._getWebGLTextureType(type);\n        // Bind\n        this._bindTextureDirectly(target, texture);\n        if (layers !== 0) {\n            texture.is2DArray = true;\n            gl.texImage3D(target, 0, sizedFormat, width, height, layers, 0, internalFormat, textureType, null);\n        }\n        else {\n            gl.texImage2D(target, 0, sizedFormat, width, height, 0, internalFormat, textureType, null);\n        }\n        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, filters.mag);\n        gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, filters.min);\n        gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n        gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n        // MipMaps\n        if (generateMipMaps) {\n            this._gl.generateMipmap(target);\n        }\n        this._bindTextureDirectly(target, null);\n        texture._useSRGBBuffer = useSRGBBuffer;\n        texture.baseWidth = width;\n        texture.baseHeight = height;\n        texture.width = width;\n        texture.height = height;\n        texture.depth = layers;\n        texture.isReady = true;\n        texture.samples = samples;\n        texture.generateMipMaps = generateMipMaps;\n        texture.samplingMode = samplingMode;\n        texture.type = type;\n        texture.format = format;\n        texture.label = label;\n        this._internalTexturesCache.push(texture);\n        return texture;\n    }\n    /**\n     * @internal\n     */\n    _getUseSRGBBuffer(useSRGBBuffer, noMipmap) {\n        // Generating mipmaps for sRGB textures is not supported in WebGL1 so we must disable the support if mipmaps is enabled\n        return useSRGBBuffer && this._caps.supportSRGBBuffers && (this.webGLVersion > 1 || this.isWebGPU || noMipmap);\n    }\n    _createTextureBase(url, noMipmap, invertY, scene, samplingMode = 3, onLoad = null, onError = null, prepareTexture, prepareTextureProcessFunction, buffer = null, fallback = null, format = null, forcedExtension = null, mimeType, loaderOptions, useSRGBBuffer) {\n        url = url || \"\";\n        const fromData = url.substr(0, 5) === \"data:\";\n        const fromBlob = url.substr(0, 5) === \"blob:\";\n        const isBase64 = fromData && url.indexOf(\";base64,\") !== -1;\n        const texture = fallback ? fallback : new InternalTexture(this, InternalTextureSource.Url);\n        if (texture !== fallback) {\n            texture.label = url.substring(0, 60); // default label, can be overriden by the caller\n        }\n        const originalUrl = url;\n        if (this._transformTextureUrl && !isBase64 && !fallback && !buffer) {\n            url = this._transformTextureUrl(url);\n        }\n        if (originalUrl !== url) {\n            texture._originalUrl = originalUrl;\n        }\n        // establish the file extension, if possible\n        const lastDot = url.lastIndexOf(\".\");\n        let extension = forcedExtension ? forcedExtension : lastDot > -1 ? url.substring(lastDot).toLowerCase() : \"\";\n        let loader = null;\n        // Remove query string\n        const queryStringIndex = extension.indexOf(\"?\");\n        if (queryStringIndex > -1) {\n            extension = extension.split(\"?\")[0];\n        }\n        for (const availableLoader of ThinEngine._TextureLoaders) {\n            if (availableLoader.canLoad(extension, mimeType)) {\n                loader = availableLoader;\n                break;\n            }\n        }\n        if (scene) {\n            scene.addPendingData(texture);\n        }\n        texture.url = url;\n        texture.generateMipMaps = !noMipmap;\n        texture.samplingMode = samplingMode;\n        texture.invertY = invertY;\n        texture._useSRGBBuffer = this._getUseSRGBBuffer(!!useSRGBBuffer, noMipmap);\n        if (!this._doNotHandleContextLost) {\n            // Keep a link to the buffer only if we plan to handle context lost\n            texture._buffer = buffer;\n        }\n        let onLoadObserver = null;\n        if (onLoad && !fallback) {\n            onLoadObserver = texture.onLoadedObservable.add(onLoad);\n        }\n        if (!fallback) {\n            this._internalTexturesCache.push(texture);\n        }\n        const onInternalError = (message, exception) => {\n            if (scene) {\n                scene.removePendingData(texture);\n            }\n            if (url === originalUrl) {\n                if (onLoadObserver) {\n                    texture.onLoadedObservable.remove(onLoadObserver);\n                }\n                if (EngineStore.UseFallbackTexture) {\n                    this._createTextureBase(EngineStore.FallbackTexture, noMipmap, texture.invertY, scene, samplingMode, null, onError, prepareTexture, prepareTextureProcessFunction, buffer, texture);\n                }\n                message = (message || \"Unknown error\") + (EngineStore.UseFallbackTexture ? \" - Fallback texture was used\" : \"\");\n                texture.onErrorObservable.notifyObservers({ message, exception });\n                if (onError) {\n                    onError(message, exception);\n                }\n            }\n            else {\n                // fall back to the original url if the transformed url fails to load\n                Logger.Warn(`Failed to load ${url}, falling back to ${originalUrl}`);\n                this._createTextureBase(originalUrl, noMipmap, texture.invertY, scene, samplingMode, onLoad, onError, prepareTexture, prepareTextureProcessFunction, buffer, texture, format, forcedExtension, mimeType, loaderOptions, useSRGBBuffer);\n            }\n        };\n        // processing for non-image formats\n        if (loader) {\n            const callback = (data) => {\n                loader.loadData(data, texture, (width, height, loadMipmap, isCompressed, done, loadFailed) => {\n                    if (loadFailed) {\n                        onInternalError(\"TextureLoader failed to load data\");\n                    }\n                    else {\n                        prepareTexture(texture, extension, scene, { width, height }, texture.invertY, !loadMipmap, isCompressed, () => {\n                            done();\n                            return false;\n                        }, samplingMode);\n                    }\n                }, loaderOptions);\n            };\n            if (!buffer) {\n                this._loadFile(url, (data) => callback(new Uint8Array(data)), undefined, scene ? scene.offlineProvider : undefined, true, (request, exception) => {\n                    onInternalError(\"Unable to load \" + (request ? request.responseURL : url, exception));\n                });\n            }\n            else {\n                if (buffer instanceof ArrayBuffer) {\n                    callback(new Uint8Array(buffer));\n                }\n                else if (ArrayBuffer.isView(buffer)) {\n                    callback(buffer);\n                }\n                else {\n                    if (onError) {\n                        onError(\"Unable to load: only ArrayBuffer or ArrayBufferView is supported\", null);\n                    }\n                }\n            }\n        }\n        else {\n            const onload = (img) => {\n                if (fromBlob && !this._doNotHandleContextLost) {\n                    // We need to store the image if we need to rebuild the texture\n                    // in case of a webgl context lost\n                    texture._buffer = img;\n                }\n                prepareTexture(texture, extension, scene, img, texture.invertY, noMipmap, false, prepareTextureProcessFunction, samplingMode);\n            };\n            // According to the WebGL spec section 6.10, ImageBitmaps must be inverted on creation.\n            // So, we pass imageOrientation to _FileToolsLoadImage() as it may create an ImageBitmap.\n            if (!fromData || isBase64) {\n                if (buffer && (typeof buffer.decoding === \"string\" || buffer.close)) {\n                    onload(buffer);\n                }\n                else {\n                    ThinEngine._FileToolsLoadImage(url, onload, onInternalError, scene ? scene.offlineProvider : null, mimeType, texture.invertY && this._features.needsInvertingBitmap ? { imageOrientation: \"flipY\" } : undefined);\n                }\n            }\n            else if (typeof buffer === \"string\" || buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer) || buffer instanceof Blob) {\n                ThinEngine._FileToolsLoadImage(buffer, onload, onInternalError, scene ? scene.offlineProvider : null, mimeType, texture.invertY && this._features.needsInvertingBitmap ? { imageOrientation: \"flipY\" } : undefined);\n            }\n            else if (buffer) {\n                onload(buffer);\n            }\n        }\n        return texture;\n    }\n    /**\n     * Usually called from Texture.ts.\n     * Passed information to create a WebGLTexture\n     * @param url defines a value which contains one of the following:\n     * * A conventional http URL, e.g. 'http://...' or 'file://...'\n     * * A base64 string of in-line texture data, e.g. 'data:image/jpg;base64,/...'\n     * * An indicator that data being passed using the buffer parameter, e.g. 'data:mytexture.jpg'\n     * @param noMipmap defines a boolean indicating that no mipmaps shall be generated.  Ignored for compressed textures.  They must be in the file\n     * @param invertY when true, image is flipped when loaded.  You probably want true. Certain compressed textures may invert this if their default is inverted (eg. ktx)\n     * @param scene needed for loading to the correct scene\n     * @param samplingMode mode with should be used sample / access the texture (Default: Texture.TRILINEAR_SAMPLINGMODE)\n     * @param onLoad optional callback to be called upon successful completion\n     * @param onError optional callback to be called upon failure\n     * @param buffer a source of a file previously fetched as either a base64 string, an ArrayBuffer (compressed or image format), HTMLImageElement (image format), or a Blob\n     * @param fallback an internal argument in case the function must be called again, due to etc1 not having alpha capabilities\n     * @param format internal format.  Default: RGB when extension is '.jpg' else RGBA.  Ignored for compressed textures\n     * @param forcedExtension defines the extension to use to pick the right loader\n     * @param mimeType defines an optional mime type\n     * @param loaderOptions options to be passed to the loader\n     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns a InternalTexture for assignment back into BABYLON.Texture\n     */\n    createTexture(url, noMipmap, invertY, scene, samplingMode = 3, onLoad = null, onError = null, buffer = null, fallback = null, format = null, forcedExtension = null, mimeType, loaderOptions, creationFlags, useSRGBBuffer) {\n        return this._createTextureBase(url, noMipmap, invertY, scene, samplingMode, onLoad, onError, this._prepareWebGLTexture.bind(this), (potWidth, potHeight, img, extension, texture, continuationCallback) => {\n            const gl = this._gl;\n            const isPot = img.width === potWidth && img.height === potHeight;\n            const internalFormat = format\n                ? this._getInternalFormat(format, texture._useSRGBBuffer)\n                : extension === \".jpg\" && !texture._useSRGBBuffer\n                    ? gl.RGB\n                    : texture._useSRGBBuffer\n                        ? this._glSRGBExtensionValues.SRGB8_ALPHA8\n                        : gl.RGBA;\n            let texelFormat = format ? this._getInternalFormat(format) : extension === \".jpg\" && !texture._useSRGBBuffer ? gl.RGB : gl.RGBA;\n            if (texture._useSRGBBuffer && this.webGLVersion === 1) {\n                texelFormat = internalFormat;\n            }\n            if (isPot) {\n                gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, texelFormat, gl.UNSIGNED_BYTE, img);\n                return false;\n            }\n            const maxTextureSize = this._caps.maxTextureSize;\n            if (img.width > maxTextureSize || img.height > maxTextureSize || !this._supportsHardwareTextureRescaling) {\n                this._prepareWorkingCanvas();\n                if (!this._workingCanvas || !this._workingContext) {\n                    return false;\n                }\n                this._workingCanvas.width = potWidth;\n                this._workingCanvas.height = potHeight;\n                this._workingContext.drawImage(img, 0, 0, img.width, img.height, 0, 0, potWidth, potHeight);\n                gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, texelFormat, gl.UNSIGNED_BYTE, this._workingCanvas);\n                texture.width = potWidth;\n                texture.height = potHeight;\n                return false;\n            }\n            else {\n                // Using shaders when possible to rescale because canvas.drawImage is lossy\n                const source = new InternalTexture(this, InternalTextureSource.Temp);\n                this._bindTextureDirectly(gl.TEXTURE_2D, source, true);\n                gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, texelFormat, gl.UNSIGNED_BYTE, img);\n                this._rescaleTexture(source, texture, scene, internalFormat, () => {\n                    this._releaseTexture(source);\n                    this._bindTextureDirectly(gl.TEXTURE_2D, texture, true);\n                    continuationCallback();\n                });\n            }\n            return true;\n        }, buffer, fallback, format, forcedExtension, mimeType, loaderOptions, useSRGBBuffer);\n    }\n    /**\n     * Loads an image as an HTMLImageElement.\n     * @param input url string, ArrayBuffer, or Blob to load\n     * @param onLoad callback called when the image successfully loads\n     * @param onError callback called when the image fails to load\n     * @param offlineProvider offline provider for caching\n     * @param mimeType optional mime type\n     * @param imageBitmapOptions optional the options to use when creating an ImageBitmap\n     * @returns the HTMLImageElement of the loaded image\n     * @internal\n     */\n    static _FileToolsLoadImage(input, onLoad, onError, offlineProvider, mimeType, imageBitmapOptions) {\n        throw _WarnImport(\"FileTools\");\n    }\n    /**\n     * @internal\n     */\n    _rescaleTexture(source, destination, scene, internalFormat, onComplete) { }\n    /**\n     * Creates a raw texture\n     * @param data defines the data to store in the texture\n     * @param width defines the width of the texture\n     * @param height defines the height of the texture\n     * @param format defines the format of the data\n     * @param generateMipMaps defines if the engine should generate the mip levels\n     * @param invertY defines if data must be stored with Y axis inverted\n     * @param samplingMode defines the required sampling mode (Texture.NEAREST_SAMPLINGMODE by default)\n     * @param compression defines the compression used (null by default)\n     * @param type defines the type fo the data (Engine.TEXTURETYPE_UNSIGNED_INT by default)\n     * @param creationFlags specific flags to use when creating the texture (1 for storage textures, for eg)\n     * @param useSRGBBuffer defines if the texture must be loaded in a sRGB GPU buffer (if supported by the GPU).\n     * @returns the raw texture inside an InternalTexture\n     */\n    createRawTexture(data, width, height, format, generateMipMaps, invertY, samplingMode, compression = null, type = 0, creationFlags = 0, useSRGBBuffer = false) {\n        throw _WarnImport(\"Engine.RawTexture\");\n    }\n    /**\n     * Creates a new raw cube texture\n     * @param data defines the array of data to use to create each face\n     * @param size defines the size of the textures\n     * @param format defines the format of the data\n     * @param type defines the type of the data (like Engine.TEXTURETYPE_UNSIGNED_INT)\n     * @param generateMipMaps  defines if the engine should generate the mip levels\n     * @param invertY defines if data must be stored with Y axis inverted\n     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)\n     * @param compression defines the compression used (null by default)\n     * @returns the cube texture as an InternalTexture\n     */\n    createRawCubeTexture(data, size, format, type, generateMipMaps, invertY, samplingMode, compression = null) {\n        throw _WarnImport(\"Engine.RawTexture\");\n    }\n    /**\n     * Creates a new raw 3D texture\n     * @param data defines the data used to create the texture\n     * @param width defines the width of the texture\n     * @param height defines the height of the texture\n     * @param depth defines the depth of the texture\n     * @param format defines the format of the texture\n     * @param generateMipMaps defines if the engine must generate mip levels\n     * @param invertY defines if data must be stored with Y axis inverted\n     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)\n     * @param compression defines the compressed used (can be null)\n     * @param textureType defines the compressed used (can be null)\n     * @returns a new raw 3D texture (stored in an InternalTexture)\n     */\n    createRawTexture3D(data, width, height, depth, format, generateMipMaps, invertY, samplingMode, compression = null, textureType = 0) {\n        throw _WarnImport(\"Engine.RawTexture\");\n    }\n    /**\n     * Creates a new raw 2D array texture\n     * @param data defines the data used to create the texture\n     * @param width defines the width of the texture\n     * @param height defines the height of the texture\n     * @param depth defines the number of layers of the texture\n     * @param format defines the format of the texture\n     * @param generateMipMaps defines if the engine must generate mip levels\n     * @param invertY defines if data must be stored with Y axis inverted\n     * @param samplingMode defines the required sampling mode (like Texture.NEAREST_SAMPLINGMODE)\n     * @param compression defines the compressed used (can be null)\n     * @param textureType defines the compressed used (can be null)\n     * @returns a new raw 2D array texture (stored in an InternalTexture)\n     */\n    createRawTexture2DArray(data, width, height, depth, format, generateMipMaps, invertY, samplingMode, compression = null, textureType = 0) {\n        throw _WarnImport(\"Engine.RawTexture\");\n    }\n    /**\n     * @internal\n     */\n    _unpackFlipY(value) {\n        if (this._unpackFlipYCached !== value) {\n            this._gl.pixelStorei(this._gl.UNPACK_FLIP_Y_WEBGL, value ? 1 : 0);\n            if (this.enableUnpackFlipYCached) {\n                this._unpackFlipYCached = value;\n            }\n        }\n    }\n    /** @internal */\n    _getUnpackAlignement() {\n        return this._gl.getParameter(this._gl.UNPACK_ALIGNMENT);\n    }\n    _getTextureTarget(texture) {\n        if (texture.isCube) {\n            return this._gl.TEXTURE_CUBE_MAP;\n        }\n        else if (texture.is3D) {\n            return this._gl.TEXTURE_3D;\n        }\n        else if (texture.is2DArray || texture.isMultiview) {\n            return this._gl.TEXTURE_2D_ARRAY;\n        }\n        return this._gl.TEXTURE_2D;\n    }\n    /**\n     * Update the sampling mode of a given texture\n     * @param samplingMode defines the required sampling mode\n     * @param texture defines the texture to update\n     * @param generateMipMaps defines whether to generate mipmaps for the texture\n     */\n    updateTextureSamplingMode(samplingMode, texture, generateMipMaps = false) {\n        const target = this._getTextureTarget(texture);\n        const filters = this._getSamplingParameters(samplingMode, texture.useMipMaps || generateMipMaps);\n        this._setTextureParameterInteger(target, this._gl.TEXTURE_MAG_FILTER, filters.mag, texture);\n        this._setTextureParameterInteger(target, this._gl.TEXTURE_MIN_FILTER, filters.min);\n        if (generateMipMaps) {\n            texture.generateMipMaps = true;\n            this._gl.generateMipmap(target);\n        }\n        this._bindTextureDirectly(target, null);\n        texture.samplingMode = samplingMode;\n    }\n    /**\n     * Update the dimensions of a texture\n     * @param texture texture to update\n     * @param width new width of the texture\n     * @param height new height of the texture\n     * @param depth new depth of the texture\n     */\n    updateTextureDimensions(texture, width, height, depth = 1) { }\n    /**\n     * Update the sampling mode of a given texture\n     * @param texture defines the texture to update\n     * @param wrapU defines the texture wrap mode of the u coordinates\n     * @param wrapV defines the texture wrap mode of the v coordinates\n     * @param wrapR defines the texture wrap mode of the r coordinates\n     */\n    updateTextureWrappingMode(texture, wrapU, wrapV = null, wrapR = null) {\n        const target = this._getTextureTarget(texture);\n        if (wrapU !== null) {\n            this._setTextureParameterInteger(target, this._gl.TEXTURE_WRAP_S, this._getTextureWrapMode(wrapU), texture);\n            texture._cachedWrapU = wrapU;\n        }\n        if (wrapV !== null) {\n            this._setTextureParameterInteger(target, this._gl.TEXTURE_WRAP_T, this._getTextureWrapMode(wrapV), texture);\n            texture._cachedWrapV = wrapV;\n        }\n        if ((texture.is2DArray || texture.is3D) && wrapR !== null) {\n            this._setTextureParameterInteger(target, this._gl.TEXTURE_WRAP_R, this._getTextureWrapMode(wrapR), texture);\n            texture._cachedWrapR = wrapR;\n        }\n        this._bindTextureDirectly(target, null);\n    }\n    /**\n     * @internal\n     */\n    _setupDepthStencilTexture(internalTexture, size, generateStencil, bilinearFiltering, comparisonFunction, samples = 1) {\n        const width = size.width || size;\n        const height = size.height || size;\n        const layers = size.layers || 0;\n        internalTexture.baseWidth = width;\n        internalTexture.baseHeight = height;\n        internalTexture.width = width;\n        internalTexture.height = height;\n        internalTexture.is2DArray = layers > 0;\n        internalTexture.depth = layers;\n        internalTexture.isReady = true;\n        internalTexture.samples = samples;\n        internalTexture.generateMipMaps = false;\n        internalTexture.samplingMode = bilinearFiltering ? 2 : 1;\n        internalTexture.type = 0;\n        internalTexture._comparisonFunction = comparisonFunction;\n        const gl = this._gl;\n        const target = this._getTextureTarget(internalTexture);\n        const samplingParameters = this._getSamplingParameters(internalTexture.samplingMode, false);\n        gl.texParameteri(target, gl.TEXTURE_MAG_FILTER, samplingParameters.mag);\n        gl.texParameteri(target, gl.TEXTURE_MIN_FILTER, samplingParameters.min);\n        gl.texParameteri(target, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n        gl.texParameteri(target, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n        // TEXTURE_COMPARE_FUNC/MODE are only availble in WebGL2.\n        if (this.webGLVersion > 1) {\n            if (comparisonFunction === 0) {\n                gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, 515);\n                gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.NONE);\n            }\n            else {\n                gl.texParameteri(target, gl.TEXTURE_COMPARE_FUNC, comparisonFunction);\n                gl.texParameteri(target, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);\n            }\n        }\n    }\n    /**\n     * @internal\n     */\n    _uploadCompressedDataToTextureDirectly(texture, internalFormat, width, height, data, faceIndex = 0, lod = 0) {\n        const gl = this._gl;\n        let target = gl.TEXTURE_2D;\n        if (texture.isCube) {\n            target = gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex;\n        }\n        if (texture._useSRGBBuffer) {\n            switch (internalFormat) {\n                case 37492:\n                case 36196:\n                    // Note, if using ETC1 and sRGB is requested, this will use ETC2 if available.\n                    if (this._caps.etc2) {\n                        internalFormat = gl.COMPRESSED_SRGB8_ETC2;\n                    }\n                    else {\n                        texture._useSRGBBuffer = false;\n                    }\n                    break;\n                case 37496:\n                    if (this._caps.etc2) {\n                        internalFormat = gl.COMPRESSED_SRGB8_ALPHA8_ETC2_EAC;\n                    }\n                    else {\n                        texture._useSRGBBuffer = false;\n                    }\n                    break;\n                case 36492:\n                    internalFormat = gl.COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT;\n                    break;\n                case 37808:\n                    internalFormat = gl.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR;\n                    break;\n                case 33776:\n                    if (this._caps.s3tc_srgb) {\n                        internalFormat = gl.COMPRESSED_SRGB_S3TC_DXT1_EXT;\n                    }\n                    else {\n                        // S3TC sRGB extension not supported\n                        texture._useSRGBBuffer = false;\n                    }\n                    break;\n                case 33777:\n                    if (this._caps.s3tc_srgb) {\n                        internalFormat = gl.COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT;\n                    }\n                    else {\n                        // S3TC sRGB extension not supported\n                        texture._useSRGBBuffer = false;\n                    }\n                    break;\n                case 33779:\n                    if (this._caps.s3tc_srgb) {\n                        internalFormat = gl.COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT;\n                    }\n                    else {\n                        // S3TC sRGB extension not supported\n                        texture._useSRGBBuffer = false;\n                    }\n                    break;\n                default:\n                    // We don't support a sRGB format corresponding to internalFormat, so revert to non sRGB format\n                    texture._useSRGBBuffer = false;\n                    break;\n            }\n        }\n        this._gl.compressedTexImage2D(target, lod, internalFormat, width, height, 0, data);\n    }\n    /**\n     * @internal\n     */\n    _uploadDataToTextureDirectly(texture, imageData, faceIndex = 0, lod = 0, babylonInternalFormat, useTextureWidthAndHeight = false) {\n        const gl = this._gl;\n        const textureType = this._getWebGLTextureType(texture.type);\n        const format = this._getInternalFormat(texture.format);\n        const internalFormat = babylonInternalFormat === undefined\n            ? this._getRGBABufferInternalSizedFormat(texture.type, texture.format, texture._useSRGBBuffer)\n            : this._getInternalFormat(babylonInternalFormat, texture._useSRGBBuffer);\n        this._unpackFlipY(texture.invertY);\n        let target = gl.TEXTURE_2D;\n        if (texture.isCube) {\n            target = gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex;\n        }\n        const lodMaxWidth = Math.round(Math.log(texture.width) * Math.LOG2E);\n        const lodMaxHeight = Math.round(Math.log(texture.height) * Math.LOG2E);\n        const width = useTextureWidthAndHeight ? texture.width : Math.pow(2, Math.max(lodMaxWidth - lod, 0));\n        const height = useTextureWidthAndHeight ? texture.height : Math.pow(2, Math.max(lodMaxHeight - lod, 0));\n        gl.texImage2D(target, lod, internalFormat, width, height, 0, format, textureType, imageData);\n    }\n    /**\n     * Update a portion of an internal texture\n     * @param texture defines the texture to update\n     * @param imageData defines the data to store into the texture\n     * @param xOffset defines the x coordinates of the update rectangle\n     * @param yOffset defines the y coordinates of the update rectangle\n     * @param width defines the width of the update rectangle\n     * @param height defines the height of the update rectangle\n     * @param faceIndex defines the face index if texture is a cube (0 by default)\n     * @param lod defines the lod level to update (0 by default)\n     * @param generateMipMaps defines whether to generate mipmaps or not\n     */\n    updateTextureData(texture, imageData, xOffset, yOffset, width, height, faceIndex = 0, lod = 0, generateMipMaps = false) {\n        const gl = this._gl;\n        const textureType = this._getWebGLTextureType(texture.type);\n        const format = this._getInternalFormat(texture.format);\n        this._unpackFlipY(texture.invertY);\n        let targetForBinding = gl.TEXTURE_2D;\n        let target = gl.TEXTURE_2D;\n        if (texture.isCube) {\n            target = gl.TEXTURE_CUBE_MAP_POSITIVE_X + faceIndex;\n            targetForBinding = gl.TEXTURE_CUBE_MAP;\n        }\n        this._bindTextureDirectly(targetForBinding, texture, true);\n        gl.texSubImage2D(target, lod, xOffset, yOffset, width, height, format, textureType, imageData);\n        if (generateMipMaps) {\n            this._gl.generateMipmap(target);\n        }\n        this._bindTextureDirectly(targetForBinding, null);\n    }\n    /**\n     * @internal\n     */\n    _uploadArrayBufferViewToTexture(texture, imageData, faceIndex = 0, lod = 0) {\n        const gl = this._gl;\n        const bindTarget = texture.isCube ? gl.TEXTURE_CUBE_MAP : gl.TEXTURE_2D;\n        this._bindTextureDirectly(bindTarget, texture, true);\n        this._uploadDataToTextureDirectly(texture, imageData, faceIndex, lod);\n        this._bindTextureDirectly(bindTarget, null, true);\n    }\n    _prepareWebGLTextureContinuation(texture, scene, noMipmap, isCompressed, samplingMode) {\n        const gl = this._gl;\n        if (!gl) {\n            return;\n        }\n        const filters = this._getSamplingParameters(samplingMode, !noMipmap);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filters.mag);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filters.min);\n        if (!noMipmap && !isCompressed) {\n            gl.generateMipmap(gl.TEXTURE_2D);\n        }\n        this._bindTextureDirectly(gl.TEXTURE_2D, null);\n        // this.resetTextureCache();\n        if (scene) {\n            scene.removePendingData(texture);\n        }\n        texture.onLoadedObservable.notifyObservers(texture);\n        texture.onLoadedObservable.clear();\n    }\n    _prepareWebGLTexture(texture, extension, scene, img, invertY, noMipmap, isCompressed, processFunction, samplingMode = 3) {\n        const maxTextureSize = this.getCaps().maxTextureSize;\n        const potWidth = Math.min(maxTextureSize, this.needPOTTextures ? ThinEngine.GetExponentOfTwo(img.width, maxTextureSize) : img.width);\n        const potHeight = Math.min(maxTextureSize, this.needPOTTextures ? ThinEngine.GetExponentOfTwo(img.height, maxTextureSize) : img.height);\n        const gl = this._gl;\n        if (!gl) {\n            return;\n        }\n        if (!texture._hardwareTexture) {\n            //  this.resetTextureCache();\n            if (scene) {\n                scene.removePendingData(texture);\n            }\n            return;\n        }\n        this._bindTextureDirectly(gl.TEXTURE_2D, texture, true);\n        this._unpackFlipY(invertY === undefined ? true : invertY ? true : false);\n        texture.baseWidth = img.width;\n        texture.baseHeight = img.height;\n        texture.width = potWidth;\n        texture.height = potHeight;\n        texture.isReady = true;\n        if (processFunction(potWidth, potHeight, img, extension, texture, () => {\n            this._prepareWebGLTextureContinuation(texture, scene, noMipmap, isCompressed, samplingMode);\n        })) {\n            // Returning as texture needs extra async steps\n            return;\n        }\n        this._prepareWebGLTextureContinuation(texture, scene, noMipmap, isCompressed, samplingMode);\n    }\n    /**\n     * @internal\n     */\n    _setupFramebufferDepthAttachments(generateStencilBuffer, generateDepthBuffer, width, height, samples = 1) {\n        const gl = this._gl;\n        // Create the depth/stencil buffer\n        if (generateStencilBuffer && generateDepthBuffer) {\n            return this._createRenderBuffer(width, height, samples, gl.DEPTH_STENCIL, gl.DEPTH24_STENCIL8, gl.DEPTH_STENCIL_ATTACHMENT);\n        }\n        if (generateDepthBuffer) {\n            let depthFormat = gl.DEPTH_COMPONENT16;\n            if (this._webGLVersion > 1) {\n                depthFormat = gl.DEPTH_COMPONENT32F;\n            }\n            return this._createRenderBuffer(width, height, samples, depthFormat, depthFormat, gl.DEPTH_ATTACHMENT);\n        }\n        if (generateStencilBuffer) {\n            return this._createRenderBuffer(width, height, samples, gl.STENCIL_INDEX8, gl.STENCIL_INDEX8, gl.STENCIL_ATTACHMENT);\n        }\n        return null;\n    }\n    /**\n     * @internal\n     */\n    _createRenderBuffer(width, height, samples, internalFormat, msInternalFormat, attachment, unbindBuffer = true) {\n        const gl = this._gl;\n        const renderBuffer = gl.createRenderbuffer();\n        return this._updateRenderBuffer(renderBuffer, width, height, samples, internalFormat, msInternalFormat, attachment, unbindBuffer);\n    }\n    _updateRenderBuffer(renderBuffer, width, height, samples, internalFormat, msInternalFormat, attachment, unbindBuffer = true) {\n        const gl = this._gl;\n        gl.bindRenderbuffer(gl.RENDERBUFFER, renderBuffer);\n        if (samples > 1 && gl.renderbufferStorageMultisample) {\n            gl.renderbufferStorageMultisample(gl.RENDERBUFFER, samples, msInternalFormat, width, height);\n        }\n        else {\n            gl.renderbufferStorage(gl.RENDERBUFFER, internalFormat, width, height);\n        }\n        gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, renderBuffer);\n        if (unbindBuffer) {\n            gl.bindRenderbuffer(gl.RENDERBUFFER, null);\n        }\n        return renderBuffer;\n    }\n    /**\n     * @internal\n     */\n    _releaseTexture(texture) {\n        var _a;\n        this._deleteTexture((_a = texture._hardwareTexture) === null || _a === void 0 ? void 0 : _a.underlyingResource);\n        // Unbind channels\n        this.unbindAllTextures();\n        const index = this._internalTexturesCache.indexOf(texture);\n        if (index !== -1) {\n            this._internalTexturesCache.splice(index, 1);\n        }\n        // Integrated fixed lod samplers.\n        if (texture._lodTextureHigh) {\n            texture._lodTextureHigh.dispose();\n        }\n        if (texture._lodTextureMid) {\n            texture._lodTextureMid.dispose();\n        }\n        if (texture._lodTextureLow) {\n            texture._lodTextureLow.dispose();\n        }\n        // Integrated irradiance map.\n        if (texture._irradianceTexture) {\n            texture._irradianceTexture.dispose();\n        }\n    }\n    /**\n     * @internal\n     */\n    _releaseRenderTargetWrapper(rtWrapper) {\n        const index = this._renderTargetWrapperCache.indexOf(rtWrapper);\n        if (index !== -1) {\n            this._renderTargetWrapperCache.splice(index, 1);\n        }\n    }\n    _deleteTexture(texture) {\n        if (texture) {\n            this._gl.deleteTexture(texture);\n        }\n    }\n    _setProgram(program) {\n        if (this._currentProgram !== program) {\n            this._gl.useProgram(program);\n            this._currentProgram = program;\n        }\n    }\n    /**\n     * Binds an effect to the webGL context\n     * @param effect defines the effect to bind\n     */\n    bindSamplers(effect) {\n        const webGLPipelineContext = effect.getPipelineContext();\n        this._setProgram(webGLPipelineContext.program);\n        const samplers = effect.getSamplers();\n        for (let index = 0; index < samplers.length; index++) {\n            const uniform = effect.getUniform(samplers[index]);\n            if (uniform) {\n                this._boundUniforms[index] = uniform;\n            }\n        }\n        this._currentEffect = null;\n    }\n    _activateCurrentTexture() {\n        if (this._currentTextureChannel !== this._activeChannel) {\n            this._gl.activeTexture(this._gl.TEXTURE0 + this._activeChannel);\n            this._currentTextureChannel = this._activeChannel;\n        }\n    }\n    /**\n     * @internal\n     */\n    _bindTextureDirectly(target, texture, forTextureDataUpdate = false, force = false) {\n        var _a, _b;\n        let wasPreviouslyBound = false;\n        const isTextureForRendering = texture && texture._associatedChannel > -1;\n        if (forTextureDataUpdate && isTextureForRendering) {\n            this._activeChannel = texture._associatedChannel;\n        }\n        const currentTextureBound = this._boundTexturesCache[this._activeChannel];\n        if (currentTextureBound !== texture || force) {\n            this._activateCurrentTexture();\n            if (texture && texture.isMultiview) {\n                //this._gl.bindTexture(target, texture ? texture._colorTextureArray : null);\n                console.error(target, texture);\n                throw \"_bindTextureDirectly called with a multiview texture!\";\n            }\n            else {\n                this._gl.bindTexture(target, (_b = (_a = texture === null || texture === void 0 ? void 0 : texture._hardwareTexture) === null || _a === void 0 ? void 0 : _a.underlyingResource) !== null && _b !== void 0 ? _b : null);\n            }\n            this._boundTexturesCache[this._activeChannel] = texture;\n            if (texture) {\n                texture._associatedChannel = this._activeChannel;\n            }\n        }\n        else if (forTextureDataUpdate) {\n            wasPreviouslyBound = true;\n            this._activateCurrentTexture();\n        }\n        if (isTextureForRendering && !forTextureDataUpdate) {\n            this._bindSamplerUniformToChannel(texture._associatedChannel, this._activeChannel);\n        }\n        return wasPreviouslyBound;\n    }\n    /**\n     * @internal\n     */\n    _bindTexture(channel, texture, name) {\n        if (channel === undefined) {\n            return;\n        }\n        if (texture) {\n            texture._associatedChannel = channel;\n        }\n        this._activeChannel = channel;\n        const target = texture ? this._getTextureTarget(texture) : this._gl.TEXTURE_2D;\n        this._bindTextureDirectly(target, texture);\n    }\n    /**\n     * Unbind all textures from the webGL context\n     */\n    unbindAllTextures() {\n        for (let channel = 0; channel < this._maxSimultaneousTextures; channel++) {\n            this._activeChannel = channel;\n            this._bindTextureDirectly(this._gl.TEXTURE_2D, null);\n            this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null);\n            if (this.webGLVersion > 1) {\n                this._bindTextureDirectly(this._gl.TEXTURE_3D, null);\n                this._bindTextureDirectly(this._gl.TEXTURE_2D_ARRAY, null);\n            }\n        }\n    }\n    /**\n     * Sets a texture to the according uniform.\n     * @param channel The texture channel\n     * @param uniform The uniform to set\n     * @param texture The texture to apply\n     * @param name The name of the uniform in the effect\n     */\n    setTexture(channel, uniform, texture, name) {\n        if (channel === undefined) {\n            return;\n        }\n        if (uniform) {\n            this._boundUniforms[channel] = uniform;\n        }\n        this._setTexture(channel, texture);\n    }\n    _bindSamplerUniformToChannel(sourceSlot, destination) {\n        const uniform = this._boundUniforms[sourceSlot];\n        if (!uniform || uniform._currentState === destination) {\n            return;\n        }\n        this._gl.uniform1i(uniform, destination);\n        uniform._currentState = destination;\n    }\n    _getTextureWrapMode(mode) {\n        switch (mode) {\n            case 1:\n                return this._gl.REPEAT;\n            case 0:\n                return this._gl.CLAMP_TO_EDGE;\n            case 2:\n                return this._gl.MIRRORED_REPEAT;\n        }\n        return this._gl.REPEAT;\n    }\n    _setTexture(channel, texture, isPartOfTextureArray = false, depthStencilTexture = false, name = \"\") {\n        // Not ready?\n        if (!texture) {\n            if (this._boundTexturesCache[channel] != null) {\n                this._activeChannel = channel;\n                this._bindTextureDirectly(this._gl.TEXTURE_2D, null);\n                this._bindTextureDirectly(this._gl.TEXTURE_CUBE_MAP, null);\n                if (this.webGLVersion > 1) {\n                    this._bindTextureDirectly(this._gl.TEXTURE_3D, null);\n                    this._bindTextureDirectly(this._gl.TEXTURE_2D_ARRAY, null);\n                }\n            }\n            return false;\n        }\n        // Video\n        if (texture.video) {\n            this._activeChannel = channel;\n            const videoInternalTexture = texture.getInternalTexture();\n            if (videoInternalTexture) {\n                videoInternalTexture._associatedChannel = channel;\n            }\n            texture.update();\n        }\n        else if (texture.delayLoadState === 4) {\n            // Delay loading\n            texture.delayLoad();\n            return false;\n        }\n        let internalTexture;\n        if (depthStencilTexture) {\n            internalTexture = texture.depthStencilTexture;\n        }\n        else if (texture.isReady()) {\n            internalTexture = texture.getInternalTexture();\n        }\n        else if (texture.isCube) {\n            internalTexture = this.emptyCubeTexture;\n        }\n        else if (texture.is3D) {\n            internalTexture = this.emptyTexture3D;\n        }\n        else if (texture.is2DArray) {\n            internalTexture = this.emptyTexture2DArray;\n        }\n        else {\n            internalTexture = this.emptyTexture;\n        }\n        if (!isPartOfTextureArray && internalTexture) {\n            internalTexture._associatedChannel = channel;\n        }\n        let needToBind = true;\n        if (this._boundTexturesCache[channel] === internalTexture) {\n            if (!isPartOfTextureArray) {\n                this._bindSamplerUniformToChannel(internalTexture._associatedChannel, channel);\n            }\n            needToBind = false;\n        }\n        this._activeChannel = channel;\n        const target = this._getTextureTarget(internalTexture);\n        if (needToBind) {\n            this._bindTextureDirectly(target, internalTexture, isPartOfTextureArray);\n        }\n        if (internalTexture && !internalTexture.isMultiview) {\n            // CUBIC_MODE and SKYBOX_MODE both require CLAMP_TO_EDGE.  All other modes use REPEAT.\n            if (internalTexture.isCube && internalTexture._cachedCoordinatesMode !== texture.coordinatesMode) {\n                internalTexture._cachedCoordinatesMode = texture.coordinatesMode;\n                const textureWrapMode = texture.coordinatesMode !== 3 && texture.coordinatesMode !== 5\n                    ? 1\n                    : 0;\n                texture.wrapU = textureWrapMode;\n                texture.wrapV = textureWrapMode;\n            }\n            if (internalTexture._cachedWrapU !== texture.wrapU) {\n                internalTexture._cachedWrapU = texture.wrapU;\n                this._setTextureParameterInteger(target, this._gl.TEXTURE_WRAP_S, this._getTextureWrapMode(texture.wrapU), internalTexture);\n            }\n            if (internalTexture._cachedWrapV !== texture.wrapV) {\n                internalTexture._cachedWrapV = texture.wrapV;\n                this._setTextureParameterInteger(target, this._gl.TEXTURE_WRAP_T, this._getTextureWrapMode(texture.wrapV), internalTexture);\n            }\n            if (internalTexture.is3D && internalTexture._cachedWrapR !== texture.wrapR) {\n                internalTexture._cachedWrapR = texture.wrapR;\n                this._setTextureParameterInteger(target, this._gl.TEXTURE_WRAP_R, this._getTextureWrapMode(texture.wrapR), internalTexture);\n            }\n            this._setAnisotropicLevel(target, internalTexture, texture.anisotropicFilteringLevel);\n        }\n        return true;\n    }\n    /**\n     * Sets an array of texture to the webGL context\n     * @param channel defines the channel where the texture array must be set\n     * @param uniform defines the associated uniform location\n     * @param textures defines the array of textures to bind\n     * @param name name of the channel\n     */\n    setTextureArray(channel, uniform, textures, name) {\n        if (channel === undefined || !uniform) {\n            return;\n        }\n        if (!this._textureUnits || this._textureUnits.length !== textures.length) {\n            this._textureUnits = new Int32Array(textures.length);\n        }\n        for (let i = 0; i < textures.length; i++) {\n            const texture = textures[i].getInternalTexture();\n            if (texture) {\n                this._textureUnits[i] = channel + i;\n                texture._associatedChannel = channel + i;\n            }\n            else {\n                this._textureUnits[i] = -1;\n            }\n        }\n        this._gl.uniform1iv(uniform, this._textureUnits);\n        for (let index = 0; index < textures.length; index++) {\n            this._setTexture(this._textureUnits[index], textures[index], true);\n        }\n    }\n    /**\n     * @internal\n     */\n    _setAnisotropicLevel(target, internalTexture, anisotropicFilteringLevel) {\n        const anisotropicFilterExtension = this._caps.textureAnisotropicFilterExtension;\n        if (internalTexture.samplingMode !== 11 &&\n            internalTexture.samplingMode !== 3 &&\n            internalTexture.samplingMode !== 2) {\n            anisotropicFilteringLevel = 1; // Forcing the anisotropic to 1 because else webgl will force filters to linear\n        }\n        if (anisotropicFilterExtension && internalTexture._cachedAnisotropicFilteringLevel !== anisotropicFilteringLevel) {\n            this._setTextureParameterFloat(target, anisotropicFilterExtension.TEXTURE_MAX_ANISOTROPY_EXT, Math.min(anisotropicFilteringLevel, this._caps.maxAnisotropy), internalTexture);\n            internalTexture._cachedAnisotropicFilteringLevel = anisotropicFilteringLevel;\n        }\n    }\n    _setTextureParameterFloat(target, parameter, value, texture) {\n        this._bindTextureDirectly(target, texture, true, true);\n        this._gl.texParameterf(target, parameter, value);\n    }\n    _setTextureParameterInteger(target, parameter, value, texture) {\n        if (texture) {\n            this._bindTextureDirectly(target, texture, true, true);\n        }\n        this._gl.texParameteri(target, parameter, value);\n    }\n    /**\n     * Unbind all vertex attributes from the webGL context\n     */\n    unbindAllAttributes() {\n        if (this._mustWipeVertexAttributes) {\n            this._mustWipeVertexAttributes = false;\n            for (let i = 0; i < this._caps.maxVertexAttribs; i++) {\n                this.disableAttributeByIndex(i);\n            }\n            return;\n        }\n        for (let i = 0, ul = this._vertexAttribArraysEnabled.length; i < ul; i++) {\n            if (i >= this._caps.maxVertexAttribs || !this._vertexAttribArraysEnabled[i]) {\n                continue;\n            }\n            this.disableAttributeByIndex(i);\n        }\n    }\n    /**\n     * Force the engine to release all cached effects. This means that next effect compilation will have to be done completely even if a similar effect was already compiled\n     */\n    releaseEffects() {\n        for (const name in this._compiledEffects) {\n            const webGLPipelineContext = this._compiledEffects[name].getPipelineContext();\n            this._deletePipelineContext(webGLPipelineContext);\n        }\n        this._compiledEffects = {};\n    }\n    /**\n     * Dispose and release all associated resources\n     */\n    dispose() {\n        var _a;\n        this._isDisposed = true;\n        this.stopRenderLoop();\n        // Clear observables\n        if (this.onBeforeTextureInitObservable) {\n            this.onBeforeTextureInitObservable.clear();\n        }\n        // Empty texture\n        if (this._emptyTexture) {\n            this._releaseTexture(this._emptyTexture);\n            this._emptyTexture = null;\n        }\n        if (this._emptyCubeTexture) {\n            this._releaseTexture(this._emptyCubeTexture);\n            this._emptyCubeTexture = null;\n        }\n        if (this._dummyFramebuffer) {\n            this._gl.deleteFramebuffer(this._dummyFramebuffer);\n        }\n        // Release effects\n        this.releaseEffects();\n        (_a = this.releaseComputeEffects) === null || _a === void 0 ? void 0 : _a.call(this);\n        // Unbind\n        this.unbindAllAttributes();\n        this._boundUniforms = {};\n        // Events\n        if (IsWindowObjectExist()) {\n            if (this._renderingCanvas) {\n                if (!this._doNotHandleContextLost) {\n                    this._renderingCanvas.removeEventListener(\"webglcontextlost\", this._onContextLost);\n                    this._renderingCanvas.removeEventListener(\"webglcontextrestored\", this._onContextRestored);\n                }\n                window.removeEventListener(\"resize\", this._checkForMobile);\n            }\n        }\n        this._workingCanvas = null;\n        this._workingContext = null;\n        this._currentBufferPointers.length = 0;\n        this._renderingCanvas = null;\n        this._currentProgram = null;\n        this._boundRenderFunction = null;\n        Effect.ResetCache();\n        // Abort active requests\n        for (const request of this._activeRequests) {\n            request.abort();\n        }\n        this.onDisposeObservable.notifyObservers(this);\n        this.onDisposeObservable.clear();\n    }\n    /**\n     * Attach a new callback raised when context lost event is fired\n     * @param callback defines the callback to call\n     */\n    attachContextLostEvent(callback) {\n        if (this._renderingCanvas) {\n            this._renderingCanvas.addEventListener(\"webglcontextlost\", callback, false);\n        }\n    }\n    /**\n     * Attach a new callback raised when context restored event is fired\n     * @param callback defines the callback to call\n     */\n    attachContextRestoredEvent(callback) {\n        if (this._renderingCanvas) {\n            this._renderingCanvas.addEventListener(\"webglcontextrestored\", callback, false);\n        }\n    }\n    /**\n     * Get the current error code of the webGL context\n     * @returns the error code\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/getError\n     */\n    getError() {\n        return this._gl.getError();\n    }\n    _canRenderToFloatFramebuffer() {\n        if (this._webGLVersion > 1) {\n            return this._caps.colorBufferFloat;\n        }\n        return this._canRenderToFramebuffer(1);\n    }\n    _canRenderToHalfFloatFramebuffer() {\n        if (this._webGLVersion > 1) {\n            return this._caps.colorBufferFloat;\n        }\n        return this._canRenderToFramebuffer(2);\n    }\n    // Thank you : http://stackoverflow.com/questions/28827511/webgl-ios-render-to-floating-point-texture\n    _canRenderToFramebuffer(type) {\n        const gl = this._gl;\n        //clear existing errors\n        // eslint-disable-next-line no-empty\n        while (gl.getError() !== gl.NO_ERROR) { }\n        let successful = true;\n        const texture = gl.createTexture();\n        gl.bindTexture(gl.TEXTURE_2D, texture);\n        gl.texImage2D(gl.TEXTURE_2D, 0, this._getRGBABufferInternalSizedFormat(type), 1, 1, 0, gl.RGBA, this._getWebGLTextureType(type), null);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n        const fb = gl.createFramebuffer();\n        gl.bindFramebuffer(gl.FRAMEBUFFER, fb);\n        gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, texture, 0);\n        const status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);\n        successful = successful && status === gl.FRAMEBUFFER_COMPLETE;\n        successful = successful && gl.getError() === gl.NO_ERROR;\n        //try render by clearing frame buffer's color buffer\n        if (successful) {\n            gl.clear(gl.COLOR_BUFFER_BIT);\n            successful = successful && gl.getError() === gl.NO_ERROR;\n        }\n        //try reading from frame to ensure render occurs (just creating the FBO is not sufficient to determine if rendering is supported)\n        if (successful) {\n            //in practice it's sufficient to just read from the backbuffer rather than handle potentially issues reading from the texture\n            gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n            const readFormat = gl.RGBA;\n            const readType = gl.UNSIGNED_BYTE;\n            const buffer = new Uint8Array(4);\n            gl.readPixels(0, 0, 1, 1, readFormat, readType, buffer);\n            successful = successful && gl.getError() === gl.NO_ERROR;\n        }\n        //clean up\n        gl.deleteTexture(texture);\n        gl.deleteFramebuffer(fb);\n        gl.bindFramebuffer(gl.FRAMEBUFFER, null);\n        //clear accumulated errors\n        // eslint-disable-next-line no-empty\n        while (!successful && gl.getError() !== gl.NO_ERROR) { }\n        return successful;\n    }\n    /**\n     * @internal\n     */\n    _getWebGLTextureType(type) {\n        if (this._webGLVersion === 1) {\n            switch (type) {\n                case 1:\n                    return this._gl.FLOAT;\n                case 2:\n                    return this._gl.HALF_FLOAT_OES;\n                case 0:\n                    return this._gl.UNSIGNED_BYTE;\n                case 8:\n                    return this._gl.UNSIGNED_SHORT_4_4_4_4;\n                case 9:\n                    return this._gl.UNSIGNED_SHORT_5_5_5_1;\n                case 10:\n                    return this._gl.UNSIGNED_SHORT_5_6_5;\n            }\n            return this._gl.UNSIGNED_BYTE;\n        }\n        switch (type) {\n            case 3:\n                return this._gl.BYTE;\n            case 0:\n                return this._gl.UNSIGNED_BYTE;\n            case 4:\n                return this._gl.SHORT;\n            case 5:\n                return this._gl.UNSIGNED_SHORT;\n            case 6:\n                return this._gl.INT;\n            case 7: // Refers to UNSIGNED_INT\n                return this._gl.UNSIGNED_INT;\n            case 1:\n                return this._gl.FLOAT;\n            case 2:\n                return this._gl.HALF_FLOAT;\n            case 8:\n                return this._gl.UNSIGNED_SHORT_4_4_4_4;\n            case 9:\n                return this._gl.UNSIGNED_SHORT_5_5_5_1;\n            case 10:\n                return this._gl.UNSIGNED_SHORT_5_6_5;\n            case 11:\n                return this._gl.UNSIGNED_INT_2_10_10_10_REV;\n            case 12:\n                return this._gl.UNSIGNED_INT_24_8;\n            case 13:\n                return this._gl.UNSIGNED_INT_10F_11F_11F_REV;\n            case 14:\n                return this._gl.UNSIGNED_INT_5_9_9_9_REV;\n            case 15:\n                return this._gl.FLOAT_32_UNSIGNED_INT_24_8_REV;\n        }\n        return this._gl.UNSIGNED_BYTE;\n    }\n    /**\n     * @internal\n     */\n    _getInternalFormat(format, useSRGBBuffer = false) {\n        let internalFormat = useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA;\n        switch (format) {\n            case 0:\n                internalFormat = this._gl.ALPHA;\n                break;\n            case 1:\n                internalFormat = this._gl.LUMINANCE;\n                break;\n            case 2:\n                internalFormat = this._gl.LUMINANCE_ALPHA;\n                break;\n            case 6:\n                internalFormat = this._gl.RED;\n                break;\n            case 7:\n                internalFormat = this._gl.RG;\n                break;\n            case 4:\n                internalFormat = useSRGBBuffer ? this._glSRGBExtensionValues.SRGB : this._gl.RGB;\n                break;\n            case 5:\n                internalFormat = useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA;\n                break;\n        }\n        if (this._webGLVersion > 1) {\n            switch (format) {\n                case 8:\n                    internalFormat = this._gl.RED_INTEGER;\n                    break;\n                case 9:\n                    internalFormat = this._gl.RG_INTEGER;\n                    break;\n                case 10:\n                    internalFormat = this._gl.RGB_INTEGER;\n                    break;\n                case 11:\n                    internalFormat = this._gl.RGBA_INTEGER;\n                    break;\n            }\n        }\n        return internalFormat;\n    }\n    /**\n     * @internal\n     */\n    _getRGBABufferInternalSizedFormat(type, format, useSRGBBuffer = false) {\n        if (this._webGLVersion === 1) {\n            if (format !== undefined) {\n                switch (format) {\n                    case 0:\n                        return this._gl.ALPHA;\n                    case 1:\n                        return this._gl.LUMINANCE;\n                    case 2:\n                        return this._gl.LUMINANCE_ALPHA;\n                    case 4:\n                        return useSRGBBuffer ? this._glSRGBExtensionValues.SRGB : this._gl.RGB;\n                }\n            }\n            return this._gl.RGBA;\n        }\n        switch (type) {\n            case 3:\n                switch (format) {\n                    case 6:\n                        return this._gl.R8_SNORM;\n                    case 7:\n                        return this._gl.RG8_SNORM;\n                    case 4:\n                        return this._gl.RGB8_SNORM;\n                    case 8:\n                        return this._gl.R8I;\n                    case 9:\n                        return this._gl.RG8I;\n                    case 10:\n                        return this._gl.RGB8I;\n                    case 11:\n                        return this._gl.RGBA8I;\n                    default:\n                        return this._gl.RGBA8_SNORM;\n                }\n            case 0:\n                switch (format) {\n                    case 6:\n                        return this._gl.R8;\n                    case 7:\n                        return this._gl.RG8;\n                    case 4:\n                        return useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8 : this._gl.RGB8; // By default. Other possibilities are RGB565, SRGB8.\n                    case 5:\n                        return useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA8; // By default. Other possibilities are RGB5_A1, RGBA4, SRGB8_ALPHA8.\n                    case 8:\n                        return this._gl.R8UI;\n                    case 9:\n                        return this._gl.RG8UI;\n                    case 10:\n                        return this._gl.RGB8UI;\n                    case 11:\n                        return this._gl.RGBA8UI;\n                    case 0:\n                        return this._gl.ALPHA;\n                    case 1:\n                        return this._gl.LUMINANCE;\n                    case 2:\n                        return this._gl.LUMINANCE_ALPHA;\n                    default:\n                        return this._gl.RGBA8;\n                }\n            case 4:\n                switch (format) {\n                    case 8:\n                        return this._gl.R16I;\n                    case 9:\n                        return this._gl.RG16I;\n                    case 10:\n                        return this._gl.RGB16I;\n                    case 11:\n                        return this._gl.RGBA16I;\n                    default:\n                        return this._gl.RGBA16I;\n                }\n            case 5:\n                switch (format) {\n                    case 8:\n                        return this._gl.R16UI;\n                    case 9:\n                        return this._gl.RG16UI;\n                    case 10:\n                        return this._gl.RGB16UI;\n                    case 11:\n                        return this._gl.RGBA16UI;\n                    default:\n                        return this._gl.RGBA16UI;\n                }\n            case 6:\n                switch (format) {\n                    case 8:\n                        return this._gl.R32I;\n                    case 9:\n                        return this._gl.RG32I;\n                    case 10:\n                        return this._gl.RGB32I;\n                    case 11:\n                        return this._gl.RGBA32I;\n                    default:\n                        return this._gl.RGBA32I;\n                }\n            case 7: // Refers to UNSIGNED_INT\n                switch (format) {\n                    case 8:\n                        return this._gl.R32UI;\n                    case 9:\n                        return this._gl.RG32UI;\n                    case 10:\n                        return this._gl.RGB32UI;\n                    case 11:\n                        return this._gl.RGBA32UI;\n                    default:\n                        return this._gl.RGBA32UI;\n                }\n            case 1:\n                switch (format) {\n                    case 6:\n                        return this._gl.R32F; // By default. Other possibility is R16F.\n                    case 7:\n                        return this._gl.RG32F; // By default. Other possibility is RG16F.\n                    case 4:\n                        return this._gl.RGB32F; // By default. Other possibilities are RGB16F, R11F_G11F_B10F, RGB9_E5.\n                    case 5:\n                        return this._gl.RGBA32F; // By default. Other possibility is RGBA16F.\n                    default:\n                        return this._gl.RGBA32F;\n                }\n            case 2:\n                switch (format) {\n                    case 6:\n                        return this._gl.R16F;\n                    case 7:\n                        return this._gl.RG16F;\n                    case 4:\n                        return this._gl.RGB16F; // By default. Other possibilities are R11F_G11F_B10F, RGB9_E5.\n                    case 5:\n                        return this._gl.RGBA16F;\n                    default:\n                        return this._gl.RGBA16F;\n                }\n            case 10:\n                return this._gl.RGB565;\n            case 13:\n                return this._gl.R11F_G11F_B10F;\n            case 14:\n                return this._gl.RGB9_E5;\n            case 8:\n                return this._gl.RGBA4;\n            case 9:\n                return this._gl.RGB5_A1;\n            case 11:\n                switch (format) {\n                    case 5:\n                        return this._gl.RGB10_A2; // By default. Other possibility is RGB5_A1.\n                    case 11:\n                        return this._gl.RGB10_A2UI;\n                    default:\n                        return this._gl.RGB10_A2;\n                }\n        }\n        return useSRGBBuffer ? this._glSRGBExtensionValues.SRGB8_ALPHA8 : this._gl.RGBA8;\n    }\n    /**\n     * @internal\n     */\n    _getRGBAMultiSampleBufferFormat(type, format = 5) {\n        switch (type) {\n            case 1:\n                switch (format) {\n                    case 6:\n                        return this._gl.R32F;\n                    default:\n                        return this._gl.RGBA32F;\n                }\n            case 2:\n                switch (format) {\n                    case 6:\n                        return this._gl.R16F;\n                    default:\n                        return this._gl.RGBA16F;\n                }\n        }\n        return this._gl.RGBA8;\n    }\n    /**\n     * @internal\n     */\n    _loadFile(url, onSuccess, onProgress, offlineProvider, useArrayBuffer, onError) {\n        const request = ThinEngine._FileToolsLoadFile(url, onSuccess, onProgress, offlineProvider, useArrayBuffer, onError);\n        this._activeRequests.push(request);\n        request.onCompleteObservable.add((request) => {\n            this._activeRequests.splice(this._activeRequests.indexOf(request), 1);\n        });\n        return request;\n    }\n    /**\n     * Loads a file from a url\n     * @param url url to load\n     * @param onSuccess callback called when the file successfully loads\n     * @param onProgress callback called while file is loading (if the server supports this mode)\n     * @param offlineProvider defines the offline provider for caching\n     * @param useArrayBuffer defines a boolean indicating that date must be returned as ArrayBuffer\n     * @param onError callback called when the file fails to load\n     * @returns a file request object\n     * @internal\n     */\n    static _FileToolsLoadFile(url, onSuccess, onProgress, offlineProvider, useArrayBuffer, onError) {\n        throw _WarnImport(\"FileTools\");\n    }\n    /**\n     * Reads pixels from the current frame buffer. Please note that this function can be slow\n     * @param x defines the x coordinate of the rectangle where pixels must be read\n     * @param y defines the y coordinate of the rectangle where pixels must be read\n     * @param width defines the width of the rectangle where pixels must be read\n     * @param height defines the height of the rectangle where pixels must be read\n     * @param hasAlpha defines whether the output should have alpha or not (defaults to true)\n     * @param flushRenderer true to flush the renderer from the pending commands before reading the pixels\n     * @returns a ArrayBufferView promise (Uint8Array) containing RGBA colors\n     */\n    readPixels(x, y, width, height, hasAlpha = true, flushRenderer = true) {\n        const numChannels = hasAlpha ? 4 : 3;\n        const format = hasAlpha ? this._gl.RGBA : this._gl.RGB;\n        const data = new Uint8Array(height * width * numChannels);\n        if (flushRenderer) {\n            this.flushFramebuffer();\n        }\n        this._gl.readPixels(x, y, width, height, format, this._gl.UNSIGNED_BYTE, data);\n        return Promise.resolve(data);\n    }\n    /**\n     * Gets a Promise<boolean> indicating if the engine can be instantiated (ie. if a webGL context can be found)\n     */\n    static get IsSupportedAsync() {\n        return Promise.resolve(this.isSupported());\n    }\n    /**\n     * Gets a boolean indicating if the engine can be instantiated (ie. if a webGL context can be found)\n     */\n    static get IsSupported() {\n        return this.isSupported(); // Backward compat\n    }\n    /**\n     * Gets a boolean indicating if the engine can be instantiated (ie. if a webGL context can be found)\n     * @returns true if the engine can be created\n     * @ignorenaming\n     */\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    static isSupported() {\n        if (this._HasMajorPerformanceCaveat !== null) {\n            return !this._HasMajorPerformanceCaveat; // We know it is performant so WebGL is supported\n        }\n        if (this._IsSupported === null) {\n            try {\n                const tempcanvas = this._CreateCanvas(1, 1);\n                const gl = tempcanvas.getContext(\"webgl\") || tempcanvas.getContext(\"experimental-webgl\");\n                this._IsSupported = gl != null && !!window.WebGLRenderingContext;\n            }\n            catch (e) {\n                this._IsSupported = false;\n            }\n        }\n        return this._IsSupported;\n    }\n    /**\n     * Gets a boolean indicating if the engine can be instantiated on a performant device (ie. if a webGL context can be found and it does not use a slow implementation)\n     */\n    static get HasMajorPerformanceCaveat() {\n        if (this._HasMajorPerformanceCaveat === null) {\n            try {\n                const tempcanvas = this._CreateCanvas(1, 1);\n                const gl = tempcanvas.getContext(\"webgl\", { failIfMajorPerformanceCaveat: true }) ||\n                    tempcanvas.getContext(\"experimental-webgl\", { failIfMajorPerformanceCaveat: true });\n                this._HasMajorPerformanceCaveat = !gl;\n            }\n            catch (e) {\n                this._HasMajorPerformanceCaveat = false;\n            }\n        }\n        return this._HasMajorPerformanceCaveat;\n    }\n    /**\n     * Find the next highest power of two.\n     * @param x Number to start search from.\n     * @returns Next highest power of two.\n     */\n    static CeilingPOT(x) {\n        x--;\n        x |= x >> 1;\n        x |= x >> 2;\n        x |= x >> 4;\n        x |= x >> 8;\n        x |= x >> 16;\n        x++;\n        return x;\n    }\n    /**\n     * Find the next lowest power of two.\n     * @param x Number to start search from.\n     * @returns Next lowest power of two.\n     */\n    static FloorPOT(x) {\n        x = x | (x >> 1);\n        x = x | (x >> 2);\n        x = x | (x >> 4);\n        x = x | (x >> 8);\n        x = x | (x >> 16);\n        return x - (x >> 1);\n    }\n    /**\n     * Find the nearest power of two.\n     * @param x Number to start search from.\n     * @returns Next nearest power of two.\n     */\n    static NearestPOT(x) {\n        const c = ThinEngine.CeilingPOT(x);\n        const f = ThinEngine.FloorPOT(x);\n        return c - x > x - f ? f : c;\n    }\n    /**\n     * Get the closest exponent of two\n     * @param value defines the value to approximate\n     * @param max defines the maximum value to return\n     * @param mode defines how to define the closest value\n     * @returns closest exponent of two of the given value\n     */\n    static GetExponentOfTwo(value, max, mode = 2) {\n        let pot;\n        switch (mode) {\n            case 1:\n                pot = ThinEngine.FloorPOT(value);\n                break;\n            case 2:\n                pot = ThinEngine.NearestPOT(value);\n                break;\n            case 3:\n            default:\n                pot = ThinEngine.CeilingPOT(value);\n                break;\n        }\n        return Math.min(pot, max);\n    }\n    /**\n     * Queue a new function into the requested animation frame pool (ie. this function will be executed by the browser (or the javascript engine) for the next frame)\n     * @param func - the function to be called\n     * @param requester - the object that will request the next frame. Falls back to window.\n     * @returns frame number\n     */\n    static QueueNewFrame(func, requester) {\n        // Note that there is kind of a typing issue here, as `setTimeout` might return something else than a number (NodeJs returns a NodeJS.Timeout object).\n        // Also if the global `requestAnimationFrame`'s returnType is number, `requester.requestPostAnimationFrame` and `requester.requestAnimationFrame` types\n        // are `any`.\n        if (!IsWindowObjectExist()) {\n            if (typeof requestAnimationFrame === \"function\") {\n                return requestAnimationFrame(func);\n            }\n        }\n        else {\n            const { requestPostAnimationFrame, requestAnimationFrame } = requester || window;\n            if (typeof requestPostAnimationFrame === \"function\") {\n                return requestPostAnimationFrame(func);\n            }\n            if (typeof requestAnimationFrame === \"function\") {\n                return requestAnimationFrame(func);\n            }\n        }\n        // fallback to the global `setTimeout`.\n        // In most cases (aka in the browser), `window` is the global object, so instead of calling `window.setTimeout` we could call the global `setTimeout`.\n        return setTimeout(func, 16);\n    }\n    /**\n     * Gets host document\n     * @returns the host document object\n     */\n    getHostDocument() {\n        if (this._renderingCanvas && this._renderingCanvas.ownerDocument) {\n            return this._renderingCanvas.ownerDocument;\n        }\n        return IsDocumentAvailable() ? document : null;\n    }\n}\n/** Use this array to turn off some WebGL2 features on known buggy browsers version */\nThinEngine.ExceptionList = [\n    { key: \"Chrome/63.0\", capture: \"63\\\\.0\\\\.3239\\\\.(\\\\d+)\", captureConstraint: 108, targets: [\"uniformBuffer\"] },\n    { key: \"Firefox/58\", capture: null, captureConstraint: null, targets: [\"uniformBuffer\"] },\n    { key: \"Firefox/59\", capture: null, captureConstraint: null, targets: [\"uniformBuffer\"] },\n    { key: \"Chrome/72.+?Mobile\", capture: null, captureConstraint: null, targets: [\"vao\"] },\n    { key: \"Chrome/73.+?Mobile\", capture: null, captureConstraint: null, targets: [\"vao\"] },\n    { key: \"Chrome/74.+?Mobile\", capture: null, captureConstraint: null, targets: [\"vao\"] },\n    { key: \"Mac OS.+Chrome/71\", capture: null, captureConstraint: null, targets: [\"vao\"] },\n    { key: \"Mac OS.+Chrome/72\", capture: null, captureConstraint: null, targets: [\"vao\"] },\n    { key: \"Mac OS.+Chrome\", capture: null, captureConstraint: null, targets: [\"uniformBuffer\"] },\n    // desktop osx safari 15.4\n    { key: \".*AppleWebKit.*(15.4).*Safari\", capture: null, captureConstraint: null, targets: [\"antialias\", \"maxMSAASamples\"] },\n    // mobile browsers using safari 15.4 on ios\n    { key: \".*(15.4).*AppleWebKit.*Safari\", capture: null, captureConstraint: null, targets: [\"antialias\", \"maxMSAASamples\"] },\n];\n/** @internal */\nThinEngine._TextureLoaders = [];\n// Updatable statics so stick with vars here\n/**\n * Gets or sets the epsilon value used by collision engine\n */\nThinEngine.CollisionsEpsilon = 0.001;\n// Statics\nThinEngine._IsSupported = null;\nThinEngine._HasMajorPerformanceCaveat = null;\n//# sourceMappingURL=thinEngine.js.map"],"names":["BufferPointer","ThinEngine","NpmPackage","Version","description","this","name","webGLVersion","_caps","parallelShaderCompile","_name","value","version","_webGLVersion","isDisposed","_isDisposed","ShadersRepository","_getShaderProcessor","shaderLanguage","_shaderProcessor","useReverseDepthBuffer","_useReverseDepthBuffer","useReverse","_depthCullingState","depthFunc","frameId","_frameId","supportsUniformBuffers","disableUniformBuffers","getCreationOptions","_creationOptions","_shouldUseHighPrecisionShader","highPrecisionShaderSupported","_highPrecisionShadersAllowed","needPOTTextures","forcePOTTextures","activeRenderLoops","_activeRenderLoops","doNotHandleContextLost","_doNotHandleContextLost","_supportsHardwareTextureRescaling","framebufferDimensionsObject","dimensions","_framebufferDimensionsObject","currentViewport","_cachedViewport","emptyTexture","_emptyTexture","createRawTexture","Uint8Array","emptyTexture3D","_emptyTexture3D","createRawTexture3D","emptyTexture2DArray","_emptyTexture2DArray","createRawTexture2DArray","emptyCubeTexture","_emptyCubeTexture","faceData","cubeData","createRawCubeTexture","isWebGPU","_isWebGPU","shaderPlatformName","_shaderPlatformName","snapshotRendering","activate","snapshotRenderingMode","_snapshotRenderingMode","mode","snapshotRenderingReset","static","width","height","document","OffscreenCanvas","canvas","createElement","createCanvas","_CreateCanvas","createCanvasImage","constructor","canvasOrContext","antialias","options","adaptToDeviceRatio","_a","_b","_c","_d","_e","_f","_g","_h","_j","_k","_l","isFullscreen","cullBackFaces","renderEvenInBackground","preventCacheWipeBetweenFrames","validateShaderPrograms","isNDCHalfZRange","hasOriginBottomLeft","onDisposeObservable","_uniformBuffers","Array","_storageBuffers","_windowIsBackground","_badOS","_badDesktopOS","_renderingQueueLaunched","onContextLostObservable","onContextRestoredObservable","_contextWasLost","disableVertexArrayObjects","_colorWrite","_colorWriteChanged","_stencilStateComposer","_stencilState","_alphaState","_alphaMode","_alphaEquation","_internalTexturesCache","_renderTargetWrapperCache","_activeChannel","_currentTextureChannel","_boundTexturesCache","_compiledEffects","_vertexAttribArraysEnabled","_uintIndicesCurrentlySet","_currentBoundBuffer","_currentFramebuffer","_dummyFramebuffer","_currentBufferPointers","_currentInstanceLocations","_currentInstanceBuffers","_vaoRecordInProgress","_mustWipeVertexAttributes","_nextFreeTextureSlots","_maxSimultaneousTextures","_maxMSAASamplesOverride","_activeRequests","_lastDevicePixelRatio","_transformTextureUrl","hostInformation","isMobile","premultipliedAlpha","onBeforeTextureInitObservable","_viewportCached","x","y","z","w","_unpackFlipYCached","enableUnpackFlipYCached","_boundUniforms","startTime","Now","stencilGlobal","SetMatrixPrecision","useHighPrecisionMatrix","deterministicLockstep","lockstepMaxSteps","timeStep","audioEngine","stencil","_audioContext","audioEngineOptions","audioContext","_audioDestination","audioDestination","useExactSrgbConversions","_isStencilEnable","devicePixelRatio","window","limitDeviceRatio","_hardwareScalingLevel","Math","min","getContext","_renderingCanvas","undefined","preserveDrawingBuffer","xrCompatible","navigator","userAgent","_setupMobileChecks","ua","exception","ExceptionList","key","targets","RegExp","test","capture","captureConstraint","constraint","matches","exec","length","parseInt","target","_onContextLost","evt","preventDefault","Warn","notifyObservers","_onContextRestored","_restoreEngineAfterContextLost","_initGLContext","bind","addEventListener","powerPreference","disableWebGL2Support","_gl","deleteQuery","e","Error","renderbufferStorageMultisample","attributes","getContextAttributes","pixelStorei","UNPACK_COLORSPACE_CONVERSION_WEBGL","NONE","useHighPrecisionFloats","resize","_initFeatures","i","maxVertexAttribs","versionToLog","console","log","setAttribute","_checkForMobile","currentUA","indexOf","initEngine","setTimeout","async","depthTest","depthMask","stencilTest","wipeCaches","_rebuildEffects","_rebuildComputeEffects","call","_rebuildBuffers","_rebuildInternalTextures","_rebuildRenderTargetWrappers","_sharedInit","_getShaderProcessingContext","currentState","slice","internalTexture","_rebuild","renderTargetWrapper","effect","_pipelineContext","_wasPreviouslyReady","_prepareEffect","ResetCache","areAllEffectsReady","isReady","uniformBuffer","storageBuffer","maxTexturesImageUnits","getParameter","MAX_TEXTURE_IMAGE_UNITS","maxCombinedTexturesImageUnits","MAX_COMBINED_TEXTURE_IMAGE_UNITS","maxVertexTextureImageUnits","MAX_VERTEX_TEXTURE_IMAGE_UNITS","maxTextureSize","MAX_TEXTURE_SIZE","maxSamples","MAX_SAMPLES","maxCubemapTextureSize","MAX_CUBE_MAP_TEXTURE_SIZE","maxRenderTextureSize","MAX_RENDERBUFFER_SIZE","MAX_VERTEX_ATTRIBS","maxVaryingVectors","MAX_VARYING_VECTORS","maxFragmentUniformVectors","MAX_FRAGMENT_UNIFORM_VECTORS","maxVertexUniformVectors","MAX_VERTEX_UNIFORM_VECTORS","getExtension","standardDerivatives","maxAnisotropy","astc","bptc","s3tc","s3tc_srgb","pvrtc","etc1","etc2","textureAnisotropicFilterExtension","uintIndices","fragmentDepthSupported","timerQuery","supportOcclusionQuery","canUseTimestampForTimerQuery","drawBuffersExtension","maxMSAASamples","colorBufferFloat","colorBufferHalfFloat","textureFloat","textureHalfFloat","textureHalfFloatRender","textureFloatLinearFiltering","textureFloatRender","textureHalfFloatLinearFiltering","vertexArrayObject","instancedArrays","textureLOD","texelFetch","blendMinMax","multiview","oculusMultiview","depthTextureExtension","canUseGLInstanceID","canUseGLVertexID","supportComputeShaders","supportSRGBBuffers","supportTransformFeedbacks","textureMaxLevel","texture2DArrayMaxLayerCount","MAX_ARRAY_TEXTURE_LAYERS","disableMorphTargetTexture","_glVersion","VERSION","rendererInfo","_glRenderer","UNMASKED_RENDERER_WEBGL","_glVendor","UNMASKED_VENDOR_WEBGL","VENDOR","RENDERER","HALF_FLOAT_OES","RGBA16F","RGBA32F","DEPTH24_STENCIL8","getQuery","getQueryEXT","TIMESTAMP_EXT","QUERY_COUNTER_BITS_EXT","MAX_TEXTURE_MAX_ANISOTROPY_EXT","_canRenderToFloatFramebuffer","COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR","COMPRESSED_SRGB_ALPHA_BPTC_UNORM_EXT","COMPRESSED_SRGB_S3TC_DXT1_EXT","COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT","COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT","COMPRESSED_SRGB8_ETC2","COMPRESSED_SRGB8_ALPHA8_ETC2_EAC","_canRenderToHalfFloatFramebuffer","drawBuffers","drawBuffersWEBGL","DRAW_FRAMEBUFFER","FRAMEBUFFER","UNSIGNED_INT_24_8","UNSIGNED_INT_24_8_WEBGL","vertexArrayObjectExtension","createVertexArray","createVertexArrayOES","bindVertexArray","bindVertexArrayOES","deleteVertexArray","deleteVertexArrayOES","instanceExtension","drawArraysInstanced","drawArraysInstancedANGLE","drawElementsInstanced","drawElementsInstancedANGLE","vertexAttribDivisor","vertexAttribDivisorANGLE","getShaderPrecisionFormat","vertexhighp","VERTEX_SHADER","HIGH_FLOAT","fragmenthighp","FRAGMENT_SHADER","precision","blendMinMaxExtension","MAX","MAX_EXT","MIN","MIN_EXT","_glSRGBExtensionValues","SRGB","WebGL2RenderingContext","SRGB8","SRGB8_ALPHA8","sRGBExtension","SRGB_EXT","SRGB_ALPHA_EXT","forceSRGBBufferSupportState","LEQUAL","slot","push","_features","forceBitmapOverHTMLImageElement","supportRenderAndCopyToLodForFloatTextures","supportDepthStencilTexture","supportShadowSamplers","uniformBufferHardCheckMatrix","allowTexturePrefiltering","trackUbosInFrame","checkUbosContentBeforeUpload","supportCSM","basisNeedsPOT","support3DTextures","needTypeSuffixInShaderConstants","supportMSAA","supportSSAO2","supportExtendedTextureFormats","supportSwitchCaseInShader","supportSyncTextureRead","needsInvertingBitmap","useUBOBindingCache","needShaderCodeInlining","needToAlwaysBindUniformBuffers","supportRenderPasses","supportSpriteInstancing","_collectUbosUpdatedInFrame","getClassName","isStencilEnable","_prepareWorkingCanvas","_workingCanvas","context","_workingContext","resetTextureCache","Object","prototype","hasOwnProperty","getInfo","getGlInfo","vendor","renderer","setHardwareScalingLevel","level","getHardwareScalingLevel","getLoadedTexturesCache","getCaps","stopRenderLoop","renderFunction","index","splice","_renderLoop","shouldRender","beginFrame","endFrame","_frameHandler","_queueNewFrame","_boundRenderFunction","getHostWindow","getRenderingCanvas","getAudioContext","getAudioDestination","ownerDocument","defaultView","getRenderWidth","useScreen","_currentRenderTarget","framebufferWidth","drawingBufferWidth","getRenderHeight","framebufferHeight","drawingBufferHeight","bindedRenderFunction","requester","QueueNewFrame","runRenderLoop","clear","color","backBuffer","depth","useStencilGlobalOnly","stencilStateComposer","applyStates","clearColor","r","g","b","a","COLOR_BUFFER_BIT","GEQUAL","clearDepth","DEPTH_BUFFER_BIT","clearStencil","STENCIL_BUFFER_BIT","_viewport","viewport","setViewport","requiredWidth","requiredHeight","flushFramebuffer","forceSetSize","changeRatio","boundingRect","getBoundingClientRect","clientWidth","clientHeight","innerWidth","innerHeight","setSize","bindFramebuffer","rtWrapper","faceIndex","forceFullscreenViewport","lodLevel","layer","webglRTWrapper","unBindFramebuffer","_bindUnboundFramebuffer","_MSAAFramebuffer","_framebuffer","gl","isMulti","is2DArray","framebufferTextureLayer","COLOR_ATTACHMENT0","texture","_hardwareTexture","underlyingResource","isCube","framebufferTexture2D","TEXTURE_CUBE_MAP_POSITIVE_X","depthStencilTexture","_depthStencilTexture","attachment","_depthStencilTextureWithStencil","DEPTH_STENCIL_ATTACHMENT","DEPTH_ATTACHMENT","TEXTURE_2D","pow","setState","culling","zOffset","force","reverseSide","zOffsetUnits","cull","cullFace","BACK","FRONT","setZOffset","setZOffsetUnits","frontFace","CW","CCW","stencilMaterial","getDepthBuffer","setDepthBuffer","enable","getZOffset","getZOffsetUnits","framebuffer","_currentFrameBufferIsDefaultFrameBuffer","generateMipmaps","_bindTextureDirectly","generateMipmap","disableGenerateMipMaps","onBeforeUnbind","unBindMultiColorAttachmentFramebuffer","READ_FRAMEBUFFER","blitFramebuffer","NEAREST","generateMipMaps","flush","restoreDefaultFramebuffer","_resetVertexBufferBinding","bindArrayBuffer","_cachedVertexBuffers","createVertexBuffer","data","_createVertexBuffer","STATIC_DRAW","usage","vbo","createBuffer","dataBuffer","bufferData","ARRAY_BUFFER","Float32Array","references","createDynamicVertexBuffer","DYNAMIC_DRAW","_resetIndexBufferBinding","bindIndexBuffer","_cachedIndexBuffer","createIndexBuffer","indices","updatable","_normalizeIndexData","ELEMENT_ARRAY_BUFFER","is32Bits","BYTES_PER_ELEMENT","Uint32Array","Uint16Array","buffer","_unbindVertexArrayObject","_bindBuffer","bindUniformBlock","pipelineContext","blockName","program","uniformLocation","getUniformBlockIndex","uniformBlockBinding","bindBuffer","updateArrayBuffer","bufferSubData","_vertexAttribPointer","indx","size","type","normalized","stride","offset","pointer","changed","active","UNSIGNED_INT","INT","vertexAttribIPointer","vertexAttribPointer","_bindIndexBufferWithCache","indexBuffer","_bindVertexBuffersAttributes","vertexBuffers","overrideVertexBuffers","getAttributesNames","unbindAllAttributes","order","getAttributeLocation","ai","vertexBuffer","enableVertexAttribArray","getBuffer","getSize","byteStride","byteOffset","getIsInstanced","getInstanceDivisor","recordVertexArrayObject","vao","bindVertexArrayObject","_cachedVertexArrayObject","bindBuffersDirectly","vertexDeclaration","vertexStrideSize","_cachedEffectForVertexBuffers","attributesCount","getAttributesCount","FLOAT","bindBuffers","unbindInstanceAttributes","boundBuffer","ul","instancesBuffer","offsetLocation","releaseVertexArrayObject","_releaseBuffer","_deleteBuffer","deleteBuffer","updateAndBindInstancesBuffer","offsetLocations","bindInstancesBuffer","attributesInfo","computeStride","attributeSize","_currentEffect","getAttributeLocationByName","attributeName","attributeType","divisor","disableInstanceAttributeByName","attributeLocation","disableInstanceAttribute","shouldClean","disableAttributeByIndex","disableVertexAttribArray","draw","useTriangles","indexStart","indexCount","instancesCount","drawElementsType","drawPointClouds","verticesStart","verticesCount","drawArraysType","drawUnIndexed","fillMode","_reportDrawCall","drawMode","_drawMode","indexFormat","UNSIGNED_SHORT","mult","drawElements","drawArrays","TRIANGLES","POINTS","LINES","LINE_LOOP","LINE_STRIP","TRIANGLE_STRIP","TRIANGLE_FAN","_releaseEffect","_key","getPipelineContext","_deletePipelineContext","webGLPipelineContext","__SPECTOR_rebuildProgram","deleteProgram","_getGlobalDefines","defines","s","createEffect","baseName","attributesNamesOrOptions","uniformsNamesOrEngine","samplers","fallbacks","onCompiled","onError","indexParameters","GLSL","vertex","vertexElement","vertexToken","vertexSource","fragment","fragmentElement","fragmentToken","fragmentSource","globalDefines","fullDefines","compiledEffect","source","shaderVersion","_compileShader","_compileRawShader","_ConcatenateShader","shader","createShader","error","NO_ERROR","tempError","getError","isContextLost","shaderSource","compileShader","_getShaderSource","getShaderSource","createRawShaderProgram","vertexCode","fragmentCode","transformFeedbackVaryings","vertexShader","fragmentShader","_createShaderProgram","createShaderProgram","inlineShaderCode","code","createPipelineContext","shaderProcessingContext","engine","isParallelCompiled","createMaterialContext","createDrawContext","shaderProgram","createProgram","attachShader","linkProgram","_finalizePipelineContext","getProgramParameter","LINK_STATUS","getShaderParameter","COMPILE_STATUS","getShaderInfoLog","vertexCompilationError","fragmentCompilationError","getProgramInfoLog","programLinkError","validateProgram","VALIDATE_STATUS","programValidationError","deleteShader","_preparePipelineContext","vertexSourceCode","fragmentSourceCode","createAsRaw","rawVertexSourceCode","rawFragmentSourceCode","rebuildRebind","webGLRenderingState","_isRenderingStateCompiled","COMPLETION_STATUS_KHR","_executeWhenRenderingStateIsCompiled","action","oldHandler","getUniforms","uniformsNames","results","getUniformLocation","getAttributes","attributesNames","getAttribLocation","enableEffect","IsWrapper","bindSamplers","onBind","_onBindObservable","setInt","uniform","uniform1i","setInt2","uniform2i","setInt3","uniform3i","setInt4","uniform4i","setIntArray","array","uniform1iv","setIntArray2","uniform2iv","setIntArray3","uniform3iv","setIntArray4","uniform4iv","setUInt","uniform1ui","setUInt2","uniform2ui","setUInt3","uniform3ui","setUInt4","uniform4ui","setUIntArray","uniform1uiv","setUIntArray2","uniform2uiv","setUIntArray3","uniform3uiv","setUIntArray4","uniform4uiv","setArray","uniform1fv","setArray2","uniform2fv","setArray3","uniform3fv","setArray4","uniform4fv","setMatrices","matrices","uniformMatrix4fv","setMatrix3x3","matrix","uniformMatrix3fv","setMatrix2x2","uniformMatrix2fv","setFloat","uniform1f","setFloat2","uniform2f","setFloat3","uniform3f","setFloat4","uniform4f","apply","colorMask","setColorWrite","getColorWrite","depthCullingState","alphaState","stencilState","clearInternalTexturesCache","bruteForce","_currentProgram","reset","UNPACK_PREMULTIPLY_ALPHA_WEBGL","_getSamplingParameters","samplingMode","magFilter","minFilter","LINEAR","LINEAR_MIPMAP_NEAREST","LINEAR_MIPMAP_LINEAR","NEAREST_MIPMAP_LINEAR","NEAREST_MIPMAP_NEAREST","mag","_createTexture","createTexture","_createHardwareTexture","_createInternalTexture","delayGPUTextureCreation","Unknown","label","format","useSRGBBuffer","samples","layers","filters","TEXTURE_2D_ARRAY","sizedFormat","_getRGBABufferInternalSizedFormat","internalFormat","_getInternalFormat","textureType","_getWebGLTextureType","texImage3D","texImage2D","texParameteri","TEXTURE_MAG_FILTER","TEXTURE_MIN_FILTER","TEXTURE_WRAP_S","CLAMP_TO_EDGE","TEXTURE_WRAP_T","_useSRGBBuffer","baseWidth","baseHeight","_getUseSRGBBuffer","noMipmap","_createTextureBase","url","invertY","scene","onLoad","prepareTexture","prepareTextureProcessFunction","fallback","forcedExtension","mimeType","loaderOptions","fromData","substr","fromBlob","isBase64","Url","substring","originalUrl","_originalUrl","lastDot","lastIndexOf","extension","toLowerCase","loader","split","availableLoader","_TextureLoaders","canLoad","addPendingData","_buffer","onLoadObserver","onLoadedObservable","add","onInternalError","message","removePendingData","remove","UseFallbackTexture","FallbackTexture","onErrorObservable","callback","loadData","loadMipmap","isCompressed","done","loadFailed","ArrayBuffer","isView","_loadFile","offlineProvider","request","responseURL","onload","img","decoding","close","_FileToolsLoadImage","imageOrientation","Blob","creationFlags","_prepareWebGLTexture","potWidth","potHeight","continuationCallback","isPot","RGBA","RGB","texelFormat","UNSIGNED_BYTE","drawImage","Temp","_rescaleTexture","_releaseTexture","input","imageBitmapOptions","destination","onComplete","compression","_unpackFlipY","UNPACK_FLIP_Y_WEBGL","_getUnpackAlignement","UNPACK_ALIGNMENT","_getTextureTarget","TEXTURE_CUBE_MAP","is3D","TEXTURE_3D","isMultiview","updateTextureSamplingMode","useMipMaps","_setTextureParameterInteger","updateTextureDimensions","updateTextureWrappingMode","wrapU","wrapV","wrapR","_getTextureWrapMode","_cachedWrapU","_cachedWrapV","TEXTURE_WRAP_R","_cachedWrapR","_setupDepthStencilTexture","generateStencil","bilinearFiltering","comparisonFunction","_comparisonFunction","samplingParameters","TEXTURE_COMPARE_FUNC","TEXTURE_COMPARE_MODE","COMPARE_REF_TO_TEXTURE","_uploadCompressedDataToTextureDirectly","lod","compressedTexImage2D","_uploadDataToTextureDirectly","imageData","babylonInternalFormat","useTextureWidthAndHeight","lodMaxWidth","round","LOG2E","lodMaxHeight","max","updateTextureData","xOffset","yOffset","targetForBinding","texSubImage2D","_uploadArrayBufferViewToTexture","bindTarget","_prepareWebGLTextureContinuation","processFunction","GetExponentOfTwo","_setupFramebufferDepthAttachments","generateStencilBuffer","generateDepthBuffer","_createRenderBuffer","DEPTH_STENCIL","depthFormat","DEPTH_COMPONENT16","DEPTH_COMPONENT32F","STENCIL_INDEX8","STENCIL_ATTACHMENT","msInternalFormat","unbindBuffer","renderBuffer","createRenderbuffer","_updateRenderBuffer","bindRenderbuffer","RENDERBUFFER","renderbufferStorage","framebufferRenderbuffer","_deleteTexture","unbindAllTextures","_lodTextureHigh","dispose","_lodTextureMid","_lodTextureLow","_irradianceTexture","_releaseRenderTargetWrapper","deleteTexture","_setProgram","useProgram","getSamplers","getUniform","_activateCurrentTexture","activeTexture","TEXTURE0","forTextureDataUpdate","wasPreviouslyBound","isTextureForRendering","_associatedChannel","bindTexture","_bindSamplerUniformToChannel","_bindTexture","channel","setTexture","_setTexture","sourceSlot","_currentState","REPEAT","MIRRORED_REPEAT","isPartOfTextureArray","video","videoInternalTexture","getInternalTexture","update","delayLoadState","delayLoad","needToBind","_cachedCoordinatesMode","coordinatesMode","textureWrapMode","_setAnisotropicLevel","anisotropicFilteringLevel","setTextureArray","textures","_textureUnits","Int32Array","anisotropicFilterExtension","_cachedAnisotropicFilteringLevel","_setTextureParameterFloat","TEXTURE_MAX_ANISOTROPY_EXT","parameter","texParameterf","releaseEffects","deleteFramebuffer","releaseComputeEffects","removeEventListener","abort","attachContextLostEvent","attachContextRestoredEvent","_canRenderToFramebuffer","successful","fb","createFramebuffer","status","checkFramebufferStatus","FRAMEBUFFER_COMPLETE","readFormat","readType","readPixels","UNSIGNED_SHORT_4_4_4_4","UNSIGNED_SHORT_5_5_5_1","UNSIGNED_SHORT_5_6_5","BYTE","SHORT","HALF_FLOAT","UNSIGNED_INT_2_10_10_10_REV","UNSIGNED_INT_10F_11F_11F_REV","UNSIGNED_INT_5_9_9_9_REV","FLOAT_32_UNSIGNED_INT_24_8_REV","ALPHA","LUMINANCE","LUMINANCE_ALPHA","RED","RG","RED_INTEGER","RG_INTEGER","RGB_INTEGER","RGBA_INTEGER","R8_SNORM","RG8_SNORM","RGB8_SNORM","R8I","RG8I","RGB8I","RGBA8I","RGBA8_SNORM","R8","RG8","RGB8","RGBA8","R8UI","RG8UI","RGB8UI","RGBA8UI","R16I","RG16I","RGB16I","RGBA16I","R16UI","RG16UI","RGB16UI","RGBA16UI","R32I","RG32I","RGB32I","RGBA32I","R32UI","RG32UI","RGB32UI","RGBA32UI","R32F","RG32F","RGB32F","R16F","RG16F","RGB16F","RGB565","R11F_G11F_B10F","RGB9_E5","RGBA4","RGB5_A1","RGB10_A2","RGB10_A2UI","_getRGBAMultiSampleBufferFormat","onSuccess","onProgress","useArrayBuffer","_FileToolsLoadFile","onCompleteObservable","hasAlpha","flushRenderer","numChannels","Promise","resolve","IsSupportedAsync","isSupported","IsSupported","_HasMajorPerformanceCaveat","_IsSupported","tempcanvas","WebGLRenderingContext","HasMajorPerformanceCaveat","failIfMajorPerformanceCaveat","c","CeilingPOT","f","FloorPOT","pot","NearestPOT","func","requestPostAnimationFrame","requestAnimationFrame","getHostDocument","CollisionsEpsilon"],"sourceRoot":""}