{"mappings":";;shBAAA,IAAAA,EAAAC,EAAAC,GAAA,cACA,IAAIC,GAAaD,GAAQA,EAAK,WAAe,UAAY,CACrD,IAAIE,EAAgB,SAAUC,EAAGC,EAAG,CAChC,OAAAF,EAAgB,OAAO,gBAClB,CAAE,UAAW,CAAC,CAAE,YAAa,OAAS,SAAUC,EAAGC,EAAG,CAAED,EAAE,UAAYC,CAAG,GAC1E,SAAUD,EAAGC,EAAG,CAAE,QAASC,KAAKD,EAAOA,EAAE,eAAeC,CAAC,IAAGF,EAAEE,CAAC,EAAID,EAAEC,CAAC,EAAG,EACtEH,EAAcC,EAAGC,CAAC,CAC7B,EACA,OAAO,SAAUD,EAAGC,EAAG,CACnBF,EAAcC,EAAGC,CAAC,EAClB,SAASE,GAAK,CAAE,KAAK,YAAcH,CAAG,CACtCA,EAAE,UAAYC,IAAM,KAAO,OAAO,OAAOA,CAAC,GAAKE,EAAG,UAAYF,EAAE,UAAW,IAAIE,EACnF,CACJ,EAAG,EACH,OAAO,eAAeN,EAAS,aAAc,CAAE,MAAO,EAAK,CAAC,EAC5DA,EAAQ,cAAgBA,EAAQ,YAAcA,EAAQ,OAAS,OAK/D,IAAIO,EAAwB,SAAUC,EAAQ,CAC1CP,GAAUM,EAAQC,CAAM,EACxB,SAASD,EAAOE,EAAMC,EAAS,CAC3B,IAAIC,EAAQH,EAAO,KAAK,KAAME,CAAO,GAAK,KAC1C,OAAAC,EAAM,KAAOF,EAEb,OAAO,eAAeE,EAAOJ,EAAO,SAAS,EACtCI,CACX,CACA,OAAOJ,CACX,EAAE,KAAK,EACPP,EAAQ,OAASO,EAMjB,IAAIK,GAA6B,UAAY,CACzC,SAASA,GAAc,CACvB,CACA,OAAAA,EAAY,UAAU,KAAO,SAAUC,EAASH,EAASI,EAAO,CAC5D,MAAO,EACX,EACAF,EAAY,UAAU,cAAgB,UAAY,CAAE,OAAO,IAAM,EACjEA,EAAY,UAAU,cAAgB,UAAY,CAAE,OAAO,IAAM,EACjEA,EAAY,UAAU,aAAe,SAAUG,EAAI,CAAE,EAC9CH,CACX,EAAE,EACFZ,EAAQ,YAAcY,GAItB,IAAII,EAA+B,UAAY,CAC3C,SAASA,GAAgB,CAErB,KAAK,WAAa,CAAC,EAAE,EACrB,KAAK,UAAY,CAAC,IAAI,EAGtB,KAAK,OAAS,CAClB,CACA,OAAAA,EAAc,UAAU,KAAO,SAAUH,EAASH,EAASI,EAAO,CAC9D,YAAK,WAAW,KAAKD,CAAO,EAC5B,KAAK,UAAU,KAAKH,CAAO,EAC3B,KAAK,QAAUI,EACR,EACX,EACAE,EAAc,UAAU,cAAgB,UAAY,CAChD,OAAO,IAAIC,EACf,EACAD,EAAc,UAAU,aAAe,SAAUE,EAAe,CAI5D,QAHIC,EAAIC,EACJC,EAAIH,EACJI,EAAO,KACFC,EAAK,EAAGC,EAAKH,EAAE,SAAUE,EAAKC,EAAG,OAAQD,IAAM,CACpD,IAAIE,EAAMD,EAAGD,CAAE,GACX,CAACD,GAAQG,EAAI,QAAUH,EAAK,UAC5BA,EAAOG,EAEf,CACIH,GAAQA,EAAK,OAAS,KACrBH,EAAK,KAAK,YAAY,KAAK,MAAMA,EAAIG,EAAK,UAAU,GACpDF,EAAK,KAAK,WAAW,KAAK,MAAMA,EAAIE,EAAK,SAAS,EAE3D,EACAN,EAAc,UAAU,SAAW,SAAUP,EAAM,CAE/C,QADIiB,EAAW,CAAC,EACPC,EAAI,KAAK,WAAW,OAAS,EAAGA,GAAK,EAAGA,IAAK,CAClD,IAAItB,EAAI,KAAK,WAAWsB,CAAC,EACzBlB,GAAS,OAAOJ,GAAM,SAAY,IAAMA,EAAI,IAAOA,EAAI,IAAMA,EAAI,GACjE,IAAIuB,EAAI,KAAK,UAAUD,CAAC,EACpBC,GACAF,EAAS,KAAKjB,EAAO,IAAMmB,CAAC,CAEpC,CACA,OAAO,IAAIrB,EAAOE,EAAMiB,EAAS,KAAK,IAAI,CAAC,CAC/C,EACAV,EAAc,UAAU,eAAiB,SAAUP,EAAM,CAErD,QADIoB,EAAU,CAAC,EACNF,EAAI,KAAK,WAAW,OAAS,EAAGA,GAAK,EAAGA,IAAK,CAClD,IAAItB,EAAI,KAAK,WAAWsB,CAAC,EACzBlB,GAAS,OAAOJ,GAAM,SAAY,IAAMA,EAAI,IAAOA,EAAI,IAAMA,EAAI,GACjE,IAAIK,EAAU,KAAK,UAAUiB,CAAC,EAC1BjB,GACAmB,EAAQ,KAAK,CAAE,KAAMpB,EAAM,QAASC,CAAQ,CAAC,CAErD,CAEA,QADIoB,EAAS,KACJH,EAAIE,EAAQ,OAAS,EAAGF,GAAK,EAAGA,IACjCG,IACAD,EAAQF,CAAC,EAAE,OAAS,CAACG,CAAM,GAE/BA,EAASD,EAAQF,CAAC,EAEtB,OAAOG,CACX,EACOd,CACX,EAAE,EACFhB,EAAQ,cAAgBgB,EACxB,IAAIC,GAAqC,UAAY,CACjD,SAASA,GAAsB,CAC3B,KAAK,SAAW,CAAC,CACrB,CACA,OAAAA,EAAoB,UAAU,cAAgB,UAAY,CACtD,IAAIQ,EAAM,IAAIT,EACd,YAAK,SAAS,KAAKS,CAAG,EACfA,CACX,EACOR,CACX,EAAE,ICjIF,IAAAc,EAAAC,EAAAC,GAAA,cAKA,IAAIC,EAAaD,GAAQA,EAAK,WAAe,UAAY,CACrD,IAAIE,EAAgB,SAAUC,EAAGC,EAAG,CAChC,OAAAF,EAAgB,OAAO,gBAClB,CAAE,UAAW,CAAC,CAAE,YAAa,OAAS,SAAUC,EAAGC,EAAG,CAAED,EAAE,UAAYC,CAAG,GAC1E,SAAUD,EAAGC,EAAG,CAAE,QAASC,KAAKD,EAAOA,EAAE,eAAeC,CAAC,IAAGF,EAAEE,CAAC,EAAID,EAAEC,CAAC,EAAG,EACtEH,EAAcC,EAAGC,CAAC,CAC7B,EACA,OAAO,SAAUD,EAAGC,EAAG,CACnBF,EAAcC,EAAGC,CAAC,EAClB,SAASE,GAAK,CAAE,KAAK,YAAcH,CAAG,CACtCA,EAAE,UAAYC,IAAM,KAAO,OAAO,OAAOA,CAAC,GAAKE,EAAG,UAAYF,EAAE,UAAW,IAAIE,EACnF,CACJ,EAAG,EACH,OAAO,eAAeN,EAAS,aAAc,CAAE,MAAO,EAAK,CAAC,EAC5DA,EAAQ,WAAaA,EAAQ,UAAYA,EAAQ,WAAaA,EAAQ,OAASA,EAAQ,MAAQA,EAAQ,MAAQA,EAAQ,KAAOA,EAAQ,MAAQA,EAAQ,UAAYA,EAAQ,IAAMA,EAAQ,OAASA,EAAQ,MAAQA,EAAQ,aAAeA,EAAQ,QAAUA,EAAQ,UAAYA,EAAQ,SAAWA,EAAQ,cAAgBA,EAAQ,aAAeA,EAAQ,OAASA,EAAQ,MAAQA,EAAQ,OAASA,EAAQ,MAAQA,EAAQ,OAASA,EAAQ,MAAQA,EAAQ,SAAWA,EAAQ,IAAMA,EAAQ,MAAQA,EAAQ,KAAOA,EAAQ,MAAQ,OACngB,IAAIO,EAAS,IAETC,EAAuB,UAAY,CACnC,SAASA,GAAQ,CACjB,CACA,OAAOA,CACX,EAAE,EACFR,EAAQ,MAAQQ,EAEhB,SAASC,EAAUC,EAAU,CACzB,OAAO,OAAOA,GAAa,SAAWC,EAAKD,CAAQ,EAAIA,CAC3D,CACA,SAASE,EAAaC,EAAOF,EAAM,CAC/B,IAAIG,EAAQD,EAAMF,CAAI,EACtB,GAAI,CAACG,EACD,MAAM,IAAI,MAAM,gBAAkBH,CAAI,EAE1C,OAAOG,CACX,CAKA,SAASH,EAAKI,EAAO,CAAE,OAAO,IAAIC,EAAMD,CAAK,CAAG,CAChDf,EAAQ,KAAOW,EACf,IAAIK,EAAuB,SAAUC,EAAQ,CACzChB,EAAUe,EAAOC,CAAM,EACvB,SAASD,EAAML,EAAM,CACjB,IAAIO,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,KAAOP,EACbO,EAAM,SAAW,YAAcP,EACxBO,CACX,CACA,OAAAF,EAAM,UAAU,WAAa,SAAUH,EAAOM,EAAQC,EAAc,CAChE,IAAIF,EAAQ,KACRJ,EAAQF,EAAaC,EAAO,KAAK,IAAI,EACrCQ,EAAUP,EAAM,WAAWD,EAAOM,EAAQC,CAAY,EAC1D,OAAIN,aAAiBQ,GAAaR,aAAiBE,EACxCK,EAGJ,SAAUN,EAAOQ,EAAK,CAAE,OAAOF,EAAQN,EAAOQ,CAAG,EAAI,GAAOA,EAAI,KAAK,KAAML,EAAM,SAAU,CAAC,CAAG,CAC1G,EACOF,CACX,EAAER,CAAK,EACPR,EAAQ,MAAQgB,EAIhB,SAASQ,GAAIT,EAAO,CAAE,OAAO,IAAIU,EAASV,CAAK,CAAG,CAClDf,EAAQ,IAAMwB,GACd,IAAIC,EAA0B,SAAUR,EAAQ,CAC5ChB,EAAUwB,EAAUR,CAAM,EAC1B,SAASQ,EAASV,EAAO,CACrB,IAAIG,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,MAAQH,EACdG,EAAM,KAAO,KAAK,UAAUH,CAAK,EACjCG,EAAM,SAAW,UAAYA,EAAM,KAC5BA,CACX,CACA,OAAAO,EAAS,UAAU,WAAa,SAAUZ,EAAOM,EAAQ,CACrD,IAAID,EAAQ,KACZ,OAAO,SAAUH,EAAOQ,EAAK,CAAE,OAAQR,IAAUG,EAAM,MAAS,GAAOK,EAAI,KAAK,KAAML,EAAM,SAAU,EAAE,CAAG,CAC/G,EACOO,CACX,EAAEjB,CAAK,EACPR,EAAQ,SAAWyB,EAInB,SAASC,GAAMhB,EAAU,CAAE,OAAO,IAAIiB,EAAOlB,EAAUC,CAAQ,CAAC,CAAG,CACnEV,EAAQ,MAAQ0B,GAChB,IAAIC,EAAwB,SAAUV,EAAQ,CAC1ChB,EAAU0B,EAAQV,CAAM,EACxB,SAASU,EAAOb,EAAO,CACnB,IAAII,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,MAAQJ,EACPI,CACX,CACA,OAAAS,EAAO,UAAU,WAAa,SAAUd,EAAOM,EAAQ,CACnD,IAAIS,EAAc,KAAK,MAAM,WAAWf,EAAOM,CAAM,EACrD,OAAO,SAAUJ,EAAOQ,EAAK,CACzB,GAAI,CAAC,MAAM,QAAQR,CAAK,EACpB,OAAOQ,EAAI,KAAK,KAAM,kBAAmB,CAAC,EAE9C,QAASM,EAAI,EAAGA,EAAId,EAAM,OAAQc,IAAK,CACnC,IAAIC,EAAKF,EAAYb,EAAMc,CAAC,EAAGN,CAAG,EAClC,GAAI,CAACO,EACD,OAAOP,EAAI,KAAKM,EAAG,KAAM,CAAC,CAElC,CACA,MAAO,EACX,CACJ,EACOF,CACX,EAAEnB,CAAK,EACPR,EAAQ,OAAS2B,EAIjB,SAASI,IAAQ,CAEb,QADIrB,EAAW,CAAC,EACPsB,EAAK,EAAGA,EAAK,UAAU,OAAQA,IACpCtB,EAASsB,CAAE,EAAI,UAAUA,CAAE,EAE/B,OAAO,IAAIC,EAAOvB,EAAS,IAAI,SAAUwB,EAAG,CAAE,OAAOzB,EAAUyB,CAAC,CAAG,CAAC,CAAC,CACzE,CACAlC,EAAQ,MAAQ+B,GAChB,IAAIE,EAAwB,SAAUhB,EAAQ,CAC1ChB,EAAUgC,EAAQhB,CAAM,EACxB,SAASgB,EAAOE,EAAQ,CACpB,IAAIjB,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,OAASiB,EACRjB,CACX,CACA,OAAAe,EAAO,UAAU,WAAa,SAAUpB,EAAOM,EAAQ,CACnD,IAAIiB,EAAe,KAAK,OAAO,IAAI,SAAUF,EAAG,CAAE,OAAOA,EAAE,WAAWrB,EAAOM,CAAM,CAAG,CAAC,EACnFE,EAAU,SAAUN,EAAOQ,EAAK,CAChC,GAAI,CAAC,MAAM,QAAQR,CAAK,EACpB,OAAOQ,EAAI,KAAK,KAAM,kBAAmB,CAAC,EAE9C,QAASM,EAAI,EAAGA,EAAIO,EAAa,OAAQP,IAAK,CAC1C,IAAIC,EAAKM,EAAaP,CAAC,EAAEd,EAAMc,CAAC,EAAGN,CAAG,EACtC,GAAI,CAACO,EACD,OAAOP,EAAI,KAAKM,EAAG,KAAM,CAAC,CAElC,CACA,MAAO,EACX,EACA,OAAKV,EAGE,SAAUJ,EAAOQ,EAAK,CACzB,OAAKF,EAAQN,EAAOQ,CAAG,EAGhBR,EAAM,QAAUqB,EAAa,OAAS,GACzCb,EAAI,KAAKa,EAAa,OAAQ,gBAAiB,CAAC,EAHzC,EAIf,EARWf,CASf,EACOY,CACX,EAAEzB,CAAK,EACPR,EAAQ,OAASiC,EAIjB,SAASI,IAAQ,CAEb,QADI3B,EAAW,CAAC,EACPsB,EAAK,EAAGA,EAAK,UAAU,OAAQA,IACpCtB,EAASsB,CAAE,EAAI,UAAUA,CAAE,EAE/B,OAAO,IAAIM,EAAO5B,EAAS,IAAI,SAAUwB,EAAG,CAAE,OAAOzB,EAAUyB,CAAC,CAAG,CAAC,CAAC,CACzE,CACAlC,EAAQ,MAAQqC,GAChB,IAAIC,EAAwB,SAAUrB,EAAQ,CAC1ChB,EAAUqC,EAAQrB,CAAM,EACxB,SAASqB,EAAOH,EAAQ,CACpB,IAAIjB,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjCC,EAAM,OAASiB,EACf,IAAII,EAAQJ,EAAO,IAAI,SAAUD,EAAG,CAAE,OAAOA,aAAalB,GAASkB,aAAaT,EAAWS,EAAE,KAAO,IAAM,CAAC,EACtG,OAAO,SAAUM,EAAG,CAAE,OAAOA,CAAG,CAAC,EAClCC,EAAaN,EAAO,OAASI,EAAM,OACvC,OAAIA,EAAM,QACFE,EAAa,GACbF,EAAM,KAAKE,EAAa,OAAO,EAEnCvB,EAAM,SAAW,cAAgBqB,EAAM,KAAK,IAAI,GAGhDrB,EAAM,SAAW,cAAgBuB,EAAa,SAE3CvB,CACX,CACA,OAAAoB,EAAO,UAAU,WAAa,SAAUzB,EAAOM,EAAQ,CACnD,IAAID,EAAQ,KACRkB,EAAe,KAAK,OAAO,IAAI,SAAUF,EAAG,CAAE,OAAOA,EAAE,WAAWrB,EAAOM,CAAM,CAAG,CAAC,EACvF,OAAO,SAAUJ,EAAOQ,EAAK,CAEzB,QADImB,EAAKnB,EAAI,cAAc,EAClBM,EAAI,EAAGA,EAAIO,EAAa,OAAQP,IAAK,CAC1C,IAAIC,EAAKM,EAAaP,CAAC,EAAEd,EAAO2B,EAAG,cAAc,CAAC,EAClD,GAAIZ,EACA,MAAO,EAEf,CACA,OAAAP,EAAI,aAAamB,CAAE,EACZnB,EAAI,KAAK,KAAML,EAAM,SAAU,CAAC,CAC3C,CACJ,EACOoB,CACX,EAAE9B,CAAK,EACPR,EAAQ,OAASsC,EAIjB,SAASK,IAAe,CAEpB,QADIjC,EAAW,CAAC,EACPsB,EAAK,EAAGA,EAAK,UAAU,OAAQA,IACpCtB,EAASsB,CAAE,EAAI,UAAUA,CAAE,EAE/B,OAAO,IAAIY,EAAclC,EAAS,IAAI,SAAUwB,EAAG,CAAE,OAAOzB,EAAUyB,CAAC,CAAG,CAAC,CAAC,CAChF,CACAlC,EAAQ,aAAe2C,GACvB,IAAIC,EAA+B,SAAU3B,EAAQ,CACjDhB,EAAU2C,EAAe3B,CAAM,EAC/B,SAAS2B,EAAcT,EAAQ,CAC3B,IAAIjB,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,OAASiB,EACRjB,CACX,CACA,OAAA0B,EAAc,UAAU,WAAa,SAAU/B,EAAOM,EAAQ,CAC1D,IAAIC,EAAe,IAAI,IACnBgB,EAAe,KAAK,OAAO,IAAI,SAAUF,EAAG,CAAE,OAAOA,EAAE,WAAWrB,EAAOM,EAAQC,CAAY,CAAG,CAAC,EACrG,OAAO,SAAUL,EAAOQ,EAAK,CACzB,IAAIO,EAAKM,EAAa,MAAM,SAAUf,EAAS,CAAE,OAAOA,EAAQN,EAAOQ,CAAG,CAAG,CAAC,EAC9E,OAAIO,EACO,GAEJP,EAAI,KAAK,KAAM,KAAM,CAAC,CACjC,CACJ,EACOqB,CACX,EAAEpC,CAAK,EACPR,EAAQ,cAAgB4C,EAIxB,SAASC,GAASC,EAAQ,CACtB,OAAO,IAAIC,EAAUD,CAAM,CAC/B,CACA9C,EAAQ,SAAW6C,GACnB,IAAIE,EAA2B,SAAU9B,EAAQ,CAC7ChB,EAAU8C,EAAW9B,CAAM,EAC3B,SAAS8B,EAAUC,EAAS,CACxB,IAAI9B,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,QAAU8B,EAChB9B,EAAM,YAAc,IAAI,IACxBA,EAAM,SAAW,4BACjBA,EAAM,YAAc,IAAI,IAAI,OAAO,KAAK8B,CAAO,EAAE,IAAI,SAAUrC,EAAM,CAAE,OAAOqC,EAAQrC,CAAI,CAAG,CAAC,CAAC,EACxFO,CACX,CACA,OAAA6B,EAAU,UAAU,WAAa,SAAUlC,EAAOM,EAAQ,CACtD,IAAID,EAAQ,KACZ,OAAO,SAAUH,EAAOQ,EAAK,CACzB,OAAQL,EAAM,YAAY,IAAIH,CAAK,EAAI,GAAOQ,EAAI,KAAK,KAAML,EAAM,SAAU,CAAC,CAClF,CACJ,EACO6B,CACX,EAAEvC,CAAK,EACPR,EAAQ,UAAY+C,EAIpB,SAASE,GAAQtC,EAAMuC,EAAM,CACzB,OAAO,IAAIC,EAAaxC,EAAMuC,CAAI,CACtC,CACAlD,EAAQ,QAAUiD,GAClB,IAAIE,EAA8B,SAAUlC,EAAQ,CAChDhB,EAAUkD,EAAclC,CAAM,EAC9B,SAASkC,EAAaC,EAAUF,EAAM,CAClC,IAAIhC,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,SAAWkC,EACjBlC,EAAM,KAAOgC,EACbhC,EAAM,SAAW,UAAYkC,EAAW,IAAMF,EACvChC,CACX,CACA,OAAAiC,EAAa,UAAU,WAAa,SAAUtC,EAAOM,EAAQ,CACzD,IAAID,EAAQ,KACRJ,EAAQF,EAAaC,EAAO,KAAK,QAAQ,EAC7C,GAAI,EAAEC,aAAiBiC,GACnB,MAAM,IAAI,MAAM,QAAU,KAAK,SAAW,sCAAsC,EAEpF,IAAIM,EAAMvC,EAAM,QAAQ,KAAK,IAAI,EACjC,GAAI,CAACA,EAAM,QAAQ,eAAe,KAAK,IAAI,EACvC,MAAM,IAAI,MAAM,iBAAmB,KAAK,SAAW,IAAM,KAAK,KAAO,kBAAkB,EAE3F,OAAO,SAAUC,EAAOQ,EAAK,CAAE,OAAQR,IAAUsC,EAAO,GAAO9B,EAAI,KAAK,KAAML,EAAM,SAAU,EAAE,CAAG,CACvG,EACOiC,CACX,EAAE3C,CAAK,EACPR,EAAQ,aAAemD,EACvB,SAASG,GAAeC,EAAO,CAC3B,OAAO,OAAO,KAAKA,CAAK,EAAE,IAAI,SAAU5C,EAAM,CAAE,OAAO6C,GAAc7C,EAAM4C,EAAM5C,CAAI,CAAC,CAAG,CAAC,CAC9F,CACA,SAAS6C,GAAc7C,EAAMuC,EAAM,CAC/B,OAAOA,aAAgBO,EACnB,IAAIC,EAAM/C,EAAMuC,EAAK,MAAO,EAAI,EAChC,IAAIQ,EAAM/C,EAAMF,EAAUyC,CAAI,EAAG,EAAK,CAC9C,CAKA,SAASS,GAAMC,EAAOL,EAAO,CACzB,OAAO,IAAIM,EAAOD,EAAON,GAAeC,CAAK,CAAC,CAClD,CACAvD,EAAQ,MAAQ2D,GAChB,IAAIE,EAAwB,SAAU5C,EAAQ,CAC1ChB,EAAU4D,EAAQ5C,CAAM,EACxB,SAAS4C,EAAOD,EAAOL,EAAO,CAC1B,IAAIrC,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,MAAQ0C,EACd1C,EAAM,MAAQqC,EACdrC,EAAM,QAAU,IAAI,IAAIqC,EAAM,IAAI,SAAUlD,EAAG,CAAE,OAAOA,EAAE,IAAM,CAAC,CAAC,EAC3Da,CACX,CACA,OAAA2C,EAAO,UAAU,WAAa,SAAUhD,EAAOM,EAAQC,EAAc,CACjE,IAAIF,EAAQ,KACR4C,EAAe,KAAK,MAAM,IAAI,SAAU1D,EAAG,CAAE,OAAOQ,EAAaC,EAAOT,CAAC,EAAE,WAAWS,EAAOM,CAAM,CAAG,CAAC,EACvG4C,EAAe,KAAK,MAAM,IAAI,SAAUb,EAAM,CAAE,OAAOA,EAAK,MAAM,WAAWrC,EAAOM,CAAM,CAAG,CAAC,EAC9F6C,EAAU,IAAIzD,EAAO,YAErB0D,EAAiB,KAAK,MAAM,IAAI,SAAUf,EAAMrB,EAAG,CACnD,MAAO,CAACqB,EAAK,OAAS,CAACa,EAAalC,CAAC,EAAE,OAAWmC,CAAO,CAC7D,CAAC,EACG3C,EAAU,SAAUN,EAAOQ,EAAK,CAChC,GAAI,OAAOR,GAAU,UAAYA,IAAU,KACvC,OAAOQ,EAAI,KAAK,KAAM,mBAAoB,CAAC,EAE/C,QAASM,EAAI,EAAGA,EAAIiC,EAAa,OAAQjC,IACrC,GAAI,CAACiC,EAAajC,CAAC,EAAEd,EAAOQ,CAAG,EAC3B,MAAO,GAGf,QAASM,EAAI,EAAGA,EAAIkC,EAAa,OAAQlC,IAAK,CAC1C,IAAIqC,EAAShD,EAAM,MAAMW,CAAC,EAAE,KACxBsC,EAAIpD,EAAMmD,CAAM,EACpB,GAAIC,IAAM,QACN,GAAIF,EAAepC,CAAC,EAChB,OAAON,EAAI,KAAK2C,EAAQ,aAAc,CAAC,MAG1C,CACD,IAAIpC,GAAKiC,EAAalC,CAAC,EAAEsC,EAAG5C,CAAG,EAC/B,GAAI,CAACO,GACD,OAAOP,EAAI,KAAK2C,EAAQ,KAAM,CAAC,CAEvC,CACJ,CACA,MAAO,EACX,EACA,GAAI,CAAC/C,EACD,OAAOE,EAEX,IAAI+C,EAAU,KAAK,QACnB,OAAIhD,IACA,KAAK,QAAQ,QAAQ,SAAU8B,EAAM,CAAE,OAAO9B,EAAa,IAAI8B,CAAI,CAAG,CAAC,EACvEkB,EAAUhD,GAGP,SAAUL,EAAOQ,EAAK,CACzB,GAAI,CAACF,EAAQN,EAAOQ,CAAG,EACnB,MAAO,GAEX,QAAS2B,KAAQnC,EACb,GAAI,CAACqD,EAAQ,IAAIlB,CAAI,EACjB,OAAO3B,EAAI,KAAK2B,EAAM,gBAAiB,CAAC,EAGhD,MAAO,EACX,CACJ,EACOW,CACX,EAAErD,CAAK,EACPR,EAAQ,OAAS6D,EAIjB,SAASQ,GAAI3D,EAAU,CAAE,OAAO,IAAI+C,EAAUhD,EAAUC,CAAQ,CAAC,CAAG,CACpEV,EAAQ,IAAMqE,GACd,IAAIZ,EAA2B,SAAUxC,EAAQ,CAC7ChB,EAAUwD,EAAWxC,CAAM,EAC3B,SAASwC,EAAU3C,EAAO,CACtB,IAAII,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,MAAQJ,EACPI,CACX,CACA,OAAAuC,EAAU,UAAU,WAAa,SAAU5C,EAAOM,EAAQ,CACtD,IAAIS,EAAc,KAAK,MAAM,WAAWf,EAAOM,CAAM,EACrD,OAAO,SAAUJ,EAAOQ,EAAK,CACzB,OAAOR,IAAU,QAAaa,EAAYb,EAAOQ,CAAG,CACxD,CACJ,EACOkC,CACX,EAAEjD,CAAK,EACPR,EAAQ,UAAYyD,EAIpB,IAAIC,EAAuB,UAAY,CACnC,SAASA,EAAM/C,EAAMG,EAAOwD,EAAO,CAC/B,KAAK,KAAO3D,EACZ,KAAK,MAAQG,EACb,KAAK,MAAQwD,CACjB,CACA,OAAOZ,CACX,EAAE,EACF1D,EAAQ,MAAQ0D,EAKhB,SAASa,GAAKC,EAAY,CAEtB,QADIC,EAAS,CAAC,EACLzC,EAAK,EAAGA,EAAK,UAAU,OAAQA,IACpCyC,EAAOzC,EAAK,CAAC,EAAI,UAAUA,CAAE,EAEjC,OAAO,IAAI0C,EAAM,IAAIC,GAAWF,CAAM,EAAGhE,EAAU+D,CAAU,CAAC,CAClE,CACAxE,EAAQ,KAAOuE,GACf,IAAIG,EAAuB,SAAUzD,EAAQ,CACzChB,EAAUyE,EAAOzD,CAAM,EACvB,SAASyD,EAAME,EAAWC,EAAQ,CAC9B,IAAI3D,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,UAAY0D,EAClB1D,EAAM,OAAS2D,EACR3D,CACX,CACA,OAAAwD,EAAM,UAAU,WAAa,SAAU7D,EAAOM,EAAQ,CAClD,OAAO,SAAUJ,EAAOQ,EAAK,CACzB,OAAO,OAAOR,GAAU,WAAa,GAAOQ,EAAI,KAAK,KAAM,oBAAqB,CAAC,CACrF,CACJ,EACOmD,CACX,EAAElE,CAAK,EACPR,EAAQ,MAAQ0E,EAIhB,SAASI,GAAMnE,EAAMD,EAAU4D,EAAO,CAClC,OAAO,IAAIS,EAAOpE,EAAMF,EAAUC,CAAQ,EAAG,EAAQ4D,CAAM,CAC/D,CACAtE,EAAQ,MAAQ8E,GAChB,IAAIC,EAAwB,UAAY,CACpC,SAASA,EAAOpE,EAAMG,EAAOwD,EAAO,CAChC,KAAK,KAAO3D,EACZ,KAAK,MAAQG,EACb,KAAK,MAAQwD,CACjB,CACA,OAAOS,CACX,EAAE,EACF/E,EAAQ,OAAS+E,EAIjB,IAAIJ,GAA4B,SAAU1D,EAAQ,CAC9ChB,EAAU0E,EAAY1D,CAAM,EAC5B,SAAS0D,EAAWF,EAAQ,CACxB,IAAIvD,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,OAASuD,EACRvD,CACX,CACA,OAAAyD,EAAW,UAAU,WAAa,SAAU9D,EAAOM,EAAQ,CACvD,IAAID,EAAQ,KACRkB,EAAe,KAAK,OAAO,IAAI,SAAUF,EAAG,CAAE,OAAOA,EAAE,MAAM,WAAWrB,EAAOM,CAAM,CAAG,CAAC,EACzF6C,EAAU,IAAIzD,EAAO,YACrByE,EAAkB,KAAK,OAAO,IAAI,SAAUF,EAAOjD,EAAG,CACtD,MAAO,CAACiD,EAAM,OAAS,CAAC1C,EAAaP,CAAC,EAAE,OAAWmC,CAAO,CAC9D,CAAC,EACG3C,EAAU,SAAUN,EAAOQ,EAAK,CAChC,GAAI,CAAC,MAAM,QAAQR,CAAK,EACpB,OAAOQ,EAAI,KAAK,KAAM,kBAAmB,CAAC,EAE9C,QAASM,EAAI,EAAGA,EAAIO,EAAa,OAAQP,IAAK,CAC1C,IAAIxB,EAAIa,EAAM,OAAOW,CAAC,EACtB,GAAId,EAAMc,CAAC,IAAM,QACb,GAAImD,EAAgBnD,CAAC,EACjB,OAAON,EAAI,KAAKlB,EAAE,KAAM,aAAc,CAAC,MAG1C,CACD,IAAIyB,EAAKM,EAAaP,CAAC,EAAEd,EAAMc,CAAC,EAAGN,CAAG,EACtC,GAAI,CAACO,EACD,OAAOP,EAAI,KAAKlB,EAAE,KAAM,KAAM,CAAC,CAEvC,CACJ,CACA,MAAO,EACX,EACA,OAAKc,EAGE,SAAUJ,EAAOQ,EAAK,CACzB,OAAKF,EAAQN,EAAOQ,CAAG,EAGhBR,EAAM,QAAUqB,EAAa,OAAS,GACzCb,EAAI,KAAKa,EAAa,OAAQ,gBAAiB,CAAC,EAHzC,EAIf,EARWf,CASf,EACOsD,CACX,EAAEnE,CAAK,EACPR,EAAQ,WAAa2E,GAIrB,IAAIrD,EAA2B,SAAUL,EAAQ,CAC7ChB,EAAUqB,EAAWL,CAAM,EAC3B,SAASK,EAAU2D,EAAWC,EAAS,CACnC,IAAIhE,EAAQD,EAAO,KAAK,IAAI,GAAK,KACjC,OAAAC,EAAM,UAAY+D,EAClB/D,EAAM,QAAUgE,EACThE,CACX,CACA,OAAAI,EAAU,UAAU,WAAa,SAAUT,EAAOM,EAAQ,CACtD,IAAID,EAAQ,KACZ,OAAO,SAAUH,EAAOQ,EAAK,CAAE,OAAOL,EAAM,UAAUH,CAAK,EAAI,GAAOQ,EAAI,KAAK,KAAML,EAAM,QAAS,CAAC,CAAG,CAC5G,EACOI,CACX,EAAEd,CAAK,EACPR,EAAQ,UAAYsB,EAIpBtB,EAAQ,WAAa,CACjB,IAAK,IAAIsB,EAAU,SAAU6C,EAAG,CAAE,MAAO,EAAM,EAAG,YAAY,EAC9D,OAAQ,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQ,OAAOA,GAAM,QAAW,EAAG,iBAAiB,EACzF,OAAQ,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQ,OAAOA,GAAM,UAAYA,CAAI,EAAG,kBAAkB,EAC/F,QAAS,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQ,OAAOA,GAAM,SAAY,EAAG,kBAAkB,EAC5F,OAAQ,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQ,OAAOA,GAAM,QAAW,EAAG,iBAAiB,EACzF,OAAQ,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQ,OAAOA,GAAM,QAAW,EAAG,iBAAiB,EACzF,KAAM,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQA,GAAK,IAAO,EAAG,aAAa,EACvE,UAAW,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQA,IAAM,MAAY,EAAG,kBAAkB,EACvF,KAAM,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,OAAQA,IAAM,IAAO,EAAG,aAAa,EACxE,MAAO,IAAI7C,EAAU,SAAU6C,EAAG,CAAE,MAAO,EAAO,EAAG,eAAe,EACpE,KAAM,IAAI7C,EAAU6D,EAAmB,eAAe,EAAG,eAAe,EACxE,OAAQ,IAAI7D,EAAU6D,EAAmB,iBAAiB,EAAG,iBAAiB,CAClF,EAIA,IAAIC,GAAiB,OAAO,UAAU,SACtC,SAASD,EAAmBE,EAAK,CAC7B,OAAO,SAAUlB,EAAG,CAAE,OAAO,OAAOA,GAAM,UAAYA,GAAKiB,GAAe,KAAKjB,CAAC,IAAMkB,CAAK,CAC/F,CACI,OAAO,UAAW,MAClBrF,EAAQ,WAAW,OAAS,IAAIsB,EAAU,SAAU6C,EAAG,CAAE,OAAO,UAAO,SAASA,CAAC,CAAG,EAAG,iBAAiB,GAE5G,IAAImB,GAAU,SAAUC,EAAS,CAC7BvF,EAAQ,WAAWuF,EAAQ,IAAI,EAAI,IAAIjE,EAAU,SAAU6C,EAAG,CAAE,OAAQA,aAAaoB,CAAU,EAAG,YAAcA,EAAQ,IAAI,CAChI,EAEA,IAASvD,EAAK,EAAGwD,EAAK,CAAC,UAAW,WAAY,kBAAmB,WAAY,YACzE,WAAY,YAAa,aAAc,aAAc,WAAW,EAAGxD,EAAKwD,EAAG,OAAQxD,IAC/EuD,EAAUC,EAAGxD,CAAE,EACnBsD,GAAQC,CAAO,EADX,IAAAA,EAFCvD,EAAQwD,ICjjBjB,IAAAC,GAAAC,EAAAC,GAAA,cACA,IAAIC,GAAkBD,GAAQA,EAAK,gBAAmB,UAAY,CAC9D,QAASE,EAAI,EAAGC,EAAI,EAAGC,EAAK,UAAU,OAAQD,EAAIC,EAAID,IAAKD,GAAK,UAAUC,CAAC,EAAE,OAC7E,QAASE,EAAI,MAAMH,CAAC,EAAGI,EAAI,EAAGH,EAAI,EAAGA,EAAIC,EAAID,IACzC,QAASI,EAAI,UAAUJ,CAAC,EAAGK,EAAI,EAAGC,EAAKF,EAAE,OAAQC,EAAIC,EAAID,IAAKF,IAC1DD,EAAEC,CAAC,EAAIC,EAAEC,CAAC,EAClB,OAAOH,CACX,EACA,OAAO,eAAeL,EAAS,aAAc,CAAE,MAAO,EAAK,CAAC,EAC5DA,EAAQ,QAAUA,EAAQ,eAAiB,OAC3C,IAAIU,EAAU,IACVC,EAAS,IAITC,EAAU,IACd,OAAO,eAAeZ,EAAS,SAAU,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,MAAQ,CAAE,CAAC,EAC1G,OAAO,eAAeZ,EAAS,YAAa,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,SAAW,CAAE,CAAC,EAChH,OAAO,eAAeZ,EAAS,eAAgB,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,YAAc,CAAE,CAAC,EACtH,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,SAAU,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,MAAQ,CAAE,CAAC,EAC1G,OAAO,eAAeZ,EAAS,WAAY,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,QAAU,CAAE,CAAC,EAC9G,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,YAAa,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,SAAW,CAAE,CAAC,EAChH,OAAO,eAAeZ,EAAS,SAAU,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,MAAQ,CAAE,CAAC,EAC1G,OAAO,eAAeZ,EAAS,aAAc,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,UAAY,CAAE,CAAC,EAClH,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,SAAU,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,MAAQ,CAAE,CAAC,EAC1G,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,SAAU,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,MAAQ,CAAE,CAAC,EAC1G,OAAO,eAAeZ,EAAS,gBAAiB,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,aAAe,CAAE,CAAC,EACxH,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,UAAW,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,OAAS,CAAE,CAAC,EAC5G,OAAO,eAAeZ,EAAS,WAAY,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,QAAU,CAAE,CAAC,EAC9G,OAAO,eAAeZ,EAAS,OAAQ,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,IAAM,CAAE,CAAC,EACtG,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,MAAO,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,GAAK,CAAE,CAAC,EACpG,OAAO,eAAeZ,EAAS,OAAQ,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,IAAM,CAAE,CAAC,EACtG,OAAO,eAAeZ,EAAS,MAAO,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,GAAK,CAAE,CAAC,EACpG,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,QAAS,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,KAAO,CAAE,CAAC,EACxG,OAAO,eAAeZ,EAAS,eAAgB,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,YAAc,CAAE,CAAC,EACtH,OAAO,eAAeZ,EAAS,YAAa,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOY,EAAQ,SAAW,CAAE,CAAC,EAChH,IAAIC,GAAS,IACb,OAAO,eAAeb,EAAS,SAAU,CAAE,WAAY,GAAM,IAAK,UAAY,CAAE,OAAOa,GAAO,MAAQ,CAAE,CAAC,EAQzG,SAASC,IAAiB,CAEtB,QADIC,EAAY,CAAC,EACRC,EAAK,EAAGA,EAAK,UAAU,OAAQA,IACpCD,EAAUC,CAAE,EAAI,UAAUA,CAAE,EAIhC,QAFIC,EAAY,OAAO,OAAO,MAAM,OAAQhB,GAAe,CAAC,CAAC,EAAGS,EAAQ,UAAU,EAAGK,CAAS,CAAC,EAC3FG,EAAW,CAAC,EACPC,EAAK,EAAGC,EAAcL,EAAWI,EAAKC,EAAY,OAAQD,IAE/D,QADIE,EAAUD,EAAYD,CAAE,EACnBG,EAAK,EAAGC,EAAK,OAAO,KAAKF,CAAO,EAAGC,EAAKC,EAAG,OAAQD,IAAM,CAC9D,IAAIE,EAAOD,EAAGD,CAAE,EAChBJ,EAASM,CAAI,EAAI,IAAIC,GAAQR,EAAWI,EAAQG,CAAI,CAAC,CACzD,CAEJ,OAAON,CACX,CACAlB,EAAQ,eAAiBc,GAKzB,IAAIW,GAAyB,UAAY,CAErC,SAASA,EAAQC,EAAOC,EAAOC,EAAO,CAMlC,GALIA,IAAU,SAAUA,EAAQ,SAChC,KAAK,MAAQF,EACb,KAAK,MAAQC,EACb,KAAK,MAAQC,EACb,KAAK,MAAQ,IAAI,IACbD,aAAiBjB,EAAQ,OACzB,QAASM,EAAK,EAAGG,EAAKQ,EAAM,MAAOX,EAAKG,EAAG,OAAQH,IAAM,CACrD,IAAIa,EAAIV,EAAGH,CAAE,EACb,KAAK,MAAM,IAAIa,EAAE,KAAMA,EAAE,KAAK,CAClC,CAEJ,KAAK,aAAe,KAAK,MAAM,WAAWH,EAAO,EAAK,EACtD,KAAK,cAAgB,KAAK,MAAM,WAAWA,EAAO,EAAI,CAC1D,CAKA,OAAAD,EAAQ,UAAU,gBAAkB,SAAUK,EAAM,CAChD,KAAK,MAAQA,CACjB,EAIAL,EAAQ,UAAU,MAAQ,SAAUM,EAAO,CAAE,OAAO,KAAK,SAAS,KAAK,aAAcA,CAAK,CAAG,EAK7FN,EAAQ,UAAU,KAAO,SAAUM,EAAO,CACtC,OAAO,KAAK,aAAaA,EAAO,IAAIpB,EAAO,WAAa,CAC5D,EAKAc,EAAQ,UAAU,SAAW,SAAUM,EAAO,CAC1C,OAAO,KAAK,YAAY,KAAK,aAAcA,CAAK,CACpD,EAMAN,EAAQ,UAAU,YAAc,SAAUM,EAAO,CAAE,OAAO,KAAK,SAAS,KAAK,cAAeA,CAAK,CAAG,EAKpGN,EAAQ,UAAU,WAAa,SAAUM,EAAO,CAC5C,OAAO,KAAK,cAAcA,EAAO,IAAIpB,EAAO,WAAa,CAC7D,EAKAc,EAAQ,UAAU,eAAiB,SAAUM,EAAO,CAChD,OAAO,KAAK,YAAY,KAAK,cAAeA,CAAK,CACrD,EAKAN,EAAQ,UAAU,QAAU,SAAUO,EAAM,CACxC,IAAIL,EAAQ,KAAK,MAAM,IAAIK,CAAI,EAC/B,GAAI,CAACL,EACD,MAAM,IAAI,MAAM,wBAA0BK,CAAI,EAElD,OAAO,IAAIP,EAAQ,KAAK,MAAOE,EAAO,KAAK,MAAQ,IAAMK,CAAI,CACjE,EASAP,EAAQ,UAAU,WAAa,SAAUQ,EAAY,CACjD,IAAIC,EAAQ,KAAK,WAAWD,CAAU,EACtC,OAAO,IAAIR,EAAQ,KAAK,MAAOS,EAAM,SAAS,CAClD,EAKAT,EAAQ,UAAU,aAAe,SAAUQ,EAAY,CACnD,IAAIC,EAAQ,KAAK,WAAWD,CAAU,EACtC,OAAO,IAAIR,EAAQ,KAAK,MAAOS,EAAM,MAAM,CAC/C,EAIAT,EAAQ,UAAU,QAAU,UAAY,CACpC,GAAI,EAAE,KAAK,iBAAiBf,EAAQ,OAChC,MAAM,IAAI,MAAM,mCAAmC,EAEvD,OAAO,IAAIe,EAAQ,KAAK,MAAO,KAAK,MAAM,SAAS,CACvD,EAIAA,EAAQ,UAAU,UAAY,UAAY,CACtC,GAAI,EAAE,KAAK,iBAAiBf,EAAQ,OAChC,MAAM,IAAI,MAAM,qCAAqC,EAEzD,OAAO,IAAIe,EAAQ,KAAK,MAAO,KAAK,MAAM,MAAM,CACpD,EAIAA,EAAQ,UAAU,QAAU,UAAY,CACpC,OAAO,KAAK,KAChB,EAIAA,EAAQ,UAAU,SAAW,SAAUU,EAAaJ,EAAO,CACvD,IAAIK,EAAU,IAAIzB,EAAO,YACzB,GAAI,CAACwB,EAAYJ,EAAOK,CAAO,EAAG,CAC9B,IAAIC,EAAY,IAAI1B,EAAO,cAC3B,MAAAwB,EAAYJ,EAAOM,CAAS,EACtBA,EAAU,SAAS,KAAK,KAAK,CACvC,CACJ,EACAZ,EAAQ,UAAU,YAAc,SAAUU,EAAaJ,EAAO,CAC1D,IAAIK,EAAU,IAAIzB,EAAO,YACzB,GAAIwB,EAAYJ,EAAOK,CAAO,EAC1B,OAAO,KAEX,IAAIC,EAAY,IAAI1B,EAAO,cAC3B,OAAAwB,EAAYJ,EAAOM,CAAS,EACrBA,EAAU,eAAe,KAAK,KAAK,CAC9C,EACAZ,EAAQ,UAAU,WAAa,SAAUQ,EAAY,CACjD,IAAIN,EAAQ,KAAK,MAAM,IAAIM,CAAU,EACrC,GAAI,CAACN,EACD,MAAM,IAAI,MAAM,wBAA0BM,CAAU,EAExD,GAAI,EAAEN,aAAiBjB,EAAQ,OAC3B,MAAM,IAAI,MAAM,YAAcuB,EAAa,kBAAkB,EAEjE,OAAON,CACX,EACOF,CACX,EAAE,EACFzB,EAAQ,QAAUyB,KC/NlB,IAAAa,EAAsB,SAAoC,CAAE,WAAAC,GAAW,QAAAC,GAAQ,eAAAC,GAAe,OAAAC,GAAO,UAAAC,GAAU,aAAAC,GAAa,MAAAC,GAAM,OAAAC,GAAO,SAAAC,GAAS,MAAAC,GAAM,UAAAC,GAAU,OAAAC,GAAO,WAAAC,GAAW,MAAAC,GAAM,OAAAC,GAAO,MAAAC,GAAM,OAAAC,GAAO,cAAAC,GAAc,MAAAC,GAAM,QAAAC,GAAQ,SAAAC,GAAS,KAAAC,GAAK,MAAAC,GAAM,IAAAC,GAAI,KAAAC,GAAK,IAAAC,GAAI,MAAAC,GAAM,MAAAC,GAAM,MAAAC,GAAM,aAAAC,GAAa,UAAAC,GAAU,OAAAC,EAAO,EAAIhC,EAAYiC,GAAa,WAAWjC","names":["require_util","__commonJSMin","exports","__extends","extendStatics","d","b","p","__","VError","_super","path","message","_this","NoopContext","relPath","score","ur","DetailContext","DetailUnionResolver","unionResolver","_a","_b","u","best","_i","_c","ctx","msgParts","i","m","details","detail","require_types","__commonJSMin","exports","__extends","extendStatics","d","b","p","__","util_1","TType","parseSpec","typeSpec","name","getNamedType","suite","ttype","value","TName","_super","_this","strict","allowedProps","checker","BasicType","ctx","lit","TLiteral","array","TArray","itemChecker","i","ok","tuple","_i","TTuple","t","ttypes","itemCheckers","union","TUnion","names","n","otherTypes","ur","intersection","TIntersection","enumtype","values","TEnumType","members","enumlit","prop","TEnumLiteral","enumName","val","makeIfaceProps","props","makeIfaceProp","TOptional","TProp","iface","bases","TIface","baseCheckers","propCheckers","testCtx","isPropRequired","name_1","v","propSet","opt","isOpt","func","resultSpec","params","TFunc","TParamList","paramList","result","param","TParam","isParamRequired","validator","message","getIsNativeChecker","nativeToString","tag","_loop_1","array_1","_a","require_dist","__commonJSMin","exports","__spreadArrays","s","i","il","r","k","a","j","jl","types_1","util_1","types_2","util_2","createCheckers","typeSuite","_i","fullSuite","checkers","_a","typeSuite_1","suite_1","_b","_c","name","Checker","suite","ttype","_path","p","path","value","prop","methodName","tfunc","checkerFunc","noopCtx","detailCtx","cjsm","__esModule","Checker","createCheckers","TArray","TEnumType","TEnumLiteral","TFunc","TIface","TLiteral","TName","TOptional","TParam","TParamList","TProp","TTuple","TType","TUnion","TIntersection","array","enumlit","enumtype","func","iface","lit","name","opt","param","tuple","union","intersection","BasicType","VError","endpoint_default"],"sources":["../esm/npm/ts-interface-checker@0.1.13/node_modules/ts-interface-checker/dist/util.js","../esm/npm/ts-interface-checker@0.1.13/node_modules/ts-interface-checker/dist/types.js","../esm/npm/ts-interface-checker@0.1.13/node_modules/ts-interface-checker/dist/index.js","endpoint.js"],"sourcesContent":["\"use strict\";\nvar __extends = (this \u0026\u0026 this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array \u0026\u0026 function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.DetailContext = exports.NoopContext = exports.VError = void 0;\n/**\n * Error thrown by validation. Besides an informative message, it includes the path to the\n * property which triggered the failure.\n */\nvar VError = /** @class */ (function (_super) {\n    __extends(VError, _super);\n    function VError(path, message) {\n        var _this = _super.call(this, message) || this;\n        _this.path = path;\n        // See https://github.com/Microsoft/TypeScript/wiki/Breaking-Changes#extending-built-ins-like-error-array-and-map-may-no-longer-work for info about this workaround.\n        Object.setPrototypeOf(_this, VError.prototype);\n        return _this;\n    }\n    return VError;\n}(Error));\nexports.VError = VError;\n/**\n * Fast implementation of IContext used for first-pass validation. If that fails, we can validate\n * using DetailContext to collect error messages. That's faster for the common case when messages\n * normally pass validation.\n */\nvar NoopContext = /** @class */ (function () {\n    function NoopContext() {\n    }\n    NoopContext.prototype.fail = function (relPath, message, score) {\n        return false;\n    };\n    NoopContext.prototype.unionResolver = function () { return this; };\n    NoopContext.prototype.createContext = function () { return this; };\n    NoopContext.prototype.resolveUnion = function (ur) { };\n    return NoopContext;\n}());\nexports.NoopContext = NoopContext;\n/**\n * Complete implementation of IContext that collects meaningfull errors.\n */\nvar DetailContext = /** @class */ (function () {\n    function DetailContext() {\n        // Stack of property names and associated messages for reporting helpful error messages.\n        this._propNames = [\"\"];\n        this._messages = [null];\n        // Score is used to choose the best union member whose DetailContext to use for reporting.\n        // Higher score means better match (or rather less severe mismatch).\n        this._score = 0;\n    }\n    DetailContext.prototype.fail = function (relPath, message, score) {\n        this._propNames.push(relPath);\n        this._messages.push(message);\n        this._score += score;\n        return false;\n    };\n    DetailContext.prototype.unionResolver = function () {\n        return new DetailUnionResolver();\n    };\n    DetailContext.prototype.resolveUnion = function (unionResolver) {\n        var _a, _b;\n        var u = unionResolver;\n        var best = null;\n        for (var _i = 0, _c = u.contexts; _i \u003c _c.length; _i++) {\n            var ctx = _c[_i];\n            if (!best || ctx._score \u003e= best._score) {\n                best = ctx;\n            }\n        }\n        if (best \u0026\u0026 best._score \u003e 0) {\n            (_a = this._propNames).push.apply(_a, best._propNames);\n            (_b = this._messages).push.apply(_b, best._messages);\n        }\n    };\n    DetailContext.prototype.getError = function (path) {\n        var msgParts = [];\n        for (var i = this._propNames.length - 1; i \u003e= 0; i--) {\n            var p = this._propNames[i];\n            path += (typeof p === \"number\") ? \"[\" + p + \"]\" : (p ? \".\" + p : \"\");\n            var m = this._messages[i];\n            if (m) {\n                msgParts.push(path + \" \" + m);\n            }\n        }\n        return new VError(path, msgParts.join(\"; \"));\n    };\n    DetailContext.prototype.getErrorDetail = function (path) {\n        var details = [];\n        for (var i = this._propNames.length - 1; i \u003e= 0; i--) {\n            var p = this._propNames[i];\n            path += (typeof p === \"number\") ? \"[\" + p + \"]\" : (p ? \".\" + p : \"\");\n            var message = this._messages[i];\n            if (message) {\n                details.push({ path: path, message: message });\n            }\n        }\n        var detail = null;\n        for (var i = details.length - 1; i \u003e= 0; i--) {\n            if (detail) {\n                details[i].nested = [detail];\n            }\n            detail = details[i];\n        }\n        return detail;\n    };\n    return DetailContext;\n}());\nexports.DetailContext = DetailContext;\nvar DetailUnionResolver = /** @class */ (function () {\n    function DetailUnionResolver() {\n        this.contexts = [];\n    }\n    DetailUnionResolver.prototype.createContext = function () {\n        var ctx = new DetailContext();\n        this.contexts.push(ctx);\n        return ctx;\n    };\n    return DetailUnionResolver;\n}());\n","\"use strict\";\n/**\n * This module defines nodes used to define types and validations for objects and interfaces.\n */\n// tslint:disable:no-shadowed-variable prefer-for-of\nvar __extends = (this \u0026\u0026 this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array \u0026\u0026 function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.basicTypes = exports.BasicType = exports.TParamList = exports.TParam = exports.param = exports.TFunc = exports.func = exports.TProp = exports.TOptional = exports.opt = exports.TIface = exports.iface = exports.TEnumLiteral = exports.enumlit = exports.TEnumType = exports.enumtype = exports.TIntersection = exports.intersection = exports.TUnion = exports.union = exports.TTuple = exports.tuple = exports.TArray = exports.array = exports.TLiteral = exports.lit = exports.TName = exports.name = exports.TType = void 0;\nvar util_1 = require(\"./util\");\n/** Node that represents a type. */\nvar TType = /** @class */ (function () {\n    function TType() {\n    }\n    return TType;\n}());\nexports.TType = TType;\n/** Parses a type spec into a TType node. */\nfunction parseSpec(typeSpec) {\n    return typeof typeSpec === \"string\" ? name(typeSpec) : typeSpec;\n}\nfunction getNamedType(suite, name) {\n    var ttype = suite[name];\n    if (!ttype) {\n        throw new Error(\"Unknown type \" + name);\n    }\n    return ttype;\n}\n/**\n * Defines a type name, either built-in, or defined in this suite. It can typically be included in\n * the specs as just a plain string.\n */\nfunction name(value) { return new TName(value); }\nexports.name = name;\nvar TName = /** @class */ (function (_super) {\n    __extends(TName, _super);\n    function TName(name) {\n        var _this = _super.call(this) || this;\n        _this.name = name;\n        _this._failMsg = \"is not a \" + name;\n        return _this;\n    }\n    TName.prototype.getChecker = function (suite, strict, allowedProps) {\n        var _this = this;\n        var ttype = getNamedType(suite, this.name);\n        var checker = ttype.getChecker(suite, strict, allowedProps);\n        if (ttype instanceof BasicType || ttype instanceof TName) {\n            return checker;\n        }\n        // For complex types, add an additional \"is not a \u003cType\u003e\" message on failure.\n        return function (value, ctx) { return checker(value, ctx) ? true : ctx.fail(null, _this._failMsg, 0); };\n    };\n    return TName;\n}(TType));\nexports.TName = TName;\n/**\n * Defines a literal value, e.g. lit('hello') or lit(123).\n */\nfunction lit(value) { return new TLiteral(value); }\nexports.lit = lit;\nvar TLiteral = /** @class */ (function (_super) {\n    __extends(TLiteral, _super);\n    function TLiteral(value) {\n        var _this = _super.call(this) || this;\n        _this.value = value;\n        _this.name = JSON.stringify(value);\n        _this._failMsg = \"is not \" + _this.name;\n        return _this;\n    }\n    TLiteral.prototype.getChecker = function (suite, strict) {\n        var _this = this;\n        return function (value, ctx) { return (value === _this.value) ? true : ctx.fail(null, _this._failMsg, -1); };\n    };\n    return TLiteral;\n}(TType));\nexports.TLiteral = TLiteral;\n/**\n * Defines an array type, e.g. array('number').\n */\nfunction array(typeSpec) { return new TArray(parseSpec(typeSpec)); }\nexports.array = array;\nvar TArray = /** @class */ (function (_super) {\n    __extends(TArray, _super);\n    function TArray(ttype) {\n        var _this = _super.call(this) || this;\n        _this.ttype = ttype;\n        return _this;\n    }\n    TArray.prototype.getChecker = function (suite, strict) {\n        var itemChecker = this.ttype.getChecker(suite, strict);\n        return function (value, ctx) {\n            if (!Array.isArray(value)) {\n                return ctx.fail(null, \"is not an array\", 0);\n            }\n            for (var i = 0; i \u003c value.length; i++) {\n                var ok = itemChecker(value[i], ctx);\n                if (!ok) {\n                    return ctx.fail(i, null, 1);\n                }\n            }\n            return true;\n        };\n    };\n    return TArray;\n}(TType));\nexports.TArray = TArray;\n/**\n * Defines a tuple type, e.g. tuple('string', 'number').\n */\nfunction tuple() {\n    var typeSpec = [];\n    for (var _i = 0; _i \u003c arguments.length; _i++) {\n        typeSpec[_i] = arguments[_i];\n    }\n    return new TTuple(typeSpec.map(function (t) { return parseSpec(t); }));\n}\nexports.tuple = tuple;\nvar TTuple = /** @class */ (function (_super) {\n    __extends(TTuple, _super);\n    function TTuple(ttypes) {\n        var _this = _super.call(this) || this;\n        _this.ttypes = ttypes;\n        return _this;\n    }\n    TTuple.prototype.getChecker = function (suite, strict) {\n        var itemCheckers = this.ttypes.map(function (t) { return t.getChecker(suite, strict); });\n        var checker = function (value, ctx) {\n            if (!Array.isArray(value)) {\n                return ctx.fail(null, \"is not an array\", 0);\n            }\n            for (var i = 0; i \u003c itemCheckers.length; i++) {\n                var ok = itemCheckers[i](value[i], ctx);\n                if (!ok) {\n                    return ctx.fail(i, null, 1);\n                }\n            }\n            return true;\n        };\n        if (!strict) {\n            return checker;\n        }\n        return function (value, ctx) {\n            if (!checker(value, ctx)) {\n                return false;\n            }\n            return value.length \u003c= itemCheckers.length ? true :\n                ctx.fail(itemCheckers.length, \"is extraneous\", 2);\n        };\n    };\n    return TTuple;\n}(TType));\nexports.TTuple = TTuple;\n/**\n * Defines a union type, e.g. union('number', 'null').\n */\nfunction union() {\n    var typeSpec = [];\n    for (var _i = 0; _i \u003c arguments.length; _i++) {\n        typeSpec[_i] = arguments[_i];\n    }\n    return new TUnion(typeSpec.map(function (t) { return parseSpec(t); }));\n}\nexports.union = union;\nvar TUnion = /** @class */ (function (_super) {\n    __extends(TUnion, _super);\n    function TUnion(ttypes) {\n        var _this = _super.call(this) || this;\n        _this.ttypes = ttypes;\n        var names = ttypes.map(function (t) { return t instanceof TName || t instanceof TLiteral ? t.name : null; })\n            .filter(function (n) { return n; });\n        var otherTypes = ttypes.length - names.length;\n        if (names.length) {\n            if (otherTypes \u003e 0) {\n                names.push(otherTypes + \" more\");\n            }\n            _this._failMsg = \"is none of \" + names.join(\", \");\n        }\n        else {\n            _this._failMsg = \"is none of \" + otherTypes + \" types\";\n        }\n        return _this;\n    }\n    TUnion.prototype.getChecker = function (suite, strict) {\n        var _this = this;\n        var itemCheckers = this.ttypes.map(function (t) { return t.getChecker(suite, strict); });\n        return function (value, ctx) {\n            var ur = ctx.unionResolver();\n            for (var i = 0; i \u003c itemCheckers.length; i++) {\n                var ok = itemCheckers[i](value, ur.createContext());\n                if (ok) {\n                    return true;\n                }\n            }\n            ctx.resolveUnion(ur);\n            return ctx.fail(null, _this._failMsg, 0);\n        };\n    };\n    return TUnion;\n}(TType));\nexports.TUnion = TUnion;\n/**\n * Defines an intersection type, e.g. intersection('number', 'null').\n */\nfunction intersection() {\n    var typeSpec = [];\n    for (var _i = 0; _i \u003c arguments.length; _i++) {\n        typeSpec[_i] = arguments[_i];\n    }\n    return new TIntersection(typeSpec.map(function (t) { return parseSpec(t); }));\n}\nexports.intersection = intersection;\nvar TIntersection = /** @class */ (function (_super) {\n    __extends(TIntersection, _super);\n    function TIntersection(ttypes) {\n        var _this = _super.call(this) || this;\n        _this.ttypes = ttypes;\n        return _this;\n    }\n    TIntersection.prototype.getChecker = function (suite, strict) {\n        var allowedProps = new Set();\n        var itemCheckers = this.ttypes.map(function (t) { return t.getChecker(suite, strict, allowedProps); });\n        return function (value, ctx) {\n            var ok = itemCheckers.every(function (checker) { return checker(value, ctx); });\n            if (ok) {\n                return true;\n            }\n            return ctx.fail(null, null, 0);\n        };\n    };\n    return TIntersection;\n}(TType));\nexports.TIntersection = TIntersection;\n/**\n * Defines an enum type, e.g. enum({'A': 1, 'B': 2}).\n */\nfunction enumtype(values) {\n    return new TEnumType(values);\n}\nexports.enumtype = enumtype;\nvar TEnumType = /** @class */ (function (_super) {\n    __extends(TEnumType, _super);\n    function TEnumType(members) {\n        var _this = _super.call(this) || this;\n        _this.members = members;\n        _this.validValues = new Set();\n        _this._failMsg = \"is not a valid enum value\";\n        _this.validValues = new Set(Object.keys(members).map(function (name) { return members[name]; }));\n        return _this;\n    }\n    TEnumType.prototype.getChecker = function (suite, strict) {\n        var _this = this;\n        return function (value, ctx) {\n            return (_this.validValues.has(value) ? true : ctx.fail(null, _this._failMsg, 0));\n        };\n    };\n    return TEnumType;\n}(TType));\nexports.TEnumType = TEnumType;\n/**\n * Defines a literal enum value, such as Direction.Up, specified as enumlit(\"Direction\", \"Up\").\n */\nfunction enumlit(name, prop) {\n    return new TEnumLiteral(name, prop);\n}\nexports.enumlit = enumlit;\nvar TEnumLiteral = /** @class */ (function (_super) {\n    __extends(TEnumLiteral, _super);\n    function TEnumLiteral(enumName, prop) {\n        var _this = _super.call(this) || this;\n        _this.enumName = enumName;\n        _this.prop = prop;\n        _this._failMsg = \"is not \" + enumName + \".\" + prop;\n        return _this;\n    }\n    TEnumLiteral.prototype.getChecker = function (suite, strict) {\n        var _this = this;\n        var ttype = getNamedType(suite, this.enumName);\n        if (!(ttype instanceof TEnumType)) {\n            throw new Error(\"Type \" + this.enumName + \" used in enumlit is not an enum type\");\n        }\n        var val = ttype.members[this.prop];\n        if (!ttype.members.hasOwnProperty(this.prop)) {\n            throw new Error(\"Unknown value \" + this.enumName + \".\" + this.prop + \" used in enumlit\");\n        }\n        return function (value, ctx) { return (value === val) ? true : ctx.fail(null, _this._failMsg, -1); };\n    };\n    return TEnumLiteral;\n}(TType));\nexports.TEnumLiteral = TEnumLiteral;\nfunction makeIfaceProps(props) {\n    return Object.keys(props).map(function (name) { return makeIfaceProp(name, props[name]); });\n}\nfunction makeIfaceProp(name, prop) {\n    return prop instanceof TOptional ?\n        new TProp(name, prop.ttype, true) :\n        new TProp(name, parseSpec(prop), false);\n}\n/**\n * Defines an interface. The first argument is an array of interfaces that it extends, and the\n * second is an array of properties.\n */\nfunction iface(bases, props) {\n    return new TIface(bases, makeIfaceProps(props));\n}\nexports.iface = iface;\nvar TIface = /** @class */ (function (_super) {\n    __extends(TIface, _super);\n    function TIface(bases, props) {\n        var _this = _super.call(this) || this;\n        _this.bases = bases;\n        _this.props = props;\n        _this.propSet = new Set(props.map(function (p) { return p.name; }));\n        return _this;\n    }\n    TIface.prototype.getChecker = function (suite, strict, allowedProps) {\n        var _this = this;\n        var baseCheckers = this.bases.map(function (b) { return getNamedType(suite, b).getChecker(suite, strict); });\n        var propCheckers = this.props.map(function (prop) { return prop.ttype.getChecker(suite, strict); });\n        var testCtx = new util_1.NoopContext();\n        // Consider a prop required if it's not optional AND does not allow for undefined as a value.\n        var isPropRequired = this.props.map(function (prop, i) {\n            return !prop.isOpt \u0026\u0026 !propCheckers[i](undefined, testCtx);\n        });\n        var checker = function (value, ctx) {\n            if (typeof value !== \"object\" || value === null) {\n                return ctx.fail(null, \"is not an object\", 0);\n            }\n            for (var i = 0; i \u003c baseCheckers.length; i++) {\n                if (!baseCheckers[i](value, ctx)) {\n                    return false;\n                }\n            }\n            for (var i = 0; i \u003c propCheckers.length; i++) {\n                var name_1 = _this.props[i].name;\n                var v = value[name_1];\n                if (v === undefined) {\n                    if (isPropRequired[i]) {\n                        return ctx.fail(name_1, \"is missing\", 1);\n                    }\n                }\n                else {\n                    var ok = propCheckers[i](v, ctx);\n                    if (!ok) {\n                        return ctx.fail(name_1, null, 1);\n                    }\n                }\n            }\n            return true;\n        };\n        if (!strict) {\n            return checker;\n        }\n        var propSet = this.propSet;\n        if (allowedProps) {\n            this.propSet.forEach(function (prop) { return allowedProps.add(prop); });\n            propSet = allowedProps;\n        }\n        // In strict mode, check also for unknown enumerable properties.\n        return function (value, ctx) {\n            if (!checker(value, ctx)) {\n                return false;\n            }\n            for (var prop in value) {\n                if (!propSet.has(prop)) {\n                    return ctx.fail(prop, \"is extraneous\", 2);\n                }\n            }\n            return true;\n        };\n    };\n    return TIface;\n}(TType));\nexports.TIface = TIface;\n/**\n * Defines an optional property on an interface.\n */\nfunction opt(typeSpec) { return new TOptional(parseSpec(typeSpec)); }\nexports.opt = opt;\nvar TOptional = /** @class */ (function (_super) {\n    __extends(TOptional, _super);\n    function TOptional(ttype) {\n        var _this = _super.call(this) || this;\n        _this.ttype = ttype;\n        return _this;\n    }\n    TOptional.prototype.getChecker = function (suite, strict) {\n        var itemChecker = this.ttype.getChecker(suite, strict);\n        return function (value, ctx) {\n            return value === undefined || itemChecker(value, ctx);\n        };\n    };\n    return TOptional;\n}(TType));\nexports.TOptional = TOptional;\n/**\n * Defines a property in an interface.\n */\nvar TProp = /** @class */ (function () {\n    function TProp(name, ttype, isOpt) {\n        this.name = name;\n        this.ttype = ttype;\n        this.isOpt = isOpt;\n    }\n    return TProp;\n}());\nexports.TProp = TProp;\n/**\n * Defines a function. The first argument declares the function's return type, the rest declare\n * its parameters.\n */\nfunction func(resultSpec) {\n    var params = [];\n    for (var _i = 1; _i \u003c arguments.length; _i++) {\n        params[_i - 1] = arguments[_i];\n    }\n    return new TFunc(new TParamList(params), parseSpec(resultSpec));\n}\nexports.func = func;\nvar TFunc = /** @class */ (function (_super) {\n    __extends(TFunc, _super);\n    function TFunc(paramList, result) {\n        var _this = _super.call(this) || this;\n        _this.paramList = paramList;\n        _this.result = result;\n        return _this;\n    }\n    TFunc.prototype.getChecker = function (suite, strict) {\n        return function (value, ctx) {\n            return typeof value === \"function\" ? true : ctx.fail(null, \"is not a function\", 0);\n        };\n    };\n    return TFunc;\n}(TType));\nexports.TFunc = TFunc;\n/**\n * Defines a function parameter.\n */\nfunction param(name, typeSpec, isOpt) {\n    return new TParam(name, parseSpec(typeSpec), Boolean(isOpt));\n}\nexports.param = param;\nvar TParam = /** @class */ (function () {\n    function TParam(name, ttype, isOpt) {\n        this.name = name;\n        this.ttype = ttype;\n        this.isOpt = isOpt;\n    }\n    return TParam;\n}());\nexports.TParam = TParam;\n/**\n * Defines a function parameter list.\n */\nvar TParamList = /** @class */ (function (_super) {\n    __extends(TParamList, _super);\n    function TParamList(params) {\n        var _this = _super.call(this) || this;\n        _this.params = params;\n        return _this;\n    }\n    TParamList.prototype.getChecker = function (suite, strict) {\n        var _this = this;\n        var itemCheckers = this.params.map(function (t) { return t.ttype.getChecker(suite, strict); });\n        var testCtx = new util_1.NoopContext();\n        var isParamRequired = this.params.map(function (param, i) {\n            return !param.isOpt \u0026\u0026 !itemCheckers[i](undefined, testCtx);\n        });\n        var checker = function (value, ctx) {\n            if (!Array.isArray(value)) {\n                return ctx.fail(null, \"is not an array\", 0);\n            }\n            for (var i = 0; i \u003c itemCheckers.length; i++) {\n                var p = _this.params[i];\n                if (value[i] === undefined) {\n                    if (isParamRequired[i]) {\n                        return ctx.fail(p.name, \"is missing\", 1);\n                    }\n                }\n                else {\n                    var ok = itemCheckers[i](value[i], ctx);\n                    if (!ok) {\n                        return ctx.fail(p.name, null, 1);\n                    }\n                }\n            }\n            return true;\n        };\n        if (!strict) {\n            return checker;\n        }\n        return function (value, ctx) {\n            if (!checker(value, ctx)) {\n                return false;\n            }\n            return value.length \u003c= itemCheckers.length ? true :\n                ctx.fail(itemCheckers.length, \"is extraneous\", 2);\n        };\n    };\n    return TParamList;\n}(TType));\nexports.TParamList = TParamList;\n/**\n * Single TType implementation for all basic built-in types.\n */\nvar BasicType = /** @class */ (function (_super) {\n    __extends(BasicType, _super);\n    function BasicType(validator, message) {\n        var _this = _super.call(this) || this;\n        _this.validator = validator;\n        _this.message = message;\n        return _this;\n    }\n    BasicType.prototype.getChecker = function (suite, strict) {\n        var _this = this;\n        return function (value, ctx) { return _this.validator(value) ? true : ctx.fail(null, _this.message, 0); };\n    };\n    return BasicType;\n}(TType));\nexports.BasicType = BasicType;\n/**\n * Defines the suite of basic types.\n */\nexports.basicTypes = {\n    any: new BasicType(function (v) { return true; }, \"is invalid\"),\n    number: new BasicType(function (v) { return (typeof v === \"number\"); }, \"is not a number\"),\n    object: new BasicType(function (v) { return (typeof v === \"object\" \u0026\u0026 v); }, \"is not an object\"),\n    boolean: new BasicType(function (v) { return (typeof v === \"boolean\"); }, \"is not a boolean\"),\n    string: new BasicType(function (v) { return (typeof v === \"string\"); }, \"is not a string\"),\n    symbol: new BasicType(function (v) { return (typeof v === \"symbol\"); }, \"is not a symbol\"),\n    void: new BasicType(function (v) { return (v == null); }, \"is not void\"),\n    undefined: new BasicType(function (v) { return (v === undefined); }, \"is not undefined\"),\n    null: new BasicType(function (v) { return (v === null); }, \"is not null\"),\n    never: new BasicType(function (v) { return false; }, \"is unexpected\"),\n    Date: new BasicType(getIsNativeChecker(\"[object Date]\"), \"is not a Date\"),\n    RegExp: new BasicType(getIsNativeChecker(\"[object RegExp]\"), \"is not a RegExp\"),\n};\n// This approach for checking native object types mirrors that of lodash. Its advantage over\n// `isinstance` is that it can still return true for native objects created in different JS\n// execution environments.\nvar nativeToString = Object.prototype.toString;\nfunction getIsNativeChecker(tag) {\n    return function (v) { return typeof v === \"object\" \u0026\u0026 v \u0026\u0026 nativeToString.call(v) === tag; };\n}\nif (typeof Buffer !== \"undefined\") {\n    exports.basicTypes.Buffer = new BasicType(function (v) { return Buffer.isBuffer(v); }, \"is not a Buffer\");\n}\nvar _loop_1 = function (array_1) {\n    exports.basicTypes[array_1.name] = new BasicType(function (v) { return (v instanceof array_1); }, \"is not a \" + array_1.name);\n};\n// Support typed arrays of various flavors\nfor (var _i = 0, _a = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array,\n    Int32Array, Uint32Array, Float32Array, Float64Array, ArrayBuffer]; _i \u003c _a.length; _i++) {\n    var array_1 = _a[_i];\n    _loop_1(array_1);\n}\n","\"use strict\";\nvar __spreadArrays = (this \u0026\u0026 this.__spreadArrays) || function () {\n    for (var s = 0, i = 0, il = arguments.length; i \u003c il; i++) s += arguments[i].length;\n    for (var r = Array(s), k = 0, i = 0; i \u003c il; i++)\n        for (var a = arguments[i], j = 0, jl = a.length; j \u003c jl; j++, k++)\n            r[k] = a[j];\n    return r;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Checker = exports.createCheckers = void 0;\nvar types_1 = require(\"./types\");\nvar util_1 = require(\"./util\");\n/**\n * Export functions used to define interfaces.\n */\nvar types_2 = require(\"./types\");\nObject.defineProperty(exports, \"TArray\", { enumerable: true, get: function () { return types_2.TArray; } });\nObject.defineProperty(exports, \"TEnumType\", { enumerable: true, get: function () { return types_2.TEnumType; } });\nObject.defineProperty(exports, \"TEnumLiteral\", { enumerable: true, get: function () { return types_2.TEnumLiteral; } });\nObject.defineProperty(exports, \"TFunc\", { enumerable: true, get: function () { return types_2.TFunc; } });\nObject.defineProperty(exports, \"TIface\", { enumerable: true, get: function () { return types_2.TIface; } });\nObject.defineProperty(exports, \"TLiteral\", { enumerable: true, get: function () { return types_2.TLiteral; } });\nObject.defineProperty(exports, \"TName\", { enumerable: true, get: function () { return types_2.TName; } });\nObject.defineProperty(exports, \"TOptional\", { enumerable: true, get: function () { return types_2.TOptional; } });\nObject.defineProperty(exports, \"TParam\", { enumerable: true, get: function () { return types_2.TParam; } });\nObject.defineProperty(exports, \"TParamList\", { enumerable: true, get: function () { return types_2.TParamList; } });\nObject.defineProperty(exports, \"TProp\", { enumerable: true, get: function () { return types_2.TProp; } });\nObject.defineProperty(exports, \"TTuple\", { enumerable: true, get: function () { return types_2.TTuple; } });\nObject.defineProperty(exports, \"TType\", { enumerable: true, get: function () { return types_2.TType; } });\nObject.defineProperty(exports, \"TUnion\", { enumerable: true, get: function () { return types_2.TUnion; } });\nObject.defineProperty(exports, \"TIntersection\", { enumerable: true, get: function () { return types_2.TIntersection; } });\nObject.defineProperty(exports, \"array\", { enumerable: true, get: function () { return types_2.array; } });\nObject.defineProperty(exports, \"enumlit\", { enumerable: true, get: function () { return types_2.enumlit; } });\nObject.defineProperty(exports, \"enumtype\", { enumerable: true, get: function () { return types_2.enumtype; } });\nObject.defineProperty(exports, \"func\", { enumerable: true, get: function () { return types_2.func; } });\nObject.defineProperty(exports, \"iface\", { enumerable: true, get: function () { return types_2.iface; } });\nObject.defineProperty(exports, \"lit\", { enumerable: true, get: function () { return types_2.lit; } });\nObject.defineProperty(exports, \"name\", { enumerable: true, get: function () { return types_2.name; } });\nObject.defineProperty(exports, \"opt\", { enumerable: true, get: function () { return types_2.opt; } });\nObject.defineProperty(exports, \"param\", { enumerable: true, get: function () { return types_2.param; } });\nObject.defineProperty(exports, \"tuple\", { enumerable: true, get: function () { return types_2.tuple; } });\nObject.defineProperty(exports, \"union\", { enumerable: true, get: function () { return types_2.union; } });\nObject.defineProperty(exports, \"intersection\", { enumerable: true, get: function () { return types_2.intersection; } });\nObject.defineProperty(exports, \"BasicType\", { enumerable: true, get: function () { return types_2.BasicType; } });\nvar util_2 = require(\"./util\");\nObject.defineProperty(exports, \"VError\", { enumerable: true, get: function () { return util_2.VError; } });\n/**\n * Takes one of more type suites (e.g. a module generated by `ts-interface-builder`), and combines\n * them into a suite of interface checkers. If a type is used by name, that name should be present\n * among the passed-in type suites.\n *\n * The returned object maps type names to Checker objects.\n */\nfunction createCheckers() {\n    var typeSuite = [];\n    for (var _i = 0; _i \u003c arguments.length; _i++) {\n        typeSuite[_i] = arguments[_i];\n    }\n    var fullSuite = Object.assign.apply(Object, __spreadArrays([{}, types_1.basicTypes], typeSuite));\n    var checkers = {};\n    for (var _a = 0, typeSuite_1 = typeSuite; _a \u003c typeSuite_1.length; _a++) {\n        var suite_1 = typeSuite_1[_a];\n        for (var _b = 0, _c = Object.keys(suite_1); _b \u003c _c.length; _b++) {\n            var name = _c[_b];\n            checkers[name] = new Checker(fullSuite, suite_1[name]);\n        }\n    }\n    return checkers;\n}\nexports.createCheckers = createCheckers;\n/**\n * Checker implements validation of objects, and also includes accessors to validate method calls.\n * Checkers should be created using `createCheckers()`.\n */\nvar Checker = /** @class */ (function () {\n    // Create checkers by using `createCheckers()` function.\n    function Checker(suite, ttype, _path) {\n        if (_path === void 0) { _path = 'value'; }\n        this.suite = suite;\n        this.ttype = ttype;\n        this._path = _path;\n        this.props = new Map();\n        if (ttype instanceof types_1.TIface) {\n            for (var _i = 0, _a = ttype.props; _i \u003c _a.length; _i++) {\n                var p = _a[_i];\n                this.props.set(p.name, p.ttype);\n            }\n        }\n        this.checkerPlain = this.ttype.getChecker(suite, false);\n        this.checkerStrict = this.ttype.getChecker(suite, true);\n    }\n    /**\n     * Set the path to report in errors, instead of the default \"value\". (E.g. if the Checker is for\n     * a \"person\" interface, set path to \"person\" to report e.g. \"person.name is not a string\".)\n     */\n    Checker.prototype.setReportedPath = function (path) {\n        this._path = path;\n    };\n    /**\n     * Check that the given value satisfies this checker's type, or throw Error.\n     */\n    Checker.prototype.check = function (value) { return this._doCheck(this.checkerPlain, value); };\n    /**\n     * A fast check for whether or not the given value satisfies this Checker's type. This returns\n     * true or false, does not produce an error message, and is fast both on success and on failure.\n     */\n    Checker.prototype.test = function (value) {\n        return this.checkerPlain(value, new util_1.NoopContext());\n    };\n    /**\n     * Returns an error object describing the errors if the given value does not satisfy this\n     * Checker's type, or null if it does.\n     */\n    Checker.prototype.validate = function (value) {\n        return this._doValidate(this.checkerPlain, value);\n    };\n    /**\n     * Check that the given value satisfies this checker's type strictly. This checks that objects\n     * and tuples have no extra members. Note that this prevents backward compatibility, so usually\n     * a plain check() is more appropriate.\n     */\n    Checker.prototype.strictCheck = function (value) { return this._doCheck(this.checkerStrict, value); };\n    /**\n     * A fast strict check for whether or not the given value satisfies this Checker's type. Returns\n     * true or false, does not produce an error message, and is fast both on success and on failure.\n     */\n    Checker.prototype.strictTest = function (value) {\n        return this.checkerStrict(value, new util_1.NoopContext());\n    };\n    /**\n     * Returns an error object describing the errors if the given value does not satisfy this\n     * Checker's type strictly, or null if it does.\n     */\n    Checker.prototype.strictValidate = function (value) {\n        return this._doValidate(this.checkerStrict, value);\n    };\n    /**\n     * If this checker is for an interface, returns a Checker for the type required for the given\n     * property of this interface.\n     */\n    Checker.prototype.getProp = function (prop) {\n        var ttype = this.props.get(prop);\n        if (!ttype) {\n            throw new Error(\"Type has no property \" + prop);\n        }\n        return new Checker(this.suite, ttype, this._path + \".\" + prop);\n    };\n    /**\n     * If this checker is for an interface, returns a Checker for the argument-list required to call\n     * the given method of this interface. E.g. if this Checker is for the interface:\n     *    interface Foo {\n     *      find(s: string, pos?: number): number;\n     *    }\n     * Then methodArgs(\"find\").check(...) will succeed for [\"foo\"] and [\"foo\", 3], but not for [17].\n     */\n    Checker.prototype.methodArgs = function (methodName) {\n        var tfunc = this._getMethod(methodName);\n        return new Checker(this.suite, tfunc.paramList);\n    };\n    /**\n     * If this checker is for an interface, returns a Checker for the return value of the given\n     * method of this interface.\n     */\n    Checker.prototype.methodResult = function (methodName) {\n        var tfunc = this._getMethod(methodName);\n        return new Checker(this.suite, tfunc.result);\n    };\n    /**\n     * If this checker is for a function, returns a Checker for its argument-list.\n     */\n    Checker.prototype.getArgs = function () {\n        if (!(this.ttype instanceof types_1.TFunc)) {\n            throw new Error(\"getArgs() applied to non-function\");\n        }\n        return new Checker(this.suite, this.ttype.paramList);\n    };\n    /**\n     * If this checker is for a function, returns a Checker for its result.\n     */\n    Checker.prototype.getResult = function () {\n        if (!(this.ttype instanceof types_1.TFunc)) {\n            throw new Error(\"getResult() applied to non-function\");\n        }\n        return new Checker(this.suite, this.ttype.result);\n    };\n    /**\n     * Return the type for which this is a checker.\n     */\n    Checker.prototype.getType = function () {\n        return this.ttype;\n    };\n    /**\n     * Actual implementation of check() and strictCheck().\n     */\n    Checker.prototype._doCheck = function (checkerFunc, value) {\n        var noopCtx = new util_1.NoopContext();\n        if (!checkerFunc(value, noopCtx)) {\n            var detailCtx = new util_1.DetailContext();\n            checkerFunc(value, detailCtx);\n            throw detailCtx.getError(this._path);\n        }\n    };\n    Checker.prototype._doValidate = function (checkerFunc, value) {\n        var noopCtx = new util_1.NoopContext();\n        if (checkerFunc(value, noopCtx)) {\n            return null;\n        }\n        var detailCtx = new util_1.DetailContext();\n        checkerFunc(value, detailCtx);\n        return detailCtx.getErrorDetail(this._path);\n    };\n    Checker.prototype._getMethod = function (methodName) {\n        var ttype = this.props.get(methodName);\n        if (!ttype) {\n            throw new Error(\"Type has no property \" + methodName);\n        }\n        if (!(ttype instanceof types_1.TFunc)) {\n            throw new Error(\"Property \" + methodName + \" is not a method\");\n        }\n        return ttype;\n    };\n    return Checker;\n}());\nexports.Checker = Checker;\n","import * as cjsm from \"ts-interface-checker\";export const { __esModule,Checker,createCheckers,TArray,TEnumType,TEnumLiteral,TFunc,TIface,TLiteral,TName,TOptional,TParam,TParamList,TProp,TTuple,TType,TUnion,TIntersection,array,enumlit,enumtype,func,iface,lit,name,opt,param,tuple,union,intersection,BasicType,VError } = cjsm;export default cjsm.default ?? cjsm;"],"version":3}