{"version":3,"file":"vendor.flatbuffers.692a2838a9281cc1.bundle.js","mappings":"6IAAO,MAGMA,EAAqB,ECHrBC,EAAQ,IAAIC,WAAW,GACvBC,EAAU,IAAIC,aAAaH,EAAMI,QACjCC,EAAU,IAAIC,aAAaN,EAAMI,QACjCG,EAAuE,IAAtD,IAAIC,YAAY,IAAIC,WAAW,CAAC,EAAG,IAAIL,QAAQ,GCHtE,IAAIM,GACX,SAAWA,GACPA,EAASA,EAAqB,WAAI,GAAK,aACvCA,EAASA,EAAuB,aAAI,GAAK,cAC5C,CAHD,CAGGA,IAAaA,EAAW,CAAC,ICDrB,MAAMC,EAIT,WAAAC,CAAYC,GACRC,KAAKD,OAASA,EACdC,KAAKC,UAAY,EACjBD,KAAKE,cAAgB,IAAIC,WAC7B,CAIA,eAAOC,CAASC,GACZ,OAAO,IAAIR,EAAW,IAAIF,WAAWU,GACzC,CACA,KAAAC,GACIN,KAAKC,UAAY,CACrB,CAIA,KAAAM,GACI,OAAOP,KAAKD,MAChB,CAIA,QAAAS,GACI,OAAOR,KAAKC,SAChB,CAIA,WAAAQ,CAAYD,GACRR,KAAKC,UAAYO,CACrB,CAIA,QAAAE,GACI,OAAOV,KAAKD,OAAOY,MACvB,CACA,QAAAC,CAASC,GACL,OAAOb,KAAKc,UAAUD,IAAW,IAAM,EAC3C,CACA,SAAAC,CAAUD,GACN,OAAOb,KAAKD,OAAOc,EACvB,CACA,SAAAE,CAAUF,GACN,OAAOb,KAAKgB,WAAWH,IAAW,IAAM,EAC5C,CACA,UAAAG,CAAWH,GACP,OAAOb,KAAKD,OAAOc,GAAUb,KAAKD,OAAOc,EAAS,IAAM,CAC5D,CACA,SAAAI,CAAUJ,GACN,OAAOb,KAAKD,OAAOc,GAAUb,KAAKD,OAAOc,EAAS,IAAM,EAAIb,KAAKD,OAAOc,EAAS,IAAM,GAAKb,KAAKD,OAAOc,EAAS,IAAM,EAC3H,CACA,UAAAK,CAAWL,GACP,OAAOb,KAAKiB,UAAUJ,KAAY,CACtC,CACA,SAAAM,CAAUN,GACN,OAAOO,OAAOC,OAAO,GAAID,OAAOpB,KAAKkB,WAAWL,KAAYO,OAAOpB,KAAKkB,WAAWL,EAAS,KAAOO,OAAO,KAC9G,CACA,UAAAE,CAAWT,GACP,OAAOO,OAAOG,QAAQ,GAAIH,OAAOpB,KAAKkB,WAAWL,KAAYO,OAAOpB,KAAKkB,WAAWL,EAAS,KAAOO,OAAO,KAC/G,CACA,WAAAI,CAAYX,GAER,OADA3B,EAAM,GAAKc,KAAKiB,UAAUJ,GACnBzB,EAAQ,EACnB,CACA,WAAAqC,CAAYZ,GAGR,OAFA3B,EAAMO,EAAiB,EAAI,GAAKO,KAAKiB,UAAUJ,GAC/C3B,EAAMO,EAAiB,EAAI,GAAKO,KAAKiB,UAAUJ,EAAS,GACjDtB,EAAQ,EACnB,CACA,SAAAmC,CAAUb,EAAQc,GACd3B,KAAKD,OAAOc,GAAUc,CAC1B,CACA,UAAAC,CAAWf,EAAQc,GACf3B,KAAKD,OAAOc,GAAUc,CAC1B,CACA,UAAAE,CAAWhB,EAAQc,GACf3B,KAAKD,OAAOc,GAAUc,EACtB3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,CACvC,CACA,WAAAG,CAAYjB,EAAQc,GAChB3B,KAAKD,OAAOc,GAAUc,EACtB3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,CACvC,CACA,UAAAI,CAAWlB,EAAQc,GACf3B,KAAKD,OAAOc,GAAUc,EACtB3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,EACnC3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,GACnC3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,EACvC,CACA,WAAAK,CAAYnB,EAAQc,GAChB3B,KAAKD,OAAOc,GAAUc,EACtB3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,EACnC3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,GACnC3B,KAAKD,OAAOc,EAAS,GAAKc,GAAS,EACvC,CACA,UAAAM,CAAWpB,EAAQc,GACf3B,KAAK+B,WAAWlB,EAAQqB,OAAOd,OAAOC,OAAO,GAAIM,KACjD3B,KAAK+B,WAAWlB,EAAS,EAAGqB,OAAOd,OAAOC,OAAO,GAAIM,GAASP,OAAO,MACzE,CACA,WAAAe,CAAYtB,EAAQc,GAChB3B,KAAKgC,YAAYnB,EAAQqB,OAAOd,OAAOG,QAAQ,GAAII,KACnD3B,KAAKgC,YAAYnB,EAAS,EAAGqB,OAAOd,OAAOG,QAAQ,GAAII,GAASP,OAAO,MAC3E,CACA,YAAAgB,CAAavB,EAAQc,GACjBvC,EAAQ,GAAKuC,EACb3B,KAAK+B,WAAWlB,EAAQ3B,EAAM,GAClC,CACA,YAAAmD,CAAaxB,EAAQc,GACjBpC,EAAQ,GAAKoC,EACb3B,KAAK+B,WAAWlB,EAAQ3B,EAAMO,EAAiB,EAAI,IACnDO,KAAK+B,WAAWlB,EAAS,EAAG3B,EAAMO,EAAiB,EAAI,GAC3D,CAMA,mBAAA6C,GACI,GAAItC,KAAKD,OAAOY,OAASX,KAAKC,UH9HZ,EACY,EG+H1B,MAAM,IAAIsC,MAAM,kEAEpB,IAAIC,EAAS,GACb,IAAK,IAAIC,EAAI,EAAGA,EHlIc,EGkIcA,IACxCD,GAAUE,OAAOC,aAAa3C,KAAKY,SAASZ,KAAKC,UHpInC,EGoI4DwC,IAE9E,OAAOD,CACX,CAKA,QAAAI,CAASC,EAAQC,GACb,MAAMC,EAASF,EAAS7C,KAAKiB,UAAU4B,GACvC,OAAOC,EAAgB9C,KAAKe,UAAUgC,GAAU/C,KAAKe,UAAUgC,EAASD,GAAiB,CAC7F,CAIA,OAAAE,CAAQC,EAAGpC,GAGP,OAFAoC,EAAEJ,OAAShC,EAASb,KAAKiB,UAAUJ,GACnCoC,EAAEC,GAAKlD,KACAiD,CACX,CAYA,QAAAE,CAAStC,EAAQuC,GACbvC,GAAUb,KAAKiB,UAAUJ,GACzB,MAAMF,EAASX,KAAKiB,UAAUJ,GAC9BA,GHtKkB,EGuKlB,MAAMwC,EAAYrD,KAAKD,OAAOuD,SAASzC,EAAQA,EAASF,GACxD,OAAIyC,IAAiBxD,EAAS2D,WACnBF,EAEArD,KAAKE,cAAcsD,OAAOH,EACzC,CAQA,mBAAAI,CAAoBC,EAAG7C,GACnB,MAAiB,iBAAN6C,EACA1D,KAAKmD,SAAStC,GAElBb,KAAKgD,QAAQU,EAAG7C,EAC3B,CAIA,UAAA8C,CAAW9C,GACP,OAAOA,EAASb,KAAKiB,UAAUJ,EACnC,CAIA,QAAA+C,CAAS/C,GACL,OAAOA,EAASb,KAAKiB,UAAUJ,GHpMb,CGqMtB,CAIA,YAAAgD,CAAahD,GACT,OAAOb,KAAKiB,UAAUJ,EAASb,KAAKiB,UAAUJ,GAClD,CACA,gBAAAiD,CAAiBC,GACb,GH5M8B,GG4M1BA,EAAMpD,OACN,MAAM,IAAI4B,MAAM,iDAGpB,IAAK,IAAIE,EAAI,EAAGA,EHhNc,EGgNcA,IACxC,GAAIsB,EAAMC,WAAWvB,IAAMzC,KAAKY,SAASZ,KAAKQ,WHlNhC,EGkN0DiC,GACpE,OAAO,EAGf,OAAO,CACX,CAIA,gBAAAwB,CAAiBC,EAAcC,GAC3B,MAAMC,EAAM,GACZ,IAAK,IAAI3B,EAAI,EAAGA,EAAI0B,IAAc1B,EAAG,CACjC,MAAM4B,EAAMH,EAAazB,GACb,OAAR4B,GACAD,EAAIE,KAAKD,EAEjB,CACA,OAAOD,CACX,CAOA,aAAAG,CAAcL,EAAcC,GACxB,MAAMC,EAAM,GACZ,IAAK,IAAI3B,EAAI,EAAGA,EAAI0B,IAAc1B,EAAG,CACjC,MAAM4B,EAAMH,EAAazB,GACb,OAAR4B,GACAD,EAAIE,KAAKD,EAAIG,SAErB,CACA,OAAOJ,CACX,ECnPG,MAAMK,EAIT,WAAA3E,CAAY4E,GAmBR,IAAIC,EAjBJ3E,KAAK4E,SAAW,EAEhB5E,KAAK+C,OAAS,KAEd/C,KAAK6E,cAAgB,EAErB7E,KAAK8E,UAAW,EAEhB9E,KAAK+E,aAAe,EAEpB/E,KAAKgF,QAAU,GAEfhF,KAAKiF,iBAAmB,EAExBjF,KAAKkF,gBAAiB,EACtBlF,KAAKmF,YAAc,KACnBnF,KAAKoF,aAAe,IAAIC,YAMpBV,EAJCD,GACc,KASnB1E,KAAKkD,GAAKrD,EAAWO,SAASuE,GAC9B3E,KAAKsF,MAAQX,CACjB,CACA,KAAArE,GACIN,KAAKkD,GAAG5C,QACRN,KAAKsF,MAAQtF,KAAKkD,GAAGxC,WACrBV,KAAK4E,SAAW,EAChB5E,KAAK+C,OAAS,KACd/C,KAAK6E,cAAgB,EACrB7E,KAAK8E,UAAW,EAChB9E,KAAK+E,aAAe,EACpB/E,KAAKgF,QAAU,GACfhF,KAAKiF,iBAAmB,EACxBjF,KAAKkF,gBAAiB,EACtBlF,KAAKmF,YAAc,IACvB,CAQA,aAAAI,CAAcA,GACVvF,KAAKkF,eAAiBK,CAC1B,CAMA,UAAAC,GACI,OAAOxF,KAAKkD,EAChB,CAKA,YAAAuC,GACI,OAAOzF,KAAKkD,GAAG3C,QAAQ+C,SAAStD,KAAKkD,GAAG1C,WAAYR,KAAKkD,GAAG1C,WAAaR,KAAKa,SAClF,CAUA,IAAA6E,CAAKC,EAAMC,GAEHD,EAAO3F,KAAK4E,WACZ5E,KAAK4E,SAAWe,GAIpB,MAAME,EAAwE,IAAvD7F,KAAKkD,GAAGxC,WAAaV,KAAKsF,MAAQM,GAA2BD,EAAO,EAE3F,KAAO3F,KAAKsF,MAAQO,EAAaF,EAAOC,GAAkB,CACtD,MAAME,EAAe9F,KAAKkD,GAAGxC,WAC7BV,KAAKkD,GAAKuB,EAAQsB,eAAe/F,KAAKkD,IACtClD,KAAKsF,OAAStF,KAAKkD,GAAGxC,WAAaoF,CACvC,CACA9F,KAAKgG,IAAIH,EACb,CACA,GAAAG,CAAI3F,GACA,IAAK,IAAIoC,EAAI,EAAGA,EAAIpC,EAAWoC,IAC3BzC,KAAKkD,GAAGxB,YAAY1B,KAAKsF,MAAO,EAExC,CACA,SAAA5D,CAAUC,GACN3B,KAAKkD,GAAGxB,UAAU1B,KAAKsF,OAAS,EAAG3D,EACvC,CACA,UAAAE,CAAWF,GACP3B,KAAKkD,GAAGrB,WAAW7B,KAAKsF,OAAS,EAAG3D,EACxC,CACA,UAAAI,CAAWJ,GACP3B,KAAKkD,GAAGnB,WAAW/B,KAAKsF,OAAS,EAAG3D,EACxC,CACA,UAAAM,CAAWN,GACP3B,KAAKkD,GAAGjB,WAAWjC,KAAKsF,OAAS,EAAG3D,EACxC,CACA,YAAAS,CAAaT,GACT3B,KAAKkD,GAAGd,aAAapC,KAAKsF,OAAS,EAAG3D,EAC1C,CACA,YAAAU,CAAaV,GACT3B,KAAKkD,GAAGb,aAAarC,KAAKsF,OAAS,EAAG3D,EAC1C,CAKA,OAAAsE,CAAQtE,GACJ3B,KAAK0F,KAAK,EAAG,GACb1F,KAAK0B,UAAUC,EACnB,CAKA,QAAAuE,CAASvE,GACL3B,KAAK0F,KAAK,EAAG,GACb1F,KAAK6B,WAAWF,EACpB,CAKA,QAAAwE,CAASxE,GACL3B,KAAK0F,KAAK,EAAG,GACb1F,KAAK+B,WAAWJ,EACpB,CAKA,QAAAyE,CAASzE,GACL3B,KAAK0F,KAAK,EAAG,GACb1F,KAAKiC,WAAWN,EACpB,CAKA,UAAA0E,CAAW1E,GACP3B,KAAK0F,KAAK,EAAG,GACb1F,KAAKoC,aAAaT,EACtB,CAKA,UAAA2E,CAAW3E,GACP3B,KAAK0F,KAAK,EAAG,GACb1F,KAAKqC,aAAaV,EACtB,CACA,YAAA4E,CAAaC,EAAS7E,EAAO8E,IACrBzG,KAAKkF,gBAAkBvD,GAAS8E,KAChCzG,KAAKiG,QAAQtE,GACb3B,KAAK0G,KAAKF,GAElB,CACA,aAAAG,CAAcH,EAAS7E,EAAO8E,IACtBzG,KAAKkF,gBAAkBvD,GAAS8E,KAChCzG,KAAKkG,SAASvE,GACd3B,KAAK0G,KAAKF,GAElB,CACA,aAAAI,CAAcJ,EAAS7E,EAAO8E,IACtBzG,KAAKkF,gBAAkBvD,GAAS8E,KAChCzG,KAAKmG,SAASxE,GACd3B,KAAK0G,KAAKF,GAElB,CACA,aAAAK,CAAcL,EAAS7E,EAAO8E,IACtBzG,KAAKkF,gBAAkBvD,IAAU8E,KACjCzG,KAAKoG,SAASzE,GACd3B,KAAK0G,KAAKF,GAElB,CACA,eAAAM,CAAgBN,EAAS7E,EAAO8E,IACxBzG,KAAKkF,gBAAkBvD,GAAS8E,KAChCzG,KAAKqG,WAAW1E,GAChB3B,KAAK0G,KAAKF,GAElB,CACA,eAAAO,CAAgBP,EAAS7E,EAAO8E,IACxBzG,KAAKkF,gBAAkBvD,GAAS8E,KAChCzG,KAAKsG,WAAW3E,GAChB3B,KAAK0G,KAAKF,GAElB,CACA,cAAAQ,CAAeR,EAAS7E,EAAO8E,IACvBzG,KAAKkF,gBAAkBvD,GAAS8E,KAChCzG,KAAKiH,UAAUtF,GACf3B,KAAK0G,KAAKF,GAElB,CAIA,cAAAU,CAAeV,EAAS7E,EAAO8E,GACvB9E,GAAS8E,IACTzG,KAAKmH,OAAOxF,GACZ3B,KAAK0G,KAAKF,GAElB,CAMA,MAAAW,CAAOC,GACH,GAAIA,GAAOpH,KAAKa,SACZ,MAAM,IAAIwG,UAAU,iDAE5B,CAKA,SAAAC,GACI,GAAItH,KAAK8E,SACL,MAAM,IAAIuC,UAAU,wDAE5B,CAIA,IAAAX,CAAKF,GACmB,OAAhBxG,KAAK+C,SACL/C,KAAK+C,OAAOyD,GAAWxG,KAAKa,SACpC,CAIA,MAAAA,GACI,OAAOb,KAAKkD,GAAGxC,WAAaV,KAAKsF,KACrC,CAaA,qBAAOS,CAAe7C,GAClB,MAAM4C,EAAe5C,EAAGxC,WAExB,GAAmB,WAAfoF,EACA,MAAM,IAAIvD,MAAM,uDAEpB,MAAMgF,EAAezB,GAAgB,EAC/B0B,EAAM3H,EAAWO,SAASmH,GAGhC,OAFAC,EAAI/G,YAAY8G,EAAezB,GAC/B0B,EAAIjH,QAAQkH,IAAIvE,EAAG3C,QAASgH,EAAezB,GACpC0B,CACX,CAMA,SAAAP,CAAUpG,GACNb,KAAK0F,KJ7Ra,EI6RI,GACtB1F,KAAK+B,WAAW/B,KAAKa,SAAWA,EJ9Rd,EI+RtB,CAMA,WAAA6G,CAAYC,GACR3H,KAAKsH,YACc,MAAftH,KAAK+C,SACL/C,KAAK+C,OAAS,IAElB/C,KAAK6E,cAAgB8C,EACrB,IAAK,IAAIlF,EAAI,EAAGA,EAAIkF,EAAWlF,IAC3BzC,KAAK+C,OAAON,GAAK,EAErBzC,KAAK8E,UAAW,EAChB9E,KAAK+E,aAAe/E,KAAKa,QAC7B,CAMA,SAAA+G,GACI,GAAmB,MAAf5H,KAAK+C,SAAmB/C,KAAK8E,SAC7B,MAAM,IAAIvC,MAAM,qDAEpBvC,KAAKmG,SAAS,GACd,MAAM0B,EAAY7H,KAAKa,SAEvB,IAAI4B,EAAIzC,KAAK6E,cAAgB,EAE7B,KAAOpC,GAAK,GAAuB,GAAlBzC,KAAK+C,OAAON,GAASA,KACtC,MAAMqF,EAAerF,EAAI,EAEzB,KAAOA,GAAK,EAAGA,IAEXzC,KAAKkG,SAA2B,GAAlBlG,KAAK+C,OAAON,GAAUoF,EAAY7H,KAAK+C,OAAON,GAAK,GAGrEzC,KAAKkG,SAAS2B,EAAY7H,KAAK+E,cAC/B,MAAMgD,EJzUc,GIyUPD,EAFW,GAGxB9H,KAAKkG,SAAS6B,GAEd,IAAIC,EAAkB,EACtB,MAAMC,EAAMjI,KAAKsF,MACjB4C,EAAY,IAAKzF,EAAI,EAAGA,EAAIzC,KAAKgF,QAAQrE,OAAQ8B,IAAK,CAClD,MAAM0F,EAAMnI,KAAKkD,GAAGxC,WAAaV,KAAKgF,QAAQvC,GAC9C,GAAIsF,GAAO/H,KAAKkD,GAAGnC,UAAUoH,GAAM,CAC/B,IAAK,IAAIC,EJjVG,EIiVeA,EAAIL,EAAKK,GJjVxB,EIkVR,GAAIpI,KAAKkD,GAAGnC,UAAUkH,EAAMG,IAAMpI,KAAKkD,GAAGnC,UAAUoH,EAAMC,GACtD,SAASF,EAGjBF,EAAkBhI,KAAKgF,QAAQvC,GAC/B,KACJ,CACJ,CAgBA,OAfIuF,GAGAhI,KAAKsF,MAAQtF,KAAKkD,GAAGxC,WAAamH,EAElC7H,KAAKkD,GAAGnB,WAAW/B,KAAKsF,MAAO0C,EAAkBH,KAKjD7H,KAAKgF,QAAQV,KAAKtE,KAAKa,UAEvBb,KAAKkD,GAAGnB,WAAW/B,KAAKkD,GAAGxC,WAAamH,EAAW7H,KAAKa,SAAWgH,IAEvE7H,KAAK8E,UAAW,EACT+C,CACX,CAIA,MAAAQ,CAAOC,EAAYC,EAAqBC,GACpC,MAAMC,EAAcD,EAAkBvJ,EAAqB,EAC3D,GAAIsJ,EAAqB,CACrB,MAAMG,EAAkBH,EAGxB,GAFAvI,KAAK0F,KAAK1F,KAAK4E,SAAU+D,EACIF,GJjXH,GIkXtBC,EAAgB/H,OAChB,MAAM,IAAI0G,UAAU,iDAGxB,IAAK,IAAI5E,EAAImG,EAA4BnG,GAAK,EAAGA,IAC7CzC,KAAK0B,UAAUgH,EAAgB1E,WAAWvB,GAElD,CACAzC,KAAK0F,KAAK1F,KAAK4E,SJ3XG,EI2XoB6D,GACtCzI,KAAKiH,UAAUqB,GACXG,GACAzI,KAAKmG,SAASnG,KAAKkD,GAAGxC,WAAaV,KAAKsF,OAE5CtF,KAAKkD,GAAGzC,YAAYT,KAAKsF,MAC7B,CAIA,kBAAAuD,CAAmBP,EAAYC,GAC3BvI,KAAKqI,OAAOC,EAAYC,GAAqB,EACjD,CAKA,aAAAO,CAAcC,EAAOC,GACjB,MAAMC,EAAcjJ,KAAKkD,GAAGxC,WAAaqI,EACnCG,EAAeD,EAAcjJ,KAAKkD,GAAGjC,UAAUgI,GAIrD,KAHWD,EAAQhJ,KAAKkD,GAAGnC,UAAUmI,IACU,GAA3ClJ,KAAKkD,GAAGnC,UAAUmI,EAAeF,IAGjC,MAAM,IAAI3B,UAAU,sBAAwB2B,EAAQ,eAE5D,CAUA,WAAAG,CAAYC,EAAWC,EAAWC,GAC9BtJ,KAAKsH,YACLtH,KAAKiF,iBAAmBoE,EACxBrJ,KAAK0F,KJlaa,EIkaI0D,EAAYC,GAClCrJ,KAAK0F,KAAK4D,EAAWF,EAAYC,EACrC,CAQA,SAAAE,GAEI,OADAvJ,KAAK+B,WAAW/B,KAAKiF,kBACdjF,KAAKa,QAChB,CAQA,kBAAA2I,CAAmBC,GACf,IAAKA,EACD,OAAO,EAKX,GAHKzJ,KAAKmF,cACNnF,KAAKmF,YAAc,IAAIuE,KAEvB1J,KAAKmF,YAAYwE,IAAIF,GACrB,OAAOzJ,KAAKmF,YAAYyE,IAAIH,GAEhC,MAAM5I,EAASb,KAAK6J,aAAaJ,GAEjC,OADAzJ,KAAKmF,YAAYsC,IAAIgC,EAAG5I,GACjBA,CACX,CAQA,YAAAgJ,CAAaJ,GACT,GAAIA,QACA,OAAO,EAEX,IAAIK,EAEAA,EADAL,aAAa9J,WACN8J,EAGAzJ,KAAKoF,aAAa2E,OAAON,GAEpCzJ,KAAKiG,QAAQ,GACbjG,KAAKmJ,YAAY,EAAGW,EAAKnJ,OAAQ,GACjCX,KAAKkD,GAAGzC,YAAYT,KAAKsF,OAASwE,EAAKnJ,QACvC,IAAK,IAAI8B,EAAI,EAAG5B,EAASb,KAAKsF,MAAO/E,EAAQP,KAAKkD,GAAG3C,QAASkC,EAAIqH,EAAKnJ,OAAQ8B,IAC3ElC,EAAMM,KAAYiJ,EAAKrH,GAE3B,OAAOzC,KAAKuJ,WAChB,CAMA,kBAAAS,CAAmB5C,GACf,OAAY,OAARA,EACO,EAEQ,iBAARA,EACApH,KAAK6J,aAAazC,GAGlBA,EAAI6C,KAAKjK,KAExB,CAMA,sBAAAkK,CAAuBC,GACnB,MAAM/F,EAAM,GACZ,IAAK,IAAI3B,EAAI,EAAGA,EAAI0H,EAAKxJ,SAAU8B,EAAG,CAClC,MAAM4B,EAAM8F,EAAK1H,GACjB,GAAY,OAAR4B,EAIA,MAAM,IAAIgD,UAAU,yEAHpBjD,EAAIE,KAAKtE,KAAKgK,mBAAmB3F,GAKzC,CACA,OAAOD,CACX,CACA,sBAAAgG,CAAuBD,EAAME,GAGzB,OAFAA,EAAUrK,KAAMmK,EAAKxJ,QACrBX,KAAKkK,uBAAuBC,EAAKG,QAAQC,WAClCvK,KAAKuJ,WAChB,E","sources":["webpack://client-app/./node_modules/flatbuffers/mjs/constants.js","webpack://client-app/./node_modules/flatbuffers/mjs/utils.js","webpack://client-app/./node_modules/flatbuffers/mjs/encoding.js","webpack://client-app/./node_modules/flatbuffers/mjs/byte-buffer.js","webpack://client-app/./node_modules/flatbuffers/mjs/builder.js"],"sourcesContent":["export const SIZEOF_SHORT = 2;\nexport const SIZEOF_INT = 4;\nexport const FILE_IDENTIFIER_LENGTH = 4;\nexport const SIZE_PREFIX_LENGTH = 4;\n","export const int32 = new Int32Array(2);\nexport const float32 = new Float32Array(int32.buffer);\nexport const float64 = new Float64Array(int32.buffer);\nexport const isLittleEndian = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;\n","export var Encoding;\n(function (Encoding) {\n    Encoding[Encoding[\"UTF8_BYTES\"] = 1] = \"UTF8_BYTES\";\n    Encoding[Encoding[\"UTF16_STRING\"] = 2] = \"UTF16_STRING\";\n})(Encoding || (Encoding = {}));\n","import { FILE_IDENTIFIER_LENGTH, SIZEOF_INT } from \"./constants.js\";\nimport { int32, isLittleEndian, float32, float64 } from \"./utils.js\";\nimport { Encoding } from \"./encoding.js\";\nexport class ByteBuffer {\n    /**\n     * Create a new ByteBuffer with a given array of bytes (`Uint8Array`)\n     */\n    constructor(bytes_) {\n        this.bytes_ = bytes_;\n        this.position_ = 0;\n        this.text_decoder_ = new TextDecoder();\n    }\n    /**\n     * Create and allocate a new ByteBuffer with a given size.\n     */\n    static allocate(byte_size) {\n        return new ByteBuffer(new Uint8Array(byte_size));\n    }\n    clear() {\n        this.position_ = 0;\n    }\n    /**\n     * Get the underlying `Uint8Array`.\n     */\n    bytes() {\n        return this.bytes_;\n    }\n    /**\n     * Get the buffer's position.\n     */\n    position() {\n        return this.position_;\n    }\n    /**\n     * Set the buffer's position.\n     */\n    setPosition(position) {\n        this.position_ = position;\n    }\n    /**\n     * Get the buffer's capacity.\n     */\n    capacity() {\n        return this.bytes_.length;\n    }\n    readInt8(offset) {\n        return this.readUint8(offset) << 24 >> 24;\n    }\n    readUint8(offset) {\n        return this.bytes_[offset];\n    }\n    readInt16(offset) {\n        return this.readUint16(offset) << 16 >> 16;\n    }\n    readUint16(offset) {\n        return this.bytes_[offset] | this.bytes_[offset + 1] << 8;\n    }\n    readInt32(offset) {\n        return this.bytes_[offset] | this.bytes_[offset + 1] << 8 | this.bytes_[offset + 2] << 16 | this.bytes_[offset + 3] << 24;\n    }\n    readUint32(offset) {\n        return this.readInt32(offset) >>> 0;\n    }\n    readInt64(offset) {\n        return BigInt.asIntN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));\n    }\n    readUint64(offset) {\n        return BigInt.asUintN(64, BigInt(this.readUint32(offset)) + (BigInt(this.readUint32(offset + 4)) << BigInt(32)));\n    }\n    readFloat32(offset) {\n        int32[0] = this.readInt32(offset);\n        return float32[0];\n    }\n    readFloat64(offset) {\n        int32[isLittleEndian ? 0 : 1] = this.readInt32(offset);\n        int32[isLittleEndian ? 1 : 0] = this.readInt32(offset + 4);\n        return float64[0];\n    }\n    writeInt8(offset, value) {\n        this.bytes_[offset] = value;\n    }\n    writeUint8(offset, value) {\n        this.bytes_[offset] = value;\n    }\n    writeInt16(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n    }\n    writeUint16(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n    }\n    writeInt32(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n        this.bytes_[offset + 2] = value >> 16;\n        this.bytes_[offset + 3] = value >> 24;\n    }\n    writeUint32(offset, value) {\n        this.bytes_[offset] = value;\n        this.bytes_[offset + 1] = value >> 8;\n        this.bytes_[offset + 2] = value >> 16;\n        this.bytes_[offset + 3] = value >> 24;\n    }\n    writeInt64(offset, value) {\n        this.writeInt32(offset, Number(BigInt.asIntN(32, value)));\n        this.writeInt32(offset + 4, Number(BigInt.asIntN(32, value >> BigInt(32))));\n    }\n    writeUint64(offset, value) {\n        this.writeUint32(offset, Number(BigInt.asUintN(32, value)));\n        this.writeUint32(offset + 4, Number(BigInt.asUintN(32, value >> BigInt(32))));\n    }\n    writeFloat32(offset, value) {\n        float32[0] = value;\n        this.writeInt32(offset, int32[0]);\n    }\n    writeFloat64(offset, value) {\n        float64[0] = value;\n        this.writeInt32(offset, int32[isLittleEndian ? 0 : 1]);\n        this.writeInt32(offset + 4, int32[isLittleEndian ? 1 : 0]);\n    }\n    /**\n     * Return the file identifier.   Behavior is undefined for FlatBuffers whose\n     * schema does not include a file_identifier (likely points at padding or the\n     * start of a the root vtable).\n     */\n    getBufferIdentifier() {\n        if (this.bytes_.length < this.position_ + SIZEOF_INT +\n            FILE_IDENTIFIER_LENGTH) {\n            throw new Error('FlatBuffers: ByteBuffer is too short to contain an identifier.');\n        }\n        let result = \"\";\n        for (let i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {\n            result += String.fromCharCode(this.readInt8(this.position_ + SIZEOF_INT + i));\n        }\n        return result;\n    }\n    /**\n     * Look up a field in the vtable, return an offset into the object, or 0 if the\n     * field is not present.\n     */\n    __offset(bb_pos, vtable_offset) {\n        const vtable = bb_pos - this.readInt32(bb_pos);\n        return vtable_offset < this.readInt16(vtable) ? this.readInt16(vtable + vtable_offset) : 0;\n    }\n    /**\n     * Initialize any Table-derived type to point to the union at the given offset.\n     */\n    __union(t, offset) {\n        t.bb_pos = offset + this.readInt32(offset);\n        t.bb = this;\n        return t;\n    }\n    /**\n     * Create a JavaScript string from UTF-8 data stored inside the FlatBuffer.\n     * This allocates a new string and converts to wide chars upon each access.\n     *\n     * To avoid the conversion to string, pass Encoding.UTF8_BYTES as the\n     * \"optionalEncoding\" argument. This is useful for avoiding conversion when\n     * the data will just be packaged back up in another FlatBuffer later on.\n     *\n     * @param offset\n     * @param opt_encoding Defaults to UTF16_STRING\n     */\n    __string(offset, opt_encoding) {\n        offset += this.readInt32(offset);\n        const length = this.readInt32(offset);\n        offset += SIZEOF_INT;\n        const utf8bytes = this.bytes_.subarray(offset, offset + length);\n        if (opt_encoding === Encoding.UTF8_BYTES)\n            return utf8bytes;\n        else\n            return this.text_decoder_.decode(utf8bytes);\n    }\n    /**\n     * Handle unions that can contain string as its member, if a Table-derived type then initialize it,\n     * if a string then return a new one\n     *\n     * WARNING: strings are immutable in JS so we can't change the string that the user gave us, this\n     * makes the behaviour of __union_with_string different compared to __union\n     */\n    __union_with_string(o, offset) {\n        if (typeof o === 'string') {\n            return this.__string(offset);\n        }\n        return this.__union(o, offset);\n    }\n    /**\n     * Retrieve the relative offset stored at \"offset\"\n     */\n    __indirect(offset) {\n        return offset + this.readInt32(offset);\n    }\n    /**\n     * Get the start of data of a vector whose offset is stored at \"offset\" in this object.\n     */\n    __vector(offset) {\n        return offset + this.readInt32(offset) + SIZEOF_INT; // data starts after the length\n    }\n    /**\n     * Get the length of a vector whose offset is stored at \"offset\" in this object.\n     */\n    __vector_len(offset) {\n        return this.readInt32(offset + this.readInt32(offset));\n    }\n    __has_identifier(ident) {\n        if (ident.length != FILE_IDENTIFIER_LENGTH) {\n            throw new Error('FlatBuffers: file identifier must be length ' +\n                FILE_IDENTIFIER_LENGTH);\n        }\n        for (let i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {\n            if (ident.charCodeAt(i) != this.readInt8(this.position() + SIZEOF_INT + i)) {\n                return false;\n            }\n        }\n        return true;\n    }\n    /**\n     * A helper function for generating list for obj api\n     */\n    createScalarList(listAccessor, listLength) {\n        const ret = [];\n        for (let i = 0; i < listLength; ++i) {\n            const val = listAccessor(i);\n            if (val !== null) {\n                ret.push(val);\n            }\n        }\n        return ret;\n    }\n    /**\n     * A helper function for generating list for obj api\n     * @param listAccessor function that accepts an index and return data at that index\n     * @param listLength listLength\n     * @param res result list\n     */\n    createObjList(listAccessor, listLength) {\n        const ret = [];\n        for (let i = 0; i < listLength; ++i) {\n            const val = listAccessor(i);\n            if (val !== null) {\n                ret.push(val.unpack());\n            }\n        }\n        return ret;\n    }\n}\n","import { ByteBuffer } from \"./byte-buffer.js\";\nimport { SIZEOF_SHORT, SIZE_PREFIX_LENGTH, SIZEOF_INT, FILE_IDENTIFIER_LENGTH } from \"./constants.js\";\nexport class Builder {\n    /**\n     * Create a FlatBufferBuilder.\n     */\n    constructor(opt_initial_size) {\n        /** Minimum alignment encountered so far. */\n        this.minalign = 1;\n        /** The vtable for the current table. */\n        this.vtable = null;\n        /** The amount of fields we're actually using. */\n        this.vtable_in_use = 0;\n        /** Whether we are currently serializing a table. */\n        this.isNested = false;\n        /** Starting offset of the current struct/table. */\n        this.object_start = 0;\n        /** List of offsets of all vtables. */\n        this.vtables = [];\n        /** For the current vector being built. */\n        this.vector_num_elems = 0;\n        /** False omits default values from the serialized data */\n        this.force_defaults = false;\n        this.string_maps = null;\n        this.text_encoder = new TextEncoder();\n        let initial_size;\n        if (!opt_initial_size) {\n            initial_size = 1024;\n        }\n        else {\n            initial_size = opt_initial_size;\n        }\n        /**\n         * @type {ByteBuffer}\n         * @private\n         */\n        this.bb = ByteBuffer.allocate(initial_size);\n        this.space = initial_size;\n    }\n    clear() {\n        this.bb.clear();\n        this.space = this.bb.capacity();\n        this.minalign = 1;\n        this.vtable = null;\n        this.vtable_in_use = 0;\n        this.isNested = false;\n        this.object_start = 0;\n        this.vtables = [];\n        this.vector_num_elems = 0;\n        this.force_defaults = false;\n        this.string_maps = null;\n    }\n    /**\n     * In order to save space, fields that are set to their default value\n     * don't get serialized into the buffer. Forcing defaults provides a\n     * way to manually disable this optimization.\n     *\n     * @param forceDefaults true always serializes default values\n     */\n    forceDefaults(forceDefaults) {\n        this.force_defaults = forceDefaults;\n    }\n    /**\n     * Get the ByteBuffer representing the FlatBuffer. Only call this after you've\n     * called finish(). The actual data starts at the ByteBuffer's current position,\n     * not necessarily at 0.\n     */\n    dataBuffer() {\n        return this.bb;\n    }\n    /**\n     * Get the bytes representing the FlatBuffer. Only call this after you've\n     * called finish().\n     */\n    asUint8Array() {\n        return this.bb.bytes().subarray(this.bb.position(), this.bb.position() + this.offset());\n    }\n    /**\n     * Prepare to write an element of `size` after `additional_bytes` have been\n     * written, e.g. if you write a string, you need to align such the int length\n     * field is aligned to 4 bytes, and the string data follows it directly. If all\n     * you need to do is alignment, `additional_bytes` will be 0.\n     *\n     * @param size This is the of the new element to write\n     * @param additional_bytes The padding size\n     */\n    prep(size, additional_bytes) {\n        // Track the biggest thing we've ever aligned to.\n        if (size > this.minalign) {\n            this.minalign = size;\n        }\n        // Find the amount of alignment needed such that `size` is properly\n        // aligned after `additional_bytes`\n        const align_size = ((~(this.bb.capacity() - this.space + additional_bytes)) + 1) & (size - 1);\n        // Reallocate the buffer if needed.\n        while (this.space < align_size + size + additional_bytes) {\n            const old_buf_size = this.bb.capacity();\n            this.bb = Builder.growByteBuffer(this.bb);\n            this.space += this.bb.capacity() - old_buf_size;\n        }\n        this.pad(align_size);\n    }\n    pad(byte_size) {\n        for (let i = 0; i < byte_size; i++) {\n            this.bb.writeInt8(--this.space, 0);\n        }\n    }\n    writeInt8(value) {\n        this.bb.writeInt8(this.space -= 1, value);\n    }\n    writeInt16(value) {\n        this.bb.writeInt16(this.space -= 2, value);\n    }\n    writeInt32(value) {\n        this.bb.writeInt32(this.space -= 4, value);\n    }\n    writeInt64(value) {\n        this.bb.writeInt64(this.space -= 8, value);\n    }\n    writeFloat32(value) {\n        this.bb.writeFloat32(this.space -= 4, value);\n    }\n    writeFloat64(value) {\n        this.bb.writeFloat64(this.space -= 8, value);\n    }\n    /**\n     * Add an `int8` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int8` to add the buffer.\n     */\n    addInt8(value) {\n        this.prep(1, 0);\n        this.writeInt8(value);\n    }\n    /**\n     * Add an `int16` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int16` to add the buffer.\n     */\n    addInt16(value) {\n        this.prep(2, 0);\n        this.writeInt16(value);\n    }\n    /**\n     * Add an `int32` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int32` to add the buffer.\n     */\n    addInt32(value) {\n        this.prep(4, 0);\n        this.writeInt32(value);\n    }\n    /**\n     * Add an `int64` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `int64` to add the buffer.\n     */\n    addInt64(value) {\n        this.prep(8, 0);\n        this.writeInt64(value);\n    }\n    /**\n     * Add a `float32` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `float32` to add the buffer.\n     */\n    addFloat32(value) {\n        this.prep(4, 0);\n        this.writeFloat32(value);\n    }\n    /**\n     * Add a `float64` to the buffer, properly aligned, and grows the buffer (if necessary).\n     * @param value The `float64` to add the buffer.\n     */\n    addFloat64(value) {\n        this.prep(8, 0);\n        this.writeFloat64(value);\n    }\n    addFieldInt8(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addInt8(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldInt16(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addInt16(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldInt32(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addInt32(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldInt64(voffset, value, defaultValue) {\n        if (this.force_defaults || value !== defaultValue) {\n            this.addInt64(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldFloat32(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addFloat32(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldFloat64(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addFloat64(value);\n            this.slot(voffset);\n        }\n    }\n    addFieldOffset(voffset, value, defaultValue) {\n        if (this.force_defaults || value != defaultValue) {\n            this.addOffset(value);\n            this.slot(voffset);\n        }\n    }\n    /**\n     * Structs are stored inline, so nothing additional is being added. `d` is always 0.\n     */\n    addFieldStruct(voffset, value, defaultValue) {\n        if (value != defaultValue) {\n            this.nested(value);\n            this.slot(voffset);\n        }\n    }\n    /**\n     * Structures are always stored inline, they need to be created right\n     * where they're used.  You'll get this assertion failure if you\n     * created it elsewhere.\n     */\n    nested(obj) {\n        if (obj != this.offset()) {\n            throw new TypeError('FlatBuffers: struct must be serialized inline.');\n        }\n    }\n    /**\n     * Should not be creating any other object, string or vector\n     * while an object is being constructed\n     */\n    notNested() {\n        if (this.isNested) {\n            throw new TypeError('FlatBuffers: object serialization must not be nested.');\n        }\n    }\n    /**\n     * Set the current vtable at `voffset` to the current location in the buffer.\n     */\n    slot(voffset) {\n        if (this.vtable !== null)\n            this.vtable[voffset] = this.offset();\n    }\n    /**\n     * @returns Offset relative to the end of the buffer.\n     */\n    offset() {\n        return this.bb.capacity() - this.space;\n    }\n    /**\n     * Doubles the size of the backing ByteBuffer and copies the old data towards\n     * the end of the new buffer (since we build the buffer backwards).\n     *\n     * @param bb The current buffer with the existing data\n     * @returns A new byte buffer with the old data copied\n     * to it. The data is located at the end of the buffer.\n     *\n     * uint8Array.set() formally takes {Array<number>|ArrayBufferView}, so to pass\n     * it a uint8Array we need to suppress the type check:\n     * @suppress {checkTypes}\n     */\n    static growByteBuffer(bb) {\n        const old_buf_size = bb.capacity();\n        // Ensure we don't grow beyond what fits in an int.\n        if (old_buf_size & 0xC0000000) {\n            throw new Error('FlatBuffers: cannot grow buffer beyond 2 gigabytes.');\n        }\n        const new_buf_size = old_buf_size << 1;\n        const nbb = ByteBuffer.allocate(new_buf_size);\n        nbb.setPosition(new_buf_size - old_buf_size);\n        nbb.bytes().set(bb.bytes(), new_buf_size - old_buf_size);\n        return nbb;\n    }\n    /**\n     * Adds on offset, relative to where it will be written.\n     *\n     * @param offset The offset to add.\n     */\n    addOffset(offset) {\n        this.prep(SIZEOF_INT, 0); // Ensure alignment is already done.\n        this.writeInt32(this.offset() - offset + SIZEOF_INT);\n    }\n    /**\n     * Start encoding a new object in the buffer.  Users will not usually need to\n     * call this directly. The FlatBuffers compiler will generate helper methods\n     * that call this method internally.\n     */\n    startObject(numfields) {\n        this.notNested();\n        if (this.vtable == null) {\n            this.vtable = [];\n        }\n        this.vtable_in_use = numfields;\n        for (let i = 0; i < numfields; i++) {\n            this.vtable[i] = 0; // This will push additional elements as needed\n        }\n        this.isNested = true;\n        this.object_start = this.offset();\n    }\n    /**\n     * Finish off writing the object that is under construction.\n     *\n     * @returns The offset to the object inside `dataBuffer`\n     */\n    endObject() {\n        if (this.vtable == null || !this.isNested) {\n            throw new Error('FlatBuffers: endObject called without startObject');\n        }\n        this.addInt32(0);\n        const vtableloc = this.offset();\n        // Trim trailing zeroes.\n        let i = this.vtable_in_use - 1;\n        // eslint-disable-next-line no-empty\n        for (; i >= 0 && this.vtable[i] == 0; i--) { }\n        const trimmed_size = i + 1;\n        // Write out the current vtable.\n        for (; i >= 0; i--) {\n            // Offset relative to the start of the table.\n            this.addInt16(this.vtable[i] != 0 ? vtableloc - this.vtable[i] : 0);\n        }\n        const standard_fields = 2; // The fields below:\n        this.addInt16(vtableloc - this.object_start);\n        const len = (trimmed_size + standard_fields) * SIZEOF_SHORT;\n        this.addInt16(len);\n        // Search for an existing vtable that matches the current one.\n        let existing_vtable = 0;\n        const vt1 = this.space;\n        outer_loop: for (i = 0; i < this.vtables.length; i++) {\n            const vt2 = this.bb.capacity() - this.vtables[i];\n            if (len == this.bb.readInt16(vt2)) {\n                for (let j = SIZEOF_SHORT; j < len; j += SIZEOF_SHORT) {\n                    if (this.bb.readInt16(vt1 + j) != this.bb.readInt16(vt2 + j)) {\n                        continue outer_loop;\n                    }\n                }\n                existing_vtable = this.vtables[i];\n                break;\n            }\n        }\n        if (existing_vtable) {\n            // Found a match:\n            // Remove the current vtable.\n            this.space = this.bb.capacity() - vtableloc;\n            // Point table to existing vtable.\n            this.bb.writeInt32(this.space, existing_vtable - vtableloc);\n        }\n        else {\n            // No match:\n            // Add the location of the current vtable to the list of vtables.\n            this.vtables.push(this.offset());\n            // Point table to current vtable.\n            this.bb.writeInt32(this.bb.capacity() - vtableloc, this.offset() - vtableloc);\n        }\n        this.isNested = false;\n        return vtableloc;\n    }\n    /**\n     * Finalize a buffer, poiting to the given `root_table`.\n     */\n    finish(root_table, opt_file_identifier, opt_size_prefix) {\n        const size_prefix = opt_size_prefix ? SIZE_PREFIX_LENGTH : 0;\n        if (opt_file_identifier) {\n            const file_identifier = opt_file_identifier;\n            this.prep(this.minalign, SIZEOF_INT +\n                FILE_IDENTIFIER_LENGTH + size_prefix);\n            if (file_identifier.length != FILE_IDENTIFIER_LENGTH) {\n                throw new TypeError('FlatBuffers: file identifier must be length ' +\n                    FILE_IDENTIFIER_LENGTH);\n            }\n            for (let i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {\n                this.writeInt8(file_identifier.charCodeAt(i));\n            }\n        }\n        this.prep(this.minalign, SIZEOF_INT + size_prefix);\n        this.addOffset(root_table);\n        if (size_prefix) {\n            this.addInt32(this.bb.capacity() - this.space);\n        }\n        this.bb.setPosition(this.space);\n    }\n    /**\n     * Finalize a size prefixed buffer, pointing to the given `root_table`.\n     */\n    finishSizePrefixed(root_table, opt_file_identifier) {\n        this.finish(root_table, opt_file_identifier, true);\n    }\n    /**\n     * This checks a required field has been set in a given table that has\n     * just been constructed.\n     */\n    requiredField(table, field) {\n        const table_start = this.bb.capacity() - table;\n        const vtable_start = table_start - this.bb.readInt32(table_start);\n        const ok = field < this.bb.readInt16(vtable_start) &&\n            this.bb.readInt16(vtable_start + field) != 0;\n        // If this fails, the caller will show what field needs to be set.\n        if (!ok) {\n            throw new TypeError('FlatBuffers: field ' + field + ' must be set');\n        }\n    }\n    /**\n     * Start a new array/vector of objects.  Users usually will not call\n     * this directly. The FlatBuffers compiler will create a start/end\n     * method for vector types in generated code.\n     *\n     * @param elem_size The size of each element in the array\n     * @param num_elems The number of elements in the array\n     * @param alignment The alignment of the array\n     */\n    startVector(elem_size, num_elems, alignment) {\n        this.notNested();\n        this.vector_num_elems = num_elems;\n        this.prep(SIZEOF_INT, elem_size * num_elems);\n        this.prep(alignment, elem_size * num_elems); // Just in case alignment > int.\n    }\n    /**\n     * Finish off the creation of an array and all its elements. The array must be\n     * created with `startVector`.\n     *\n     * @returns The offset at which the newly created array\n     * starts.\n     */\n    endVector() {\n        this.writeInt32(this.vector_num_elems);\n        return this.offset();\n    }\n    /**\n     * Encode the string `s` in the buffer using UTF-8. If the string passed has\n     * already been seen, we return the offset of the already written string\n     *\n     * @param s The string to encode\n     * @return The offset in the buffer where the encoded string starts\n     */\n    createSharedString(s) {\n        if (!s) {\n            return 0;\n        }\n        if (!this.string_maps) {\n            this.string_maps = new Map();\n        }\n        if (this.string_maps.has(s)) {\n            return this.string_maps.get(s);\n        }\n        const offset = this.createString(s);\n        this.string_maps.set(s, offset);\n        return offset;\n    }\n    /**\n     * Encode the string `s` in the buffer using UTF-8. If a Uint8Array is passed\n     * instead of a string, it is assumed to contain valid UTF-8 encoded data.\n     *\n     * @param s The string to encode\n     * @return The offset in the buffer where the encoded string starts\n     */\n    createString(s) {\n        if (s === null || s === undefined) {\n            return 0;\n        }\n        let utf8;\n        if (s instanceof Uint8Array) {\n            utf8 = s;\n        }\n        else {\n            utf8 = this.text_encoder.encode(s);\n        }\n        this.addInt8(0);\n        this.startVector(1, utf8.length, 1);\n        this.bb.setPosition(this.space -= utf8.length);\n        for (let i = 0, offset = this.space, bytes = this.bb.bytes(); i < utf8.length; i++) {\n            bytes[offset++] = utf8[i];\n        }\n        return this.endVector();\n    }\n    /**\n     * A helper function to pack an object\n     *\n     * @returns offset of obj\n     */\n    createObjectOffset(obj) {\n        if (obj === null) {\n            return 0;\n        }\n        if (typeof obj === 'string') {\n            return this.createString(obj);\n        }\n        else {\n            return obj.pack(this);\n        }\n    }\n    /**\n     * A helper function to pack a list of object\n     *\n     * @returns list of offsets of each non null object\n     */\n    createObjectOffsetList(list) {\n        const ret = [];\n        for (let i = 0; i < list.length; ++i) {\n            const val = list[i];\n            if (val !== null) {\n                ret.push(this.createObjectOffset(val));\n            }\n            else {\n                throw new TypeError('FlatBuffers: Argument for createObjectOffsetList cannot contain null.');\n            }\n        }\n        return ret;\n    }\n    createStructOffsetList(list, startFunc) {\n        startFunc(this, list.length);\n        this.createObjectOffsetList(list.slice().reverse());\n        return this.endVector();\n    }\n}\n"],"names":["SIZE_PREFIX_LENGTH","int32","Int32Array","float32","Float32Array","buffer","float64","Float64Array","isLittleEndian","Uint16Array","Uint8Array","Encoding","ByteBuffer","constructor","bytes_","this","position_","text_decoder_","TextDecoder","allocate","byte_size","clear","bytes","position","setPosition","capacity","length","readInt8","offset","readUint8","readInt16","readUint16","readInt32","readUint32","readInt64","BigInt","asIntN","readUint64","asUintN","readFloat32","readFloat64","writeInt8","value","writeUint8","writeInt16","writeUint16","writeInt32","writeUint32","writeInt64","Number","writeUint64","writeFloat32","writeFloat64","getBufferIdentifier","Error","result","i","String","fromCharCode","__offset","bb_pos","vtable_offset","vtable","__union","t","bb","__string","opt_encoding","utf8bytes","subarray","UTF8_BYTES","decode","__union_with_string","o","__indirect","__vector","__vector_len","__has_identifier","ident","charCodeAt","createScalarList","listAccessor","listLength","ret","val","push","createObjList","unpack","Builder","opt_initial_size","initial_size","minalign","vtable_in_use","isNested","object_start","vtables","vector_num_elems","force_defaults","string_maps","text_encoder","TextEncoder","space","forceDefaults","dataBuffer","asUint8Array","prep","size","additional_bytes","align_size","old_buf_size","growByteBuffer","pad","addInt8","addInt16","addInt32","addInt64","addFloat32","addFloat64","addFieldInt8","voffset","defaultValue","slot","addFieldInt16","addFieldInt32","addFieldInt64","addFieldFloat32","addFieldFloat64","addFieldOffset","addOffset","addFieldStruct","nested","obj","TypeError","notNested","new_buf_size","nbb","set","startObject","numfields","endObject","vtableloc","trimmed_size","len","existing_vtable","vt1","outer_loop","vt2","j","finish","root_table","opt_file_identifier","opt_size_prefix","size_prefix","file_identifier","SIZEOF_INT","FILE_IDENTIFIER_LENGTH","finishSizePrefixed","requiredField","table","field","table_start","vtable_start","startVector","elem_size","num_elems","alignment","endVector","createSharedString","s","Map","has","get","createString","utf8","encode","createObjectOffset","pack","createObjectOffsetList","list","createStructOffsetList","startFunc","slice","reverse"],"sourceRoot":""}