{"version":3,"file":"static/js/vendors-595702a8.1e933919.js","mappings":"gwBAiBA,IALA,IAAMA,EACJ,mEAGIC,EAAS,IAAIC,WAAW,KACrBC,EAAI,EAAGA,EAAIH,GAAcG,IAChCF,EAAOD,EAAMI,WAAWD,IAAMA,ECZhC,IDeO,IAAME,EAAiB,SAACC,GAG7B,IAFA,IAAIC,EAAS,GACPC,EAAMF,EAAMG,OACTN,EAAI,EAAGA,EAAIK,EAAKL,GAAK,EAC5BI,GAAUP,EAAMM,EAAMH,IAAM,GAC5BI,GAAUP,GAAmB,EAAXM,EAAMH,KAAW,EAAMG,EAAMH,EAAI,IAAM,GACzDI,GAAUP,GAAuB,GAAfM,EAAMH,EAAI,KAAY,EAAMG,EAAMH,EAAI,IAAM,GAC9DI,GAAUP,EAAqB,GAAfM,EAAMH,EAAI,IAS5B,OANIK,EAAM,GAAM,EACdD,EAASA,EAAOG,UAAU,EAAGH,EAAOE,OAAS,GAAK,IACzCD,EAAM,GAAM,IACrBD,EAASA,EAAOG,UAAU,EAAGH,EAAOE,OAAS,GAAK,MAG7CF,CACT,EAEaI,EAAmB,SAACJ,GAC/B,IAEIJ,EAEAS,EACAC,EACAC,EACAC,EAPAC,EAA+B,IAAhBT,EAAOE,OACpBD,EAAMD,EAAOE,OAEfQ,EAAI,EAM0B,MAA9BV,EAAOA,EAAOE,OAAS,KACzBO,IACkC,MAA9BT,EAAOA,EAAOE,OAAS,IACzBO,KAIJ,IAAMV,EAAQ,IAAIJ,WAAWc,GAE7B,IAAKb,EAAI,EAAGA,EAAIK,EAAKL,GAAK,EACxBS,EAAWX,EAAOM,EAAOH,WAAWD,IACpCU,EAAWZ,EAAOM,EAAOH,WAAWD,EAAI,IACxCW,EAAWb,EAAOM,EAAOH,WAAWD,EAAI,IACxCY,EAAWd,EAAOM,EAAOH,WAAWD,EAAI,IAExCG,EAAMW,KAAQL,GAAY,EAAMC,GAAY,EAC5CP,EAAMW,MAAoB,GAAXJ,IAAkB,EAAMC,GAAY,EACnDR,EAAMW,MAAoB,EAAXH,IAAiB,EAAiB,GAAXC,EAGxC,OAAOT,CACT,EAIMY,EAAwB,uD,YExEjBC,EAAO,SAAIC,GAAkB,OAAAA,EAAMA,EAAMX,OAAS,EAArB,EAK7BY,EAAgB,SAACC,GAC5B,GAAIA,aAAiBpB,WAAY,OAAOoB,EAGxC,IAFA,IAAMb,EAASa,EAAMb,OACfc,EAAa,IAAIrB,WAAWO,GACzBe,EAAM,EAAGA,EAAMf,EAAQe,IAC9BD,EAAWC,GAAOF,EAAMlB,WAAWoB,GAErC,OAAOD,CACT,EAEaE,EAAsB,W,IAAC,IAAAC,EAAA,GAAAC,EAAA,EAAAA,EAAAC,UAAAnB,OAAAkB,IAAAD,EAAAC,GAAAC,UAAAD,GAIlC,IAHA,IAAME,EAAaH,EAAOjB,OAEpBqB,EAA4B,GACzBN,EAAM,EAAGA,EAAMK,EAAYL,IAAO,CACzC,IAAMO,EAAUL,EAAOF,GACvBM,EAAYN,GACVO,aAAmB7B,WAAa6B,EAAUV,EAAcU,E,CAG5D,IAAIC,EAAY,EAChB,IAASR,EAAM,EAAGA,EAAMK,EAAYL,IAClCQ,GAAaN,EAAOF,GAAKf,OAK3B,IAFA,IAAMwB,EAAS,IAAI/B,WAAW8B,GAC1BE,EAAS,EACJC,EAAS,EAAGA,EAASN,EAAYM,IAExC,IADA,IAAMC,EAAMN,EAAYK,GACfE,EAAU,EAAGC,EAASF,EAAI3B,OAAQ4B,EAAUC,EAAQD,IAC3DJ,EAAOC,KAAYE,EAAIC,GAI3B,OAAOJ,CACT,EAEaM,EAAmB,SAACb,GAE/B,IADA,IAAIM,EAAY,EACPR,EAAM,EAAGhB,EAAMkB,EAAOjB,OAAQe,EAAMhB,EAAKgB,IAChDQ,GAAaN,EAAOF,GAAKf,OAG3B,IAAM+B,EAAe,IAAItC,WAAW8B,GAChCE,EAAS,EACb,IAASV,EAAM,EAAGhB,EAAMkB,EAAOjB,OAAQe,EAAMhB,EAAKgB,IAAO,CACvD,IAAMJ,EAAQM,EAAOF,GACrBgB,EAAaC,IAAIrB,EAAOc,GACxBA,GAAUd,EAAMX,M,CAGlB,OAAO+B,CACT,EAEaE,EAAgB,SAACtB,GAE5B,IADA,IAAIuB,EAAM,GACDnB,EAAM,EAAGhB,EAAMY,EAAMX,OAAQe,EAAMhB,EAAKgB,IAC/CmB,IAAOC,EAAAA,EAAAA,IAAaxB,EAAMI,IAE5B,OAAOmB,CACT,EAEaE,EAAgB,SAAwBC,EAAMC,GAAS,OAAAD,EAAEE,GAAKD,EAAEC,EAAT,EAEvDC,EAAa,SAAI7B,EAAY8B,GAGxC,IAFA,IAAMC,EAAY,GAET3B,EAAM,EAAGhB,EAAMY,EAAMX,OAAQe,EAAMhB,EAAKgB,IAAO,CACtD,IAAM4B,EAAOhC,EAAMI,GACb6B,EAAOjC,EAAMI,EAAM,GACb,IAARA,GAAa0B,EAAQE,KAAUF,EAAQG,IACzCF,EAAKG,KAAKF,E,CAId,OAAOD,CACT,EAKaI,EAAe,SAACnC,GAE3B,IADA,IAAMoC,EAAWpC,EAAMX,OACde,EAAM,EAAGhB,EAAMiD,KAAKC,MAAMF,EAAW,GAAIhC,EAAMhB,EAAKgB,IAAO,CAClE,IAAMmC,EAAUnC,EACVoC,EAAWJ,EAAWhC,EAAM,EAC5BqC,EAAOzC,EAAMI,GAEnBJ,EAAMuC,GAAWvC,EAAMwC,GACvBxC,EAAMwC,GAAYC,C,CAEpB,OAAOzC,CACT,EAEa0C,EAAM,SAAC1C,GAElB,IADA,IAAI2C,EAAQ,EACHvC,EAAM,EAAGhB,EAAMY,EAAMX,OAAQe,EAAMhB,EAAKgB,IAC/CuC,GAAS3C,EAAMI,GAEjB,OAAOuC,CACT,EAEaC,EAAQ,SAACC,EAAeC,GAEnC,IADA,IAAM9B,EAAM,IAAI+B,MAAMD,EAAMD,GACnBzC,EAAM,EAAGhB,EAAM4B,EAAI3B,OAAQe,EAAMhB,EAAKgB,IAC7CY,EAAIZ,GAAOyC,EAAQzC,EAErB,OAAOY,CACT,EAEagC,EAAe,SAAIhC,EAAUiC,GAExC,IADA,IAAMC,EAAU,IAAIH,MAASE,EAAQ5D,QAC5Be,EAAM,EAAGhB,EAAM6D,EAAQ5D,OAAQe,EAAMhB,EAAKgB,IACjD8C,EAAQ9C,GAAOY,EAAIiC,EAAQ7C,IAE7B,OAAO8C,CACT,EAEaC,EAA6B,SACxCC,GAEA,OAAAA,aAAiBtE,YACjBsE,aAAiBC,aACA,iBAAVD,CAFP,EAIWE,EAAe,SAACF,GAC3B,GAAqB,iBAAVA,EACT,OFnDmC,SAACG,GACtC,IAAMC,EAAaD,EAAQE,OAGrBC,EADSF,EAAWlE,UAAU,EAAG,KACpBqE,MAAM7D,GAGzB,IAAK4D,EAAK,OAAOnE,EAAiBiE,GAG3B,IAAAI,EAAaF,EAAG,GACjBG,EAAOL,EAAWlE,UAAUsE,EAAUvE,QAE5C,OAAOE,EAAiBsE,EAC1B,CEqCWC,CAAwBV,GAC1B,GAAIA,aAAiBC,YAC1B,OAAO,IAAIvE,WAAWsE,GACjB,GAAIA,aAAiBtE,WAC1B,OAAOsE,EAEP,MAAM,IAAIW,UACR,6DAGN,EC7IaC,EAAc,WACzB,WAAIC,SAAQ,SAACC,GACXC,YAAW,WAAM,OAAAD,GAAA,GAAW,EAC9B,GAFA,E,YCKWE,EAAiB,SAACC,GAC7B,IAYMC,EAZFC,EAASC,OAAOH,GAEpB,GAAIhC,KAAKoC,IAAIJ,GAAO,GAElB,GADMC,EAAII,SAASL,EAAIM,WAAWC,MAAM,MAAM,IACvC,CACL,IAAMC,EAAWR,EAAM,EACnBQ,IAAUR,IAAQ,GACtBA,GAAOhC,KAAKyC,IAAI,GAAIR,EAAI,GACxBC,EAAS,KAAO,IAAIxB,MAAMuB,GAAGS,KAAK,KAAOV,EAAIM,WAAWrF,UAAU,GAC9DuF,IAAUN,EAAS,IAAMA,E,OAG3BD,EAAII,SAASL,EAAIM,WAAWC,MAAM,KAAK,KACnC,KACNN,GAAK,GAELC,GADAF,GAAOhC,KAAKyC,IAAI,GAAIR,IACPK,WAAa,IAAI5B,MAAMuB,EAAI,GAAGS,KAAK,MAIpD,OAAOR,CACT,EAEaS,EAAc,SAACC,GAAc,OAAA5C,KAAK6C,KAAKD,EAAEN,SAAS,GAAGtF,OAAS,EAAjC,EAc7B8F,EAAW,SAACF,GAEvB,IADA,IAAM/F,EAAQ,IAAIJ,WAAWkG,EAAYC,IAChClG,EAAI,EAAGA,GAAKG,EAAMG,OAAQN,IACjCG,EAAMH,EAAI,GAAKkG,GAA2B,GAApB/F,EAAMG,OAASN,GAEvC,OAAOG,CACT,ECtDakG,EAAQ,SAACC,GACpB,MAAM,IAAIC,MAAMD,EAClB,E,YCAaE,EAAS,SAACC,GAAa,OAAAC,OAAOC,KAAKF,GAAKG,KAAI,SAACC,GAAM,OAAAJ,EAAII,EAAJ,GAA5B,EAEvBC,EAAqBN,EAAOO,EAAAA,IAE5BC,EAAiB,SAAC3C,GAC7B,OAAAyC,EAAmBG,SAAS5C,EAA5B,EAEW6C,EAAqB,SAChCvE,EACAC,GACG,OAAAD,EAAEwE,IAAMvE,EAAEuE,GAAKxE,EAAEyE,IAAMxE,EAAEwE,GAAKzE,EAAE0E,QAAUzE,EAAEyE,OAAS1E,EAAE2E,SAAW1E,EAAE0E,MAApE,ECRQC,EAAW,SAACC,GAAa,UAAKA,EAAG,GAAR,EAMhCC,EAAc,SAACtG,GACnB,IAAMuG,SAAcvG,EACpB,MAAY,WAARuG,EAPmC,IAOEvG,EAPK,IAQ7B,cAARuG,EAA4BH,EAASpG,GAClCA,CACd,EAoBawG,EAAgB,SAC3BxG,EACAyG,EACAC,GAEK7D,MAAM8D,QAAQD,KACjBA,EAAgBE,EAAaF,IAE/B,IAAK,IAAIxG,EAAM,EAAGhB,EAAMwH,EAAcvH,OAAQe,EAAMhB,EAAKgB,IACvD,GAAIF,IAAU0G,EAAcxG,GAAM,OAEpC,MAAM,IAAI2D,UA7BuB,SACjC7D,EACAyG,EACApB,GAIA,IAFA,IAAMqB,EAAgB,IAAI7D,MAAMwC,EAAOlG,QAE9Be,EAAM,EAAGhB,EAAMmG,EAAOlG,OAAQe,EAAMhB,EAAKgB,IAAO,CACvD,IAAM2G,EAAIxB,EAAOnF,GACjBwG,EAAcxG,GAAOoG,EAAYO,E,CAGnC,IAAMC,EAAeJ,EAAc7B,KAAK,QAGxC,OAAUuB,EAASK,GAAU,mBAAmBK,EAAY,sBAAsBR,EAAYtG,EAChG,CAasB+G,CAAoB/G,EAAOyG,EAAWC,GAC5D,EAEaM,EAA2B,SACtChH,EACAyG,EACAC,GAEK7D,MAAM8D,QAAQD,KACjBA,EAAgBE,EAAaF,IAE/BF,EAAcxG,EAAOyG,EAAWC,EAAcO,YAAOC,GACvD,EAEaC,EAAiB,SAC5B9B,EACAoB,EACAC,GAEK7D,MAAM8D,QAAQD,KACjBA,EAAgBE,EAAaF,IAE/B,IAAK,IAAIxG,EAAM,EAAGhB,EAAMmG,EAAOlG,OAAQe,EAAMhB,EAAKgB,IAChDsG,EAAcnB,EAAOnF,GAAMuG,EAAWC,EAE1C,EAgCaU,EAAS,SAACpH,EAAYuG,GACjC,MAAa,SAATA,EAAkC,OAAVvG,EACf,cAATuG,OAAuCW,IAAVlH,EACpB,WAATuG,EAA2C,iBAAVvG,EACxB,WAATuG,EAA2C,iBAAVvG,IAAuBqH,MAAMrH,GACrD,YAATuG,EAA4C,kBAAVvG,EACzB,WAATuG,EAA2C,iBAAVvG,EACxB,WAATuG,EAA2C,iBAAVvG,EACjCuG,IAASe,KAAatH,aAAiBsH,KACvCf,IAAS1D,MAAc7C,aAAiB6C,MACxC0D,IAAS3H,WAAmBoB,aAAiBpB,WAC7C2H,IAASpD,YAAoBnD,aAAiBmD,YAC9CoD,IAASgB,SAAiBvH,aAAiBuH,SACxCvH,aAAkBuG,EAA4B,EACvD,EAEaiB,EAAqB,SAChCxH,EACAyG,EACAgB,GAIA,IAFA,IAAMC,EAAe,IAAI7E,MAAM4E,EAAMtI,QAE5Be,EAAM,EAAGhB,EAAMuI,EAAMtI,OAAQe,EAAMhB,EAAKgB,IAAO,CACtD,IAAMqG,EAAOkB,EAAMvH,GACN,SAATqG,IAAiBmB,EAAaxH,GAAOkG,EAAS,SACrC,cAATG,IAAsBmB,EAAaxH,GAAOkG,EAAS,cAC1C,WAATG,EAAmBmB,EAAaxH,GAAOkG,EAAS,UAClC,WAATG,EAAmBmB,EAAaxH,GAAOkG,EAAS,UACvC,YAATG,EAAoBmB,EAAaxH,GAAOkG,EAAS,WACxC,WAATG,EAAmBmB,EAAaxH,GAAOkG,EAAS,UACvC,WAATG,EAAmBmB,EAAaxH,GAAOkG,EAAS,UAChDG,IAAS1D,MAAO6E,EAAaxH,GAAOkG,EAAS,SAC7CG,IAAS3H,WAAY8I,EAAaxH,GAAOkG,EAAS,cAClDG,IAASpD,YAAauE,EAAaxH,GAAOkG,EAAS,eACvDsB,EAAaxH,GAAOkG,EAAUG,EAA4B,G,CAGjE,IApEsBF,EAoEhBsB,EAAcD,EAAa7C,KAAK,QAGtC,OAAUuB,EAASK,GAAU,oBAAoBkB,EAAW,8BAA8BvB,EAtE9E,QADUC,EAuEqFrG,GAtElF,YACbkH,IAARb,EAA0B,YACX,iBAARA,EAAyB,SAChCgB,MAAMhB,GAAa,MACJ,iBAARA,EAAyB,SACjB,kBAARA,EAA0B,UAClB,iBAARA,EAAyB,SACjB,iBAARA,EAAyB,SAChCA,EAAIuB,aAAevB,EAAIuB,YAAYC,KAAaxB,EAAIuB,YAAYC,KAChExB,EAAIwB,KAAaxB,EAAIwB,KACrBxB,EAAIuB,YAAoBtD,OAAO+B,EAAIuB,aAChCtD,OAAO+B,GA4DhB,EAEayB,EAAW,SACtB9H,EACAyG,EACAgB,GAEA,IAAK,IAAIvH,EAAM,EAAGhB,EAAMuI,EAAMtI,OAAQe,EAAMhB,EAAKgB,IAC/C,GAAIkH,EAAOpH,EAAOyH,EAAMvH,IAAO,OAEjC,MAAM,IAAI2D,UAAU2D,EAAmBxH,EAAOyG,EAAWgB,GAC3D,EAEaM,EAAoB,SAC/B/H,EACAyG,EACAgB,GAEAK,EAAS9H,EAAOyG,EAAWgB,EAAMR,OAAO,aAC1C,EAEae,EAAe,SAC1B3C,EACAoB,EACAgB,GAEA,IAAK,IAAIvH,EAAM,EAAGhB,EAAMmG,EAAOlG,OAAQe,EAAMhB,EAAKgB,IAChD4H,EAASzC,EAAOnF,GAAMuG,EAAWgB,EAErC,EAEaQ,EAAc,SACzBjI,EACAyG,EACAyB,EACAC,GAMA,GAJAL,EAAS9H,EAAOyG,EAAW,CAAC,WAC5BqB,EAASI,EAAK,MAAO,CAAC,WACtBJ,EAASK,EAAK,MAAO,CAAC,WACtBA,EAAMhG,KAAKgG,IAAID,EAAKC,GAChBnI,EAAQkI,GAAOlI,EAAQmI,EAEzB,MAAM,IAAI/C,MAASgB,EAASK,GAAU,qBAAqByB,EAAG,gBAAgBC,EAAG,sBAAsBnI,EAE3G,EAEaoI,EAAyB,SACpCpI,EACAyG,EACAyB,EACAC,GAEAL,EAAS9H,EAAOyG,EAAW,CAAC,SAAU,cACjB,iBAAVzG,GAAoBiI,EAAYjI,EAAOyG,EAAWyB,EAAKC,EACpE,EAEaE,EAAiB,SAC5BrI,EACAyG,EACA6B,GAGA,GADAR,EAAS9H,EAAOyG,EAAW,CAAC,WACxBzG,EAAQsI,GAAe,EAEzB,MAAM,IAAIlD,MAASgB,EAASK,GAAU,0BAA0B6B,EAAU,sBAAsBtI,EAEpG,EAEauI,EAAgB,SAACvI,EAAYyG,GACxC,IAAK+B,OAAOC,UAAUzI,GACpB,MAAM,IAAIoF,MACLgB,EAASK,GAAU,yCAAyCzG,EAGrE,EAEa0I,EAAiB,SAAC1I,EAAeyG,GAC5C,IAAK,CAAC,EAAG,GAAGX,SAAS3D,KAAKwG,KAAK3I,IAE7B,MAAM,IAAIoF,MAASgB,EAASK,GAAU,qDAAqDzG,EAE/F,ENhOM4I,EAA0B,IAAIC,YAAY,KAGvC3I,EAAM,EAAGA,EAAM,IAAKA,IAC3B0I,EAAwB1I,GAAOA,EAIjC0I,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,KAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAC3CF,EAAwB,MAAQE,EAAAA,EAAAA,IAAW,KAQpC,IAAMC,EAAuB,SAAC/J,GAEnC,IADA,IAAMgK,EAAa,IAAInG,MAAM7D,EAAMG,QAC1Be,EAAM,EAAGhB,EAAMF,EAAMG,OAAQe,EAAMhB,EAAKgB,IAC/C8I,EAAW9I,GAAO0I,EAAwB5J,EAAMkB,IAElD,OAAOoE,OAAO2E,cAAaC,MAApB5E,OAAwB0E,EACjC,EO3CA,QAzBA,WAME,SAAAG,EAAoBC,GAClBC,KAAKD,SAAWA,EAChBC,KAAKrJ,WAAQkH,CACf,CAcF,OAZEiC,EAAAG,UAAAC,SAAA,WACE,OAAOF,KAAKrJ,KACd,EAEAmJ,EAAAG,UAAAE,OAAA,WAEE,OADKH,KAAKrJ,QAAOqJ,KAAKrJ,MAAQqJ,KAAKD,YAC5BC,KAAKrJ,KACd,EAEAmJ,EAAAG,UAAAG,WAAA,WACEJ,KAAKrJ,WAAQkH,CACf,EArBgBiC,EAAAO,YAAc,SAAIN,GAAsB,WAAID,EAAMC,EAAV,EAsB1DD,C,CAvBA,E,qDC+BYQ,E,aAAZ,SAAYA,GACVA,EAAA,sBACAA,EAAA,wBACAA,EAAA,8BACAA,EAAA,wCACAA,EAAA,yCACD,CAND,CAAYA,IAAAA,EAAO,KAQnB,IAAAC,EAAA,WAUE,SAAAA,EAAoBC,GAClB,IAAMC,EAAOC,EAAAA,EAAKC,OAAOH,GACnBI,EAASF,EAAAA,EAAKG,QAAQJ,GAE5B,GAAIG,EAAO9K,OAAS,EAAG,MAAM,IAAIiG,MAAM,mCAEvC,IACM+E,EA7CgB,SAACC,GAUzB,IATA,IAAMC,EAAalI,KAAKC,MAAMgI,EAAYjL,OAAS,GAE7CmL,EAAa,IAAI1L,WAAwB,EAAbyL,GAC5BE,EAAe,IAAI3L,WAAwB,EAAbyL,GAEhCG,EAAa,EACbC,EAAY,EACZC,EAAc,EAEXF,EAAaJ,EAAYjL,QAC9BmL,EAAWG,KAAeL,EAAYI,KACtCF,EAAWG,KAAeL,EAAYI,KACtCF,EAAWG,KAAeL,EAAYI,KACtCD,EAAaG,KAAiBN,EAAYI,KAG5C,MAAO,CAAEF,WAAUA,EAAEC,aAAYA,EACnC,CA2ByCI,CADvB,IAAI/L,WAAWqL,EAAO,KAC5BK,EAAUH,EAAAG,WAAEC,EAAYJ,EAAAI,aAEhClB,KAAKiB,WAAaA,EAEKC,EAAaK,MAAK,SAACpJ,GAAM,OAAAA,EAAI,GAAJ,MAC5B6H,KAAKkB,aAAeA,GAExClB,KAAK9C,KA7DY,SAACsE,GACpB,GAAc,IAAVA,EAAa,OAAOlB,EAAQmB,UAChC,GAAc,IAAVD,EAAa,OAAOlB,EAAQoB,WAChC,GAAc,IAAVF,EAAa,OAAOlB,EAAQqB,cAChC,GAAc,IAAVH,EAAa,OAAOlB,EAAQsB,mBAChC,GAAc,IAAVJ,EAAa,OAAOlB,EAAQuB,oBAChC,MAAM,IAAI9F,MAAM,uBAAuByF,EACzC,CAsDgBM,CAAarB,EAAKe,OAE9BxB,KAAKnD,MAAQ4D,EAAK5D,MAClBmD,KAAKlD,OAAS2D,EAAK3D,OACnBkD,KAAK+B,iBAAmB,CAC1B,CACF,OA7BSxB,EAAAyB,KAAO,SAACxB,GAAwB,WAAID,EAAIC,EAAR,EA6BzCD,C,CA9BA,E,gDChCA,IAAA0B,EAAA,WAKE,SAAAA,EAAoBC,GAClBlC,KAAKkC,KAAOA,CACd,CAMF,OAJED,EAAAhC,UAAAkC,QAAA,WACE,IAAMxF,EAA4B,IAAxB7D,KAAKsJ,IAAIpC,KAAKkC,QACxB,OAAOvF,EAAI7D,KAAKC,MAAM4D,EACxB,EAXOsF,EAAAI,SAAW,SAACH,GAAiB,WAAID,EAAUC,EAAd,EAYtCD,C,CAbA,E,yLCPO,IAAMxC,EAAa,SAAC6C,GAAsB,OAAAA,EAAU7M,WAAW,EAArB,EAEpC8M,EAAc,SAACD,GAAsB,OAAAA,EAAUE,YAAY,EAAtB,EAErCC,EAAyB,SAAC3H,EAAa4H,GAClD,OAAAC,EAAS7H,EAAIM,SAAS,IAAKsH,EAAW,KAAKE,aAA3C,EAEWC,EAAc,SAAC/H,GAAgB,OAAA2H,EAAuB3H,EAAK,EAA5B,EAE/B7C,EAAe,SAAC6K,GAAiB,OAAA7H,OAAO8H,aAAaD,EAApB,EAEjCE,EAAkB,SAACC,GAAgB,OAAAhL,EAAakD,SAAS8H,EAAK,IAA3B,EAEnCN,EAAW,SAAChM,EAAeb,EAAgBoN,GAEtD,IADA,IAAIC,EAAU,GACLtM,EAAM,EAAGhB,EAAMC,EAASa,EAAMb,OAAQe,EAAMhB,EAAKgB,IACxDsM,GAAWD,EAEb,OAAOC,EAAUxM,CACnB,EAEayM,EAAuB,SAClCpL,EACAqL,EACA9L,GAGA,IADA,IAAMzB,EAASkC,EAAIlC,OACVe,EAAM,EAAGA,EAAMf,EAAQe,IAC9BwM,EAAO9L,KAAYS,EAAIvC,WAAWoB,GAEpC,OAAOf,CACT,EAQawN,EAAY,SAACC,GACxB,OAAAA,EAAKC,QAAQ,2BAA4B,QAAQA,QAAQ,UAAW,GAApE,EAEWC,EAAsB,YAAC,MAAO,MAAO,MAAO,WAAU,KAItDC,EAAgB,SAACH,GAAiB,yBAAmBI,KAAKJ,EAAxB,EAElCK,EAAY,SAACL,GAAiB,OAAAA,EAAKlI,MAAM,iBAAX,EAE9BwI,EAAa,SAACN,GACzB,OAAAA,EAAKC,QAAQ,kBAAmB,IAAhC,EAOWM,EAAc,SAACP,EAAcQ,GAExC,IACIC,EADEC,EAAUV,EAAK9N,WAAWsO,GAE1BG,EAAYH,EAAQ,EACtBjO,EAAS,EAUb,OAPEmO,GAAW,OACXA,GAAW,OACXV,EAAKzN,OAASoO,IAEdF,EAAWT,EAAK9N,WAAWyO,KACX,OAAUF,GAAY,QAAQlO,EAAS,GAElD,CAACyN,EAAKY,MAAMJ,EAAOA,EAAQjO,GAASA,EAC7C,EAEasO,EAAY,SAACb,GAGxB,IAFA,IAAMlO,EAAkB,GAEfwB,EAAM,EAAGhB,EAAM0N,EAAKzN,OAAQe,EAAMhB,GAAO,CAC1C,IAAAiL,EAAYgD,EAAYP,EAAM1M,GAA7BwN,EAACvD,EAAA,GAAEwD,EAAIxD,EAAA,GACdzL,EAAMsD,KAAK0L,GACXxN,GAAOyN,C,CAGT,OAAOjP,CACT,EAkBakP,EAAqB,SAChChB,EACAiB,EACAC,EACAC,GAgBA,IAdA,IAAMC,EAtBoB,SAACH,GAI3B,IAHA,IAAMI,EAAmBnB,EAAoBjI,KAAK,KAE5CqJ,EAAyB,CAAC,KACvBhO,EAAM,EAAGhB,EAAM2O,EAAW1O,OAAQe,EAAMhB,EAAKgB,IAAO,CAC3D,IAAMiO,EAAYN,EAAW3N,GAC7B,GAAI6M,EAAcoB,GAChB,MAAM,IAAItK,UAAU,gCAAkCoK,GAExDC,EAAalM,KAAmB,KAAdmM,EAAmB,IAAmBA,EA5DtDtB,QAAQ,sBAAuB,Q,CA+DnC,IAAMuB,EAAaF,EAAarJ,KAAK,KACrC,OAAO,IAAIwJ,OAAO,IAAIJ,EAAgB,YAAYG,EAAU,KAAM,KACpE,CAQgBE,CAAoBT,GAE5BU,EAAQ5B,EAAUC,GAAMnJ,MAAMuK,GAEhCQ,EAAW,GACXC,EAAY,EACVC,EAAkB,GAElBC,EAAe,WACF,KAAbH,GAAiBE,EAAM1M,KAAKwM,GAChCA,EAAW,GACXC,EAAY,CACd,EAESvO,EAAM,EAAGhB,EAAMqP,EAAMpP,OAAQe,EAAMhB,EAAKgB,IAAO,CACtD,IAAM0O,EAAOL,EAAMrO,GACnB,GAAI6M,EAAc6B,GAChBD,QACK,CACL,IAAMzI,EAAQ6H,EAAmBa,GAC7BH,EAAYvI,EAAQ4H,GAAUa,IAClCH,GAAYI,EACZH,GAAavI,C,EAKjB,OAFAyI,IAEOD,CACT,EAGMG,EAAY,+EAELC,EAAY,SAACC,GACxB,IAAMtL,EAAQsL,EAAQtL,MAAMoL,GAE5B,GAAKpL,EAAL,CAIE,IAAAuL,EASEvL,EAAK,GARP0G,EAQE1G,EAAK,GARPwL,OAAK,IAAA9E,EAAG,KAAIA,EACZ+E,EAOEzL,EAAK,GAPP0L,OAAG,IAAAD,EAAG,KAAIA,EACVE,EAME3L,EAAK,GANP4L,OAAK,IAAAD,EAAG,KAAIA,EACZE,EAKE7L,EAAK,GALP8L,OAAI,IAAAD,EAAG,KAAIA,EACXE,EAIE/L,EAAK,GAJPgM,OAAI,IAAAD,EAAG,KAAIA,EACXE,EAGEjM,EAAK,GAHPkM,OAAU,IAAAD,EAAG,IAAGA,EAChBE,EAEEnM,EAAK,GAFPoM,OAAW,IAAAD,EAAG,KAAIA,EAClBE,EACErM,EAAK,GAST,OAJa,IAAI6D,KACZ0H,EAAI,IAAIC,EAAK,IAAIE,EAAG,IAAIE,EAAK,IAAIE,EAAI,IAAIE,GAF7B,MAAfE,EAAqB,IAAM,GAAGA,EAAaE,EAAW,UAL5C,IAAAC,EAAG,KAAIA,IAZS,CAuB9B,EAEaC,EAAgB,SAAC/P,EAAegO,GAG3C,I,MADIgC,EADAC,EAAW,EAERA,EAAWjQ,EAAMb,QAAQ,CAC9B,IAAMsE,EAAQzD,EAAMZ,UAAU6Q,GAAUxM,MAAMuK,GAC9C,IAAKvK,EAAO,MAAO,CAAEA,MAAOuM,EAAWE,IAAKD,GAC5CD,EAAYvM,EACZwM,IAAwB,QAAZ9F,EAAC1G,EAAM2J,aAAK,IAAAjD,EAAAA,EAAI,GAAK1G,EAAM,GAAGtE,M,CAE5C,MAAO,CAAEsE,MAAOuM,EAAWE,IAAKD,EAClC,C,4GCkFKE,E,YA7DQC,EAAc,SACzBlN,EACAmN,QAAA,IAAAA,IAAAA,GAAA,GAEA,IAAMC,EAAU,GAEZD,GAAeC,EAAQtO,KAAK,OAEhC,IAAK,IAAI9B,EAAM,EAAGhB,EAAMgE,EAAM/D,OAAQe,EAAMhB,GAAO,CACjD,IAAMqR,EAAYrN,EAAM2I,YAAY3L,GAGpC,GAAIqQ,EAAY,MACdD,EAAQtO,KAAKuO,GACbrQ,GAAO,MAIJ,MAAIqQ,EAAY,SAMhB,MAAM,IAAInL,MAAM,0BAAyB8G,EAAAA,EAAAA,IAAYqE,IALxDD,EAAQtO,KAAKwO,EAAcD,GAAYE,EAAaF,IACpDrQ,GAAO,CAI8D,C,CAGzE,OAAO,IAAI2I,YAAYyH,EACzB,EAUaI,EAAc,SAACH,GAC1B,OAAAA,GAAa,GAAKA,GAAa,KAA/B,EASWI,EAAgB,SAACJ,GAC5B,OAAAA,GAAa,OAAYA,GAAa,OAAtC,EAIWC,EAAgB,SAACD,GAC5B,OAAApO,KAAKC,OAAOmO,EAAY,OAAW,MAAS,KAA5C,EAIWE,EAAe,SAACF,GAC3B,OAAEA,EAAY,OAAW,KAAS,KAAlC,GAEF,SAAKJ,GACHA,EAAA,sBACAA,EAAA,2BACD,CAHD,CAAKA,IAAAA,EAAS,KAKd,IAAMS,EAAc,IAAI/E,YAAY,GAcvBgF,EAAc,SACzB3N,EACAmN,GAGA,QAHA,IAAAA,IAAAA,GAAA,GAGInN,EAAM/D,QAAU,EAAG,OAAOmF,OAAO2E,cAAc2H,GASnD,IAPA,IAAME,EAAYT,EAAgBU,EAAQ7N,GAASiN,EAAUa,UAGzD9Q,EAAMmQ,EAAgB,EAAI,EAExBrH,EAAuB,GAEtB9F,EAAM/D,OAASe,GAAO,GAAG,CAC9B,IAAM+Q,EAAQC,EAAahO,EAAMhD,KAAQgD,EAAMhD,KAAQ4Q,GAEvD,GAAIK,EAAgBF,GAClB,GAAI/N,EAAM/D,OAASe,EAAM,EAEvB8I,EAAWhH,KAAK4O,OACX,CACL,IAAMQ,EAASF,EAAahO,EAAMhD,KAAQgD,EAAMhD,KAAQ4Q,GACpDO,EAAeD,GACjBpI,EAAWhH,KAAKiP,EAAOG,GAGvBpI,EAAWhH,KAAK4O,E,MAGXS,EAAeJ,IAGxB/Q,GAAO,EACP8I,EAAWhH,KAAK4O,IAEhB5H,EAAWhH,KAAKiP,E,CAOpB,OAFI/Q,EAAMgD,EAAM/D,QAAQ6J,EAAWhH,KAAK4O,GAEjCtM,OAAO2E,cAAaC,MAApB5E,OAAwB0E,EACjC,EAQMmI,EAAkB,SAACZ,GACvB,OAAAA,GAAa,OAAUA,GAAa,KAApC,EAQIc,EAAiB,SAACd,GACtB,OAAAA,GAAa,OAAUA,GAAa,KAApC,EAUIW,EAAe,SAACD,EAAeG,EAAgBN,GAInD,GAAIA,IAAcX,EAAUmB,aAAc,OAAQF,GAAU,EAAKH,EACjE,GAAIH,IAAcX,EAAUa,UAAW,OAAQC,GAAS,EAAKG,EAC7D,MAAM,IAAIhM,MAAM,sBAAsB0L,EACxC,EAWMC,EAAU,SAAC/R,GAAiC,OAC9CuS,EAAqBvS,GAASmR,EAAUa,UACxCQ,EAAwBxS,GAASmR,EAAUmB,aAC3CnB,EAAUa,SAHoC,EAM5CO,EAAuB,SAACvS,GAC5B,OAAa,MAAbA,EAAM,IAA4B,MAAbA,EAAM,EAA3B,EAEIwS,EAA0B,SAACxS,GAC/B,OAAa,MAAbA,EAAM,IAA4B,MAAbA,EAAM,EAA3B,EAEWyS,EAAc,SAACzS,GAC1B,OAAAuS,EAAqBvS,IAAUwS,EAAwBxS,EAAvD,C","sources":["../node_modules/pdf-lib/src/utils/base64.ts","../node_modules/pdf-lib/src/utils/pdfDocEncoding.ts","../node_modules/pdf-lib/src/utils/arrays.ts","../node_modules/pdf-lib/src/utils/async.ts","../node_modules/pdf-lib/src/utils/numbers.ts","../node_modules/pdf-lib/src/utils/errors.ts","../node_modules/pdf-lib/src/utils/objects.ts","../node_modules/pdf-lib/src/utils/validators.ts","../node_modules/pdf-lib/src/utils/Cache.ts","../node_modules/pdf-lib/src/utils/png.ts","../node_modules/pdf-lib/src/utils/rng.ts","../node_modules/pdf-lib/src/utils/strings.ts","../node_modules/pdf-lib/src/utils/unicode.ts"],"sourcesContent":["/*\n * The `chars`, `lookup`, `encode`, and `decode` members of this file are\n * licensed under the following:\n *\n *     base64-arraybuffer\n *     https://github.com/niklasvh/base64-arraybuffer\n *\n *     Copyright (c) 2012 Niklas von Hertzen\n *     Licensed under the MIT license.\n *\n */\n\nconst chars =\n  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\n// Use a lookup table to find the index.\nconst lookup = new Uint8Array(256);\nfor (let i = 0; i < chars.length; i++) {\n  lookup[chars.charCodeAt(i)] = i;\n}\n\nexport const encodeToBase64 = (bytes: Uint8Array): string => {\n  let base64 = '';\n  const len = bytes.length;\n  for (let i = 0; i < len; i += 3) {\n    base64 += chars[bytes[i] >> 2];\n    base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)];\n    base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)];\n    base64 += chars[bytes[i + 2] & 63];\n  }\n\n  if (len % 3 === 2) {\n    base64 = base64.substring(0, base64.length - 1) + '=';\n  } else if (len % 3 === 1) {\n    base64 = base64.substring(0, base64.length - 2) + '==';\n  }\n\n  return base64;\n};\n\nexport const decodeFromBase64 = (base64: string): Uint8Array => {\n  let bufferLength = base64.length * 0.75;\n  const len = base64.length;\n  let i;\n  let p = 0;\n  let encoded1;\n  let encoded2;\n  let encoded3;\n  let encoded4;\n\n  if (base64[base64.length - 1] === '=') {\n    bufferLength--;\n    if (base64[base64.length - 2] === '=') {\n      bufferLength--;\n    }\n  }\n\n  const bytes = new Uint8Array(bufferLength);\n\n  for (i = 0; i < len; i += 4) {\n    encoded1 = lookup[base64.charCodeAt(i)];\n    encoded2 = lookup[base64.charCodeAt(i + 1)];\n    encoded3 = lookup[base64.charCodeAt(i + 2)];\n    encoded4 = lookup[base64.charCodeAt(i + 3)];\n\n    bytes[p++] = (encoded1 << 2) | (encoded2 >> 4);\n    bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2);\n    bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63);\n  }\n\n  return bytes;\n};\n\n// This regex is designed to be as flexible as possible. It will parse certain\n// invalid data URIs.\nconst DATA_URI_PREFIX_REGEX = /^(data)?:?([\\w\\/\\+]+)?;?(charset=[\\w-]+|base64)?.*,/i;\n\n/**\n * If the `dataUri` input is a data URI, then the data URI prefix must not be\n * longer than 100 characters, or this function will fail to decode it.\n *\n * @param dataUri a base64 data URI or plain base64 string\n * @returns a Uint8Array containing the decoded input\n */\nexport const decodeFromBase64DataUri = (dataUri: string): Uint8Array => {\n  const trimmedUri = dataUri.trim();\n\n  const prefix = trimmedUri.substring(0, 100);\n  const res = prefix.match(DATA_URI_PREFIX_REGEX);\n\n  // Assume it's not a data URI - just a plain base64 string\n  if (!res) return decodeFromBase64(trimmedUri);\n\n  // Remove the data URI prefix and parse the remainder as a base64 string\n  const [fullMatch] = res;\n  const data = trimmedUri.substring(fullMatch.length);\n\n  return decodeFromBase64(data);\n};\n","import { toCharCode } from 'src/utils/strings';\n\n// Mapping from PDFDocEncoding to Unicode code point\nconst pdfDocEncodingToUnicode = new Uint16Array(256);\n\n// Initialize the code points which are the same\nfor (let idx = 0; idx < 256; idx++) {\n  pdfDocEncodingToUnicode[idx] = idx;\n}\n\n// Set differences (see \"Table D.2 – PDFDocEncoding Character Set\" of the PDF spec)\npdfDocEncodingToUnicode[0x16] = toCharCode('\\u0017'); // SYNCRONOUS IDLE\npdfDocEncodingToUnicode[0x18] = toCharCode('\\u02D8'); // BREVE\npdfDocEncodingToUnicode[0x19] = toCharCode('\\u02C7'); // CARON\npdfDocEncodingToUnicode[0x1a] = toCharCode('\\u02C6'); // MODIFIER LETTER CIRCUMFLEX ACCENT\npdfDocEncodingToUnicode[0x1b] = toCharCode('\\u02D9'); // DOT ABOVE\npdfDocEncodingToUnicode[0x1c] = toCharCode('\\u02DD'); // DOUBLE ACUTE ACCENT\npdfDocEncodingToUnicode[0x1d] = toCharCode('\\u02DB'); // OGONEK\npdfDocEncodingToUnicode[0x1e] = toCharCode('\\u02DA'); // RING ABOVE\npdfDocEncodingToUnicode[0x1f] = toCharCode('\\u02DC'); // SMALL TILDE\npdfDocEncodingToUnicode[0x7f] = toCharCode('\\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)\npdfDocEncodingToUnicode[0x80] = toCharCode('\\u2022'); // BULLET\npdfDocEncodingToUnicode[0x81] = toCharCode('\\u2020'); // DAGGER\npdfDocEncodingToUnicode[0x82] = toCharCode('\\u2021'); // DOUBLE DAGGER\npdfDocEncodingToUnicode[0x83] = toCharCode('\\u2026'); // HORIZONTAL ELLIPSIS\npdfDocEncodingToUnicode[0x84] = toCharCode('\\u2014'); // EM DASH\npdfDocEncodingToUnicode[0x85] = toCharCode('\\u2013'); // EN DASH\npdfDocEncodingToUnicode[0x86] = toCharCode('\\u0192'); // LATIN SMALL LETTER SCRIPT F\npdfDocEncodingToUnicode[0x87] = toCharCode('\\u2044'); // FRACTION SLASH (solidus)\npdfDocEncodingToUnicode[0x88] = toCharCode('\\u2039'); // SINGLE LEFT-POINTING ANGLE QUOTATION MARK\npdfDocEncodingToUnicode[0x89] = toCharCode('\\u203A'); // SINGLE RIGHT-POINTING ANGLE QUOTATION MARK\npdfDocEncodingToUnicode[0x8a] = toCharCode('\\u2212'); // MINUS SIGN\npdfDocEncodingToUnicode[0x8b] = toCharCode('\\u2030'); // PER MILLE SIGN\npdfDocEncodingToUnicode[0x8c] = toCharCode('\\u201E'); // DOUBLE LOW-9 QUOTATION MARK (quotedblbase)\npdfDocEncodingToUnicode[0x8d] = toCharCode('\\u201C'); // LEFT DOUBLE QUOTATION MARK (quotedblleft)\npdfDocEncodingToUnicode[0x8e] = toCharCode('\\u201D'); // RIGHT DOUBLE QUOTATION MARK (quotedblright)\npdfDocEncodingToUnicode[0x8f] = toCharCode('\\u2018'); // LEFT SINGLE QUOTATION MARK (quoteleft)\npdfDocEncodingToUnicode[0x90] = toCharCode('\\u2019'); // RIGHT SINGLE QUOTATION MARK (quoteright)\npdfDocEncodingToUnicode[0x91] = toCharCode('\\u201A'); // SINGLE LOW-9 QUOTATION MARK (quotesinglbase)\npdfDocEncodingToUnicode[0x92] = toCharCode('\\u2122'); // TRADE MARK SIGN\npdfDocEncodingToUnicode[0x93] = toCharCode('\\uFB01'); // LATIN SMALL LIGATURE FI\npdfDocEncodingToUnicode[0x94] = toCharCode('\\uFB02'); // LATIN SMALL LIGATURE FL\npdfDocEncodingToUnicode[0x95] = toCharCode('\\u0141'); // LATIN CAPITAL LETTER L WITH STROKE\npdfDocEncodingToUnicode[0x96] = toCharCode('\\u0152'); // LATIN CAPITAL LIGATURE OE\npdfDocEncodingToUnicode[0x97] = toCharCode('\\u0160'); // LATIN CAPITAL LETTER S WITH CARON\npdfDocEncodingToUnicode[0x98] = toCharCode('\\u0178'); // LATIN CAPITAL LETTER Y WITH DIAERESIS\npdfDocEncodingToUnicode[0x99] = toCharCode('\\u017D'); // LATIN CAPITAL LETTER Z WITH CARON\npdfDocEncodingToUnicode[0x9a] = toCharCode('\\u0131'); // LATIN SMALL LETTER DOTLESS I\npdfDocEncodingToUnicode[0x9b] = toCharCode('\\u0142'); // LATIN SMALL LETTER L WITH STROKE\npdfDocEncodingToUnicode[0x9c] = toCharCode('\\u0153'); // LATIN SMALL LIGATURE OE\npdfDocEncodingToUnicode[0x9d] = toCharCode('\\u0161'); // LATIN SMALL LETTER S WITH CARON\npdfDocEncodingToUnicode[0x9e] = toCharCode('\\u017E'); // LATIN SMALL LETTER Z WITH CARON\npdfDocEncodingToUnicode[0x9f] = toCharCode('\\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)\npdfDocEncodingToUnicode[0xa0] = toCharCode('\\u20AC'); // EURO SIGN\npdfDocEncodingToUnicode[0xad] = toCharCode('\\uFFFD'); // REPLACEMENT CHARACTER (box with questionmark)\n\n/**\n * Decode a byte array into a string using PDFDocEncoding.\n *\n * @param bytes a byte array (decimal representation) containing a string\n *              encoded with PDFDocEncoding.\n */\nexport const pdfDocEncodingDecode = (bytes: Uint8Array): string => {\n  const codePoints = new Array(bytes.length);\n  for (let idx = 0, len = bytes.length; idx < len; idx++) {\n    codePoints[idx] = pdfDocEncodingToUnicode[bytes[idx]];\n  }\n  return String.fromCodePoint(...codePoints);\n};\n","import { decodeFromBase64DataUri } from 'src/utils/base64';\nimport { charFromCode } from 'src/utils/strings';\n\nexport const last = <T>(array: T[]): T => array[array.length - 1];\n\n// export const dropLast = <T>(array: T[]): T[] =>\n// array.slice(0, array.length - 1);\n\nexport const typedArrayFor = (value: string | Uint8Array): Uint8Array => {\n  if (value instanceof Uint8Array) return value;\n  const length = value.length;\n  const typedArray = new Uint8Array(length);\n  for (let idx = 0; idx < length; idx++) {\n    typedArray[idx] = value.charCodeAt(idx);\n  }\n  return typedArray;\n};\n\nexport const mergeIntoTypedArray = (...arrays: (string | Uint8Array)[]) => {\n  const arrayCount = arrays.length;\n\n  const typedArrays: Uint8Array[] = [];\n  for (let idx = 0; idx < arrayCount; idx++) {\n    const element = arrays[idx];\n    typedArrays[idx] =\n      element instanceof Uint8Array ? element : typedArrayFor(element);\n  }\n\n  let totalSize = 0;\n  for (let idx = 0; idx < arrayCount; idx++) {\n    totalSize += arrays[idx].length;\n  }\n\n  const merged = new Uint8Array(totalSize);\n  let offset = 0;\n  for (let arrIdx = 0; arrIdx < arrayCount; arrIdx++) {\n    const arr = typedArrays[arrIdx];\n    for (let byteIdx = 0, arrLen = arr.length; byteIdx < arrLen; byteIdx++) {\n      merged[offset++] = arr[byteIdx];\n    }\n  }\n\n  return merged;\n};\n\nexport const mergeUint8Arrays = (arrays: Uint8Array[]): Uint8Array => {\n  let totalSize = 0;\n  for (let idx = 0, len = arrays.length; idx < len; idx++) {\n    totalSize += arrays[idx].length;\n  }\n\n  const mergedBuffer = new Uint8Array(totalSize);\n  let offset = 0;\n  for (let idx = 0, len = arrays.length; idx < len; idx++) {\n    const array = arrays[idx];\n    mergedBuffer.set(array, offset);\n    offset += array.length;\n  }\n\n  return mergedBuffer;\n};\n\nexport const arrayAsString = (array: Uint8Array | number[]): string => {\n  let str = '';\n  for (let idx = 0, len = array.length; idx < len; idx++) {\n    str += charFromCode(array[idx]);\n  }\n  return str;\n};\n\nexport const byAscendingId = <T extends { id: any }>(a: T, b: T) => a.id - b.id;\n\nexport const sortedUniq = <T>(array: T[], indexer: (elem: T) => any): T[] => {\n  const uniq: T[] = [];\n\n  for (let idx = 0, len = array.length; idx < len; idx++) {\n    const curr = array[idx];\n    const prev = array[idx - 1];\n    if (idx === 0 || indexer(curr) !== indexer(prev)) {\n      uniq.push(curr);\n    }\n  }\n\n  return uniq;\n};\n\n// Arrays and TypedArrays in JS both have .reverse() methods, which would seem\n// to negate the need for this function. However, not all runtimes support this\n// method (e.g. React Native). This function compensates for that fact.\nexport const reverseArray = (array: Uint8Array) => {\n  const arrayLen = array.length;\n  for (let idx = 0, len = Math.floor(arrayLen / 2); idx < len; idx++) {\n    const leftIdx = idx;\n    const rightIdx = arrayLen - idx - 1;\n    const temp = array[idx];\n\n    array[leftIdx] = array[rightIdx];\n    array[rightIdx] = temp;\n  }\n  return array;\n};\n\nexport const sum = (array: number[] | Uint8Array): number => {\n  let total = 0;\n  for (let idx = 0, len = array.length; idx < len; idx++) {\n    total += array[idx];\n  }\n  return total;\n};\n\nexport const range = (start: number, end: number): number[] => {\n  const arr = new Array(end - start);\n  for (let idx = 0, len = arr.length; idx < len; idx++) {\n    arr[idx] = start + idx;\n  }\n  return arr;\n};\n\nexport const pluckIndices = <T>(arr: T[], indices: number[]) => {\n  const plucked = new Array<T>(indices.length);\n  for (let idx = 0, len = indices.length; idx < len; idx++) {\n    plucked[idx] = arr[indices[idx]];\n  }\n  return plucked;\n};\n\nexport const canBeConvertedToUint8Array = (\n  input: any,\n): input is string | ArrayBuffer | Uint8Array =>\n  input instanceof Uint8Array ||\n  input instanceof ArrayBuffer ||\n  typeof input === 'string';\n\nexport const toUint8Array = (input: string | ArrayBuffer | Uint8Array) => {\n  if (typeof input === 'string') {\n    return decodeFromBase64DataUri(input);\n  } else if (input instanceof ArrayBuffer) {\n    return new Uint8Array(input);\n  } else if (input instanceof Uint8Array) {\n    return input;\n  } else {\n    throw new TypeError(\n      '`input` must be one of `string | ArrayBuffer | Uint8Array`',\n    );\n  }\n};\n","/**\n * Returns a Promise that resolves after at least one tick of the\n * Macro Task Queue occurs.\n */\nexport const waitForTick = (): Promise<void> =>\n  new Promise((resolve) => {\n    setTimeout(() => resolve(), 0);\n  });\n","// tslint:disable radix\n\n/**\n * Converts a number to its string representation in decimal. This function\n * differs from simply converting a number to a string with `.toString()`\n * because this function's output string will **not** contain exponential\n * notation.\n *\n * Credit: https://stackoverflow.com/a/46545519\n */\nexport const numberToString = (num: number) => {\n  let numStr = String(num);\n\n  if (Math.abs(num) < 1.0) {\n    const e = parseInt(num.toString().split('e-')[1]);\n    if (e) {\n      const negative = num < 0;\n      if (negative) num *= -1;\n      num *= Math.pow(10, e - 1);\n      numStr = '0.' + new Array(e).join('0') + num.toString().substring(2);\n      if (negative) numStr = '-' + numStr;\n    }\n  } else {\n    let e = parseInt(num.toString().split('+')[1]);\n    if (e > 20) {\n      e -= 20;\n      num /= Math.pow(10, e);\n      numStr = num.toString() + new Array(e + 1).join('0');\n    }\n  }\n\n  return numStr;\n};\n\nexport const sizeInBytes = (n: number) => Math.ceil(n.toString(2).length / 8);\n\n/**\n * Converts a number into its constituent bytes and returns them as\n * a number[].\n *\n * Returns most significant byte as first element in array. It may be necessary\n * to call .reverse() to get the bits in the desired order.\n *\n * Example:\n *   bytesFor(0x02A41E) => [ 0b10, 0b10100100, 0b11110 ]\n *\n * Credit for algorithm: https://stackoverflow.com/a/1936865\n */\nexport const bytesFor = (n: number) => {\n  const bytes = new Uint8Array(sizeInBytes(n));\n  for (let i = 1; i <= bytes.length; i++) {\n    bytes[i - 1] = n >> ((bytes.length - i) * 8);\n  }\n  return bytes;\n};\n","export const error = (msg: string) => {\n  throw new Error(msg);\n};\n","import { FontNames } from '@pdf-lib/standard-fonts';\n\nexport const values = (obj: any) => Object.keys(obj).map((k) => obj[k]);\n\nexport const StandardFontValues = values(FontNames);\n\nexport const isStandardFont = (input: any): input is FontNames =>\n  StandardFontValues.includes(input);\n\nexport const rectanglesAreEqual = (\n  a: { x: number; y: number; width: number; height: number },\n  b: { x: number; y: number; width: number; height: number },\n) => a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height;\n","/* tslint:disable:ban-types */\n\nimport { values as objectValues } from 'src/utils/objects';\n\nexport const backtick = (val: any) => `\\`${val}\\``;\nexport const singleQuote = (val: any) => `'${val}'`;\n\ntype Primitive = string | number | boolean | undefined | null;\n\n// prettier-ignore\nconst formatValue = (value: any) => {\n  const type = typeof value;\n  if (type ==='string') return singleQuote(value);\n  else if (type ==='undefined') return backtick(value);\n  else return value;\n};\n\nexport const createValueErrorMsg = (\n  value: any,\n  valueName: string,\n  values: Primitive[],\n) => {\n  const allowedValues = new Array(values.length);\n\n  for (let idx = 0, len = values.length; idx < len; idx++) {\n    const v = values[idx];\n    allowedValues[idx] = formatValue(v);\n  }\n\n  const joinedValues = allowedValues.join(' or ');\n\n  // prettier-ignore\n  return `${backtick(valueName)} must be one of ${joinedValues}, but was actually ${formatValue(value)}`;\n};\n\nexport const assertIsOneOf = (\n  value: any,\n  valueName: string,\n  allowedValues: Primitive[] | { [key: string]: Primitive },\n) => {\n  if (!Array.isArray(allowedValues)) {\n    allowedValues = objectValues(allowedValues);\n  }\n  for (let idx = 0, len = allowedValues.length; idx < len; idx++) {\n    if (value === allowedValues[idx]) return;\n  }\n  throw new TypeError(createValueErrorMsg(value, valueName, allowedValues));\n};\n\nexport const assertIsOneOfOrUndefined = (\n  value: any,\n  valueName: string,\n  allowedValues: Primitive[] | { [key: string]: Primitive },\n) => {\n  if (!Array.isArray(allowedValues)) {\n    allowedValues = objectValues(allowedValues);\n  }\n  assertIsOneOf(value, valueName, allowedValues.concat(undefined));\n};\n\nexport const assertIsSubset = (\n  values: any[],\n  valueName: string,\n  allowedValues: Primitive[] | { [key: string]: Primitive },\n) => {\n  if (!Array.isArray(allowedValues)) {\n    allowedValues = objectValues(allowedValues);\n  }\n  for (let idx = 0, len = values.length; idx < len; idx++) {\n    assertIsOneOf(values[idx], valueName, allowedValues);\n  }\n};\n\nexport const getType = (val: any) => {\n  if (val === null) return 'null';\n  if (val === undefined) return 'undefined';\n  if (typeof val === 'string') return 'string';\n  if (isNaN(val)) return 'NaN';\n  if (typeof val === 'number') return 'number';\n  if (typeof val === 'boolean') return 'boolean';\n  if (typeof val === 'symbol') return 'symbol';\n  if (typeof val === 'bigint') return 'bigint';\n  if (val.constructor && val.constructor.name) return val.constructor.name;\n  if (val.name) return val.name;\n  if (val.constructor) return String(val.constructor);\n  return String(val);\n};\n\nexport type TypeDescriptor =\n  | 'null'\n  | 'undefined'\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'symbol'\n  | 'bigint'\n  | DateConstructor\n  | ArrayConstructor\n  | Uint8ArrayConstructor\n  | ArrayBufferConstructor\n  | FunctionConstructor\n  | [Function, string];\n\nexport const isType = (value: any, type: TypeDescriptor) => {\n  if (type === 'null') return value === null;\n  if (type === 'undefined') return value === undefined;\n  if (type === 'string') return typeof value === 'string';\n  if (type === 'number') return typeof value === 'number' && !isNaN(value);\n  if (type === 'boolean') return typeof value === 'boolean';\n  if (type === 'symbol') return typeof value === 'symbol';\n  if (type === 'bigint') return typeof value === 'bigint';\n  if (type === Date) return value instanceof Date;\n  if (type === Array) return value instanceof Array;\n  if (type === Uint8Array) return value instanceof Uint8Array;\n  if (type === ArrayBuffer) return value instanceof ArrayBuffer;\n  if (type === Function) return value instanceof Function;\n  return value instanceof (type as [Function, string])[0];\n};\n\nexport const createTypeErrorMsg = (\n  value: any,\n  valueName: string,\n  types: TypeDescriptor[],\n) => {\n  const allowedTypes = new Array(types.length);\n\n  for (let idx = 0, len = types.length; idx < len; idx++) {\n    const type = types[idx];\n    if (type === 'null') allowedTypes[idx] = backtick('null');\n    if (type === 'undefined') allowedTypes[idx] = backtick('undefined');\n    if (type === 'string') allowedTypes[idx] = backtick('string');\n    else if (type === 'number') allowedTypes[idx] = backtick('number');\n    else if (type === 'boolean') allowedTypes[idx] = backtick('boolean');\n    else if (type === 'symbol') allowedTypes[idx] = backtick('symbol');\n    else if (type === 'bigint') allowedTypes[idx] = backtick('bigint');\n    else if (type === Array) allowedTypes[idx] = backtick('Array');\n    else if (type === Uint8Array) allowedTypes[idx] = backtick('Uint8Array');\n    else if (type === ArrayBuffer) allowedTypes[idx] = backtick('ArrayBuffer');\n    else allowedTypes[idx] = backtick((type as [Function, string])[1]);\n  }\n\n  const joinedTypes = allowedTypes.join(' or ');\n\n  // prettier-ignore\n  return `${backtick(valueName)} must be of type ${joinedTypes}, but was actually of type ${backtick(getType(value))}`;\n};\n\nexport const assertIs = (\n  value: any,\n  valueName: string,\n  types: TypeDescriptor[],\n) => {\n  for (let idx = 0, len = types.length; idx < len; idx++) {\n    if (isType(value, types[idx])) return;\n  }\n  throw new TypeError(createTypeErrorMsg(value, valueName, types));\n};\n\nexport const assertOrUndefined = (\n  value: any,\n  valueName: string,\n  types: TypeDescriptor[],\n) => {\n  assertIs(value, valueName, types.concat('undefined'));\n};\n\nexport const assertEachIs = (\n  values: any[],\n  valueName: string,\n  types: TypeDescriptor[],\n) => {\n  for (let idx = 0, len = values.length; idx < len; idx++) {\n    assertIs(values[idx], valueName, types);\n  }\n};\n\nexport const assertRange = (\n  value: any,\n  valueName: string,\n  min: number,\n  max: number,\n) => {\n  assertIs(value, valueName, ['number']);\n  assertIs(min, 'min', ['number']);\n  assertIs(max, 'max', ['number']);\n  max = Math.max(min, max);\n  if (value < min || value > max) {\n    // prettier-ignore\n    throw new Error(`${backtick(valueName)} must be at least ${min} and at most ${max}, but was actually ${value}`);\n  }\n};\n\nexport const assertRangeOrUndefined = (\n  value: any,\n  valueName: string,\n  min: number,\n  max: number,\n) => {\n  assertIs(value, valueName, ['number', 'undefined']);\n  if (typeof value === 'number') assertRange(value, valueName, min, max);\n};\n\nexport const assertMultiple = (\n  value: any,\n  valueName: string,\n  multiplier: number,\n) => {\n  assertIs(value, valueName, ['number']);\n  if (value % multiplier !== 0) {\n    // prettier-ignore\n    throw new Error(`${backtick(valueName)} must be a multiple of ${multiplier}, but was actually ${value}`);\n  }\n};\n\nexport const assertInteger = (value: any, valueName: string) => {\n  if (!Number.isInteger(value)) {\n    throw new Error(\n      `${backtick(valueName)} must be an integer, but was actually ${value}`,\n    );\n  }\n};\n\nexport const assertPositive = (value: number, valueName: string) => {\n  if (![1, 0].includes(Math.sign(value))) {\n    // prettier-ignore\n    throw new Error(`${backtick(valueName)} must be a positive number or 0, but was actually ${value}`);\n  }\n};\n","class Cache<T> {\n  static readonly populatedBy = <T>(populate: () => T) => new Cache(populate);\n\n  private readonly populate: () => T;\n  private value: T | undefined;\n\n  private constructor(populate: () => T) {\n    this.populate = populate;\n    this.value = undefined;\n  }\n\n  getValue(): T | undefined {\n    return this.value;\n  }\n\n  access(): T {\n    if (!this.value) this.value = this.populate();\n    return this.value;\n  }\n\n  invalidate(): void {\n    this.value = undefined;\n  }\n}\n\nexport default Cache;\n","import UPNG from '@pdf-lib/upng';\n\nconst getImageType = (ctype: number) => {\n  if (ctype === 0) return PngType.Greyscale;\n  if (ctype === 2) return PngType.Truecolour;\n  if (ctype === 3) return PngType.IndexedColour;\n  if (ctype === 4) return PngType.GreyscaleWithAlpha;\n  if (ctype === 6) return PngType.TruecolourWithAlpha;\n  throw new Error(`Unknown color type: ${ctype}`);\n};\n\nconst splitAlphaChannel = (rgbaChannel: Uint8Array) => {\n  const pixelCount = Math.floor(rgbaChannel.length / 4);\n\n  const rgbChannel = new Uint8Array(pixelCount * 3);\n  const alphaChannel = new Uint8Array(pixelCount * 1);\n\n  let rgbaOffset = 0;\n  let rgbOffset = 0;\n  let alphaOffset = 0;\n\n  while (rgbaOffset < rgbaChannel.length) {\n    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];\n    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];\n    rgbChannel[rgbOffset++] = rgbaChannel[rgbaOffset++];\n    alphaChannel[alphaOffset++] = rgbaChannel[rgbaOffset++];\n  }\n\n  return { rgbChannel, alphaChannel };\n};\n\nexport enum PngType {\n  Greyscale = 'Greyscale',\n  Truecolour = 'Truecolour',\n  IndexedColour = 'IndexedColour',\n  GreyscaleWithAlpha = 'GreyscaleWithAlpha',\n  TruecolourWithAlpha = 'TruecolourWithAlpha',\n}\n\nexport class PNG {\n  static load = (pngData: Uint8Array) => new PNG(pngData);\n\n  readonly rgbChannel: Uint8Array;\n  readonly alphaChannel?: Uint8Array;\n  readonly type: PngType;\n  readonly width: number;\n  readonly height: number;\n  readonly bitsPerComponent: number;\n\n  private constructor(pngData: Uint8Array) {\n    const upng = UPNG.decode(pngData);\n    const frames = UPNG.toRGBA8(upng);\n\n    if (frames.length > 1) throw new Error(`Animated PNGs are not supported`);\n\n    const frame = new Uint8Array(frames[0]);\n    const { rgbChannel, alphaChannel } = splitAlphaChannel(frame);\n\n    this.rgbChannel = rgbChannel;\n\n    const hasAlphaValues = alphaChannel.some((a) => a < 255);\n    if (hasAlphaValues) this.alphaChannel = alphaChannel;\n\n    this.type = getImageType(upng.ctype);\n\n    this.width = upng.width;\n    this.height = upng.height;\n    this.bitsPerComponent = 8;\n  }\n}\n","/**\n * Generates a pseudo random number. Although it is not cryptographically secure\n * and uniformly distributed, it is not a concern for the intended use-case,\n * which is to generate distinct numbers.\n *\n * Credit: https://stackoverflow.com/a/19303725/10254049\n */\nexport class SimpleRNG {\n  static withSeed = (seed: number) => new SimpleRNG(seed);\n\n  private seed: number;\n\n  private constructor(seed: number) {\n    this.seed = seed;\n  }\n\n  nextInt(): number {\n    const x = Math.sin(this.seed++) * 10000;\n    return x - Math.floor(x);\n  }\n}\n","export const toCharCode = (character: string) => character.charCodeAt(0);\n\nexport const toCodePoint = (character: string) => character.codePointAt(0);\n\nexport const toHexStringOfMinLength = (num: number, minLength: number) =>\n  padStart(num.toString(16), minLength, '0').toUpperCase();\n\nexport const toHexString = (num: number) => toHexStringOfMinLength(num, 2);\n\nexport const charFromCode = (code: number) => String.fromCharCode(code);\n\nexport const charFromHexCode = (hex: string) => charFromCode(parseInt(hex, 16));\n\nexport const padStart = (value: string, length: number, padChar: string) => {\n  let padding = '';\n  for (let idx = 0, len = length - value.length; idx < len; idx++) {\n    padding += padChar;\n  }\n  return padding + value;\n};\n\nexport const copyStringIntoBuffer = (\n  str: string,\n  buffer: Uint8Array,\n  offset: number,\n): number => {\n  const length = str.length;\n  for (let idx = 0; idx < length; idx++) {\n    buffer[offset++] = str.charCodeAt(idx);\n  }\n  return length;\n};\n\nexport const addRandomSuffix = (prefix: string, suffixLength = 4) =>\n  `${prefix}-${Math.floor(Math.random() * 10 ** suffixLength)}`;\n\nexport const escapeRegExp = (str: string) =>\n  str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n\nexport const cleanText = (text: string) =>\n  text.replace(/\\t|\\u0085|\\u2028|\\u2029/g, '    ').replace(/[\\b\\v]/g, '');\n\nexport const escapedNewlineChars = ['\\\\n', '\\\\f', '\\\\r', '\\\\u000B'];\n\nexport const newlineChars = ['\\n', '\\f', '\\r', '\\u000B'];\n\nexport const isNewlineChar = (text: string) => /^[\\n\\f\\r\\u000B]$/.test(text);\n\nexport const lineSplit = (text: string) => text.split(/[\\n\\f\\r\\u000B]/);\n\nexport const mergeLines = (text: string) =>\n  text.replace(/[\\n\\f\\r\\u000B]/g, ' ');\n\n// JavaScript's String.charAt() method doesn work on strings containing UTF-16\n// characters (with high and low surrogate pairs), such as 💩 (poo emoji). This\n// `charAtIndex()` function does.\n//\n// Credit: https://github.com/mathiasbynens/String.prototype.at/blob/master/at.js#L14-L48\nexport const charAtIndex = (text: string, index: number): [string, number] => {\n  // Get the first code unit and code unit value\n  const cuFirst = text.charCodeAt(index);\n  let cuSecond: number;\n  const nextIndex = index + 1;\n  let length = 1;\n  if (\n    // Check if it's the start of a surrogate pair.\n    cuFirst >= 0xd800 &&\n    cuFirst <= 0xdbff && // high surrogate\n    text.length > nextIndex // there is a next code unit\n  ) {\n    cuSecond = text.charCodeAt(nextIndex);\n    if (cuSecond >= 0xdc00 && cuSecond <= 0xdfff) length = 2; // low surrogate\n  }\n  return [text.slice(index, index + length), length];\n};\n\nexport const charSplit = (text: string) => {\n  const chars: string[] = [];\n\n  for (let idx = 0, len = text.length; idx < len; ) {\n    const [c, cLen] = charAtIndex(text, idx);\n    chars.push(c);\n    idx += cLen;\n  }\n\n  return chars;\n};\n\nconst buildWordBreakRegex = (wordBreaks: string[]) => {\n  const newlineCharUnion = escapedNewlineChars.join('|');\n\n  const escapedRules: string[] = ['$'];\n  for (let idx = 0, len = wordBreaks.length; idx < len; idx++) {\n    const wordBreak = wordBreaks[idx];\n    if (isNewlineChar(wordBreak)) {\n      throw new TypeError(`\\`wordBreak\\` must not include ${newlineCharUnion}`);\n    }\n    escapedRules.push(wordBreak === '' ? '.' : escapeRegExp(wordBreak));\n  }\n\n  const breakRules = escapedRules.join('|');\n  return new RegExp(`(${newlineCharUnion})|((.*?)(${breakRules}))`, 'gm');\n};\n\nexport const breakTextIntoLines = (\n  text: string,\n  wordBreaks: string[],\n  maxWidth: number,\n  computeWidthOfText: (t: string) => number,\n): string[] => {\n  const regex = buildWordBreakRegex(wordBreaks);\n\n  const words = cleanText(text).match(regex)!;\n\n  let currLine = '';\n  let currWidth = 0;\n  const lines: string[] = [];\n\n  const pushCurrLine = () => {\n    if (currLine !== '') lines.push(currLine);\n    currLine = '';\n    currWidth = 0;\n  };\n\n  for (let idx = 0, len = words.length; idx < len; idx++) {\n    const word = words[idx];\n    if (isNewlineChar(word)) {\n      pushCurrLine();\n    } else {\n      const width = computeWidthOfText(word);\n      if (currWidth + width > maxWidth) pushCurrLine();\n      currLine += word;\n      currWidth += width;\n    }\n  }\n  pushCurrLine();\n\n  return lines;\n};\n\n// See section \"7.9.4 Dates\" of the PDF specification\nconst dateRegex = /^D:(\\d\\d\\d\\d)(\\d\\d)?(\\d\\d)?(\\d\\d)?(\\d\\d)?(\\d\\d)?([+\\-Z])?(\\d\\d)?'?(\\d\\d)?'?$/;\n\nexport const parseDate = (dateStr: string): Date | undefined => {\n  const match = dateStr.match(dateRegex);\n\n  if (!match) return undefined;\n\n  const [\n    ,\n    year,\n    month = '01',\n    day = '01',\n    hours = '00',\n    mins = '00',\n    secs = '00',\n    offsetSign = 'Z',\n    offsetHours = '00',\n    offsetMins = '00',\n  ] = match;\n\n  // http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15\n  const tzOffset =\n    offsetSign === 'Z' ? 'Z' : `${offsetSign}${offsetHours}:${offsetMins}`;\n  const date = new Date(\n    `${year}-${month}-${day}T${hours}:${mins}:${secs}${tzOffset}`,\n  );\n\n  return date;\n};\n\nexport const findLastMatch = (value: string, regex: RegExp) => {\n  let position = 0;\n  let lastMatch: RegExpMatchArray | undefined;\n  while (position < value.length) {\n    const match = value.substring(position).match(regex);\n    if (!match) return { match: lastMatch, pos: position };\n    lastMatch = match;\n    position += (match.index ?? 0) + match[0].length;\n  }\n  return { match: lastMatch, pos: position };\n};\n","import { toHexString } from 'src/utils/strings';\n\n/**\n * Encodes a string to UTF-8.\n *\n * @param input The string to be encoded.\n * @param byteOrderMark Whether or not a byte order marker (BOM) should be added\n *                      to the start of the encoding. (default `true`)\n * @returns A Uint8Array containing the UTF-8 encoding of the input string.\n *\n * -----------------------------------------------------------------------------\n *\n * JavaScript strings are composed of Unicode code points. Code points are\n * integers in the range 0 to 1,114,111 (0x10FFFF). When serializing a string,\n * it must be encoded as a sequence of words. A word is typically 8, 16, or 32\n * bytes in size. As such, Unicode defines three encoding forms: UTF-8, UTF-16,\n * and UTF-32. These encoding forms are described in the Unicode standard [1].\n * This function implements the UTF-8 encoding form.\n *\n * -----------------------------------------------------------------------------\n *\n * In UTF-8, each code point is mapped to a sequence of 1, 2, 3, or 4 bytes.\n * Note that the logic which defines this mapping is slightly convoluted, and\n * not as straightforward as the mapping logic for UTF-16 or UTF-32. The UTF-8\n * mapping logic is as follows [2]:\n *\n * • If a code point is in the range U+0000..U+007F, then view it as a 7-bit\n *   integer: 0bxxxxxxx. Map the code point to 1 byte with the first high order\n *   bit set to 0:\n *\n *       b1=0b0xxxxxxx\n *\n * • If a code point is in the range U+0080..U+07FF, then view it as an 11-bit\n *   integer: 0byyyyyxxxxxx. Map the code point to 2 bytes with the first 5 bits\n *   of the code point stored in the first byte, and the last 6 bits stored in\n *   the second byte:\n *\n *       b1=0b110yyyyy    b2=0b10xxxxxx\n *\n * • If a code point is in the range U+0800..U+FFFF, then view it as a 16-bit\n *   integer, 0bzzzzyyyyyyxxxxxx. Map the code point to 3 bytes with the first\n *   4 bits stored in the first byte, the next 6 bits stored in the second byte,\n *   and the last 6 bits in the third byte:\n *\n *       b1=0b1110zzzz    b2=0b10yyyyyy    b3=0b10xxxxxx\n *\n * • If a code point is in the range U+10000...U+10FFFF, then view it as a\n *   21-bit integer, 0bvvvzzzzzzyyyyyyxxxxxx. Map the code point to 4 bytes with\n *   the first 3 bits stored in the first byte, the next 6 bits stored in the\n *   second byte, the next 6 bits stored in the third byte, and the last 6 bits\n *   stored in the fourth byte:\n *\n *       b1=0b11110xxx    b2=0b10zzzzzz    b3=0b10yyyyyy    b4=0b10xxxxxx\n *\n * -----------------------------------------------------------------------------\n *\n * It is important to note, when iterating through the code points of a string\n * in JavaScript, that if a character is encoded as a surrogate pair it will\n * increase the string's length by 2 instead of 1 [4]. For example:\n *\n * ```\n * > 'a'.length\n * 1\n * > '💩'.length\n * 2\n * > '語'.length\n * 1\n * > 'a💩語'.length\n * 4\n * ```\n *\n * The results of the above example are explained by the fact that the\n * characters 'a' and '語' are not represented by surrogate pairs, but '💩' is.\n *\n * Because of this idiosyncrasy in JavaScript's string implementation and APIs,\n * we must \"jump\" an extra index after encoding a character as a surrogate\n * pair. In practice, this means we must increment the index of our for loop by\n * 2 if we encode a surrogate pair, and 1 in all other cases.\n *\n * -----------------------------------------------------------------------------\n *\n * References:\n *   - [1] https://www.unicode.org/versions/Unicode12.0.0/UnicodeStandard-12.0.pdf\n *         3.9  Unicode Encoding Forms - UTF-8\n *   - [2] http://www.herongyang.com/Unicode/UTF-8-UTF-8-Encoding.html\n *   - [3] http://www.herongyang.com/Unicode/UTF-8-UTF-8-Encoding-Algorithm.html\n *   - [4] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description\n *\n */\nexport const utf8Encode = (input: string, byteOrderMark = true): Uint8Array => {\n  const encoded = [];\n\n  if (byteOrderMark) encoded.push(0xef, 0xbb, 0xbf);\n\n  for (let idx = 0, len = input.length; idx < len; ) {\n    const codePoint = input.codePointAt(idx)!;\n\n    // One byte encoding\n    if (codePoint < 0x80) {\n      const byte1 = codePoint & 0x7f;\n      encoded.push(byte1);\n      idx += 1;\n    }\n\n    // Two byte encoding\n    else if (codePoint < 0x0800) {\n      const byte1 = ((codePoint >> 6) & 0x1f) | 0xc0;\n      const byte2 = (codePoint & 0x3f) | 0x80;\n      encoded.push(byte1, byte2);\n      idx += 1;\n    }\n\n    // Three byte encoding\n    else if (codePoint < 0x010000) {\n      const byte1 = ((codePoint >> 12) & 0x0f) | 0xe0;\n      const byte2 = ((codePoint >> 6) & 0x3f) | 0x80;\n      const byte3 = (codePoint & 0x3f) | 0x80;\n      encoded.push(byte1, byte2, byte3);\n      idx += 1;\n    }\n\n    // Four byte encoding (surrogate pair)\n    else if (codePoint < 0x110000) {\n      const byte1 = ((codePoint >> 18) & 0x07) | 0xf0;\n      const byte2 = ((codePoint >> 12) & 0x3f) | 0x80;\n      const byte3 = ((codePoint >> 6) & 0x3f) | 0x80;\n      const byte4 = ((codePoint >> 0) & 0x3f) | 0x80;\n      encoded.push(byte1, byte2, byte3, byte4);\n      idx += 2;\n    }\n\n    // Should never reach this case\n    else throw new Error(`Invalid code point: 0x${toHexString(codePoint)}`);\n  }\n\n  return new Uint8Array(encoded);\n};\n\n/**\n * Encodes a string to UTF-16.\n *\n * @param input The string to be encoded.\n * @param byteOrderMark Whether or not a byte order marker (BOM) should be added\n *                      to the start of the encoding. (default `true`)\n * @returns A Uint16Array containing the UTF-16 encoding of the input string.\n *\n * -----------------------------------------------------------------------------\n *\n * JavaScript strings are composed of Unicode code points. Code points are\n * integers in the range 0 to 1,114,111 (0x10FFFF). When serializing a string,\n * it must be encoded as a sequence of words. A word is typically 8, 16, or 32\n * bytes in size. As such, Unicode defines three encoding forms: UTF-8, UTF-16,\n * and UTF-32. These encoding forms are described in the Unicode standard [1].\n * This function implements the UTF-16 encoding form.\n *\n * -----------------------------------------------------------------------------\n *\n * In UTF-16, each code point is mapped to one or two 16-bit integers. The\n * UTF-16 mapping logic is as follows [2]:\n *\n * • If a code point is in the range U+0000..U+FFFF, then map the code point to\n *   a 16-bit integer with the most significant byte first.\n *\n * • If a code point is in the range U+10000..U+10000, then map the code point\n *   to two 16-bit integers. The first integer should contain the high surrogate\n *   and the second integer should contain the low surrogate. Both surrogates\n *   should be written with the most significant byte first.\n *\n * -----------------------------------------------------------------------------\n *\n * It is important to note, when iterating through the code points of a string\n * in JavaScript, that if a character is encoded as a surrogate pair it will\n * increase the string's length by 2 instead of 1 [4]. For example:\n *\n * ```\n * > 'a'.length\n * 1\n * > '💩'.length\n * 2\n * > '語'.length\n * 1\n * > 'a💩語'.length\n * 4\n * ```\n *\n * The results of the above example are explained by the fact that the\n * characters 'a' and '語' are not represented by surrogate pairs, but '💩' is.\n *\n * Because of this idiosyncrasy in JavaScript's string implementation and APIs,\n * we must \"jump\" an extra index after encoding a character as a surrogate\n * pair. In practice, this means we must increment the index of our for loop by\n * 2 if we encode a surrogate pair, and 1 in all other cases.\n *\n * -----------------------------------------------------------------------------\n *\n * References:\n *   - [1] https://www.unicode.org/versions/Unicode12.0.0/UnicodeStandard-12.0.pdf\n *         3.9  Unicode Encoding Forms - UTF-8\n *   - [2] http://www.herongyang.com/Unicode/UTF-16-UTF-16-Encoding.html\n *   - [3] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length#Description\n *\n */\nexport const utf16Encode = (\n  input: string,\n  byteOrderMark = true,\n): Uint16Array => {\n  const encoded = [];\n\n  if (byteOrderMark) encoded.push(0xfeff);\n\n  for (let idx = 0, len = input.length; idx < len; ) {\n    const codePoint = input.codePointAt(idx)!;\n\n    // Two byte encoding\n    if (codePoint < 0x010000) {\n      encoded.push(codePoint);\n      idx += 1;\n    }\n\n    // Four byte encoding (surrogate pair)\n    else if (codePoint < 0x110000) {\n      encoded.push(highSurrogate(codePoint), lowSurrogate(codePoint));\n      idx += 2;\n    }\n\n    // Should never reach this case\n    else throw new Error(`Invalid code point: 0x${toHexString(codePoint)}`);\n  }\n\n  return new Uint16Array(encoded);\n};\n\n/**\n * Returns `true` if the `codePoint` is within the\n * Basic Multilingual Plane (BMP). Code points inside the BMP are not encoded\n * with surrogate pairs.\n * @param codePoint The code point to be evaluated.\n *\n * Reference: https://en.wikipedia.org/wiki/UTF-16#Description\n */\nexport const isWithinBMP = (codePoint: number) =>\n  codePoint >= 0 && codePoint <= 0xffff;\n\n/**\n * Returns `true` if the given `codePoint` is valid and must be represented\n * with a surrogate pair when encoded.\n * @param codePoint The code point to be evaluated.\n *\n * Reference: https://en.wikipedia.org/wiki/UTF-16#Description\n */\nexport const hasSurrogates = (codePoint: number) =>\n  codePoint >= 0x010000 && codePoint <= 0x10ffff;\n\n// From Unicode 3.0 spec, section 3.7:\n//   http://unicode.org/versions/Unicode3.0.0/ch03.pdf\nexport const highSurrogate = (codePoint: number) =>\n  Math.floor((codePoint - 0x10000) / 0x400) + 0xd800;\n\n// From Unicode 3.0 spec, section 3.7:\n//   http://unicode.org/versions/Unicode3.0.0/ch03.pdf\nexport const lowSurrogate = (codePoint: number) =>\n  ((codePoint - 0x10000) % 0x400) + 0xdc00;\n\nenum ByteOrder {\n  BigEndian = 'BigEndian',\n  LittleEndian = 'LittleEndian',\n}\n\nconst REPLACEMENT = '�'.codePointAt(0)!;\n\n/**\n * Decodes a Uint8Array of data to a string using UTF-16.\n *\n * Note that this function attempts to recover from erronous input by\n * inserting the replacement character (�) to mark invalid code points\n * and surrogate pairs.\n *\n * @param input A Uint8Array containing UTF-16 encoded data\n * @param byteOrderMark Whether or not a byte order marker (BOM) should be read\n *                      at the start of the encoding. (default `true`)\n * @returns The decoded string.\n */\nexport const utf16Decode = (\n  input: Uint8Array,\n  byteOrderMark = true,\n): string => {\n  // Need at least 2 bytes of data in UTF-16 encodings\n  if (input.length <= 1) return String.fromCodePoint(REPLACEMENT);\n\n  const byteOrder = byteOrderMark ? readBOM(input) : ByteOrder.BigEndian;\n\n  // Skip byte order mark if needed\n  let idx = byteOrderMark ? 2 : 0;\n\n  const codePoints: number[] = [];\n\n  while (input.length - idx >= 2) {\n    const first = decodeValues(input[idx++], input[idx++], byteOrder);\n\n    if (isHighSurrogate(first)) {\n      if (input.length - idx < 2) {\n        // Need at least 2 bytes left for the low surrogate that is required\n        codePoints.push(REPLACEMENT);\n      } else {\n        const second = decodeValues(input[idx++], input[idx++], byteOrder);\n        if (isLowSurrogate(second)) {\n          codePoints.push(first, second);\n        } else {\n          // Low surrogates should always follow high surrogates\n          codePoints.push(REPLACEMENT);\n        }\n      }\n    } else if (isLowSurrogate(first)) {\n      // High surrogates should always come first since `decodeValues()`\n      // accounts for the byte ordering\n      idx += 2;\n      codePoints.push(REPLACEMENT);\n    } else {\n      codePoints.push(first);\n    }\n  }\n\n  // There shouldn't be extra byte(s) left over\n  if (idx < input.length) codePoints.push(REPLACEMENT);\n\n  return String.fromCodePoint(...codePoints);\n};\n\n/**\n * Returns `true` if the given `codePoint` is a high surrogate.\n * @param codePoint The code point to be evaluated.\n *\n * Reference: https://en.wikipedia.org/wiki/UTF-16#Description\n */\nconst isHighSurrogate = (codePoint: number) =>\n  codePoint >= 0xd800 && codePoint <= 0xdbff;\n\n/**\n * Returns `true` if the given `codePoint` is a low surrogate.\n * @param codePoint The code point to be evaluated.\n *\n * Reference: https://en.wikipedia.org/wiki/UTF-16#Description\n */\nconst isLowSurrogate = (codePoint: number) =>\n  codePoint >= 0xdc00 && codePoint <= 0xdfff;\n\n/**\n * Decodes the given utf-16 values first and second using the specified\n * byte order.\n * @param first The first byte of the encoding.\n * @param second The second byte of the encoding.\n * @param byteOrder The byte order of the encoding.\n * Reference: https://en.wikipedia.org/wiki/UTF-16#Examples\n */\nconst decodeValues = (first: number, second: number, byteOrder: ByteOrder) => {\n  // Append the binary representation of the preceding byte by shifting the\n  // first one 8 to the left and than applying a bitwise or-operator to append\n  // the second one.\n  if (byteOrder === ByteOrder.LittleEndian) return (second << 8) | first;\n  if (byteOrder === ByteOrder.BigEndian) return (first << 8) | second;\n  throw new Error(`Invalid byteOrder: ${byteOrder}`);\n};\n\n/**\n * Returns whether the given array contains a byte order mark for the\n * UTF-16BE or UTF-16LE encoding. If it has neither, BigEndian is assumed.\n *\n * Reference: https://en.wikipedia.org/wiki/Byte_order_mark#UTF-16\n *\n * @param bytes The byte array to be evaluated.\n */\n// prettier-ignore\nconst readBOM = (bytes: Uint8Array): ByteOrder => (\n    hasUtf16BigEndianBOM(bytes) ? ByteOrder.BigEndian\n  : hasUtf16LittleEndianBOM(bytes) ? ByteOrder.LittleEndian\n  : ByteOrder.BigEndian\n);\n\nconst hasUtf16BigEndianBOM = (bytes: Uint8Array) =>\n  bytes[0] === 0xfe && bytes[1] === 0xff;\n\nconst hasUtf16LittleEndianBOM = (bytes: Uint8Array) =>\n  bytes[0] === 0xff && bytes[1] === 0xfe;\n\nexport const hasUtf16BOM = (bytes: Uint8Array) =>\n  hasUtf16BigEndianBOM(bytes) || hasUtf16LittleEndianBOM(bytes);\n"],"names":["chars","lookup","Uint8Array","i","charCodeAt","encodeToBase64","bytes","base64","len","length","substring","decodeFromBase64","encoded1","encoded2","encoded3","encoded4","bufferLength","p","DATA_URI_PREFIX_REGEX","last","array","typedArrayFor","value","typedArray","idx","mergeIntoTypedArray","arrays","_i","arguments","arrayCount","typedArrays","element","totalSize","merged","offset","arrIdx","arr","byteIdx","arrLen","mergeUint8Arrays","mergedBuffer","set","arrayAsString","str","charFromCode","byAscendingId","a","b","id","sortedUniq","indexer","uniq","curr","prev","push","reverseArray","arrayLen","Math","floor","leftIdx","rightIdx","temp","sum","total","range","start","end","Array","pluckIndices","indices","plucked","canBeConvertedToUint8Array","input","ArrayBuffer","toUint8Array","dataUri","trimmedUri","trim","res","match","fullMatch","data","decodeFromBase64DataUri","TypeError","waitForTick","Promise","resolve","setTimeout","numberToString","num","e","numStr","String","abs","parseInt","toString","split","negative","pow","join","sizeInBytes","n","ceil","bytesFor","error","msg","Error","values","obj","Object","keys","map","k","StandardFontValues","FontNames","isStandardFont","includes","rectanglesAreEqual","x","y","width","height","backtick","val","formatValue","type","assertIsOneOf","valueName","allowedValues","isArray","objectValues","v","joinedValues","createValueErrorMsg","assertIsOneOfOrUndefined","concat","undefined","assertIsSubset","isType","isNaN","Date","Function","createTypeErrorMsg","types","allowedTypes","joinedTypes","constructor","name","assertIs","assertOrUndefined","assertEachIs","assertRange","min","max","assertRangeOrUndefined","assertMultiple","multiplier","assertInteger","Number","isInteger","assertPositive","sign","pdfDocEncodingToUnicode","Uint16Array","toCharCode","pdfDocEncodingDecode","codePoints","fromCodePoint","apply","Cache","populate","this","prototype","getValue","access","invalidate","populatedBy","PngType","PNG","pngData","upng","UPNG","decode","frames","toRGBA8","_a","rgbaChannel","pixelCount","rgbChannel","alphaChannel","rgbaOffset","rgbOffset","alphaOffset","splitAlphaChannel","some","ctype","Greyscale","Truecolour","IndexedColour","GreyscaleWithAlpha","TruecolourWithAlpha","getImageType","bitsPerComponent","load","SimpleRNG","seed","nextInt","sin","withSeed","character","toCodePoint","codePointAt","toHexStringOfMinLength","minLength","padStart","toUpperCase","toHexString","code","fromCharCode","charFromHexCode","hex","padChar","padding","copyStringIntoBuffer","buffer","cleanText","text","replace","escapedNewlineChars","isNewlineChar","test","lineSplit","mergeLines","charAtIndex","index","cuSecond","cuFirst","nextIndex","slice","charSplit","c","cLen","breakTextIntoLines","wordBreaks","maxWidth","computeWidthOfText","regex","newlineCharUnion","escapedRules","wordBreak","breakRules","RegExp","buildWordBreakRegex","words","currLine","currWidth","lines","pushCurrLine","word","dateRegex","parseDate","dateStr","year","month","_b","day","_c","hours","_d","mins","_e","secs","_f","offsetSign","_g","offsetHours","_h","findLastMatch","lastMatch","position","pos","ByteOrder","utf16Encode","byteOrderMark","encoded","codePoint","highSurrogate","lowSurrogate","isWithinBMP","hasSurrogates","REPLACEMENT","utf16Decode","byteOrder","readBOM","BigEndian","first","decodeValues","isHighSurrogate","second","isLowSurrogate","LittleEndian","hasUtf16BigEndianBOM","hasUtf16LittleEndianBOM","hasUtf16BOM"],"sourceRoot":""}