{"version":3,"file":"teddy.min.mjs","mappings":"8BACIA,EAA2B,CAAC,EAGhC,SAASC,EAAoBC,GAE5B,IAAIC,EAAeH,EAAyBE,GAC5C,QAAqBE,IAAjBD,EACH,OAAOA,EAAaE,QAGrB,IAAIC,EAASN,EAAyBE,GAAY,CAGjDG,QAAS,CAAC,GAOX,OAHAE,EAAoBL,GAAUI,EAAQA,EAAOD,QAASJ,GAG/CK,EAAOD,OACf,C,sBCrBO,SAASG,EAAMC,GACpB,MAAMC,EAoFR,SAAkCD,GAChC,MAAME,EAAkB,IAAIC,IAAI,CAAC,OAAQ,OAAQ,KAAM,MAAO,QAAS,KAAM,MAAO,QAAS,OAAQ,OAAQ,QAAS,SAAU,QAAS,QACnIC,EAAOC,SAASC,cAAc,QAC9BC,EAAM,CAACH,GACPI,EAAW,GACXC,EAAqB,gDACrBC,EAAY,mDAClB,IACIC,EADAC,EAAY,EAIhB,KAAmD,QAA3CD,EAAQF,EAAmBI,KAAKb,KAAiB,CACvD,IAAKO,EAAIA,EAAIO,OAAS,GAAI,MAAM,IAAIC,MAAM,sIAC1C,MAAMC,EAAkBhB,EAAKiB,MAAML,EAAWD,EAAMO,OAGpD,GAAIF,EAAgBG,OAAQ,CAC1B,MAAMC,EAAWf,SAASgB,eAAeL,GACzCT,EAAIA,EAAIO,OAAS,GAAGQ,YAAYF,EAClC,CAEA,GAAIT,EAAM,GAAGY,WAAW,WAAS,CAE/B,MAAMC,EAAcnB,SAASoB,cAAcd,EAAM,IACjDJ,EAAIA,EAAIO,OAAS,GAAGQ,YAAYE,EAClC,KAAO,CAEL,MAAOE,EAAWC,EAASC,GAAcjB,EACnCkB,EAAmBF,EAAQG,cAEjC,GADqBJ,EAAUH,WAAW,MAExC,GAAIrB,EAAgB6B,IAAIF,GAAmB,CAEzC,MAAMG,EAAU3B,SAASC,cAAcqB,GACvCpB,EAAIA,EAAIO,OAAS,GAAGQ,YAAYU,EAClC,MAEMxB,EAASM,OAAS,GAAKN,EAASA,EAASM,OAAS,KAAOe,IAC3DrB,EAASyB,MACT1B,EAAI0B,WAGH,CAEL,MAAMD,EAAU3B,SAASC,cAAcqB,GAGvC,IAAIO,EACJ,MAAMC,EAAU,IAAIC,IACpB,KAAoD,QAA5CF,EAAYxB,EAAUG,KAAKe,KAAuB,CACxD,MAAMS,EAAWH,EAAU,GACrBI,EAAYJ,EAAU,IAAMA,EAAU,IAAM,GAGlD,GAAIC,EAAQJ,IAAIM,GAAW,CACzB,IACIE,EADAC,EAAQ,EAEZ,GACED,EAAc,GAAGF,mBAA0BG,IAC3CA,UACOL,EAAQJ,IAAIQ,IACrBJ,EAAQM,IAAIF,EAAaD,EAC3B,MAAOH,EAAQM,IAAIJ,EAAUC,EAC/B,CAGA,IAAK,MAAOI,EAAMC,KAAUR,EAC1B,IAGE,OAAQN,GACN,IAAK,MACL,IAAK,QACL,IAAK,QACL,IAAK,SACL,IAAK,SACU,QAATa,EAAgBV,EAAQY,aAAa,4BAA6BD,GACjEX,EAAQY,aAAaF,EAAMC,GAAS,IACzC,MACF,IAAK,OACU,SAATD,EAAiBV,EAAQY,aAAa,6BAA8BD,GACnEX,EAAQY,aAAaF,EAAMC,GAAS,IACzC,MACF,QACEX,EAAQY,aAAaF,EAAMC,GAAS,IAE1C,CAAE,MAAOE,GACPC,QAAQC,KAAK,mIACf,CAIFxC,EAAIA,EAAIO,OAAS,GAAGQ,YAAYU,GAG3B9B,EAAgB6B,IAAIF,IAAsBH,EAAUsB,SAAS,QAChEzC,EAAI0C,KAAKjB,GACTxB,EAASyC,KAAKpB,GAElB,CACF,CAEAjB,EAAYH,EAAmBG,SACjC,CAGA,GAAIA,EAAYZ,EAAKc,OAAQ,CAC3B,MAAMoC,EAAgBlD,EAAKiB,MAAML,GACjC,GAAIsC,EAAc/B,OAAQ,CACxB,MAAMC,EAAWf,SAASgB,eAAe6B,GACzC3C,EAAIA,EAAIO,OAAS,GAAGQ,YAAYF,EAClC,CACF,CAEA,OAAOhB,CACT,CAvMc+C,CAAwBnD,GAI9BoD,EAAI,SAAUC,GAElB,GAAqB,iBAAVA,EAAoB,CAE7B,OADYpD,EAAIqD,iBAAiBD,EAEnC,CAGA,MAAME,EAAKF,EACX,MAAO,CAGLG,SAAU,WACR,OAAOD,EAAGE,UACZ,EAGAC,KAAM,SAAUC,GACd,OAAOJ,EAAGD,iBAAiBK,EAC7B,EAGA3D,KAAM,WACJ,OAAO4D,EAAqBL,EAC9B,EAGAM,SAAU,WACR,OAAOC,EAAqBP,EAC9B,EAGAQ,KAAM,SAAUA,EAAMC,GACpB,OAAOT,EAAGX,aAAamB,EAAMC,EAC/B,EAGAC,WAAY,SAAUF,GACpB,OAAOR,EAAGW,gBAAgBH,EAC5B,EAGAI,YAAa,SAAUnE,GAErB,GAAoB,iBAATA,EAAmB,CAC5B,IAAIoE,EAAU,GACd,IAAK,MAAMb,KAAMvD,EACXuD,EAAGc,WAAaC,OAAOC,KAAKC,aAAcJ,GAAW,UAASb,EAAGkB,YAAc,SAC9EL,GAAWb,EAAGmB,WAAanB,EAAGkB,YAErCzE,EAAOoE,CACT,CACA,MAAMO,EAAOtE,SAASC,cAAc,OACpCqE,EAAKC,UAAY5E,EACjBuD,EAAGY,eAAeQ,EAAKlB,WACzB,EAGAoB,OAAQ,WACN,OAAOtB,EAAGsB,QACZ,EAEJ,EAYA,OATAzB,EAAEpD,KAAO,WACP,OAAO4D,EAAqB3D,EAC9B,EAGAmD,EAAES,SAAW,WACX,OAAOC,EAAqB7D,EAC9B,EAEOmD,CACT,CAEArD,EAAK+E,mBAAoB,EAyHzB,MAQMC,EAAgBC,OAAOC,QARC,CAC5B,YAAa,QACb,WAAY,OACZ,WAAY,OACZ,aAAc,SACd,YAAa,QACb,aAAc,WAGhB,SAASrB,EAAsBsB,GAE7B,IAAIlF,EAAO,GACX,IAAK,MAAMmF,KAASD,EAAKzB,WACvB,GAAI0B,EAAMd,WAAaC,OAAOC,KAAKa,aAAc,CAC/C,IAAIV,EAAYS,EAAMT,UACtB,IAAK,MAAOW,EAAeC,KAAkBP,EAAeL,EAAYA,EAAUa,QAAQ,IAAIC,OAAOH,EAAe,KAAMC,GAC1HtF,GAAQ0E,CACV,MAAO,GAAIS,EAAMd,WAAaC,OAAOC,KAAKkB,UAAW,CACnD,IAAIhB,EAAcU,EAAMV,YACxB,IAAK,MAAOY,EAAeC,KAAkBP,EAAeN,EAAcA,EAAYc,QAAQ,IAAIC,OAAOH,EAAe,KAAMC,GAC9HtF,GAAQyE,CACV,MAAO,GAAIU,EAAMd,WAAaC,OAAOC,KAAKC,aAAc,CACtD,IAAIkB,EAAiBP,EAAMV,YAC3B,IAAK,MAAOY,EAAeC,KAAkBP,EAAeW,EAAiBA,EAAeH,QAAQ,IAAIC,OAAOH,EAAe,KAAMC,GACpItF,GAAQ,UAAO0F,SACjB,CAGF,OAAO1F,CACT,CACA,SAAS8D,EAAsBoB,GAE7B,IAAIR,EAAY,GAEZQ,EAAKb,WAAaC,OAAOC,KAAKa,aAChCV,EAAYQ,EAAKR,UACRQ,EAAKb,WAAaC,OAAOC,KAAKkB,UACvCf,EAAYQ,EAAKT,YACRS,EAAKb,WAAaC,OAAOC,KAAKC,eACvCE,EAAY,UAAOQ,EAAKT,qBAI1B,IAAK,MAAOY,EAAeC,KAAkBP,EAAeL,EAAYA,EAAUa,QAAQ,IAAIC,OAAOH,EAAe,KAAMC,GAE1H,OAAOZ,CACT,CCpPA,MACMiB,EAAU,EAAYb,kBACtBc,EAAS,CAAC,EAChBC,IACA,IAAIC,EAAY,CAAC,EACjB,MAAMC,EAAS,CAAC,EACVC,EAAiB,CAAC,EAOxB,SAASC,EAAcC,GAErB,GAAwB,iBAAbA,EAET,OADIN,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,0EAChC,GAET,MAAML,EAAOwD,EACb,IAAIE,GAAW,EACf,IAAKN,EAAUI,KAAwC,IAA3BA,EAASG,QAAQ,MAAe,GAAM,eAAiB,CAEjFD,GAAW,EAEgB,UAAvBF,EAASjF,OAAO,KAAgBiF,GAAY,SAChD,IACEA,EAAW,eAAgBA,EAAU,OACvC,CAAE,MAAOrD,GACP,IACEqD,EAAW,eAAgBN,EAAOU,aAAeJ,EAAU,OAC7D,CAAE,MAAOrD,GACP,IACEqD,EAAW,eAAgBN,EAAOU,aAAe,IAAMJ,EAAU,OACnE,CAAE,MAAOrD,GAEPuD,GAAW,CACb,CACF,CACF,CACF,MACMN,EAAUI,IACZA,EAAWJ,EAAUI,GACrBE,GAAW,IAGgB,UAAvBF,EAASjF,OAAO,KAClBiF,GAAY,SAEVJ,EAAUI,KACZA,EAAWJ,EAAUI,GACrBE,GAAW,GAEbF,EAAWK,EAAoBL,IAGnC,OAAIE,GAEFF,EAAWK,EAAoBL,GAC/BJ,EAAUpD,GAAQwD,EACXA,GAGuB,UAAvBA,EAASjF,OAAO,GAAiBiF,EAASM,UAAU,EAAGN,EAASpF,OAAS,GAAKoF,CAEzF,CAGA,SAASK,EAAqBE,GAC5B,IAAIC,EACJ,EAAG,CAED,IAAIC,EAkBAC,EAnBJF,EAAcD,EAId,IACEE,EAAOE,EAAiBJ,EAAkB,KAAM,KAClD,CAAE,MAAO5D,GACP,OAAO4D,CACT,CACA,IAAK,IAAIK,EAAI,EAAGA,EAAIH,EAAK7F,OAAQgG,IAAKL,EAAmBA,EAAiBlB,QAAQ,KAAKoB,EAAKG,OAAQ,IAEpG,IACEH,EAAOE,EAAiBJ,EAAkB,WAAS,SACrD,CAAE,MAAO5D,GACP,OAAO4D,CACT,CACA,IAAK,IAAIK,EAAI,EAAGA,EAAIH,EAAK7F,OAAQgG,IAAKL,EAAmBA,EAAiBlB,QAAQ,WAAQoB,EAAKG,WAAS,IAIxG,IACEF,EAAaG,EAA0BN,EAAkB,CAAC,CAAC,WAAS,UAAQ,CAAC,WAAY,cAC3F,CAAE,MAAO5D,GACP,OAAO4D,CACT,CACA,IAAIO,EAAaJ,EACbA,IACEA,EAAWrF,WAAW,aACxByF,EAAaA,EAAWR,UAAU,EAAGQ,EAAWlG,OAAS,GAAGG,MAAM,GAClEwF,EAAmBA,EAAiBlB,QAAQqB,EAAYK,EAAeD,EAAW7F,WAElF6F,EAAaA,EAAWR,UAAU,EAAGQ,EAAWlG,OAAS,GAAGG,MAAM,GAClEwF,EAAmBA,EAAiBlB,QAAQqB,EAAYK,EAAeD,EAAW7F,UAGxF,OAASuF,IAAgBD,GACzB,OAAOA,CACT,CAGA,SAASS,EAAsB3G,EAAK4G,GAClC,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,sBACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CACjB1B,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,MAAMb,EAAOa,EAAG+D,QAAQ5E,KACxB,GAAIA,EAAK8E,SAAS,KAAM,SACxB,MAAMC,EAAMlE,EAAG+D,QAAQG,KAAO,OAC9B,GAAIA,EAAID,SAAS,KAAM,SACvB,MAAME,EAAQ3B,EAAOrD,GACrB,GAAIgF,GAASA,EAAMzC,QAAS,CAC1B,MAAM0C,EAASpE,EAAG+D,QAAQG,IAAMG,EAA4BT,EAAOM,GAAO,OAC1E,GAAIC,EAAMzC,QAAQ0C,GAAS,CACzB,MAAME,EAAMC,KAAKD,MAGjB,IAAMH,EAAMK,QAAWL,EAAMM,QAAWN,EAAMzC,QAAQ0C,GAAQM,cAAgBP,EAAMK,QAAUL,EAAMM,QAAUH,EAAK,CACjH,MAAMK,EAAeR,EAAMzC,QAAQ0C,GAAQQ,OAC3CT,EAAMzC,QAAQ0C,GAAQM,aAAeJ,EACrCtH,EAAIgD,GAAIY,YAAY+D,EACtB,aAESnC,EAAOrD,GAAMuC,QAAQ0C,GAC5BpH,EAAIgD,GAAIQ,KAAK,QAAS,OAE1B,MAAOxD,EAAIgD,GAAIQ,KAAK,QAAS,OAC/B,MAAOxD,EAAIgD,GAAIQ,KAAK,QAAS,QAC7BqD,GACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CAGA,SAAS6H,EAAkB7H,EAAK4G,GAC9B,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,IAAIC,EAAO9G,EAAI,wCACf,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CACrB,MAAMgB,EAAKlB,EAAMmB,eAAerF,KAAK1C,EAAIgD,GAAIvD,QAAU,EACvDO,EAAIgD,GAAIY,YAAY,gBAAgBkE,iBACpCjB,GACF,CAGF,GADAC,EAAO9G,EAAI,8BACP8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CACrB,MAAMgB,EAAKlB,EAAMmB,eAAerF,KAAK1C,EAAIgD,GAAIM,YAAc,EAC3DtD,EAAIgD,GAAIY,YAAY,gBAAgBkE,4BACpCjB,GACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CAGA,SAASgI,EAAehI,EAAK4G,EAAOqB,GAClC,IAAIpB,EACAqB,EAAS,EACb,EAAG,CAED,GADAA,IACIA,EAAS7C,EAAO8C,UAAW,MAAM,IAAI3H,MAAM,qGAAqG6E,EAAO8C,kFAE3J,IAAIrB,EAIJ,GALAD,EAAa,EAGAC,EAAO9G,EAAhBiI,EAAoB,UACR,8CACZnB,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CAErB,IAAIsB,GAAY,EACZC,GAAO,EACPC,EAAStF,EAAGsF,QAAUtF,EAAGuF,WAC7B,MAAQH,GAAW,CACjB,IAAII,EAGJ,GADKA,EADAF,EACaA,EAAOG,UAAUlH,eAAiB+G,EAAOnG,KADjC,OAEP,YAAfqG,GAA2C,YAAfA,EAA0B,CACxDH,GAAO,EACP,KACF,CAA0B,SAAfG,EAAuBJ,GAAY,EACzCE,EAASA,EAAOA,QAAUA,EAAOC,UACxC,CACA,GAAIF,EAAM,SAENjD,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,MAAM0F,EAAM1F,EAAG+D,QAAQ2B,IACvB,IAAKA,EAAK,CACJrD,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,2DACvC,QACF,CACA,GAAIkG,EAAI1H,WAAW,KAAM,CACvBhB,EAAIgD,GAAIQ,KAAK,8BAA+B,QAC5C,QACF,CACAkC,EAAagD,GACb,IAAIC,EAAWpD,EAAUmD,IAAQ,GACH,iBAAnBnD,EAAUmD,IAAwD,YAAnCrD,EAAOuD,0BAC/CD,EAAW,aAAaD,gBACpBrD,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,0FAA0FkG,MAEnI,MAAMG,EAAapE,OAAOqE,OAAO,CAAC,EAAGlC,GACrC,IAAK,MAAMmC,KAAO/I,EAAIgD,GAAIC,WAAY,CAEpC,GAAgB,SADAmC,EAAU2D,EAAIN,UAAUlH,cAAgBwH,EAAI5G,MACrC,CACjBiD,IAAS2D,EAAIhC,QAAUC,EAAW+B,IAEtC1B,EAA4BwB,EADbpE,OAAOuE,KAAKD,EAAIhC,SAAS,GACQ/G,EAAI+I,GAAKtJ,OAC3D,CACF,CACA,MAAMwJ,EAAaN,EAAS1B,SAAS,cAC/BiC,EAAaP,EAAS1B,SAAS,cAC/BkC,EAASR,EAAS1B,SAAS,UAC3BmC,EAAQT,EAAS1B,SAAS,SAC1BoC,EAAYV,EAAS1B,SAAS,aAC9BqC,EAAUX,EAAS1B,SAAS,UAC5BsC,EAAWZ,EAAS1B,SAAS,WAC7BuC,EAAUb,EAAS1B,SAAS,WAC5BwC,EAAYd,EAAS1B,SAAS,aAC9ByC,EAAcf,EAAS1B,SAAS,qBAAuB0B,EAAS1B,SAAS,mBAC/E,IAAI0C,GACAV,GAAcC,GAAcC,KAC9BQ,EAAW,EAAYhB,GACvBgB,EAAW9B,EAAiB8B,EAAUd,GACtCF,EAAWgB,EAASlK,QAEtBkK,EAAW,EAAYC,EAAUjB,EAAUE,KACvCO,GAASC,KAAWM,EAAWE,EAAkBF,EAAUd,KAC3DS,GAAWC,KAAUI,EAAWG,EAAyBH,EAAUd,IACnEW,IAASG,EAAWI,EAAWJ,EAAUd,IACzCY,IAAWE,EAAWK,EAAaL,EAAUd,IAC7Ca,IAAaC,EAAWM,EAA6BN,EAAUd,IACnE7I,EAAIgD,GAAIY,YAAY+F,EAASlK,QAC7BoH,GACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CAGA,SAAS6J,EAAmB7J,EAAK4G,GAC/B,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,cACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CAErB,IAAIsB,GAAY,EACZC,GAAO,EACPC,EAAStF,EAAGsF,QAAUtF,EAAGuF,WAC7B,MAAQH,GAAW,CACjB,IAAII,EAGJ,GADKA,EADAF,EACaA,EAAOG,UAAUlH,eAAiB+G,EAAOnG,KADjC,OAEP,SAAfqG,GAAwC,YAAfA,GAA2C,YAAfA,EAA0B,CACjFH,GAAO,EACP,KACF,CAA0B,SAAfG,EAAuBJ,GAAY,EACzCE,EAASA,EAAOA,QAAUA,EAAOC,UACxC,CACA,GAAIF,EAAM,SAEV,IAAI6B,EAAO,GACP9E,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,IAAK,IAAIQ,KAAQR,EAAG+D,QAAS,CACvBvD,EAAKyD,SAAS,qBAAoBzD,EAAOA,EAAK2G,MAAM,mBAAmB,IAC3E,IAAI1G,EAAMT,EAAG+D,QAAQvD,GACjBC,GACEA,EAAIzC,WAAW,OAAMyC,EAAMmG,EAAUnG,EAAKmD,IAC9CsD,EAAKxH,KAAK,GAAGc,KAAQC,MAChByG,EAAKxH,KAAKc,EACnB,CAEA,IAAI4G,GAAO,EAEI,YADAhF,EAAUpC,EAAGyF,UAAUlH,cAAgByB,EAAGb,QAChCiI,GAAO,GAEhC,MAAMC,EAAaC,EAAoBJ,EAAMtD,GAC7C,GAAKwD,GAAQC,IAAkBD,IAASC,EAAc,CAEpD,IAAIE,EAAcvH,EAAGuH,YACrB,MAAMC,EAAc,GACpB,KAAOD,GAAa,CAElB,OADwBnF,EAAUmF,EAAY9B,UAAUlH,cAAgBgJ,EAAYpI,MAElF,IAAK,SACL,IAAK,aACL,IAAK,OACHqI,EAAY9H,KAAK6H,GACjBA,EAAcA,EAAYA,YAC1B,MACF,IAAK,KACL,IAAK,SACHA,GAAc,EACd,MACF,QACEA,EAAcA,EAAYA,YAEhC,CACA,IAAK,MAAM9I,KAAW+I,EAAaxK,EAAIyB,GAASmC,YAAY,IAC5D5D,EAAIgD,GAAIY,YAAYZ,EAAGE,YAAcF,EAAGC,UACxC4D,GACF,KAAO,CAEL,IAAI0D,EAAcvH,EAAGuH,YACrB,KAAOA,GAAa,CAElB,OADwBnF,EAAUmF,EAAY9B,UAAUlH,cAAgBgJ,EAAYpI,MAElF,IAAK,SAEH+H,EAAO,GACH9E,IAASmF,EAAYxD,QAAUC,EAAWuD,IAC9C,IAAK,MAAM/G,KAAQ+G,EAAYxD,QAAS,CACtC,MAAMtD,EAAM8G,EAAYxD,QAAQvD,GAC5BC,EAAKyG,EAAKxH,KAAK,GAAGc,KAAQC,KACzByG,EAAKxH,KAAKc,EACjB,CACA,GAAI8G,EAAoBJ,EAAMtD,GAAQ,CAEpC,MAAM6D,EAAiBF,EACvBvK,EAAIyK,GAAgB7G,YAAY6G,EAAevH,YAAcuH,EAAexH,UAC5EsH,EAAcvH,EAAGuH,YACjB,MAAMC,EAAc,GACpB,KAAOD,GAAa,CAElB,OADwBnF,EAAUmF,EAAY9B,UAAUlH,cAAgBgJ,EAAYpI,MAElF,IAAK,SACL,IAAK,aACL,IAAK,OACHqI,EAAY9H,KAAK6H,GACjBA,EAAcA,EAAYA,YAC1B,MACF,IAAK,KACL,IAAK,SACHA,GAAc,EACd,MACF,QACEA,EAAcA,EAAYA,YAEhC,CACA,IAAK,MAAM9I,KAAW+I,EAAaxK,EAAIyB,GAASmC,YAAY,IAC5D2G,GAAc,EACd1D,GACF,KAAO,CAEL,MAAM6D,EAAgBH,EACtBA,EAAcA,EAAYA,YAC1BvK,EAAI0K,GAAe9G,YAAY,GACjC,CACA,MACF,IAAK,aAEHsG,EAAO,GACH9E,IAASmF,EAAYxD,QAAUC,EAAWuD,IAC9C,IAAK,MAAM/G,KAAQ+G,EAAYxD,QAAS,CACtC,MAAMtD,EAAM8G,EAAYxD,QAAQvD,GAC5BC,EAAKyG,EAAKxH,KAAK,GAAGc,KAAQC,KACzByG,EAAKxH,KAAKc,EACjB,CACA,GAAK8G,EAAoBJ,EAAMtD,GA0BxB,CAEL,MAAM8D,EAAgBH,EACtBA,EAAcA,EAAYA,YAC1BvK,EAAI0K,GAAe9G,YAAY,GACjC,KA/BuC,CAErC,MAAM6G,EAAiBF,EACvBvK,EAAIyK,GAAgB7G,YAAY6G,EAAevH,YAAcuH,EAAexH,UAC5EsH,EAAcvH,EAAGuH,YACjB,MAAMC,EAAc,GACpB,KAAOD,GAAa,CAElB,OADwBnF,EAAUmF,EAAY9B,UAAUlH,cAAgBgJ,EAAYpI,MAElF,IAAK,SACL,IAAK,aACL,IAAK,OACHqI,EAAY9H,KAAK6H,GACjBA,EAAcA,EAAYA,YAC1B,MACF,IAAK,KACL,IAAK,SACHA,GAAc,EACd,MACF,QACEA,EAAcA,EAAYA,YAEhC,CACA,IAAK,MAAM9I,KAAW+I,EAAaxK,EAAIyB,GAASmC,YAAY,IAC5D2G,GAAc,EACd1D,GACF,CAMA,MACF,IAAK,OAEH7G,EAAIuK,GAAa3G,YAAY2G,EAAYrH,YAAcqH,EAAYtH,UACnEsH,GAAc,EACd1D,IACA,MACF,IAAK,KACL,IAAK,SAEH0D,GAAc,EACd,MACF,QAEEA,EAAcA,EAAYA,YAEhC,CACAvK,EAAIgD,GAAIY,YAAY,GACtB,CACF,CAEJ,OAASiD,GACT,OAAO7G,CACT,CAGA,SAASsK,EAAqBK,EAAY/D,GACxC,MAAMgE,EAAmBD,EAAWpK,OAEpC,IAAK,IAAIgG,EAAI,EAAGA,EAAIqE,EAAkBrE,IAAK,CACzC,MAAMsE,EAAYF,EAAWpE,GAC7B,GAAyB,kBAAdsE,EAAX,CAEA,GAAIA,EAAU7J,WAAW,MAAQ6J,EAAUpI,SAAS,KAElD,OADI4C,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,+FAChC,EAET,GAAIqI,EAAU5D,SAAS,OAAS4D,EAAU7J,WAAW,QAEnD,OADIqE,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,yGAChC,EAGS,QAAdqI,EACEF,EAAWpE,EAAI,IAAMuE,EAAkBH,EAAWpE,EAAI,GAAIK,IAE5D+D,EAAWpE,EAAI,IAAK,EACpBoE,EAAWpE,IAAK,EAChBoE,EAAWpE,EAAI,IAAK,IAGpBoE,EAAWpE,EAAI,IAAK,EACpBoE,EAAWpE,IAAK,EAChBoE,EAAWpE,EAAI,IAAK,GAEC,OAAdsE,EACLF,EAAWpE,EAAI,IAAMuE,EAAkBH,EAAWpE,EAAI,GAAIK,GAE5D+D,EAAWI,MAAK,EAAM,EAAGxE,EAAI,IAG7BoE,EAAWpE,EAAI,IAAK,EACpBoE,EAAWpE,IAAK,EAChBoE,EAAWpE,EAAI,IAAK,GAEC,QAAdsE,IACHF,EAAWpE,EAAI,MAASuE,EAAkBH,EAAWpE,EAAI,GAAIK,IAEjE+D,EAAWpE,EAAI,IAAK,EACpBoE,EAAWpE,IAAK,EAChBoE,EAAWpE,EAAI,IAAK,IAGpBoE,EAAWpE,EAAI,IAAK,EACpBoE,EAAWpE,IAAK,EAChBoE,EAAWpE,EAAI,IAAK,GAEjBoE,EAAWpE,GAAKuE,EAAkBD,EAAWjE,EA7ChB,CA8CtC,CACA,OAAO+D,EAAWK,OAAMC,IAAiB,IAATA,MAAkB,CACpD,CAGA,SAASH,EAAmBD,EAAWjE,GACrC,IAAIsE,EACJ,GAAyB,iBAAdL,GAA0BA,EAAU5D,SAAS,KAAM,CAC5DiE,IAAQL,EAAU7J,WAAW,QACzBkK,IAAKL,EAAYA,EAAUnK,MAAM,IACrC,MAAMyK,EAAQN,EAAUV,MAAM,KACxBiB,EAAOD,EAAM,UACZA,EAAM,GACb,MAAM1H,EAAM0H,EAAME,KAAK,IAGvB,OAFehE,EAA4BT,EAAOwE,IAEpC3H,GAAayH,EACfA,CACd,CAAO,CACLA,EAA2B,iBAAdL,KAA2BA,EAAU7J,WAAW,QACzDkK,IAAKL,EAAYA,EAAUnK,MAAM,IACrC,MAAM4K,EAASjE,EAA4BT,EAAOiE,GAClD,OAAIS,EACoB,iBAAXA,GAAsD,IAA/B7G,OAAOuE,KAAKsC,GAAQ/K,OAAqB2K,GACnEA,EACIA,CAChB,CACF,CAGA,SAASpB,EAA0B9J,EAAK4G,GACtC,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,mBACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CAErB,IAAIyE,GAAQ,EACRnG,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,IAAK,MAAMQ,KAAQR,EAAG+D,QAAS,CAE7B,GADY/D,EAAG+D,QAAQvD,GACfxC,WAAW,KAAM,CACvBuK,GAAQ,EACR,KACF,CACF,CACA,GAAIA,EAAO,CACTvL,EAAIgD,GAAIQ,KAAK,kCAAmC,QAChD,QACF,CAEA,IAeIgI,EACAC,EAhBArD,GAAY,EACZC,GAAO,EACPC,EAAStF,EAAGsF,QAAUtF,EAAGuF,WAC7B,MAAQH,GAAW,CACjB,IAAII,EAGJ,GADKA,EADAF,EACaA,EAAOG,UAAUlH,eAAiB+G,EAAOnG,KADjC,OAEP,SAAfqG,GAAwC,YAAfA,GAA2C,YAAfA,EAA0B,CACjFH,GAAO,EACP,KACF,CAA0B,SAAfG,EAAuBJ,GAAY,EACzCE,EAASA,EAAOA,QAAUA,EAAOC,UACxC,CACA,GAAIF,EAAM,SAINjD,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,MAAMkH,EAAO,GACb,IAAK,MAAMwB,KAAY1I,EAAG+D,QAAS,CACjC,IAAIvD,EAAOkI,EACPjI,EAAMT,EAAG+D,QAAQvD,GAGrB,GAFIA,EAAKyD,SAAS,qBAAoBzD,EAAOA,EAAK2G,MAAM,mBAAmB,IACvE1G,GAAKzC,WAAW,OAAMyC,EAAMmG,EAAUnG,EAAKmD,IAC3CpD,EAAKxC,WAAW,OAAQ,CAC1B,MAAMmK,EAAQ3H,EAAK2G,MAAM,OACrB1G,EAAKyG,EAAKxH,KAAK,GAAGyI,EAAM,MAAM1H,KAC7ByG,EAAKxH,KAAKyI,EAAM,IACrBnL,EAAIgD,GAAIU,WAAWgI,EACrB,KAAoB,SAATlI,GACTgI,EAAS/H,EAAIkI,WAAW,SAAU,KAClC3L,EAAIgD,GAAIU,WAAWgI,IACD,UAATlI,GACTiI,EAAUhI,EAAIkI,WAAW,SAAU,KACnC3L,EAAIgD,GAAIU,WAAWgI,IACD,QAATlI,GAA2B,OAATA,GAA0B,QAATA,IAC5C0G,EAAKxH,KAAKc,GACVxD,EAAIgD,GAAIU,WAAWgI,GAEvB,CAEA,GAAIpB,EAAoBJ,EAAMtD,GAAQ,CACpC,GAAI4E,EAAQ,CACV,MAAML,EAAQK,EAAOrB,MAAM,KAC3BnK,EAAIgD,GAAIQ,KAAK2H,EAAM,GAAIA,EAAM,GAAKA,EAAM,GAAGnG,QAAQ,QAAS,IAAM,GACpE,CACA6B,GACF,MAAO,GAAI4E,EAAS,CAClB,GAAIA,EAAS,CACX,MAAMN,EAAQM,EAAQtB,MAAM,KAC5BnK,EAAIgD,GAAIQ,KAAK2H,EAAM,GAAIA,EAAM,GAAKA,EAAM,GAAGnG,QAAQ,QAAS,IAAM,GACpE,CACA6B,GACF,CACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CAGA,SAAS+J,EAAY/J,EAAK4G,GACxB,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,QACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CAErB,IAAI8E,EACAC,EACAC,EACA1G,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,IAAK,MAAMQ,KAAQR,EAAG+D,QACpB,GAAa,YAATvD,EAAoB,CACtB,IAAIuI,EAAU/I,EAAG+D,QAAQvD,GACrBuI,EAAQ/K,WAAW,OAAM+K,EAAUnC,EAAUmC,EAASnF,IAC1DgF,EAAcvE,EAA4BT,EAAOmF,EACnD,KAAoB,QAATvI,EAAgBqI,EAAU7I,EAAG+D,QAAQvD,GAC9B,QAATA,IAAgBsI,EAAU9I,EAAG+D,QAAQvD,IAGhD,IAAKoI,EAAa,CACZvG,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,yDACvCxC,EAAIgD,GAAIY,YAAY,IACpB,QACF,CACA,IAAKiI,IAAYC,EAAS,CACpBzG,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,8DACvCxC,EAAIgD,GAAIY,YAAY,IACpB,QACF,CAEA,IAAIoI,EAAY,GACZC,EAAejM,EAAIgD,GAAIvD,OACvBmM,aAAuBhM,MAAKgM,EAAc,IAAIA,IAClD,IAAK,MAAM1E,KAAO0E,EAAa,CAC7B,MAAMnI,EAAMmI,EAAY1E,GAClB2B,EAAapE,OAAOqE,OAAO,CAAC,EAAGlC,GACrCS,EAA4BwB,EAAYgD,EAAS3E,GACjDG,EAA4BwB,EAAYiD,EAASrI,GACjD,MAAMyI,EAAyBD,EAAahF,SAAS,cAC/CkF,EAAyBF,EAAahF,SAAS,cAC/CmF,EAAqBH,EAAahF,SAAS,UACjD,GAAIiF,GAA0BC,GAA0BC,EAAoB,CAC1E,IAAIzC,EAAW,EAAYsC,GAC3BtC,EAAW9B,EAAiB8B,EAAUd,GACtCoD,EAAetC,EAASlK,MAC1B,CACA,MAAM4M,EAAczC,EAAUqC,EAAcpD,IAAe,GACrDI,EAAaoD,EAAYpF,SAAS,cAClCiC,EAAamD,EAAYpF,SAAS,cAClCmC,EAAQiD,EAAYpF,SAAS,SAC7BoC,EAAYgD,EAAYpF,SAAS,aACjCqC,EAAU+C,EAAYpF,SAAS,UAC/BsC,EAAW8C,EAAYpF,SAAS,WAChCuC,EAAU6C,EAAYpF,SAAS,WAC/BwC,EAAY4C,EAAYpF,SAAS,aACjCyC,EAAc2C,EAAYpF,SAAS,qBAAuBoF,EAAYpF,SAAS,mBACrF,IAAI0C,EAAW,EAAY0C,GAAe,KACtCpD,GAAcC,KAAYS,EAAW9B,EAAiB8B,EAAUd,KAChEO,GAASC,KAAWM,EAAWE,EAAkBF,EAAUd,KAC3DS,GAAWC,KAAUI,EAAWG,EAAyBH,EAAUd,IACnEW,IAASG,EAAWI,EAAWJ,EAAUd,IACzCY,IAAWE,EAAWK,EAAaL,EAAUd,IAC7Ca,IAAaC,EAAWM,EAA6BN,EAAUd,IACnEmD,GAAarC,EAASlK,MACxB,CACA,MAAM6M,EAAS,EAAYN,GAAa,IACxChM,EAAIgD,GAAIY,YAAY0I,EAAO7M,QAC3BoH,GACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CAGA,SAASgK,EAAchK,EAAK4G,GAC1B,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,UACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CAErB,IAAIyF,EACAC,EACApH,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,IAAK,MAAMQ,KAAQR,EAAG+D,QACP,QAATvD,EAAgB+I,EAAMlF,EAA4BT,EAAO5D,EAAG+D,QAAQvD,IACtD,OAATA,IAAegJ,EAAKnF,EAA4BT,EAAO5D,EAAG+D,QAAQvD,KAG7E,IAAK+I,IAAQC,EAAI,CACXnH,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,wEACvCxC,EAAIgD,GAAIY,YAAY,IACpB,QACF,CACA,IAAIA,EAAc,GACTA,EAAL2I,EAAmB,UAAUA,YACd,WAAWC,cAC9BxM,EAAIgD,GAAIY,YAAYA,GACpBiD,GACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CAGA,SAASiK,EAA8BjK,EAAK4G,GAC1C,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,2CACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CAEjB1B,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,IAAK,IAAIQ,KAAQR,EAAG+D,QAAS,CAC3B,MAAM2E,EAAWlI,EAEjB,GADIA,EAAKyD,SAAS,qBAAoBzD,EAAOA,EAAK2G,MAAM,mBAAmB,IAC9D,mBAAT3G,EAA2B,CAC7B,MAAMC,EAAMmG,EAAU5G,EAAG+D,QAAQ2E,GAAW9E,IAAU5D,EAAG+D,QAAQ2E,GAC3DzI,EAAWjD,EAAIgD,GAAIG,KAAK,iBAC9B,IAAK,MAAMsJ,KAAOxJ,EACZmC,IAASqH,EAAI1F,QAAUC,EAAWyF,IAClCA,EAAI1F,QAAQ3E,QAAUqB,GAAKzD,EAAIyM,GAAKjJ,KAAK,WAAY,YAE3DxD,EAAIgD,GAAIU,WAAWgI,EACrB,MAAO,GAAa,kBAATlI,EAA0B,CACnC,MAAMC,EAAMmG,EAAU5G,EAAG+D,QAAQ2E,GAAW9E,IAAU5D,EAAG+D,QAAQ2E,GAC3DzI,EAAWjD,EAAIgD,GAAIG,KAAK,6DAC9B,IAAK,MAAMsJ,KAAOxJ,EACZmC,IAASqH,EAAI1F,QAAUC,EAAWyF,IAClCA,EAAI1F,QAAQ3E,QAAUqB,GAAKzD,EAAIyM,GAAKjJ,KAAK,UAAW,WAE1DxD,EAAIgD,GAAIU,WAAWgI,EACrB,CACF,CACA7E,GACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CAGA,SAAS4J,EAAW8C,EAAgB9F,GAClC,IAAIR,EACJ,IACEA,EAAOE,EAAiBoG,EAAgB,IAAK,IAC/C,CAAE,MAAOpK,GACP,OAAOoK,CACT,CACA,IAAK,IAAInG,EAAI,EAAGA,EAAIH,EAAK7F,OAAQgG,IAAK,CACpC,IAAInG,EAAQgG,EAAKG,GACjB,GAAc,KAAVnG,EAAc,SAClB,IAAK,0EAA0EuM,KAAKvM,GAAQ,CACtFiF,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,uEAAuEpC,MAC9G,QACF,CACA,GAAIA,EAAM6G,SAAS,KAAM,CAEvB,MAAM2F,EAAgBxM,EACtBA,EAAQwJ,EAAUxJ,EAAOwG,GACzB,IAEE8F,GADAA,EAAiBA,EAAe1H,QAAQ,IAAIC,OAAO,MAAM2H,KAAkB,MAAM,IAAM,MAAMxM,QAC7D4E,QAAQ,IAAIC,OAAO,IAAI2H,KAAkB,MAAM,IAAM,IAAIxM,MAC3F,CAAE,MAAOkC,GACH+C,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,uEAAuEoK,KAChH,CACF,CACA,MAAMC,EAAezM,EAAMM,OAAO,GAClC,GAAImM,EAAa5F,SAAS,MAAO,CAC/B,MAAM2F,EAAgBxM,EACtBA,EAAQA,EAAM6F,UAAU,EAAG7F,EAAMG,OAAgD,GAAtCsM,EAAa1C,MAAM,KAAK5J,OAAS,IAC5E,IAAIuM,EAASzF,EAA4BT,EAAOxG,GAGhD,GAFK0M,GAAWD,EAAa5F,SAAS,OAAsC,SAA5B5B,EAAO0H,mBAA+BF,EAAa5F,SAAS,QAAQ6F,EAAS,IACvG,iBAAXA,GAAuBA,EAAO9L,WAAW,MAAQ8L,EAAO7F,SAAS,QAAO6F,EAASA,EAAO9H,QAAQ,KAAM,KAC7G8H,GAAqB,KAAXA,EAAe,CAC3B,MAAMhF,EAAKlB,EAAMmB,eAAerF,KAAKoK,GAAU,EAC/C,IACE,IAEEJ,GADAA,EAAiBA,EAAe1H,QAAQ,IAAIC,OAAO,MAAM2H,KAAiB5H,QAAQ,sBAAuB,QAAQA,QAAQ,KAAM,SAAU,KAAM,gBAAgB8C,kBAC/H9C,QAAQ,IAAIC,OAAO,IAAI2H,KAAiB5H,QAAQ,sBAAuB,QAAQA,QAAQ,KAAM,SAAU,KAAM,gBAAgB8C,gBAC/J,CAAE,MAAOxF,GACH+C,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,uEAAuEoK,KAChH,CACF,CAAE,MAAOtK,GACP,OAAOoK,CACT,CACF,CACF,MAAO,GAAIG,EAAa5F,SAAS,MAAO,CACtC,MAAM2F,EAAgBxM,EACtBA,EAAQA,EAAM6F,UAAU,EAAG7F,EAAMG,OAAgD,GAAtCsM,EAAa1C,MAAM,KAAK5J,OAAS,IAC5E,IAAIuM,EAASzF,EAA4BT,EAAOxG,GAC5C4M,GAAiC,EAChCF,GAAWD,EAAa5F,SAAS,OAAsC,SAA5B5B,EAAO0H,mBAA+BF,EAAa5F,SAAS,MAClG6F,GAAqB,KAAXA,IAClBE,GAAiC,EACjCF,EAAS,IAAIF,MAHqGE,EAAS,GAKvG,iBAAXA,GAAuBA,EAAO9L,WAAW,MAAQ8L,EAAO7F,SAAS,QAAO6F,EAASA,EAAO9H,QAAQ,KAAM,KACjH,IACOgI,IAAgCN,EAAiBA,EAAe1H,QAAQ,IAAIC,OAAO,MAAM2H,KAAiB5H,QAAQ,sBAAuB,QAAQA,QAAQ,KAAM,SAAU,MAAM,IAAM8H,KAC1LJ,EAAiBA,EAAe1H,QAAQ,IAAIC,OAAO,IAAI2H,KAAiB5H,QAAQ,sBAAuB,QAAQA,QAAQ,KAAM,SAAU,MAAM,IAAM8H,GACrJ,CAAE,MAAOxK,GACP,OAAOoK,CACT,CACF,KAAO,CACL,IAAII,EAASzF,EAA4BT,EAAOxG,GAC5C4M,GAAiC,EAChCF,GAAWD,EAAa5F,SAAS,OAAsC,SAA5B5B,EAAO0H,mBAA+BF,EAAa5F,SAAS,MACnG6F,GAAqB,KAAXA,EAAeA,EAASpG,EAAeoG,GACtC,IAAXA,EAAcA,EAAS,KAE9BE,GAAiC,EACjCF,EAAS,IAAI1M,MALqG0M,EAAS,GAOvG,iBAAXA,GAAuBA,EAAO9L,WAAW,MAAQ8L,EAAO7F,SAAS,QAAO6F,EAASA,EAAO9H,QAAQ,KAAM,KACjH,IACOgI,IAAgCN,EAAiBA,EAAe1H,QAAQ,IAAIC,OAAO,MAAM7E,KAAS4E,QAAQ,sBAAuB,QAAQA,QAAQ,KAAM,SAAU,MAAM,IAAM8H,KAClLJ,EAAiBA,EAAe1H,QAAQ,IAAIC,OAAO,IAAI7E,KAAS4E,QAAQ,sBAAuB,QAAQA,QAAQ,KAAM,SAAU,MAAM,IAAM8H,GAC7I,CAAE,MAAOxK,GACP,OAAOoK,CACT,CACF,CACF,CACA,OAAOA,CACT,CAGA,SAASO,EAAiBjN,EAAK4G,GAC7B,IAAIC,EACJ,EAAG,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,gBACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CACjB1B,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,MAAMb,EAAOa,EAAG+D,QAAQ5E,KAClB+E,EAAMlE,EAAG+D,QAAQG,KAAO,OACxBM,EAAS0F,SAASlK,EAAG+D,QAAQS,QAAUxE,EAAG+D,QAAQU,SAAW,EAC7D0F,EAAYD,SAASlK,EAAG+D,QAAQoG,WAAanK,EAAG+D,QAAQqG,YAAc,IACtEC,EAAY9F,KAAKD,MACjBM,EAAS5H,EAAIgD,GAAIvD,OAevB,GAdK+F,EAAOrD,KACVqD,EAAOrD,GAAQ,CACb+E,MACAM,SACA2F,YACAzI,QAAS,CAAC,IAGdc,EAAOrD,GAAMuC,QAAQ1B,EAAG+D,QAAQG,IAAMG,EAA4BT,EAAOM,GAAO,QAAU,CACxFQ,aAAc2F,EACdC,QAASD,EACTzF,UAGEnD,OAAOuE,KAAKxD,EAAOrD,GAAMuC,SAASnE,OAAS4M,EAAW,CACxD,MAAMI,EAAe9I,OAAOuE,KAAKxD,EAAOrD,GAAMuC,SAAS8I,QAAO,CAACC,EAAGC,IAAMlI,EAAOrD,GAAMuC,QAAQ+I,GAAG/F,aAAelC,EAAOrD,GAAMuC,QAAQgJ,GAAGhG,aAAe+F,EAAIC,WACnJlI,EAAOrD,GAAMuC,QAAQ6I,EAC9B,CACAvN,EAAIgD,GAAIY,YAAYgE,GACpBf,GACF,CAEJ,OAASA,GACT,OAAO7G,CACT,CA2BA,MAAM2N,EAAqB,CACzB,IAAK,QACL,IAAK,OACL,IAAK,OACL,IAAK,QACL,IAAK,SAEDC,EAAanJ,OAAOuE,KAAK2E,GACzBE,EAAMD,EAAWrN,OACvB,SAASmG,EAAgBtE,GACvB,IAEImE,EACAuH,EAHAC,GAAgB,EAChBC,EAAW,GAIf,GAAqB,iBAAV5L,EACT,QAAKA,IACI6L,MAAMC,QAAQ9L,GACA,IAAjBA,EAAM7B,QACE,UAEP,YACF,QAAcnB,IAAVgD,EAAqB,OAAO,EAClC,GAAqB,kBAAVA,GAAwC,iBAAVA,EAAoB,OAAOA,EAGvE,IAAKmE,EAAI,EAAGA,EAAInE,EAAM7B,OAAQgG,IAAK,CAIjC,IAHAwH,GAAgB,EAGXD,EAAI,EAAGA,EAAID,EAAKC,IACnB,GAAI1L,EAAMmE,KAAOqH,EAAWE,GAAI,CAC9BE,GAAYL,EAAmBC,EAAWE,IAC1CC,GAAgB,EAChB,KACF,CAGGA,IAAeC,GAAY5L,EAAMmE,GACxC,CAGF,OAAOyH,CACT,CAQA,SAAS1H,EAAkB6H,EAAOC,EAAeC,GAC/C,MAAMC,EAAQ,GACRC,EAAS,GACTC,EAAaJ,EAAc7N,OAC3BkO,EAAcJ,EAAe9N,OACnC,IAAK,IAAIgG,EAAI,EAAGA,EAAI4H,EAAM5N,OAAQgG,IAChC,GAAI4H,EAAMlI,UAAUM,EAAGA,EAAIiI,KAAgBJ,EACzCE,EAAM5L,KAAK6D,EAAIiI,GACfjI,GAAKiI,EAAa,OACb,GAAIL,EAAMlI,UAAUM,EAAGA,EAAIkI,KAAiBJ,EAAgB,CACjE,MAAMK,EAAQJ,EAAM5M,MACC,IAAjB4M,EAAM/N,QAAcgO,EAAO7L,KAAKyL,EAAMlI,UAAUyI,EAAOnI,IAC3DA,GAAKkI,EAAc,CACrB,CAGF,OAAOF,CACT,CAEA,SAAS/H,EAA2BmI,EAAKC,GACvC,MAAMC,EAAU,GACVC,EAAU,GAChB,IAAK,MAAMC,KAAaH,EACtBC,EAAQnM,KAAKqM,EAAU,IACvBD,EAAQpM,KAAKqM,EAAU,IAEzB,MAAMC,EAAwB,CAAC,EAC/B,IAAIC,GAAoB,EACpB7O,EAAQ,GAEZ,IAAK,IAAI8O,EAAY,EAAGA,EAAYP,EAAIpO,OAAQ2O,IAC9C,IAAK,IAAIC,EAAiB,EAAGA,EAAiBN,EAAQtO,OAAQ4O,IAC5D,GAAIF,EAAmB,GAAKA,IAAqBE,EAAgB,CAC/D,MAAMC,EAASP,EAAQM,GACjBE,EAAeD,EAAO7O,OACtB+O,EAASR,EAAQK,GACjBI,EAAeD,EAAO/O,OAC5B,IAAIiP,EAAQb,EAAI1I,UAAUiJ,EAAWA,EAAYG,GACjD,GAAIG,IAAUJ,EACPJ,EAAsBI,GAMzBJ,EAAsBI,MALtBhP,EAAQgP,EAAO1O,MAAM,GAAI,GACzBsO,EAAsBI,GAAU,EAChCH,EAAmBE,EACnBD,EAAYA,EAAYG,EAAe,QAMzC,GADAG,EAAQb,EAAI1I,UAAUiJ,EAAWA,EAAYK,GACzCC,IAAUF,GACRN,EAAsBI,GACxB,GAAIJ,EAAsBI,GAAU,EAAGJ,EAAsBI,UACxD,GAAsC,IAAlCJ,EAAsBI,GAE7B,OADAhP,GAASkP,EACFlP,EAKX4O,EAAsBI,KAAShP,GAASuO,EAAIc,OAAOP,GACzD,CAIJ,OAAO9O,CACT,CAGA,SAASiH,EAA6BqI,EAAKC,EAAavN,GACtD,QAAKsN,IACAC,GAAsC,kBAAhBA,GAAoD,iBAAhBA,EACpC,iBAAhBA,EAAiCtI,EAA4BqI,EAAKC,EAAYxF,MAAM,KAAM/H,GACrE,IAAvBuN,EAAYpP,aAA0BnB,IAAVgD,GACnCsN,EAAIC,EAAY,IAAMvN,EACfsN,EAAIC,EAAY,KACS,IAAvBA,EAAYpP,OAAqBmP,EACZ,IAAvBC,EAAYpP,SACfmP,GAAYE,EAAsBF,EAAKC,EAAY,IAE3CtI,EAA4BuI,EAAsBF,EAAKC,EAAY,IAAKA,EAAYjP,MAAM,GAAI0B,GATZuN,GAUhG,SAASC,EAAuBF,EAAKxI,GACnC,GAAY,WAARA,EAAkB,OAAOwI,EAAInP,OACjC,MAAMsP,EAAe3I,EAAI3F,cAKzB,OAJsBkD,OAAOuE,KAAK0G,GAAKlC,QAAO,CAACsC,EAAKC,KAClDD,EAAIC,EAAExO,eAAiBmO,EAAIK,GACpBD,IACN,CAAC,GACiBD,EACvB,CACF,CAGA,SAAS7I,EAAYvF,GACnB,MAAMuO,EAAavO,EAAQuO,WACrBC,EAAmB,CAAC,EAC1B,IAAK,IAAI1J,EAAI,EAAGA,EAAIyJ,EAAWzP,OAAQgG,IAAK,CAC1C,MAAM/C,EAAOwM,EAAWzJ,GACxB0J,EAAiBzM,EAAKrB,MAAQqB,EAAKpB,KACrC,CACA,OAAO6N,CACT,CAOA,SAAS3K,IACPD,EAAOO,UAAY,EACnBP,EAAOU,aAAe,KACtBV,EAAO8C,UAAY,IACnB9C,EAAO0H,iBAAmB,UAC1B1H,EAAOuD,wBAA0B,SACnC,CAqGA,SAASsH,EAAQvK,EAAUiB,EAAOuJ,GAEhC,GAAwB,iBAAbxK,EAET,OADIN,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,sEACf,mBAAb2N,EAAgCA,EAAS,KAAM,IAC9C,GAUd,IAAInQ,EACAkG,EAPiB,iBAAVU,IACLvB,EAAOO,UAAY,GAAGrD,QAAQC,KAAK,6CACvCoE,EAAQ,CAAC,GAMXA,EAAMmB,eAAiB,GAGnBnB,EAAMwJ,UAAYxJ,EAAMwJ,SAASC,OAAS,IAAMhL,EAAOU,aAAe,UAAaa,EAAMwJ,SAASC,QAGlG1K,EAASjF,MAAM2E,EAAOU,aAAaxF,UAAY8E,EAAOU,eAAcJ,EAAWA,EAASX,QAAQK,EAAOU,aAAc,KAGzH,MAAMuK,EAAgB7K,EAAeE,GACrC,IA4EIQ,EA5EAoK,EAAW,KACXC,EAAmB,KACvB,GAAIF,EAAe,CACjB,MAAMG,EAAiBH,EAAcI,KACrC,GAAID,EAEF,GAAKA,EAAenD,QACf,KAAKmD,EAAejJ,QAAUiJ,EAAehJ,OAEhD,MAAwB,mBAAb0I,EAAgCA,EAAS,KAAMM,EAAe7I,QAC7D6I,EAAe7I,OACtB,KAAI6I,EAAenD,SAAWmD,EAAejJ,QAAUiJ,EAAehJ,QAAUF,KAAKD,OAG1F,MAAwB,mBAAb6I,EAAgCA,EAAS,KAAMM,EAAe7I,QAC7D6I,EAAe7I,OAJsE2I,EAAW,MAK9G,MAV6BA,EAAW,YAaxC,IAAK,MAAMrJ,KAAOoJ,EAGhB,GADAE,EAAmBnJ,EAA4BT,EAAOM,GAClDsJ,EAAkB,CAEpB,MAAMG,EAAyBL,EAAcpJ,GAC7C,IAAK,MAAM0J,KAAYD,EAAuBjM,QAE5C,GAAIkM,IAAaJ,EAAkB,CAEjC,MAAMK,EAAQF,EAAuBjM,QAAQkM,GAC7C,GAAKD,EAAuBnJ,QAAWmJ,EAAuBlJ,OAIvD,IAAIoJ,EAAMvD,SAAWqD,EAAuBnJ,QAAUmJ,EAAuBlJ,QAAUF,KAAKD,MAAO,CAExGiJ,EAAWrJ,EACX,KACF,CAEE,MAAwB,mBAAbiJ,EAAgCA,EAAS,KAAMU,EAAMjJ,QACpDiJ,EAAMjJ,MACpB,CAVE,MAAwB,mBAAbuI,EAAgCA,EAAS,KAAMU,EAAMjJ,QACpDiJ,EAAMjJ,MAUtB,CAGF2I,EAAWrJ,EACX,KACF,CAGN,CAGAhB,EAAmBR,EAAaC,GAG3BP,IACHc,EAAmBA,EAAiBlB,QAAQ,qCAAqC,CAAC5E,EAAOgB,EAAS4O,KAChG,MACMpO,EAAU,IAAIC,IACpB,IAAII,EAAQ,EAUZ,MAAO,IAAIb,IATiB4O,EAAWhL,QAHrB,oDAGwC,CAACrD,EAAWG,EAAUgP,EAAO/O,KACrF,GAAIH,EAAQJ,IAAIM,GAAW,CACzB,MAAME,EAAc,GAAGF,mBAA0BG,MACjD,OAAON,EAAUqD,QAAQlD,EAAUE,EACrC,CAEE,OADAJ,EAAQM,IAAIJ,GAAU,GACfH,CACT,MAEsC,KAI5C3B,EAAM,EAAYkG,GAAoB,IAEtC,IAAIgC,EAAS,EACT6I,GAAuB,EAC3B,EAAG,CAED,GADA7I,IACIA,EAAS7C,EAAO8C,UAAW,CACzB9C,EAAOO,UAAY,GAAGrD,QAAQyO,MAAM,qGAAqG3L,EAAO8C,kFACpJ,KACF,CACA,MAAM8I,EAAW/K,EAAiBe,SAAS,YACrCgC,EAAa/C,EAAiBe,SAAS,cACvCiC,EAAahD,EAAiBe,SAAS,cACvCkC,EAASjD,EAAiBe,SAAS,UACnCmC,EAAQlD,EAAiBe,SAAS,SAClCoC,EAAYnD,EAAiBe,SAAS,aACtCqC,EAAUpD,EAAiBe,SAAS,UACpCsC,EAAWrD,EAAiBe,SAAS,WACrCiK,EAAahL,EAAiBe,SAAS,cACvCuC,EAAUtD,EAAiBe,SAAS,WACpCwC,EAAYvD,EAAiBe,SAAS,aACtCyC,EAAcxD,EAAiBe,SAAS,qBAAuBf,EAAiBe,SAAS,mBAC/Fd,EAAcD,GAAoB,GAC9BgC,EAAS,IACXlI,EAAM,EAAYkG,GAAoB,IAClC6K,IAAsB/Q,EAAMgI,EAAchI,EAAK4G,GAAO,KAExDqK,IAAUjR,EAAM2G,EAAqB3G,EAAK4G,KAC1CqC,GAAcC,GAAcC,KAAQnJ,EAAM6H,EAAiB7H,EAAK4G,KAChEwC,GAASC,KAAWrJ,EAAM6J,EAAkB7J,EAAK4G,KACjD0C,GAAWC,KAAUvJ,EAAM8J,EAAyB9J,EAAK4G,IACzDsK,IAAYlR,EAAMgI,EAAchI,EAAK4G,IACrC4C,IAASxJ,EAAM+J,EAAW/J,EAAK4G,IAC/B6C,IAAWzJ,EAAMgK,EAAahK,EAAK4G,IACnC8C,IAAa1J,EAAMiK,EAA6BjK,EAAK4G,IACzD,MAAMuK,EAAqBjL,EAAiBe,SAAS,YACrDf,EAAmBlG,EAAIP,OACvByG,EAAmB0D,EAAU1D,EAAkBU,GAC3CmK,IACF7K,EAAmBF,EAAoBE,GACvC6K,GAAuB,GAErB7K,EAAiBe,SAAS,wCAC5Bd,EAAc,GACd4K,GAAuB,GAErB5K,IAAgBD,GAAoBiL,IACtCnR,EAAM,EAAYkG,GAAoB,IACtClG,EAAMiN,EAAgBjN,EAAK4G,GAC3BV,EAAmBlG,EAAIP,OAE3B,OAAS0G,IAAgBD,IAGrBA,EAAiBe,SAAS,2CAA6Cf,EAAiBe,SAAS,eAAiBf,EAAiBe,SAAS,WAAaf,EAAiBe,SAAS,UAAYf,EAAiBe,SAAS,cAAgBf,EAAiBe,SAAS,cAAgBf,EAAiBe,SAAS,kBAAoBf,EAAiBe,SAAS,YAAcf,EAAiBe,SAAS,YAAcf,EAAiBe,SAAS,aAAef,EAAiBe,SAAS,aACtdjH,EAAM,EAAYkG,GAAoB,IACtClG,EA/bJ,SAAgCA,GAC9B,IAAI6G,EACD,CACDA,EAAa,EACb,MAAMC,EAAO9G,EAAI,kHACjB,GAAI8G,EAAKvG,OAAS,EAChB,IAAK,MAAMyC,KAAM8D,EAAM,CACrB,MAAM1F,EAAUgE,EAAUpC,EAAGyF,UAAUlH,cAAgByB,EAAGb,KAC1C,YAAZf,GAAqC,QAAZA,GAAiC,OAAZA,GAAgC,WAAZA,GAAoC,WAAZA,GAAoC,eAAZA,GAAwC,SAAZA,GAAkC,SAAZA,GAAkC,UAAZA,GAC5LpB,EAAIgD,GAAIsB,SAENc,IAASpC,EAAG+D,QAAUC,EAAWhE,IACrC,IAAK,MAAMQ,KAAQR,EAAG+D,SACP,SAATvD,GAA4B,UAATA,GAA6B,UAATA,GAA6B,oCAATA,GAA8CA,EAAKxC,WAAW,SAC3HhB,EAAIgD,GAAIU,WAAWF,EAGzB,CAEJ,CACA,OAAOxD,CACT,CA0aUoR,CAAsBpR,GAC5BkG,EAAmBlG,EAAIP,QAIzB,IAAK,MAAM4R,KAAWzK,EAAMmB,eAC1B7B,EAAmBA,EAAiBlB,QAAQ,gBAAgBqM,iBAAuB,IAAMzK,EAAMmB,eAAesJ,KAC9GnL,EAAmBA,EAAiBlB,QAAQ,gBAAgBqM,4BAAkC,IAAMzK,EAAMmB,eAAesJ,KAY3H,GATIjM,IAEFc,EAAgDA,EApYvClB,QAAQ,2CAA4C,OAuY7DkB,EAAmBA,EAAiByF,WAAW,4BAA6B,OAAOA,WAAW,6BAA8B,SAI7G,SAAb4E,EACF9K,EAAeE,GAAU+K,KAAK9I,OAAS1B,EACvCT,EAAeE,GAAU+K,KAAKpD,QAAU/F,KAAKD,WACxC,GAAIiJ,IACJ9K,EAAeE,GAAU4K,GAAU7L,QAAQ8L,KAAmB/K,EAAeE,GAAU4K,GAAU7L,QAAQ8L,GAAoB,CAAC,GACnI/K,EAAeE,GAAU4K,GAAU7L,QAAQ8L,GAAkB5I,OAAS1B,EACtET,EAAeE,GAAU4K,GAAU7L,QAAQ8L,GAAkBlD,QAAU/F,KAAKD,MAExE7C,OAAOuE,KAAKvD,EAAeE,GAAU4K,GAAU7L,SAASnE,OAASkF,EAAeE,GAAU4K,GAAUpD,WAAW,CACjH,MAAMI,EAAe9I,OAAOuE,KAAKvD,EAAeE,GAAU4K,GAAU7L,SAAS8I,QAAO,CAACC,EAAGC,IAAMjI,EAAeE,GAAU4K,GAAU7L,QAAQ+I,GAAGH,QAAU7H,EAAeE,GAAU4K,GAAU7L,QAAQgJ,GAAGJ,QAAUG,EAAIC,WAC3MjI,EAAeE,GAAU4K,GAAU7L,QAAQ6I,EACpD,CAGF,MAAwB,mBAAb4C,EAAgCA,EAAS,KAAMjK,GAC9CA,CACd,CAIA,SACEb,SACAG,SACAC,iBAGA6L,QA5PF,SAAkB5E,GAChB,OAAO,SAAU9F,GACf,OAAOsJ,EAAOxD,EAAgB9F,EAChC,CACF,EAyPEtB,mBACAiM,aA/SF,SAAuBC,GACrB,OAAQA,GACN,IAAK,OACL,KAAK,EACHA,EAAI,EACJ,MACF,IAAK,UACL,KAAK,EACHA,EAAI,EACJ,MACF,IAAK,QACL,IAAK,QACL,KAAK,EACHA,EAAI,EACJ,MACF,QACEA,EAAI,EAERnM,EAAOO,UAAY4L,CACrB,EA6REC,gBA1RF,SAA0BD,GACxBnM,EAAOU,aAAe2L,OAAOF,EAC/B,EAyREG,aAtRF,SAAuBH,GACrBnM,EAAO8C,UAAYyJ,OAAOJ,EAC5B,EAqREK,oBAlRF,SAA8BL,GACVnM,EAAO0H,iBAAf,SAANyE,EAAwC,OACb,SACjC,EAgREM,2BA7QF,SAAqCN,GACjBnM,EAAOuD,wBAAf,SAAN4I,EAA+C,OACb,SACxC,EA2QEO,aAxQF,WACE,OAAOxM,CACT,EAuQEyM,YA7PF,SAAsBC,EAAMtM,GAC1BJ,EAAU0M,GAAQtM,CACpB,EA4PEuM,eAzPF,WACE3M,EAAY,CAAC,CACf,EAwPE4M,SAtPF,SAAmB9M,GACZI,EAAeJ,EAAOM,YAAWF,EAAeJ,EAAOM,UAAY,CAAC,GACrEN,EAAO6B,IACTzB,EAAeJ,EAAOM,UAAUN,EAAO6B,KAAO,CAC5CM,OAAQnC,EAAOmC,QAAUnC,EAAOoC,OAChC0F,UAAY9H,EAAO8H,WAAa9H,EAAO+H,WAAc,IACrD1I,QAAS,CAAC,GAGZe,EAAeJ,EAAOM,UAAU+K,KAAO,CACrClJ,OAAQnC,EAAOmC,QAAUnC,EAAOoC,OAChCG,OAAQ,KACR0F,QAAS,KAGf,EAwOE8E,WAlOF,SAAqBjQ,EAAMiF,GACzB,GAAoB,iBAATjF,EACLiF,SAAe5B,EAAOrD,GAAMuC,QAAQ0C,UAC5B5B,EAAOrD,QACd,GAAoB,iBAATA,EAAmB,CACnC,MAAMkD,EAASlD,EACXkD,EAAO6B,WAAYzB,EAAeJ,EAAOM,UAAUN,EAAO6B,YAClDzB,EAAeJ,EAAOM,SACpC,MAAWN,EAAOO,UAAY,GAAGrD,QAAQyO,MAAM,8CACjD,EA0NEd,SACAmC,UAAWnC,U","sources":["webpack://teddy/webpack/bootstrap","webpack://teddy/./cheerioPolyfill.js","webpack://teddy/./teddy.js"],"sourcesContent":["// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// stub out cheerio using native dom methods for frontend so we don't have to bundle cheerio on the frontend\nexport function load (html) {\n  const doc = parseTeddyDOMFromString(html) // create a DOM\n\n  // return a querySelector function with function chains\n  // e.g. dom('include') or dom(el) from teddy\n  const $ = function (query) { // query can be a string, or a dom object\n    // if query is a string, we need to create a dom object from the string: an object with elements in it, e.g. a list of include tag objects\n    if (typeof query === 'string') {\n      const els = doc.querySelectorAll(query)\n      return els // return the object collection\n    }\n\n    // if query is an object, it's assumed we're trying to perform operations on a single dom node\n    const el = query\n    return {\n\n      // e.g. dom(el).children() from teddy\n      children: function () {\n        return el.childNodes\n      },\n\n      // e.g. dom(el).find() from teddy\n      find: function (selector) {\n        return el.querySelectorAll(selector)\n      },\n\n      // e.g. dom(arg).html() from teddy\n      html: function () {\n        return getTeddyDOMInnerHTML(el)\n      },\n\n      // e.g. dom(arg).toString() from teddy\n      toString: function () {\n        return getTeddyDOMOuterHTML(el)\n      },\n\n      // e.g. dom(el).attr('teddydeferreddynamicinclude', 'true') from teddy\n      attr: function (attr, val) {\n        return el.setAttribute(attr, val)\n      },\n\n      // dom(el).removeAttr(attr) from teddy\n      removeAttr: function (attr) {\n        return el.removeAttribute(attr)\n      },\n\n      // e.g. dom(el).replaceWith(localDom.html()) from teddy\n      replaceWith: function (html) {\n        // can either be a string or an array of elements\n        if (typeof html === 'object') {\n          let newHtml = ''\n          for (const el of html) {\n            if (el.nodeType === window.Node.COMMENT_NODE) newHtml += '<!--' + el.textContent + '-->'\n            else newHtml += el.outerHTML || el.textContent\n          }\n          html = newHtml\n        }\n        const temp = document.createElement('div')\n        temp.innerHTML = html\n        el.replaceWith(...temp.childNodes)\n      },\n\n      // e.g. dom(el).remove() from teddy\n      remove: function () {\n        return el.remove()\n      }\n    }\n  }\n\n  // e.g. dom.html() from teddy\n  $.html = function () {\n    return getTeddyDOMInnerHTML(doc)\n  }\n\n  // e.g. dom.toString() from teddy\n  $.toString = function () {\n    return getTeddyDOMOuterHTML(doc)\n  }\n\n  return $\n}\n\nload.isCheerioPolyfill = true\n\n// DOM parser function like DOMParser's parseFromString but allows Teddy elements to exist in places where they otherwise wouldn't be allowed, like inside of <select> elements\nfunction parseTeddyDOMFromString (html) {\n  const selfClosingTags = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'])\n  const root = document.createElement('body')\n  const dom = [root]\n  const openTags = [] // stack to track open tags\n  const tagAndCommentRegex = /<\\/?([a-zA-Z0-9]+)([^>]*)>|<!--([\\s\\S]*?)-->/g\n  const attrRegex = /([a-zA-Z0-9-:._]+)(?:=([\"'])(.*?)\\2|([^>\\s]+))?/g\n  let lastIndex = 0\n  let match\n\n  // loop through each match and build a DOM\n  while ((match = tagAndCommentRegex.exec(html)) !== null) {\n    if (!dom[dom.length - 1]) throw new Error('Error parsing your template. There may be a coding mistake in your HTML. Look for extra closing </tags> and other common mistakes.')\n    const textBeforeMatch = html.slice(lastIndex, match.index)\n\n    // append text nodes\n    if (textBeforeMatch.trim()) {\n      const textNode = document.createTextNode(textBeforeMatch)\n      dom[dom.length - 1].appendChild(textNode)\n    }\n\n    if (match[0].startsWith('<!--')) {\n      // handle comments\n      const commentNode = document.createComment(match[3])\n      dom[dom.length - 1].appendChild(commentNode)\n    } else {\n      // handle tags\n      const [fullMatch, tagName, attrString] = match\n      const lowerCaseTagName = tagName.toLowerCase()\n      const isClosingTag = fullMatch.startsWith('</')\n      if (isClosingTag) {\n        if (selfClosingTags.has(lowerCaseTagName)) {\n          // convert incorrect closing tag for self-closing tag to self-closing tag\n          const element = document.createElement(tagName)\n          dom[dom.length - 1].appendChild(element)\n        } else {\n          // check if the closing tag matches the most recent open tag\n          if (openTags.length > 0 && openTags[openTags.length - 1] === lowerCaseTagName) {\n            openTags.pop()\n            dom.pop()\n          }\n        }\n      } else {\n        // create a new element\n        const element = document.createElement(tagName)\n\n        // set attributes\n        let attrMatch\n        const attrMap = new Map()\n        while ((attrMatch = attrRegex.exec(attrString)) !== null) {\n          const attrName = attrMatch[1]\n          const attrValue = attrMatch[3] || attrMatch[4] || ''\n\n          // handle duplicate attributes for special tags\n          if (attrMap.has(attrName)) {\n            let count = 1\n            let newAttrName\n            do {\n              newAttrName = `${attrName}-teddyduplicate${count}`\n              count++\n            } while (attrMap.has(newAttrName))\n            attrMap.set(newAttrName, attrValue)\n          } else attrMap.set(attrName, attrValue)\n        }\n\n        // apply attributes to the element\n        for (const [name, value] of attrMap) {\n          try {\n            // replace elements with `src` attributes with `data-teddy-defer-attr-src` so the browser doesn't try to prefetch the asset\n            // this is needed because the value of the `src` attribute could be a {teddyVariable} and that fetch won't resolve\n            switch (lowerCaseTagName) {\n              case 'img':\n              case 'video':\n              case 'audio':\n              case 'iframe':\n              case 'script':\n                if (name === 'src') element.setAttribute('data-teddy-defer-attr-src', value) // replace src with data-teddy-defer-attr-src\n                else element.setAttribute(name, value || '')\n                break\n              case 'link':\n                if (name === 'href') element.setAttribute('data-teddy-defer-attr-href', value) // replace src with data-teddy-defer-attr-href\n                else element.setAttribute(name, value || '')\n                break\n              default:\n                element.setAttribute(name, value || '')\n            }\n          } catch (e) {\n            console.warn('Error parsing an element attribute. You might have a typo in your HTML. A common cause is two spaces between element attributes.')\n          }\n        }\n\n        // append the new element to the current parent\n        dom[dom.length - 1].appendChild(element)\n\n        // push the new element to the dom if it's not self-closing\n        if (!selfClosingTags.has(lowerCaseTagName) && !fullMatch.endsWith('/>')) {\n          dom.push(element)\n          openTags.push(lowerCaseTagName)\n        }\n      }\n    }\n\n    lastIndex = tagAndCommentRegex.lastIndex\n  }\n\n  // append any remaining text after the last match\n  if (lastIndex < html.length) {\n    const remainingText = html.slice(lastIndex)\n    if (remainingText.trim()) {\n      const textNode = document.createTextNode(remainingText)\n      dom[dom.length - 1].appendChild(textNode)\n    }\n  }\n\n  return root\n}\n\n// custom functions to get inner/outer HTML without escaping various things to prevent teddy from infinitely escaping them\nconst doublyEncodedEntities = {\n  '&amp;amp;': '&amp;',\n  '&amp;lt;': '&lt;',\n  '&amp;gt;': '&gt;',\n  '&amp;quot;': '&quot;',\n  '&amp;#39;': '&#39;',\n  '&amp;#x2F;': '&#x2F;'\n}\nconst entityEntries = Object.entries(doublyEncodedEntities)\nfunction getTeddyDOMInnerHTML (node) {\n  // build html string\n  let html = ''\n  for (const child of node.childNodes) {\n    if (child.nodeType === window.Node.ELEMENT_NODE) {\n      let outerHTML = child.outerHTML\n      for (const [doublyEncoded, singleEncoded] of entityEntries) outerHTML = outerHTML.replace(new RegExp(doublyEncoded, 'g'), singleEncoded)\n      html += outerHTML\n    } else if (child.nodeType === window.Node.TEXT_NODE) {\n      let textContent = child.textContent\n      for (const [doublyEncoded, singleEncoded] of entityEntries) textContent = textContent.replace(new RegExp(doublyEncoded, 'g'), singleEncoded)\n      html += textContent\n    } else if (child.nodeType === window.Node.COMMENT_NODE) {\n      let commentContent = child.textContent\n      for (const [doublyEncoded, singleEncoded] of entityEntries) commentContent = commentContent.replace(new RegExp(doublyEncoded, 'g'), singleEncoded)\n      html += `<!--${commentContent}-->`\n    }\n  }\n\n  return html\n}\nfunction getTeddyDOMOuterHTML (node) {\n  // start with the outerHTML of the node\n  let outerHTML = ''\n\n  if (node.nodeType === window.Node.ELEMENT_NODE) {\n    outerHTML = node.outerHTML\n  } else if (node.nodeType === window.Node.TEXT_NODE) {\n    outerHTML = node.textContent\n  } else if (node.nodeType === window.Node.COMMENT_NODE) {\n    outerHTML = `<!--${node.textContent}-->`\n  }\n\n  // replace doubly encoded entities\n  for (const [doublyEncoded, singleEncoded] of entityEntries) outerHTML = outerHTML.replace(new RegExp(doublyEncoded, 'g'), singleEncoded)\n\n  return outerHTML\n}\n","// #region globals\n\nimport fs from 'fs' // node filesystem module\nimport path from 'path' // node path module\nimport { load as cheerioLoad } from 'cheerio/slim' // dom parser\n\nconst cheerioOptions = { xml: { xmlMode: false, lowerCaseAttributeNames: false, decodeEntities: false } }\nconst browser = cheerioLoad.isCheerioPolyfill // true if we are executing in the browser context\nconst params = {} // teddy parameters\nsetDefaultParams() // set params to the defaults\nlet templates = {} // loaded templates are stored as object collections, e.g. { \"myTemplate.html\": \"<p>some markup</p>\"}\nconst caches = {} // a place to store cached portions of templates\nconst templateCaches = {} // a place to store cached full templates\n\n// #endregion\n\n// #region private methods\n\n// loads the template from the filesystem\nfunction loadTemplate (template) {\n  // ensure template is a string\n  if (typeof template !== 'string') {\n    if (params.verbosity > 1) console.warn('teddy.loadTemplate attempted to load a template which is not a string.')\n    return ''\n  }\n  const name = template\n  let register = false\n  if (!templates[template] && template.indexOf('<') === -1 && fs && fs.readFileSync) {\n    // template is not found, it is not code, and we're in the node.js context\n    register = true\n    // append extension if not present\n    if (template.slice(-5) !== '.html') template += '.html'\n    try {\n      template = fs.readFileSync(template, 'utf8')\n    } catch (e) {\n      try {\n        template = fs.readFileSync(params.templateRoot + template, 'utf8')\n      } catch (e) {\n        try {\n          template = fs.readFileSync(params.templateRoot + '/' + template, 'utf8')\n        } catch (e) {\n          // do nothing, attempt to render it as code\n          register = false\n        }\n      }\n    }\n  } else {\n    if (templates[template]) {\n      template = templates[template]\n      register = true\n    } else {\n      // didn't find it; append extension if not present and check it again\n      if (template.slice(-5) !== '.html') {\n        template += '.html'\n      }\n      if (templates[template]) {\n        template = templates[template]\n        register = true\n      }\n      template = removeTeddyComments(template)\n    }\n  }\n  if (register) {\n    // register the new template and return the code\n    template = removeTeddyComments(template)\n    templates[name] = template\n    return template\n  } else {\n    // return the template name which is presumed to be code\n    return template.slice(-5) === '.html' ? template.substring(0, template.length - 5) : template\n  }\n}\n\n// remove teddy {! comments !} and <!--! comments -->; also replace <escape>tags</escape> and <!--# content -->\nfunction removeTeddyComments (renderedTemplate) {\n  let oldTemplate\n  do {\n    oldTemplate = renderedTemplate\n    let vars\n\n    // server-side comments\n    try {\n      vars = matchByDelimiter(renderedTemplate, '{!', '!}')\n    } catch (e) {\n      return renderedTemplate // it will match {! comments {! with comments in them !} !} but if there are unbalanced brackets, just return the original text\n    }\n    for (let i = 0; i < vars.length; i++) renderedTemplate = renderedTemplate.replace(`{!${vars[i]}!}`, '')\n\n    try {\n      vars = matchByDelimiter(renderedTemplate, '<!--!', '-->')\n    } catch (e) {\n      return renderedTemplate\n    }\n    for (let i = 0; i < vars.length; i++) renderedTemplate = renderedTemplate.replace(`<!--!${vars[i]}-->`, '')\n\n    // <!--# escape --> blocks and <escape> tags\n    let firstMatch\n    try {\n      firstMatch = getFirstMatchByDelimiters(renderedTemplate, [['<!--#', '-->'], ['<escape>', '</escape>']])\n    } catch (e) {\n      return renderedTemplate\n    }\n    let newContent = firstMatch\n    if (firstMatch) {\n      if (firstMatch.startsWith('<!--#')) {\n        newContent = newContent.substring(0, newContent.length - 3).slice(5)\n        renderedTemplate = renderedTemplate.replace(firstMatch, escapeEntities(newContent.trim()))\n      } else {\n        newContent = newContent.substring(0, newContent.length - 9).slice(8)\n        renderedTemplate = renderedTemplate.replace(firstMatch, escapeEntities(newContent.trim()))\n      }\n    }\n  } while (oldTemplate !== renderedTemplate)\n  return renderedTemplate\n}\n\n// find all cache elements and replace them with the rendered contents of their cache, then remove the cache element\nfunction replaceCacheElements (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('cache:not([defer])')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        if (browser) el.attribs = getAttribs(el)\n        const name = el.attribs.name\n        if (name.includes('{')) continue\n        const key = el.attribs.key || 'none'\n        if (key.includes('{')) continue\n        const cache = caches[name]\n        if (cache && cache.entries) {\n          const keyVal = el.attribs.key ? getOrSetObjectByDotNotation(model, key) : 'none'\n          if (cache.entries[keyVal]) {\n            const now = Date.now()\n            // if max age is not set, then there is no max age and the cache content is still valid\n            // or if last accessed + max age > now then the cache is not stale and the cache is still valid\n            if (!(cache.maxAge && !cache.maxage) || cache.entries[keyVal].lastAccessed + (cache.maxAge || cache.maxage) > now) {\n              const cacheContent = cache.entries[keyVal].markup\n              cache.entries[keyVal].lastAccessed = now\n              dom(el).replaceWith(cacheContent)\n            } else {\n              // if last accessed + max age <= now then the cache is stale and the cache is no longer valid\n              delete caches[name].entries[keyVal]\n              dom(el).attr('defer', 'true') // create a new cache\n            }\n          } else dom(el).attr('defer', 'true') // no cache exists for this yet; create after the template renders\n        } else dom(el).attr('defer', 'true') // no cache exists for this yet; create after the template renders\n        parsedTags++\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// add an id to all <noteddy> or <noparse> tags, then remove their content temporarily until the template is fully parsed\nfunction tagNoParseBlocks (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    let tags = dom('noteddy:not([id]), noparse:not([id])')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        const id = model._noTeddyBlocks.push(dom(el).html()) - 1\n        dom(el).replaceWith(`<noteddy id=\"${id}\"></noteddy>`)\n        parsedTags++\n      }\n    }\n    tags = dom('pre:not([id]):not([parse])')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        const id = model._noTeddyBlocks.push(dom(el).toString()) - 1\n        dom(el).replaceWith(`<noteddy id=\"${id}\" pre=\"true\"></noteddy>`)\n        parsedTags++\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// parse <include> tags\nfunction parseIncludes (dom, model, dynamic) {\n  let parsedTags\n  let passes = 0\n  do {\n    passes++\n    if (passes > params.maxPasses) throw new Error(`teddy could not finish rendering the template because the max number of passes over the template (${params.maxPasses}) was exceeded; there may be an infinite loop in your template logic.`)\n    parsedTags = 0\n    let tags\n    // dynamic includes are includes like <include src=\"{sourcedFromVariable}\"></include>\n    if (dynamic) tags = dom('include') // parse all includes\n    else tags = dom('include:not([teddydeferreddynamicinclude])') // parse only includes that aren't dynamic\n    if (tags.length > 0) {\n      for (const el of tags) {\n        // ensure this isn't the child of a no parse block\n        let foundBody = false\n        let next = false\n        let parent = el.parent || el.parentNode\n        while (!foundBody) {\n          let parentName\n          if (!parent) parentName = 'body'\n          else parentName = parent.nodeName?.toLowerCase() || parent.name\n          if (parentName === 'noparse' || parentName === 'noteddy') {\n            next = true\n            break\n          } else if (parentName === 'body') foundBody = true\n          else parent = parent.parent || parent.parentNode\n        }\n        if (next) continue\n        // get attributes\n        if (browser) el.attribs = getAttribs(el)\n        const src = el.attribs.src\n        if (!src) {\n          if (params.verbosity > 1) console.warn('teddy encountered an include tag with no src attribute.')\n          continue\n        }\n        if (src.startsWith('{')) {\n          dom(el).attr('teddydeferreddynamicinclude', 'true') // mark it dynamic and then skip it\n          continue\n        }\n        loadTemplate(src) // load the partial into the template list\n        let contents = templates[src] || ''\n        if (typeof templates[src] !== 'string' && params.includeNotFoundBehavior === 'display') {\n          contents = `Template \"${src}\" not found!`\n          if (params.verbosity > 1) console.warn(`teddy encountered an include tag with a src set to a template that could not be found: ${src}`)\n        }\n        const localModel = Object.assign({}, model)\n        for (const arg of dom(el).children()) {\n          const argName = browser ? arg.nodeName?.toLowerCase() : arg.name\n          if (argName === 'arg') {\n            if (browser) arg.attribs = getAttribs(arg)\n            const argval = Object.keys(arg.attribs)[0]\n            getOrSetObjectByDotNotation(localModel, argval, dom(arg).html())\n          }\n        }\n        const hasNoteddy = contents.includes('</noteddy>')\n        const hasNoparse = contents.includes('</noparse>')\n        const hasPre = contents.includes('</pre>')\n        const hasIf = contents.includes('</if>')\n        const hasUnless = contents.includes('</unless>')\n        const hasTrue = contents.includes(' true=')\n        const hasFalse = contents.includes(' false=')\n        const hasLoop = contents.includes('</loop>')\n        const hasInline = contents.includes('</inline>')\n        const hasSelected = contents.includes(' selected-value=') || contents.includes(' checked-value=')\n        let localDom\n        if (hasNoteddy || hasNoparse || hasPre) {\n          localDom = cheerioLoad(contents, cheerioOptions)\n          localDom = tagNoParseBlocks(localDom, localModel)\n          contents = localDom.html()\n        }\n        localDom = cheerioLoad(parseVars(contents, localModel), cheerioOptions)\n        if (hasIf || hasUnless) localDom = parseConditionals(localDom, localModel)\n        if (hasTrue || hasFalse) localDom = parseOneLineConditionals(localDom, localModel)\n        if (hasLoop) localDom = parseLoops(localDom, localModel)\n        if (hasInline) localDom = parseInlines(localDom, localModel)\n        if (hasSelected) localDom = parseSelectedAttributeValues(localDom, localModel)\n        dom(el).replaceWith(localDom.html())\n        parsedTags++\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// parse <if>, <elseif>, <unless>, <elseunless>, and <else> tags\nfunction parseConditionals (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('if, unless')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        // ensure this isn't the child of a loop or a no parse block\n        let foundBody = false\n        let next = false\n        let parent = el.parent || el.parentNode\n        while (!foundBody) {\n          let parentName\n          if (!parent) parentName = 'body'\n          else parentName = parent.nodeName?.toLowerCase() || parent.name\n          if (parentName === 'loop' || parentName === 'noparse' || parentName === 'noteddy') {\n            next = true\n            break\n          } else if (parentName === 'body') foundBody = true\n          else parent = parent.parent || parent.parentNode\n        }\n        if (next) continue\n        // get conditions\n        let args = []\n        if (browser) el.attribs = getAttribs(el)\n        for (let attr in el.attribs) {\n          if (attr.includes('-teddyduplicate')) attr = attr.split('-teddyduplicate')[0] // the condition is a duplicate, so remove the `-teddyduplicate1` from `conditionName-teddyduplicate1`, `conditionName-teddyduplicate2`, etc\n          let val = el.attribs[attr]\n          if (val) {\n            if (val.startsWith('{')) val = parseVars(val, model)\n            args.push(`${attr}=${val}`)\n          } else args.push(attr)\n        }\n        // check if it's an if tag and not an unless tag\n        let isIf = true\n        const elName = browser ? el.nodeName?.toLowerCase() : el.name\n        if (elName === 'unless') isIf = false\n        // evaluate conditional\n        const condResult = evaluateConditional(args, model)\n        if ((isIf && condResult) || ((!isIf && !condResult))) {\n          // render the true block and discard the elseif, elseunless, and else blocks\n          let nextSibling = el.nextSibling\n          const removeStack = []\n          while (nextSibling) {\n            const nextSiblingName = browser ? nextSibling.nodeName?.toLowerCase() : nextSibling.name\n            switch (nextSiblingName) {\n              case 'elseif':\n              case 'elseunless':\n              case 'else':\n                removeStack.push(nextSibling)\n                nextSibling = nextSibling.nextSibling\n                break\n              case 'if':\n              case 'unless':\n                nextSibling = false\n                break\n              default:\n                nextSibling = nextSibling.nextSibling\n            }\n          }\n          for (const element of removeStack) dom(element).replaceWith('')\n          dom(el).replaceWith(el.childNodes || el.children)\n          parsedTags++\n        } else {\n          // true block is false; find the next elseif, elseunless, or else tag to evaluate\n          let nextSibling = el.nextSibling\n          while (nextSibling) {\n            const nextSiblingName = browser ? nextSibling.nodeName?.toLowerCase() : nextSibling.name\n            switch (nextSiblingName) {\n              case 'elseif':\n                // get conditions\n                args = []\n                if (browser) nextSibling.attribs = getAttribs(nextSibling)\n                for (const attr in nextSibling.attribs) {\n                  const val = nextSibling.attribs[attr]\n                  if (val) args.push(`${attr}=${val}`)\n                  else args.push(attr)\n                }\n                if (evaluateConditional(args, model)) {\n                  // render the true block and discard the elseif, elseunless, and else blocks\n                  const replaceSibling = nextSibling\n                  dom(replaceSibling).replaceWith(replaceSibling.childNodes || replaceSibling.children)\n                  nextSibling = el.nextSibling\n                  const removeStack = []\n                  while (nextSibling) {\n                    const nextSiblingName = browser ? nextSibling.nodeName?.toLowerCase() : nextSibling.name\n                    switch (nextSiblingName) {\n                      case 'elseif':\n                      case 'elseunless':\n                      case 'else':\n                        removeStack.push(nextSibling)\n                        nextSibling = nextSibling.nextSibling\n                        break\n                      case 'if':\n                      case 'unless':\n                        nextSibling = false\n                        break\n                      default:\n                        nextSibling = nextSibling.nextSibling\n                    }\n                  }\n                  for (const element of removeStack) dom(element).replaceWith('')\n                  nextSibling = false\n                  parsedTags++\n                } else {\n                  // true block is false; find the next elseif, elseunless, or else tag to evaluate\n                  const siblingToWipe = nextSibling\n                  nextSibling = nextSibling.nextSibling\n                  dom(siblingToWipe).replaceWith('')\n                }\n                break\n              case 'elseunless':\n                // get conditions\n                args = []\n                if (browser) nextSibling.attribs = getAttribs(nextSibling)\n                for (const attr in nextSibling.attribs) {\n                  const val = nextSibling.attribs[attr]\n                  if (val) args.push(`${attr}=${val}`)\n                  else args.push(attr)\n                }\n                if (!evaluateConditional(args, model)) {\n                  // render the true block and discard the elseif, elseunless, and else blocks\n                  const replaceSibling = nextSibling\n                  dom(replaceSibling).replaceWith(replaceSibling.childNodes || replaceSibling.children)\n                  nextSibling = el.nextSibling\n                  const removeStack = []\n                  while (nextSibling) {\n                    const nextSiblingName = browser ? nextSibling.nodeName?.toLowerCase() : nextSibling.name\n                    switch (nextSiblingName) {\n                      case 'elseif':\n                      case 'elseunless':\n                      case 'else':\n                        removeStack.push(nextSibling)\n                        nextSibling = nextSibling.nextSibling\n                        break\n                      case 'if':\n                      case 'unless':\n                        nextSibling = false\n                        break\n                      default:\n                        nextSibling = nextSibling.nextSibling\n                    }\n                  }\n                  for (const element of removeStack) dom(element).replaceWith('')\n                  nextSibling = false\n                  parsedTags++\n                } else {\n                  // true block is false; find the next elseif, elseunless, or else tag to evaluate\n                  const siblingToWipe = nextSibling\n                  nextSibling = nextSibling.nextSibling\n                  dom(siblingToWipe).replaceWith('')\n                }\n                break\n              case 'else':\n                // else is always true, so if we've gotten here, then there's nothing to evaluate and we've reached the end of the conditional blocks\n                dom(nextSibling).replaceWith(nextSibling.childNodes || nextSibling.children)\n                nextSibling = false\n                parsedTags++\n                break\n              case 'if':\n              case 'unless':\n                // if we encounter another fresh if statement or unless statement, then there's nothing left to evaluate and we've reached the end of this conditional's blocks\n                nextSibling = false\n                break\n              default:\n                // if we encounter any other element or a text node we assume there could still be more elseif, elseunless, or else tags ahead so we keep going\n                nextSibling = nextSibling.nextSibling\n            }\n          }\n          dom(el).replaceWith('') // remove the original if statement once done with finding its siblings\n        }\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// evaluates a single <if> or <unless> tag\nfunction evaluateConditional (conditions, model) {\n  const conditionsLength = conditions.length\n  // loop through conditions and reduce them to booleans\n  for (let i = 0; i < conditionsLength; i++) {\n    const condition = conditions[i]\n    if (typeof condition === 'boolean') continue // if the condition is already a boolean then we don't need to reduce it to a boolean to evaluate it\n    // reject conditions with invalid formatting\n    if (condition.startsWith('=') || condition.endsWith('=')) {\n      if (params.verbosity > 1) console.warn('teddy encountered a conditional statement with \"=\" at the beginning or end of a condition.')\n      return false\n    }\n    if (condition.includes(':') && !condition.startsWith('not:')) {\n      if (params.verbosity > 1) console.warn('teddy encountered a conditional statement with a \"not:\" that isn\\'t at the beginning of a condition.')\n      return false\n    }\n    // deal with boolean logic\n    if (condition === 'and') {\n      if (conditions[i - 1] && evaluateCondition(conditions[i + 1], model)) {\n        // if both sides of an and are true, then reduce all 3 condition blocks to true\n        conditions[i - 1] = true\n        conditions[i] = true\n        conditions[i + 1] = true\n      } else {\n        // if either side of an and is false, then reduce all 3 condition blocks to false\n        conditions[i - 1] = false\n        conditions[i] = false\n        conditions[i + 1] = false\n      }\n    } else if (condition === 'or') {\n      if (conditions[i - 1] || evaluateCondition(conditions[i + 1], model)) {\n        // if either side of an or is true, then reduce all 3 condition blocks to true, as well as all condition blocks that precded this or\n        conditions.fill(true, 0, i + 2)\n      } else {\n        // if both sides of an or are false, then reduce all 3 condition blocks to false\n        conditions[i - 1] = false\n        conditions[i] = false\n        conditions[i + 1] = false\n      }\n    } else if (condition === 'xor') {\n      if (!!conditions[i - 1] === !!evaluateCondition(conditions[i + 1], model)) {\n        // if both sides of an xor are equal to each other, then reduce all 3 condition blocks to false\n        conditions[i - 1] = false\n        conditions[i] = false\n        conditions[i + 1] = false\n      } else {\n        // if the two sides of an xor are not equal to each other, then reduce all 3 condition blocks to true\n        conditions[i - 1] = true\n        conditions[i] = true\n        conditions[i + 1] = true\n      }\n    } else conditions[i] = evaluateCondition(condition, model)\n  }\n  return conditions.every(item => item === true) || false // if any of the booleans are false, then return false. otherwise return true\n}\n\n// determines whether a single condition in a teddy conditional is true or false\nfunction evaluateCondition (condition, model) {\n  let not // stores whether the :not modifier is present\n  if (typeof condition === 'string' && condition.includes('=')) { // it's an equality check condition\n    not = !!condition.startsWith('not:') // true if \"not:\" is present\n    if (not) condition = condition.slice(4) // remove the :not prefix\n    const parts = condition.split('=') // something=\"Some content\"\n    const cond = parts[0] // something\n    delete parts[0] // remove the something=\n    const val = parts.join('') // \"Some content\" — the path.join method ensures the string gets rebuilt even if it contains another = character\n    const lookup = getOrSetObjectByDotNotation(model, cond)\n    // the == is necessary because teddy does type-insensitive equality checks\n    if (lookup == val) return !not // eslint-disable-line\n    else return not // false\n  } else { // it's a presence check\n    not = typeof condition === 'string' ? !!condition.startsWith('not:') : false // true if \"not:\" is present\n    if (not) condition = condition.slice(4) // remove the :not prefix\n    const lookup = getOrSetObjectByDotNotation(model, condition)\n    if (lookup) {\n      if (typeof lookup === 'object' && Object.keys(lookup).length === 0) return not // false; empty object or array\n      return !not // true; var is present\n    } else return not // false; var is not present\n  }\n}\n\n// render one-line if attributes, e.g. <p if-something=\"value\" true=\"class='class-applied-if-true'\" false=\"class='class-applied-if-false'\">hello</p>\nfunction parseOneLineConditionals (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('[true], [false]')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        // skip parsing this if it uses variables as part of its conditions; it will get caught in the next pass after parseVars runs\n        let defer = false\n        if (browser) el.attribs = getAttribs(el)\n        for (const attr in el.attribs) {\n          const val = el.attribs[attr]\n          if (val.startsWith('{')) {\n            defer = true\n            break\n          }\n        }\n        if (defer) {\n          dom(el).attr('teddydeferredonelineconditional', 'true')\n          continue\n        }\n        // ensure this isn't the child of a loop or a no parse block\n        let foundBody = false\n        let next = false\n        let parent = el.parent || el.parentNode\n        while (!foundBody) {\n          let parentName\n          if (!parent) parentName = 'body'\n          else parentName = parent.nodeName?.toLowerCase() || parent.name\n          if (parentName === 'loop' || parentName === 'noparse' || parentName === 'noteddy') {\n            next = true\n            break\n          } else if (parentName === 'body') foundBody = true\n          else parent = parent.parent || parent.parentNode\n        }\n        if (next) continue\n        // get conditions\n        let ifTrue\n        let ifFalse\n        if (browser) el.attribs = getAttribs(el)\n        const args = []\n        for (const origAttr in el.attribs) {\n          let attr = origAttr\n          let val = el.attribs[attr]\n          if (attr.includes('-teddyduplicate')) attr = attr.split('-teddyduplicate')[0] // the condition is a duplicate, so remove the `-teddyduplicate1` from `conditionName-teddyduplicate1`, `conditionName-teddyduplicate2`, etc\n          if (val?.startsWith('{')) val = parseVars(val, model)\n          if (attr.startsWith('if-')) {\n            const parts = attr.split('if-')\n            if (val) args.push(`${parts[1]}=${val}`)\n            else args.push(parts[1])\n            dom(el).removeAttr(origAttr)\n          } else if (attr === 'true') {\n            ifTrue = val.replaceAll('&quot;', '\"') // true=\"class='blah'\"\n            dom(el).removeAttr(origAttr)\n          } else if (attr === 'false') {\n            ifFalse = val.replaceAll('&quot;', '\"') // false=\"class='blah'\"\n            dom(el).removeAttr(origAttr)\n          } else if (attr === 'and' || attr === 'or' || attr === 'xor') {\n            args.push(attr)\n            dom(el).removeAttr(origAttr)\n          }\n        }\n        // evaluate conditional\n        if (evaluateConditional(args, model)) {\n          if (ifTrue) {\n            const parts = ifTrue.split('=')\n            dom(el).attr(parts[0], parts[1] ? parts[1].replace(/[\"']/g, '') : '')\n          }\n          parsedTags++\n        } else if (ifFalse) {\n          if (ifFalse) {\n            const parts = ifFalse.split('=')\n            dom(el).attr(parts[0], parts[1] ? parts[1].replace(/[\"']/g, '') : '')\n          }\n          parsedTags++\n        }\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// render <loop> tags\nfunction parseLoops (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('loop')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        // get attributes\n        let loopThrough\n        let keyName\n        let valName\n        if (browser) el.attribs = getAttribs(el)\n        for (const attr in el.attribs) {\n          if (attr === 'through') {\n            let attrVal = el.attribs[attr]\n            if (attrVal.startsWith('{')) attrVal = parseVars(attrVal, model)\n            loopThrough = getOrSetObjectByDotNotation(model, attrVal)\n          } else if (attr === 'key') keyName = el.attribs[attr]\n          else if (attr === 'val') valName = el.attribs[attr]\n        }\n        // reject the loop if it has invalid attributes\n        if (!loopThrough) {\n          if (params.verbosity > 1) console.warn('teddy encountered a loop without a through attribute.')\n          dom(el).replaceWith('')\n          continue\n        }\n        if (!keyName && !valName) {\n          if (params.verbosity > 1) console.warn('teddy encountered a loop without a key or a val attribute.')\n          dom(el).replaceWith('')\n          continue\n        }\n        // loop through model[loopThrough] and parse teddy tags within the loop's iteration against the local model\n        let newMarkup = ''\n        let loopContents = dom(el).html()\n        if (loopThrough instanceof Set) loopThrough = [...loopThrough] // convert Sets to arrays\n        for (const key in loopThrough) {\n          const val = loopThrough[key]\n          const localModel = Object.assign({}, model)\n          getOrSetObjectByDotNotation(localModel, keyName, key)\n          getOrSetObjectByDotNotation(localModel, valName, val)\n          const hasNoteddyLoopContents = loopContents.includes('</noteddy>')\n          const hasNoparseLoopContents = loopContents.includes('</noparse>')\n          const hasPreLoopContents = loopContents.includes('</pre>')\n          if (hasNoteddyLoopContents || hasNoparseLoopContents || hasPreLoopContents) {\n            let localDom = cheerioLoad(loopContents, cheerioOptions)\n            localDom = tagNoParseBlocks(localDom, localModel)\n            loopContents = localDom.html()\n          }\n          const localMarkup = parseVars(loopContents, localModel) || ''\n          const hasNoteddy = localMarkup.includes('</noteddy>')\n          const hasNoparse = localMarkup.includes('</noparse>')\n          const hasIf = localMarkup.includes('</if>')\n          const hasUnless = localMarkup.includes('</unless>')\n          const hasTrue = localMarkup.includes(' true=')\n          const hasFalse = localMarkup.includes(' false=')\n          const hasLoop = localMarkup.includes('</loop>')\n          const hasInline = localMarkup.includes('</inline>')\n          const hasSelected = localMarkup.includes(' selected-value=') || localMarkup.includes(' checked-value=')\n          let localDom = cheerioLoad(localMarkup || '', cheerioOptions)\n          if (hasNoteddy || hasNoparse) localDom = tagNoParseBlocks(localDom, localModel)\n          if (hasIf || hasUnless) localDom = parseConditionals(localDom, localModel)\n          if (hasTrue || hasFalse) localDom = parseOneLineConditionals(localDom, localModel)\n          if (hasLoop) localDom = parseLoops(localDom, localModel)\n          if (hasInline) localDom = parseInlines(localDom, localModel)\n          if (hasSelected) localDom = parseSelectedAttributeValues(localDom, localModel)\n          newMarkup += localDom.html()\n        }\n        const newDom = cheerioLoad(newMarkup || '', cheerioOptions)\n        dom(el).replaceWith(newDom.html())\n        parsedTags++\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// render <inline> tags\nfunction parseInlines (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('inline')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        // get attributes\n        let css\n        let js\n        if (browser) el.attribs = getAttribs(el)\n        for (const attr in el.attribs) {\n          if (attr === 'css') css = getOrSetObjectByDotNotation(model, el.attribs[attr])\n          else if (attr === 'js') js = getOrSetObjectByDotNotation(model, el.attribs[attr])\n        }\n        // reject if it has invalid attributes\n        if (!css && !js) {\n          if (params.verbosity > 1) console.warn('teddy encountered an <inline> element without a css or js attribute.')\n          dom(el).replaceWith('')\n          continue\n        }\n        let replaceWith = ''\n        if (css) replaceWith = `<style>${css}</style>`\n        else replaceWith = `<script>${js}</script>`\n        dom(el).replaceWith(replaceWith)\n        parsedTags++\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// render `selected-value` and `checked-value` attributes\nfunction parseSelectedAttributeValues (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('select[selected-value], [checked-value]')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        // get attributes\n        if (browser) el.attribs = getAttribs(el)\n        for (let attr in el.attribs) {\n          const origAttr = attr\n          if (attr.includes('-teddyduplicate')) attr = attr.split('-teddyduplicate')[0]\n          if (attr === 'selected-value') {\n            const val = parseVars(el.attribs[origAttr], model) || el.attribs[origAttr]\n            const children = dom(el).find('option[value]')\n            for (const opt of children) {\n              if (browser) opt.attribs = getAttribs(opt)\n              if (opt.attribs.value === val) dom(opt).attr('selected', 'selected')\n            }\n            dom(el).removeAttr(origAttr)\n          } else if (attr === 'checked-value') {\n            const val = parseVars(el.attribs[origAttr], model) || el.attribs[origAttr]\n            const children = dom(el).find('input[type=\"checkbox\"][value], input[type=\"radio\"][value]')\n            for (const opt of children) {\n              if (browser) opt.attribs = getAttribs(opt)\n              if (opt.attribs.value === val) dom(opt).attr('checked', 'checked')\n            }\n            dom(el).removeAttr(origAttr)\n          }\n        }\n        parsedTags++\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// render {variables}\nfunction parseVars (templateString, model) {\n  let vars\n  try {\n    vars = matchByDelimiter(templateString, '{', '}')\n  } catch (e) {\n    return templateString // it will match {vars{withVarsInThem}} but if there are unbalanced brackets, just return the original text\n  }\n  for (let i = 0; i < vars.length; i++) {\n    let match = vars[i]\n    if (match === '') continue // empty {}\n    if (!/^(\\d+|[a-zA-Z_$][a-zA-Z0-9_$|{}.-]*(\\.[a-zA-Z_$][a-zA-Z0-9_$|{}.-]*)*)$/.test(match)) {\n      if (params.verbosity > 2) console.warn(`teddy.parseVars encountered a {variable} that could not be parsed: {${match}}`)\n      continue // skip invalid variables\n    }\n    if (match.includes('{')) {\n      // there's a variable inside the variable name\n      const originalMatch = match\n      match = parseVars(match, model)\n      try {\n        templateString = templateString.replace(new RegExp(`\\${${originalMatch}}`, 'i'), () => `\\${${match}}`)\n        templateString = templateString.replace(new RegExp(`{${originalMatch}}`, 'i'), () => `{${match}}`)\n      } catch (e) {\n        if (params.verbosity > 2) console.warn(`teddy.parseVars encountered a {variable} that could not be parsed: {${originalMatch}}`)\n      }\n    }\n    const lastSixChars = match.slice(-6)\n    if (lastSixChars.includes('|p')) { // no parse flag is set\n      const originalMatch = match\n      match = match.substring(0, match.length - (lastSixChars.split('|').length - 1) * 2) // remove last 2-n chars\n      let parsed = getOrSetObjectByDotNotation(model, match)\n      if (!parsed && !lastSixChars.includes('|d') && (params.emptyVarBehavior === 'hide' || lastSixChars.includes('|h'))) parsed = '' // display empty string instead of the variable text verbatim if this setting is set\n      if (typeof parsed === 'string' && parsed.startsWith('{') && parsed.includes('|d')) parsed = parsed.replace('|d', '')\n      if (parsed || parsed === '') {\n        const id = model._noTeddyBlocks.push(parsed) - 1\n        try {\n          try {\n            templateString = templateString.replace(new RegExp(`\\${${originalMatch}}`.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d'), 'i'), `<noteddy id=\"${id}\"></noteddy>`)\n            templateString = templateString.replace(new RegExp(`{${originalMatch}}`.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d'), 'i'), `<noteddy id=\"${id}\"></noteddy>`)\n          } catch (e) {\n            if (params.verbosity > 2) console.warn(`teddy.parseVars encountered a {variable} that could not be parsed: {${originalMatch}}`)\n          }\n        } catch (e) {\n          return templateString\n        }\n      }\n    } else if (lastSixChars.includes('|s')) { // no escape flag is set\n      const originalMatch = match\n      match = match.substring(0, match.length - (lastSixChars.split('|').length - 1) * 2) // remove last 2-n chars\n      let parsed = getOrSetObjectByDotNotation(model, match)\n      let skipTemplateLiteralReplacement = false\n      if (!parsed && !lastSixChars.includes('|d') && (params.emptyVarBehavior === 'hide' || lastSixChars.includes('|h'))) parsed = '' // display empty string instead of the variable text verbatim if this setting is set\n      else if (!parsed && parsed !== '') {\n        skipTemplateLiteralReplacement = true\n        parsed = `{${originalMatch}}`\n      }\n      if (typeof parsed === 'string' && parsed.startsWith('{') && parsed.includes('|d')) parsed = parsed.replace('|d', '')\n      try {\n        if (!skipTemplateLiteralReplacement) templateString = templateString.replace(new RegExp(`\\${${originalMatch}}`.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d'), 'i'), () => parsed)\n        templateString = templateString.replace(new RegExp(`{${originalMatch}}`.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d'), 'i'), () => parsed)\n      } catch (e) {\n        return templateString\n      }\n    } else { // no flags are set\n      let parsed = getOrSetObjectByDotNotation(model, match)\n      let skipTemplateLiteralReplacement = false\n      if (!parsed && !lastSixChars.includes('|d') && (params.emptyVarBehavior === 'hide' || lastSixChars.includes('|h'))) parsed = '' // display empty string instead of the variable text verbatim if this setting is set\n      else if (parsed || parsed === '') parsed = escapeEntities(parsed)\n      else if (parsed === 0) parsed = '0'\n      else {\n        skipTemplateLiteralReplacement = true\n        parsed = `{${match}}`\n      }\n      if (typeof parsed === 'string' && parsed.startsWith('{') && parsed.includes('|d')) parsed = parsed.replace('|d', '')\n      try {\n        if (!skipTemplateLiteralReplacement) templateString = templateString.replace(new RegExp(`\\${${match}}`.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d'), 'i'), () => parsed)\n        templateString = templateString.replace(new RegExp(`{${match}}`.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&').replace(/-/g, '\\\\x2d'), 'i'), () => parsed)\n      } catch (e) {\n        return templateString\n      }\n    }\n  }\n  return templateString\n}\n\n// once the template is fully rendered, find all cache elements that still exist and cache their contents\nfunction defineNewCaches (dom, model) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('cache[defer]')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        if (browser) el.attribs = getAttribs(el)\n        const name = el.attribs.name\n        const key = el.attribs.key || 'none'\n        const maxAge = parseInt(el.attribs.maxAge || el.attribs.maxage) || 0\n        const maxCaches = parseInt(el.attribs.maxCaches || el.attribs.maxcaches) || 1000\n        const timestamp = Date.now()\n        const markup = dom(el).html()\n        if (!caches[name]) {\n          caches[name] = {\n            key,\n            maxAge,\n            maxCaches,\n            entries: {}\n          }\n        }\n        caches[name].entries[el.attribs.key ? getOrSetObjectByDotNotation(model, key) : 'none'] = {\n          lastAccessed: timestamp,\n          created: timestamp,\n          markup\n        }\n        // invalidate oldest cache if we've reached max caches limit\n        if (Object.keys(caches[name].entries).length > maxCaches) {\n          const lowestKeyVal = Object.keys(caches[name].entries).reduce((a, b) => caches[name].entries[a].lastAccessed < caches[name].entries[b].lastAccessed ? a : b)\n          delete caches[name].entries[lowestKeyVal]\n        }\n        dom(el).replaceWith(markup)\n        parsedTags++\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// removes any remaining teddy tags from the dom before returning the parsed html to the user\nfunction cleanupStrayTeddyTags (dom) {\n  let parsedTags\n  do {\n    parsedTags = 0\n    const tags = dom('[teddydeferredonelineconditional], pre[parse], include, arg, if, unless, elseif, elseunless, else, loop, cache')\n    if (tags.length > 0) {\n      for (const el of tags) {\n        const tagName = browser ? el.nodeName?.toLowerCase() : el.name\n        if (tagName === 'include' || tagName === 'arg' || tagName === 'if' || tagName === 'unless' || tagName === 'elseif' || tagName === 'elseunless' || tagName === 'else' || tagName === 'loop' || tagName === 'cache') {\n          dom(el).remove()\n        }\n        if (browser) el.attribs = getAttribs(el)\n        for (const attr in el.attribs) {\n          if (attr === 'true' || attr === 'false' || attr === 'parse' || attr === 'teddydeferredonelineconditional' || attr.startsWith('if-')) {\n            dom(el).removeAttr(attr)\n          }\n        }\n      }\n    }\n  } while (parsedTags)\n  return dom\n}\n\n// escapes sensitive characters to prevent xss\nconst escapeHtmlEntities = {\n  '&': '&amp;',\n  '<': '&lt;',\n  '>': '&gt;',\n  '\"': '&#34;',\n  \"'\": '&#39;'\n}\nconst entityKeys = Object.keys(escapeHtmlEntities)\nconst ekl = entityKeys.length\nfunction escapeEntities (value) {\n  let escapedEntity = false\n  let newValue = ''\n  let i\n  let j\n\n  if (typeof value === 'object') { // cannot escape on this value\n    if (!value) return false // it is falsey to return false\n    else if (Array.isArray(value)) {\n      if (value.length === 0) return false // empty arrays are falsey\n      else return '[Array]' // print that it is an array with content in it, but do not print the contents\n    }\n    return '[Object]' // just print that it is an object, do not print the contents\n  } else if (value === undefined) return false // cannot escape on this value; undefined is falsey\n  else if (typeof value === 'boolean' || typeof value === 'number') return value // cannot escape on these values; if it's already a boolean or a number just return it\n  else {\n    // loop through value to find html entities\n    for (i = 0; i < value.length; i++) {\n      escapedEntity = false\n\n      // loop through list of html entities to escape\n      for (j = 0; j < ekl; j++) {\n        if (value[i] === entityKeys[j]) { // alter value to show escaped html entities\n          newValue += escapeHtmlEntities[entityKeys[j]]\n          escapedEntity = true\n          break\n        }\n      }\n\n      if (!escapedEntity) newValue += value[i]\n    }\n  }\n\n  return newValue\n}\n\n// if an entity is double-encoded, this will fix that\nfunction reverseDoubleEncodedEntities (str) {\n  return str.replace(/&amp;(#\\d+;|#x[0-9A-Fa-f]+;|[A-Za-z]+;)/g, '&$1')\n}\n\n// match strings by a custom delimiter\nfunction matchByDelimiter (input, openDelimiter, closeDelimiter) {\n  const stack = []\n  const result = []\n  const openLength = openDelimiter.length\n  const closeLength = closeDelimiter.length\n  for (let i = 0; i < input.length; i++) {\n    if (input.substring(i, i + openLength) === openDelimiter) {\n      stack.push(i + openLength)\n      i += openLength - 1\n    } else if (input.substring(i, i + closeLength) === closeDelimiter) {\n      const start = stack.pop()\n      if (stack.length === 0) result.push(input.substring(start, i))\n      i += closeLength - 1\n    }\n  }\n\n  return result\n}\n\nfunction getFirstMatchByDelimiters (str, delimiters) {\n  const openers = []\n  const closers = []\n  for (const delimiter of delimiters) {\n    openers.push(delimiter[0])\n    closers.push(delimiter[1])\n  }\n  const currentlyOpenBrackets = {}\n  let currentDelimiter = -1\n  let match = ''\n\n  for (let charIndex = 0; charIndex < str.length; charIndex++) {\n    for (let delimiterIndex = 0; delimiterIndex < openers.length; delimiterIndex++) {\n      if (currentDelimiter < 0 || currentDelimiter === delimiterIndex) {\n        const opener = openers[delimiterIndex]\n        const openerLength = opener.length\n        const closer = closers[delimiterIndex]\n        const closerLength = closer.length\n        let chunk = str.substring(charIndex, charIndex + openerLength)\n        if (chunk === opener) {\n          if (!currentlyOpenBrackets[opener]) {\n            match = opener.slice(0, -1)\n            currentlyOpenBrackets[opener] = 1\n            currentDelimiter = delimiterIndex\n            charIndex = charIndex + openerLength - 1 // move the loop ahead beyond the delimiter\n          } else {\n            currentlyOpenBrackets[opener]++\n          }\n        } else {\n          chunk = str.substring(charIndex, charIndex + closerLength)\n          if (chunk === closer) {\n            if (currentlyOpenBrackets[opener]) {\n              if (currentlyOpenBrackets[opener] > 1) currentlyOpenBrackets[opener]-- // they're nested; keep going\n              else if (currentlyOpenBrackets[opener] === 1) {\n                match += closer\n                return match\n              }\n            }\n          }\n        }\n        if (currentlyOpenBrackets[opener]) match += str.charAt(charIndex)\n      }\n    }\n  }\n\n  return match\n}\n\n// gets or sets an object by dot notation, e.g. thing.nestedThing.furtherNestedThing: two arguments gets, three arguments sets\nfunction getOrSetObjectByDotNotation (obj, dotNotation, value) {\n  if (!obj) return false\n  if (!dotNotation || typeof dotNotation === 'boolean' || typeof dotNotation === 'number') return dotNotation\n  if (typeof dotNotation === 'string') return getOrSetObjectByDotNotation(obj, dotNotation.split('.'), value)\n  else if (dotNotation.length === 1 && value !== undefined) {\n    obj[dotNotation[0]] = value\n    return obj[dotNotation[0]]\n  } else if (dotNotation.length === 0) return obj\n  else if (dotNotation.length === 1) {\n    if (obj) return caseInsensitiveLookup(obj, dotNotation[0])\n    return false\n  } else return getOrSetObjectByDotNotation(caseInsensitiveLookup(obj, dotNotation[0]), dotNotation.slice(1), value)\n  function caseInsensitiveLookup (obj, key) {\n    if (key === 'length') return obj.length\n    const lowerCaseKey = key.toLowerCase()\n    const normalizedObj = Object.keys(obj).reduce((acc, k) => {\n      acc[k.toLowerCase()] = obj[k]\n      return acc\n    }, {})\n    return normalizedObj[lowerCaseKey]\n  }\n}\n\n// cheerio polyfill\nfunction getAttribs (element) {\n  const attributes = element.attributes\n  const attributesObject = {}\n  for (let i = 0; i < attributes.length; i++) {\n    const attr = attributes[i]\n    attributesObject[attr.name] = attr.value\n  }\n  return attributesObject\n}\n\n// #endregion\n\n// #region public methods\n\n// set params to the defaults\nfunction setDefaultParams () {\n  params.verbosity = 1\n  params.templateRoot = './'\n  params.maxPasses = 1000\n  params.emptyVarBehavior = 'display' // or 'hide'\n  params.includeNotFoundBehavior = 'display' // or 'hide'\n}\n\n// mutator method to set verbosity param. takes human-readable string argument and converts it to an integer for more efficient checks against the setting\nfunction setVerbosity (v) {\n  switch (v) {\n    case 'none':\n    case 0:\n      v = 0\n      break\n    case 'verbose':\n    case 2:\n      v = 2\n      break\n    case 'debug':\n    case 'DEBUG':\n    case 3:\n      v = 3\n      break\n    default: // concise\n      v = 1\n  }\n  params.verbosity = v\n}\n\n// mutator method to set template root param; must be a string\nfunction setTemplateRoot (v) {\n  params.templateRoot = String(v)\n}\n\n// mutator method to set max passes param: the number of times the parser can iterate over the template\nfunction setMaxPasses (v) {\n  params.maxPasses = Number(v)\n}\n\n// mutator method to set empty var behavior param: whether to display {variables} that don't resolve as text ('display') or as an empty string ('hide')\nfunction setEmptyVarBehavior (v) {\n  if (v === 'hide') params.emptyVarBehavior = 'hide'\n  else params.emptyVarBehavior = 'display'\n}\n\n// mutator method to set include tag not found param: whether to display an error when an <include> tag src can't be found\nfunction setIncludeNotFoundBehavior (v) {\n  if (v === 'hide') params.includeNotFoundBehavior = 'hide'\n  else params.includeNotFoundBehavior = 'display'\n}\n\n// access templates\nfunction getTemplates () {\n  return templates\n}\n\n// takes in a template string and outputs a function which when given data will render out html\nfunction compile (templateString) {\n  return function (model) {\n    return render(templateString, model)\n  }\n}\n\n// mutator method to cache template\nfunction setTemplate (file, template) {\n  templates[file] = template\n}\n\n// mutator method to clear template cache entirely\nfunction clearTemplates () {\n  templates = {}\n}\n\nfunction setCache (params) {\n  if (!templateCaches[params.template]) templateCaches[params.template] = {}\n  if (params.key) {\n    templateCaches[params.template][params.key] = {\n      maxAge: params.maxAge || params.maxage,\n      maxCaches: (params.maxCaches || params.maxcaches) || 1000,\n      entries: {}\n    }\n  } else {\n    templateCaches[params.template].none = {\n      maxAge: params.maxAge || params.maxage,\n      markup: null,\n      created: null\n    }\n  }\n}\n\n// delete one or more cached templates\n// 1 string argument deletes the whole cache at that name for template partial caches\n// 2 arguments deletes just the value at that keyVal for template partial caches\n// 1 object argument assumes we're clearing whole template level cache\nfunction clearCache (name, keyVal) {\n  if (typeof name === 'string') {\n    if (keyVal) delete caches[name].entries[keyVal]\n    else delete caches[name]\n  } else if (typeof name === 'object') {\n    const params = name\n    if (params.key) delete templateCaches[params.template][params.key]\n    else delete templateCaches[params.template]\n  } else if (params.verbosity > 0) console.error('teddy: invalid params passed to clearCache.')\n}\n\n// parses a template\nfunction render (template, model, callback) {\n  // ensure template is a string\n  if (typeof template !== 'string') {\n    if (params.verbosity > 1) console.warn('teddy.render attempted to render a template which is not a string.')\n    if (typeof callback === 'function') return callback(null, '')\n    else return ''\n  }\n\n  // ensure model is an object\n  if (typeof model !== 'object') {\n    if (params.verbosity > 1) console.warn('teddy.render was passed an invalid model.')\n    model = {} // allow the template to render if an invalid model is supplied, but it will have an empty model\n  }\n\n  // declare vars\n  let dom\n  let renderedTemplate\n  model._noTeddyBlocks = [] // will store code blocks exempt from teddy parsing\n\n  // express.js support\n  if (model.settings && model.settings.views && path) params.templateRoot = path.resolve(model.settings.views)\n\n  // remove templateRoot from template name if necessary\n  if (template.slice(params.templateRoot.length) === params.templateRoot) template = template.replace(params.templateRoot, '')\n\n  // whole template caching\n  const templateCache = templateCaches[template]\n  let cacheKey = null\n  let cacheKeyModelVal = null\n  if (templateCache) {\n    const singletonCache = templateCache.none\n    if (singletonCache) {\n      // check if the timestamp exceeds max age\n      if (!singletonCache.created) cacheKey = 'none'\n      else if (!singletonCache.maxAge && singletonCache.maxage) {\n        // if no max age is set, then this cache doesn't expire\n        if (typeof callback === 'function') return callback(null, singletonCache.markup)\n        else return singletonCache.markup\n      } else if (singletonCache.created + (singletonCache.maxAge || singletonCache.maxage) < Date.now()) cacheKey = 'none' // if yes re-render the template and cache it again\n      else {\n        // if no return the cached markup and skip the template render\n        if (typeof callback === 'function') return callback(null, singletonCache.markup)\n        else return singletonCache.markup\n      }\n    } else {\n      // loop through its keys\n      for (const key in templateCache) {\n        // if there's a model value for that key name\n        cacheKeyModelVal = getOrSetObjectByDotNotation(model, key)\n        if (cacheKeyModelVal) {\n          // loop through its entries\n          const templateCacheAtThisKey = templateCache[key]\n          for (const entryKey in templateCacheAtThisKey.entries) {\n            // if any entry keys match the model value for that key name\n            if (entryKey === cacheKeyModelVal) {\n              // check if the timestamp exceeds max age\n              const entry = templateCacheAtThisKey.entries[entryKey]\n              if (!templateCacheAtThisKey.maxAge && !templateCacheAtThisKey.maxage) {\n                // if no max age is set, then this cache doesn't expire\n                if (typeof callback === 'function') return callback(null, entry.markup)\n                else return entry.markup\n              } else if (entry.created + (templateCacheAtThisKey.maxAge || templateCacheAtThisKey.maxage) < Date.now()) {\n                // if yes re-render the template and cache it again\n                cacheKey = key\n                break\n              } else {\n                // if no return the cached markup and skip the template render\n                if (typeof callback === 'function') return callback(null, entry.markup)\n                else return entry.markup\n              }\n            }\n          }\n          // this is a new model value so it needs a new entry\n          cacheKey = key\n          break\n        }\n      }\n    }\n  }\n\n  // start the render\n  renderedTemplate = loadTemplate(template)\n\n  // replace duplicate attributes with temporary unique names before loading into cheerio\n  if (!browser) {\n    renderedTemplate = renderedTemplate.replace(/<([a-zA-Z][a-zA-Z0-9-]*)([^>]*)>/g, (match, tagName, attributes) => {\n      const attrRegex = /([a-zA-Z0-9-:._]+)(?:=([\"'])(.*?)\\2|([^>\\s]+))?/g\n      const attrMap = new Map()\n      let count = 1\n      const processedAttributes = attributes.replace(attrRegex, (attrMatch, attrName, quote, attrValue) => {\n        if (attrMap.has(attrName)) {\n          const newAttrName = `${attrName}-teddyduplicate${count++}`\n          return attrMatch.replace(attrName, newAttrName)\n        } else {\n          attrMap.set(attrName, true)\n          return attrMatch\n        }\n      })\n      return `<${tagName}${processedAttributes}>`\n    })\n  }\n\n  dom = cheerioLoad(renderedTemplate || '', cheerioOptions)\n  let oldTemplate\n  let passes = 0\n  let parseDynamicIncludes = false\n  do {\n    passes++\n    if (passes > params.maxPasses) {\n      if (params.verbosity > 0) console.error(`teddy could not finish rendering the template because the max number of passes over the template (${params.maxPasses}) was exceeded; there may be an infinite loop in your template logic.`)\n      break\n    }\n    const hasCache = renderedTemplate.includes('</cache>')\n    const hasNoteddy = renderedTemplate.includes('</noteddy>')\n    const hasNoparse = renderedTemplate.includes('</noparse>')\n    const hasPre = renderedTemplate.includes('</pre>')\n    const hasIf = renderedTemplate.includes('</if>')\n    const hasUnless = renderedTemplate.includes('</unless>')\n    const hasTrue = renderedTemplate.includes(' true=')\n    const hasFalse = renderedTemplate.includes(' false=')\n    const hasInclude = renderedTemplate.includes('</include>')\n    const hasLoop = renderedTemplate.includes('</loop>')\n    const hasInline = renderedTemplate.includes('</inline>')\n    const hasSelected = renderedTemplate.includes(' selected-value=') || renderedTemplate.includes(' checked-value=')\n    oldTemplate = renderedTemplate || ''\n    if (passes > 1) {\n      dom = cheerioLoad(renderedTemplate || '', cheerioOptions)\n      if (parseDynamicIncludes) dom = parseIncludes(dom, model, true)\n    }\n    if (hasCache) dom = replaceCacheElements(dom, model)\n    if (hasNoteddy || hasNoparse || hasPre) dom = tagNoParseBlocks(dom, model)\n    if (hasIf || hasUnless) dom = parseConditionals(dom, model)\n    if (hasTrue || hasFalse) dom = parseOneLineConditionals(dom, model)\n    if (hasInclude) dom = parseIncludes(dom, model)\n    if (hasLoop) dom = parseLoops(dom, model)\n    if (hasInline) dom = parseInlines(dom, model)\n    if (hasSelected) dom = parseSelectedAttributeValues(dom, model)\n    const cachesStillPresent = renderedTemplate.includes('</cache>')\n    renderedTemplate = dom.html()\n    renderedTemplate = parseVars(renderedTemplate, model)\n    if (parseDynamicIncludes) {\n      renderedTemplate = removeTeddyComments(renderedTemplate)\n      parseDynamicIncludes = false\n    }\n    if (renderedTemplate.includes('teddydeferreddynamicinclude=\"true\"')) {\n      oldTemplate = '' // reset old template to force another pass\n      parseDynamicIncludes = true\n    }\n    if (oldTemplate === renderedTemplate && cachesStillPresent) {\n      dom = cheerioLoad(renderedTemplate || '', cheerioOptions)\n      dom = defineNewCaches(dom, model)\n      renderedTemplate = dom.html()\n    }\n  } while (oldTemplate !== renderedTemplate)\n\n  // remove stray teddy tags if any exist\n  if (renderedTemplate.includes('teddydeferredonelineconditional=\"true\"') || renderedTemplate.includes('</include>') || renderedTemplate.includes('</arg>') || renderedTemplate.includes('</if>') || renderedTemplate.includes('</unless>') || renderedTemplate.includes('</elseif>') || renderedTemplate.includes('</elseunless>') || renderedTemplate.includes('</else>') || renderedTemplate.includes('</loop>') || renderedTemplate.includes('</cache>') || renderedTemplate.includes('</pre>')) {\n    dom = cheerioLoad(renderedTemplate || '', cheerioOptions)\n    dom = cleanupStrayTeddyTags(dom)\n    renderedTemplate = dom.html()\n  }\n\n  // replace <noteddy> blocks with the hidden code\n  for (const blockId in model._noTeddyBlocks) {\n    renderedTemplate = renderedTemplate.replace(`<noteddy id=\"${blockId}\"></noteddy>`, () => model._noTeddyBlocks[blockId])\n    renderedTemplate = renderedTemplate.replace(`<noteddy id=\"${blockId}\" pre=\"true\"></noteddy>`, () => model._noTeddyBlocks[blockId])\n  }\n\n  if (browser) {\n    // fix double-encoding html entity bug in client-side mode\n    renderedTemplate = reverseDoubleEncodedEntities(renderedTemplate)\n\n    // now that we're done with the render, reset data-teddy-defer-attr-src and data-teddy-defer-attr-href to native attributes\n    renderedTemplate = renderedTemplate.replaceAll('data-teddy-defer-attr-src', 'src').replaceAll('data-teddy-defer-attr-href', 'href')\n  }\n\n  // cache the template\n  if (cacheKey === 'none') {\n    templateCaches[template].none.markup = renderedTemplate\n    templateCaches[template].none.created = Date.now()\n  } else if (cacheKey) {\n    if (!templateCaches[template][cacheKey].entries[cacheKeyModelVal]) templateCaches[template][cacheKey].entries[cacheKeyModelVal] = {}\n    templateCaches[template][cacheKey].entries[cacheKeyModelVal].markup = renderedTemplate\n    templateCaches[template][cacheKey].entries[cacheKeyModelVal].created = Date.now()\n    // invalidate oldest cache if we've reached max caches limit\n    if (Object.keys(templateCaches[template][cacheKey].entries).length > templateCaches[template][cacheKey].maxCaches) {\n      const lowestKeyVal = Object.keys(templateCaches[template][cacheKey].entries).reduce((a, b) => templateCaches[template][cacheKey].entries[a].created < templateCaches[template][cacheKey].entries[b].created ? a : b)\n      delete templateCaches[template][cacheKey].entries[lowestKeyVal]\n    }\n  }\n\n  if (typeof callback === 'function') return callback(null, renderedTemplate)\n  else return renderedTemplate\n}\n\n// #endregion\n\nexport default {\n  params,\n  caches,\n  templateCaches,\n\n  // functions\n  compile,\n  setDefaultParams,\n  setVerbosity,\n  setTemplateRoot,\n  setMaxPasses,\n  setEmptyVarBehavior,\n  setIncludeNotFoundBehavior,\n  getTemplates,\n  setTemplate,\n  clearTemplates,\n  setCache,\n  clearCache,\n  render,\n  __express: render\n}\n"],"names":["__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","exports","module","__webpack_modules__","load","html","doc","selfClosingTags","Set","root","document","createElement","dom","openTags","tagAndCommentRegex","attrRegex","match","lastIndex","exec","length","Error","textBeforeMatch","slice","index","trim","textNode","createTextNode","appendChild","startsWith","commentNode","createComment","fullMatch","tagName","attrString","lowerCaseTagName","toLowerCase","has","element","pop","attrMatch","attrMap","Map","attrName","attrValue","newAttrName","count","set","name","value","setAttribute","e","console","warn","endsWith","push","remainingText","parseTeddyDOMFromString","$","query","querySelectorAll","el","children","childNodes","find","selector","getTeddyDOMInnerHTML","toString","getTeddyDOMOuterHTML","attr","val","removeAttr","removeAttribute","replaceWith","newHtml","nodeType","window","Node","COMMENT_NODE","textContent","outerHTML","temp","innerHTML","remove","isCheerioPolyfill","entityEntries","Object","entries","node","child","ELEMENT_NODE","doublyEncoded","singleEncoded","replace","RegExp","TEXT_NODE","commentContent","browser","params","setDefaultParams","templates","caches","templateCaches","loadTemplate","template","verbosity","register","indexOf","templateRoot","removeTeddyComments","substring","renderedTemplate","oldTemplate","vars","firstMatch","matchByDelimiter","i","getFirstMatchByDelimiters","newContent","escapeEntities","replaceCacheElements","model","parsedTags","tags","attribs","getAttribs","includes","key","cache","keyVal","getOrSetObjectByDotNotation","now","Date","maxAge","maxage","lastAccessed","cacheContent","markup","tagNoParseBlocks","id","_noTeddyBlocks","parseIncludes","dynamic","passes","maxPasses","foundBody","next","parent","parentNode","parentName","nodeName","src","contents","includeNotFoundBehavior","localModel","assign","arg","keys","hasNoteddy","hasNoparse","hasPre","hasIf","hasUnless","hasTrue","hasFalse","hasLoop","hasInline","hasSelected","localDom","parseVars","parseConditionals","parseOneLineConditionals","parseLoops","parseInlines","parseSelectedAttributeValues","args","split","isIf","condResult","evaluateConditional","nextSibling","removeStack","replaceSibling","siblingToWipe","conditions","conditionsLength","condition","evaluateCondition","fill","every","item","not","parts","cond","join","lookup","defer","ifTrue","ifFalse","origAttr","replaceAll","loopThrough","keyName","valName","attrVal","newMarkup","loopContents","hasNoteddyLoopContents","hasNoparseLoopContents","hasPreLoopContents","localMarkup","newDom","css","js","opt","templateString","test","originalMatch","lastSixChars","parsed","emptyVarBehavior","skipTemplateLiteralReplacement","defineNewCaches","parseInt","maxCaches","maxcaches","timestamp","created","lowestKeyVal","reduce","a","b","escapeHtmlEntities","entityKeys","ekl","j","escapedEntity","newValue","Array","isArray","input","openDelimiter","closeDelimiter","stack","result","openLength","closeLength","start","str","delimiters","openers","closers","delimiter","currentlyOpenBrackets","currentDelimiter","charIndex","delimiterIndex","opener","openerLength","closer","closerLength","chunk","charAt","obj","dotNotation","caseInsensitiveLookup","lowerCaseKey","acc","k","attributes","attributesObject","render","callback","settings","views","templateCache","cacheKey","cacheKeyModelVal","singletonCache","none","templateCacheAtThisKey","entryKey","entry","quote","parseDynamicIncludes","error","hasCache","hasInclude","cachesStillPresent","cleanupStrayTeddyTags","blockId","compile","setVerbosity","v","setTemplateRoot","String","setMaxPasses","Number","setEmptyVarBehavior","setIncludeNotFoundBehavior","getTemplates","setTemplate","file","clearTemplates","setCache","clearCache","__express"],"sourceRoot":""}