taggedjs 2.5.21 → 2.5.22

package/bundle.js.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.js","mappings":"AACA,ICDWA,EDCPC,EAAsB,CEA1BA,EAAwB,CAACC,EAASC,KACjC,IAAI,IAAIC,KAAOD,EACXF,EAAoBI,EAAEF,EAAYC,KAASH,EAAoBI,EAAEH,EAASE,IAC5EE,OAAOC,eAAeL,EAASE,EAAK,CAAEI,YAAY,EAAMC,IAAKN,EAAWC,IAE1E,ECNDH,EAAwB,CAACS,EAAKC,IAAUL,OAAOM,UAAUC,eAAeC,KAAKJ,EAAKC,I,meCA3E,MAAMI,EACT,GAAAN,CAAIO,GACA,MAAO,MACX,ECFG,SAASC,EAAYC,GACxB,MAAO,CACHlB,EAAWmB,IACXnB,EAAWoB,WACbC,SAASH,GAAOI,UACtB,CACO,SAASC,EAAeL,GAC3B,OAAOA,GAAOI,YAActB,EAAWoB,SAC3C,CAEO,SAASI,EAAeN,GAC3B,OAAOA,GAAOI,YAActB,EAAWyB,YAC3C,CACO,SAASC,EAAWR,GACvB,OAAOA,GAAOI,YAActB,EAAWmB,GAC3C,CAEO,SAASQ,EAAkBC,GAC9B,SAA+B,IAAvBA,GAASC,YAAsBD,GAASE,UACpD,CACO,SAASC,EAAWb,GACvB,OAAOA,aAAiBc,OAASd,EAAMe,OAAMC,GAAK,CAC9ClC,EAAWmB,IAAKnB,EAAWoB,UAAWpB,EAAWmB,IAAKnB,EAAWyB,cACnEJ,SAASa,GAAGZ,YAClB,CCxBO,SAASa,EAAcC,GAC1B,MAAMC,EAAS,IAAIC,EA2BnB,OADAD,EAAOE,cAzBYC,IACf,MAAMC,EAAa,GACbC,EAAS,GACTC,EAAW,CAACT,EAAGU,KACjBH,EAAWG,IAAS,EACpBF,EAAOE,GAASV,EAEhB,GADqBO,EAAWI,SAAWT,EAASS,OACpD,CAGA,IAAK,IAAID,EAAQH,EAAWI,OAAS,EAAGD,GAAS,IAAKA,EAClD,IAAKH,EAAWG,GACZ,OAIRJ,EAASE,EAAQI,EAPjB,CAO8B,EAE5BC,EAAS,IAAIX,GAEbU,EADWC,EAAOC,QACMlB,WAAUI,GAAKS,EAAST,EAAG,KACnDe,EAAgBF,EAAOG,KAAI,CAACtB,EAASgB,IAAUhB,EAAQE,WAAUI,GAAKS,EAAST,EAAGU,EAAQ,OAEhG,OADAE,EAAaG,cAAgBA,EACtBH,CAAY,EAGhBT,CACX,CCQO,SAASc,EAAgBjC,EAAOkC,EAASC,GAC5C,MAAMC,EAAe,IAAIF,GACnBG,EAAcD,EAAaN,QAC3BQ,EAAQC,IACV,GAAIH,EAAaT,OACb,OAAOM,EAAgBM,EAAUH,EAAcD,GAEnDA,EAAWI,EAAS,EAExB,IAAIC,EAAUF,EACd,MAEMG,EAAiBJ,EAAYrC,EADjB,CAAE0C,WADA1B,GAAMwB,EAAUxB,EACJsB,SAEhCE,EAAQC,EACZ,ENnDA,SAAW3D,GACPA,EAAoB,QAAI,UACxBA,EAAgB,IAAI,MACpBA,EAAsB,UAAI,YAC1BA,EAAyB,aAAI,gBAC7BA,EAAqB,SAAI,YACzBA,EAAoB,QAAI,UACxBA,EAAiB,KAAI,OACrBA,EAAmB,OAAI,SACvBA,EAAoB,QAAI,UACxBA,EAAqB,SAAI,WACzBA,OAAW,GAAe,WAC7B,CAZD,CAYGA,IAAeA,EAAa,CAAC,IOVzB,MAAMsC,EACTpB,MACA2C,eAEAT,QAAU,GACVvB,WAAY,EAEZiC,YAAc,GACdvB,cACAwB,OAEAC,IACA,WAAAC,CAAY/C,EAEZ2C,GACIK,KAAKhD,MAAQA,EACbgD,KAAKL,eAAiBA,EACtBK,KAAKH,OAAS7C,EACdiD,EAAcD,KAClB,CACA,SAAApC,CAAUU,GACN,MAAMM,EDjBP,SAAyBlB,EAASY,EAAUsB,GAC/C,MAAMM,EAAe9B,EAAQ+B,gBAC7B/B,EAAQ+B,gBAAgBb,KAAKY,EAAaL,OAAS,GACnD,MAAMjB,EAAe,KACjBA,EAAawB,aAAa,EAyB9B,OAvBAxB,EAAaN,SAAWA,EACxBM,EAAaG,cAAgB,GAE7BH,EAAawB,YAAc,MAf/B,SAA4BR,EAAatB,GACrC,MAAMI,EAAQkB,EAAYS,WAAUC,GAAOA,EAAIhC,WAAaA,KAC7C,IAAXI,GACAkB,EAAYW,OAAO7B,EAAO,EAElC,CAWQ8B,CAAmBZ,EAAatB,GAEhCF,EAAQ+B,gBAAgBb,KAAKY,EAAaL,OAAS,GAEnDjB,EAAawB,YAAc,IAAMxB,EAEjC,MAAMG,EAAgBH,EAAaG,cACnC,IAAK,IAAIL,EAAQK,EAAcJ,OAAS,EAAGD,GAAS,IAAKA,EACrDK,EAAcL,GAAO0B,cAEzB,OAAOxB,CAAY,EAEvBA,EAAa6B,IAAOH,IAChB1B,EAAaG,cAAc2B,KAAKJ,GACzB1B,GAEXA,EAAaU,KAAQtC,IACjBsB,EAAStB,EAAO4B,EAAa,EAE1BA,CACX,CCb6B+B,CAAgBX,EAAM1B,EAAU0B,KAAKJ,aAEpDvB,EAAgB2B,KAAK3B,cAC3B,GAAIA,EAAe,CAEf,GAAI2B,KAAKd,QAAQP,OAAQ,CACrB,MAAMiC,EAActC,EACpBA,EAAYtB,IACRiC,EAAgBjC,EAAOgD,KAAKd,SAAS2B,GAAaD,EAAYC,EAAWjC,IAAc,CAE/F,CACA,OAAOP,EAAcC,EACzB,CAKA,OAJA0B,KAAKJ,YAAYc,KAAK9B,GAClBoB,KAAKL,gBACLK,KAAKL,eAAef,GAEjBA,CACX,CACA,IAAAU,CAAKtC,GACDgD,KAAKH,OAAS7C,EACdgD,KAAKc,MACT,CACA,IAAAA,GACI,MAAM9D,EAAQgD,KAAKH,OAEbkB,EAAO,IAAIf,KAAKJ,aAChBjB,EAASoC,EAAKpC,OACpB,IAAK,IAAID,EAAQ,EAAGA,EAAQC,IAAUD,EAAO,CACzC,MAAM4B,EAAMS,EAAKrC,GACjB4B,EAAIhC,SAAStB,EAAOsD,EACxB,CACJ,CACA,SAAAU,GACI,OAAO,IAAIC,SAAQC,IACflB,KAAKpC,WAAU,CAACI,EAAGY,KACfA,EAAawB,cACbc,EAAIlD,EAAE,GACR,GAEV,CAEA,UAAAmD,CAAW7C,GACP,MAAMM,EAAeoB,KAAKpC,WAAU,CAACI,EAAGoD,KACpCxC,EAAawB,cACb9B,EAASN,EAAE,IAEf,OAAOgC,IACX,CACA,IAAAqB,IAAQC,GACJ,MAAM5D,EAAU,IAAIU,EAAQ4B,KAAKH,QAIjC,OAHAnC,EAAQ6D,WAAWD,GACnB5D,EAAQW,cAAiBL,GAAMgC,KAAKpC,UAAUI,GAC9CN,EAAQ4B,KAAOtB,GAAKgC,KAAKV,KAAKtB,GACvBN,CACX,CACA,UAAA6D,CAAWD,GACPtB,KAAKd,QAAUoC,CACnB,CACA,UAAOE,CAAIC,GAWP,OAAOxD,EAVUwD,EAAKzC,KAAI0C,IACtB,GAAIjE,EAAkBiE,GAClB,OAAOA,EAMX,OAJU,IAAItD,EAAQsD,GAAK9C,IACvBA,EAAaU,KAAKoC,GACX9C,IAEH,IAGhB,CACA+C,uBAAyB,IAAIvD,EAAQ,GAElC,SAAS6B,EAAcvC,GAC1BtB,OAAOC,eAAeqB,EAAS,QAAS,CAEpC,GAAAoC,CAAI9C,GACAU,EAAQmC,OAAS7C,EACjBU,EAAQoD,MACZ,EAEAvE,IAAG,IACQmB,EAAQmC,SAGvBzD,OAAOC,eAAeqB,EAAS,MAAO,CAElCoC,IAAM9C,GAAUU,EAAQ4B,KAAKtC,GAE7BT,IAAK,IAAOyB,GAAMN,EAAQ4B,KAAKtB,IAEvC,CCnHO,MAAM4D,UAAqBxD,EAC9BpB,MACA,WAAA+C,CAAY/C,GACR6E,MAAM7E,GACNgD,KAAKhD,MAAQA,EACbiD,EAAcD,KAClB,CACA,SAAApC,CAAUU,GACN,MAAMM,EAAeiD,MAAMjE,UAAUU,GAGrC,OADAA,EAAS0B,KAAKH,OAAQjB,GACfA,CACX,ECbG,SAASkD,EAAaxD,GACzB,MAAO,CAAEuC,EAAWkB,KAChBA,EAAMrC,YAAW,KACG,IAEpBpB,EAASuC,EAAWkB,EAAMzC,KAC7B,CACL,CAEO,SAAS0C,EAAY1D,GACxB,MAAO,CAAEuC,EAAWkB,KAChBA,EAAMrC,YAAW,KACG,IAELpB,EAASuC,GACjBoB,MAAKjE,GAAK+D,EAAMzC,KAAKtB,IAC/B,CACL,CAEO,MAAMkE,EAAiB5D,GACnB,CAAEuC,EAAWkB,KAChBA,EAAMrC,YAAW,KACG,IAEpB,MACMd,EADSN,EAASuC,GACIjD,WAAUI,IAClCY,EAAawB,cACb2B,EAAMzC,KAAKtB,EAAE,GAEpB,EC5BE,SAASmE,IACZ,OAAOC,EAAOC,OAAOC,YAAYC,UACrC,CCFO,SAASH,EAAOI,GAEnB,MAAMC,EAAQ,CACVC,aAAcF,EAAIE,cAAgB,MAAgB,GAClDC,aAAcH,EAAIG,cAAgB,MAAgB,GAClDC,YAAaJ,EAAII,aAAe,MAAgB,GAChDC,cAAeL,EAAIK,eAAiB,MAAgB,IAExDT,EAAOU,OAAOpC,KAAK+B,EACvB,CACAL,EAAOU,OAXQ,GAYfV,EAAOC,OAAS,CAAC,ECZV,MAAMU,UAAiBC,MAC1BC,QACA,WAAAlD,CAAYmD,EAASC,EAAWF,EAAU,CAAC,GACvCpB,MAAMqB,GACNlD,KAAKlD,KAAOiG,EAASjG,KACrBkD,KAAKiD,QAAU,IAAKA,EAASE,YACjC,EAEG,MAAMC,UAAwBL,EACjC,WAAAhD,CAAYmD,EAASD,GACjBpB,MAAMqB,EAAS,qBAAsBD,GACrCjD,KAAKlD,KAAOsG,EAAgBtG,IAChC,EAEG,MAAMuG,UAA2BN,EACpC,WAAAhD,CAAYmD,EAASD,GACjBpB,MAAMqB,EAAS,uBAAwBD,GACvCjD,KAAKlD,KAAOuG,EAAmBvG,IACnC,EAEG,MAAMwG,UAA0BP,EACnC,WAAAhD,CAAYmD,EAASD,GACjBpB,MAAMqB,EAAS,sBAAuBD,GACtCjD,KAAKlD,KAAOwG,EAAkBxG,IAClC,ECtBJsF,EAAOC,OAAOC,YAAc,CACxBiB,MAAO,IAGX,MAAMb,EAAgBH,GAoDtB,SAAmBA,GACf,MAAMF,EAASE,EAAWF,OACpBmB,EAAQnB,EAAOmB,MACfC,EAASrB,EAAOC,OAAOC,YAC7BmB,EAAOC,QAAU,GACjB,MAAMC,EAAcH,GAAO7E,OAC3B,GAAIgF,EAAa,CACb,IAAK,IAAIjF,EAAQ,EAAGA,EAAQiF,IAAejF,EACvCkF,EAAcJ,EAAM9E,IAExB+E,EAAOC,QAAQhD,QAAQ8C,EAC3B,CACAC,EAAOlB,WAAaA,CACxB,CAjEqCsB,CAAUtB,GAkCxC,SAASqB,EAAcJ,GAC1B,MAAMlF,EAAWkF,EAAMlF,SACvB,IAAKA,EACD,OAAOkF,EAAMM,aAEjB,MAAO9G,EAAO+G,GA2BX,SAA0BzF,GAC7B,MAAM0F,EAAW1F,EAAS2F,IACnBjH,GAASgH,GACTD,GAAczF,EAAStB,GAC9B,MAAO,CAACA,EAAO+G,EACnB,CAhCgCG,CAAiB5F,GAC7C,GAAIyF,IAAeE,EAAe,CAC9B,MAAMf,EAAU,kPAGU5E,EAAWA,EAAS6F,WAAaC,KAAKC,UAAUb,IAAU,KAEpF,MADAc,QAAQC,MAAMrB,EAAS,CAAEM,QAAOlF,WAAUtB,QAAO+G,eAC3C,IAAIf,MAAME,EACpB,CACA,OAAOlG,CACX,CAhDAoF,EAAO,CACHM,eACAC,aAAcD,EACdE,YAAcL,IACV,MAAMF,EAASE,EAAWF,OACpBoB,EAASrB,EAAOC,OAAOC,YACvBoB,EAAUD,EAAOC,QACvB,GAAIA,EAAQ/E,QACJ+E,EAAQ/E,SAAW8E,EAAOF,MAAM5E,OAAQ,CACxC,MAAMuE,EAAU,+BAA+BQ,EAAQ/E,cAAc8E,EAAOF,MAAM5E,oPAC5E6F,EAAUjC,EAAWrF,WAAWsH,QAChCvB,EAAU,CACZwB,UAAWhB,EAAOF,MAClBmB,UAAWjB,EAAOC,QAClBiB,YAAaH,EAAQI,WAAWC,UAE9BN,EAAQ,IAAIlB,EAAmBH,EAASD,GAE9C,MADAqB,QAAQQ,KAAK5B,EAASD,GAChBsB,CACV,QAEGd,EAAOC,eACPD,EAAOlB,WACdF,EAAOmB,MAAM7E,OAAS,EACtB0D,EAAOmB,MAAM9C,QAAQ+C,EAAOF,OAC5B,MAAMC,EAAQnB,EAAOmB,MACrB,IAAK,IAAI9E,EAAQ8E,EAAM7E,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACpD,MAAMqG,EAAOvB,EAAM9E,GACnBqG,EAAKlE,UAAY+C,EAAcmB,EACnC,CACAtB,EAAOF,MAAQ,EAAE,IAmBlB,MAAMU,GCxDN,SAASe,EAAWC,EAAWC,GAClC,IAAK,IAAIxG,EAAQuG,EAAUtG,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACxD,MACMyG,EADQF,EAAUvG,GACAnC,MAClB+B,EAAW4G,EAAQxG,GAAOJ,SAC5BA,GACAA,EAAS6G,GAEbD,EAAQxG,GAAOmC,UAAYsE,CAC/B,CACJ,CCNO,SAAS3B,EAAMM,GAClB,MAAML,EAASrB,EAAOC,OAAOC,YAC7B,IAAI8C,EACJ,MACMC,EADU5B,EAAOC,QACCD,EAAOF,MAAM5E,QACrC,GAAI0G,EAAS,CACT,IAAIC,EAAW1B,EAAcyB,GAC7BD,EAAiBpH,GAAM,CAACsH,EAAUA,EAAWtH,GAC7C,MAAM0C,EAAO,CACTnE,IAAK,IAAMqH,EAAclD,GACzBpC,SAAU8G,EACVvE,UAAWyE,EACXxB,aAAcuB,EAAQvB,cAG1B,OADAL,EAAOF,MAAM7C,KAAKA,GACX4E,CACX,CAGA,IAAIC,GADczB,aAAwB0B,SAAW1B,EAAe,IAAMA,KAG1E,GAAIyB,aAAqBC,SAAU,CAC/B,MAAMxB,EAAWP,EAAOF,MAClBhB,EAAakB,EAAOlB,WACpBsC,EAAWU,EACjBA,EAAY,IAAK9D,KACb,MAEMgE,EAFSlD,EAAWmD,OACJC,OACEtD,OAAOmB,MAC/BwB,EAAWS,EAAUzB,GACrB,MAAM4B,EAASf,KAAYpD,GAE3B,OADAuD,EAAWhB,EAAUyB,GACdG,CACV,EACDL,EAAUV,SAAWA,CACzB,CACAO,EAAiBpH,GAAM,CAACuH,EAAWA,EAAYvH,GAC/C,MAAM0C,EAAO,CACTnE,IAAK,IAAMqH,EAAclD,GACzBpC,SAAU8G,EACVvE,UAAW0E,EACXzB,aAAcyB,GAGlB,OADA9B,EAAOF,MAAM7C,KAAKA,GACX6E,CACX,CCtCO,MAAMM,EAAQ,CAAEC,EAAexH,IAC3ByH,EAAWD,EAAexH,GAE/B0H,EAAkBhI,GAAMA,EAgB9B,MAAM+H,EAAa,CAACD,EAAexH,GAAY2H,OAAMC,SAAS,MAAM,GAAMC,QAAQH,GAAoB,CAAC,KACnG,IAAII,EAAW5C,EAAM,CACjB6C,gBAAYC,EACZ9H,YAAQ8H,IAEZ,MAAMC,EAAiBH,EAAS5H,OAEhC,QAAuB8H,IAAnBC,EAA8B,CAC9B,IAAKL,EAAOJ,GAER,OADAM,EAAS5H,OAASsH,EACXM,EAASC,WAEpB,MACMT,GADaK,GAAQ3H,GACDwH,EAAeS,GAGzC,OAFAH,EAASC,WAAaF,EAAMP,GAC5BQ,EAAS5H,OAASsH,EACXM,EAASC,UACpB,CAEA,GADiBP,EAAc/H,OAAM,CAACgH,EAAMrG,IAAUqG,IAASwB,EAAe7H,KAE1E,OAAO0H,EAASC,WAEpB,IAAKH,EAAOJ,GAER,OADAM,EAAS5H,OAASsH,EACXM,EAASC,WAEpB,MAAMT,EAAStH,EAASwH,EAAeS,GAIvC,OAHAH,EAASC,WAAaF,EAAMP,GAC5BW,EAAe5H,OAAS,EACxB4H,EAAe7F,QAAQoF,GAChBM,EAASC,UAAU,EAE9B,SAASG,EAAeC,EAAUC,GAqC9B,OApCAtK,OAAOC,eAAeqK,EAAU,SAAU,CACtC,GAAAnK,GACI,MAAMsJ,EAAQY,IAEd,OADAZ,EAAMc,MAAMV,KAAO,KAAe,EAC3BJ,CACX,IAEJzJ,OAAOC,eAAeqK,EAAU,YAAa,CACzC,GAAAnK,GACI,MAAMqK,EAAWH,IACXI,EAAerD,GAAM,IAAMrB,MAC3BzE,EAAU8F,GAAM,IAAM,IAAI5B,OAAa0E,KACvCQ,EAAS,CAAChB,EAAexH,KAC3ByH,EAAWD,GAAe,CAACA,EAAeS,KACtC,MAAMQ,EAAgB5E,IAChB6E,EAAQ1I,EAASwH,EAAeS,GACtC,GAAIQ,IAAkBF,EAAc,CAEhC7B,EADoB5C,EAAOC,OAAOC,YAAYiB,MACtBsD,EAAaxE,OAAOmB,MAChD,CACA9F,EAAQ4B,KAAK0H,EAAM,GACpBJ,EAASD,OACLjJ,GAIX,OAFAoJ,EAAOH,MAAQC,EAASD,MACxBH,GAAe,IAAMM,GAAQA,GACtBA,CACX,IAEJ1K,OAAOC,eAAeqK,EAAU,SAAU,CACtC,GAAAnK,GACI,MAAMsJ,EAAQY,IAEd,OADAZ,EAAMc,MAAMT,OAAUJ,GAAkBA,EAAc/H,OAAMC,GAAKA,IAC1D6H,CACX,IAEGa,CACX,CC9FO,SAAShJ,EAAQV,EAAO2C,GAC3B,MAAMsH,EAAczD,GAAM,IAAMpB,EAAOC,OAAOC,YAAYiB,QACpDwD,EAAgB5E,IACtB,OAAOqB,GAAM,IACO,IAAIpF,EAAQpB,EAAO2C,GAAgB0B,MAAKrD,IACpDgH,EAAW+B,EAAc1E,OAAOmB,MAAOyD,GAChCjJ,MAInB,CCbO,SAASkJ,EAASpD,GACrB,MAAML,EAASrB,EAAOC,OAAOC,YAE7B,IAAI8C,EACJ,MAAMC,EAFU5B,EAAOC,QAECD,EAAOF,MAAM5E,QACrC,GAAI0G,EAAS,CACT,IAAIC,EAAW1B,EAAcyB,GAC7BD,EAAiBpH,GAAM,CAACsH,EAAUA,EAAWtH,GAC7C,MAAM0C,EAAO,CACTnE,IAAK,IAAMqH,EAAclD,GACzBpC,SAAU8G,EACVvE,UAAWyE,EACXxB,aAAcuB,EAAQvB,cAG1B,OADAL,EAAOF,MAAM7C,KAAKA,GACXyG,EAAgB7B,EAAU5E,EACrC,CAGA,IAAI6E,GADczB,aAAwB0B,SAAW1B,EAAe,IAAMA,KAE1EsB,EAAiBpH,GAAM,CAACuH,EAAWA,EAAYvH,GAC/C,MAAM0C,EAAO,CACTnE,IAAK,IAAMqH,EAAclD,GACzBpC,SAAU8G,EACVvE,UAAW0E,EACXzB,aAAcyB,GAGlB,OADA9B,EAAOF,MAAM7C,KAAKA,GACXyG,EAAgB5B,EAAW7E,EACtC,CACA,SAASyG,EAAgB5B,EAAW7E,GAMhC,OAJgB0G,IACZ1G,EAAKpC,SAAW8I,GAAK,CAACpJ,GAAK,CAACuH,EAAWA,EAAYvH,IAC5CuH,EAGf,CCjCO,SAAS8B,EAAQ5K,GACpB,OAAO6K,IACH,IAAIC,EAASL,EAASzK,EAATyK,CAAeI,GAG5B,OAFAzB,EAAM,CAACpJ,IAAO,IAAM6K,EAAWC,EAAS9K,KACxC6K,EAAWC,GACJA,CAAM,CAErB,CCdO,SAASC,EAAUhL,GACtB,OAAOiL,EAAcjL,EAAK,IAAIkL,QAClC,CACA,SAASD,EAAcjL,EAAKmL,GAExB,GAAY,OAARnL,GAA+B,iBAARA,EACvB,OAAOA,EAGX,GAAImL,EAAQC,IAAIpL,GACZ,OAAOmL,EAAQpL,IAAIC,GAGvB,GAAIA,aAAeqL,KACf,OAAO,IAAIA,KAAKrL,GAEpB,GAAIA,aAAesL,OACf,OAAO,IAAIA,OAAOtL,GAGtB,MAAMuL,EAAQjK,MAAMkK,QAAQxL,GAAO,GAAKJ,OAAO6L,OAAO7L,OAAO8L,eAAe1L,IAI5E,GAFAmL,EAAQ7H,IAAItD,EAAKuL,GAEbjK,MAAMkK,QAAQxL,GACd,IAAK,IAAI2L,EAAI,EAAGA,EAAI3L,EAAImC,OAAQwJ,IAC5BJ,EAAMI,GAAKV,EAAcjL,EAAI2L,GAAIR,QAIrC,IAAK,MAAMzL,KAAOM,EACVA,EAAIG,eAAeT,KACnB6L,EAAM7L,GAAOuL,EAAcjL,EAAIN,GAAMyL,IAIjD,OAAOI,CACX,CACO,SAASK,EAAUC,EAAMC,GAC5B,OAAOC,EAAYF,EAAMC,EAAM,IAAIZ,QACvC,CACA,SAASa,EAAYF,EAAMC,EAAMX,GAE7B,SADoBU,IAASC,IAuDRE,EAtDcH,EAsDTI,EAtDeH,EAuDpBE,aAAehD,UAAYiD,aAAejD,UACxCgD,EAAIrE,aAAesE,EAAItE,iBApD1CwD,EAAQC,IAAIS,IAGI,iBAATA,GAAqC,iBAATC,IAE/BD,aAAgBR,MAAQS,aAAgBT,KACjCQ,EAAKK,YAAcJ,EAAKI,WAGnCf,EAAQ7H,IAAIuI,EAAM,GAEdvK,MAAMkK,QAAQK,IAASvK,MAAMkK,QAAQM,GA4BjD,SAA0BD,EAAMC,EAAMX,GAClC,GAAIU,EAAK1J,SAAW2J,EAAK3J,OACrB,OAAO,EAEX,IAAK,IAAIwJ,EAAI,EAAGA,EAAIE,EAAK1J,OAAQwJ,IAC7B,IAAKI,EAAYF,EAAKF,GAAIG,EAAKH,GAAIR,GAC/B,OAAO,EAGf,OAAO,CACX,CArCmBgB,CAAiBN,EAAMC,EAAMX,IAE/B7J,MAAMkK,QAAQK,KAASvK,MAAMkK,QAAQM,IAQtD,SAA2BD,EAAMC,EAAMX,GACnC,MAAMiB,EAAQxM,OAAOyM,KAAKR,GACpBS,EAAQ1M,OAAOyM,KAAKP,GAC1B,GAAqB,IAAjBM,EAAMjK,QAAiC,IAAjBmK,EAAMnK,OAC5B,OAAO,EAEX,GAAIiK,EAAMjK,SAAWmK,EAAMnK,OACvB,OAAO,EAEX,IAAK,MAAMzC,KAAO0M,EAAO,CAErB,IADiBE,EAAM3L,SAASjB,KACdqM,EAAYF,EAAKnM,GAAMoM,EAAKpM,GAAMyL,GAChD,OAAO,CAEf,CACA,OAAO,CACX,CApBeoB,CAAkBV,EAAMC,EAAMX,MAgC7C,IAAyBa,EAAKC,CA7B9B,CJiCAjC,GAAe,IAtFf,SAAkBG,GACd,MAAMG,EAAS,CAAChB,EAAexH,IACpByH,EAAWD,EAAexH,EAAUqI,GAI/C,OAFAG,EAAOH,MAAQA,EACfH,GAAe,IAAMM,GAAQA,GACtBA,CACX,CA+EqBkC,CAAS,CAAC,IAAInD,GCpFnCnI,EAAQmC,OAAU7C,IACd,MAAMiK,EAAczD,GAAM,IAAMpB,EAAOC,OAAOC,YAAYiB,QACpDwD,EAAgB5E,IACtB,OAAOqB,GAAM,IACO,IAAI5B,EAAa5E,GAAOqE,MAAKrD,IACzCgH,EAAW+B,EAAc1E,OAAOmB,MAAOyD,GAChCjJ,MAGb,EAUNN,EAAQ8D,IARR,SAAaC,GACT,MAAMwF,EAAczD,GAAM,IAAMpB,EAAOC,OAAOC,YAAYiB,QACpDwD,EAAgB5E,IACtB,OAAO/D,EAAQoD,IAAIC,GAAMJ,MAAKrD,IAC1BgH,EAAW+B,EAAc1E,OAAOmB,MAAOyD,GAChCjJ,IAEf,EIhCO,MAAMiL,EAAY,CACrBhB,OAASiB,IACL,MAAMC,EAAkB3F,GAAM,KAAM,CAAG4F,UAAW,EAAGC,cAAU/C,MAE/D,GAAI6C,EAAgBC,UAAW,CAC3B,IAAK,IAAIpL,EAAImL,EAAgBC,UAAWpL,EAAI,IAAKA,EAC7CwF,OAAM8C,GAGV,OADe9C,OAAM8C,EAEzB,CACA,MAAMV,EAASpC,GAAM,KACjB,MACMlB,EADSF,EAAOC,OACKC,YACrBgH,EAAgBhH,EAAYiB,MAAM5E,OAElC4K,EAAW,cAAeL,EAAkB,IAAIA,EAAoBA,IACpE3G,EAAaD,EAAYC,WACzB6G,EAAY9G,EAAYiB,MAAM5E,OAAS2K,EACvCD,EAAW,CACbH,kBACAK,WACAxB,MAAOP,EAAU+B,GACjBH,YACAI,MAAOjH,EACPkH,SAAU,IAKd,OAHAN,EAAgBE,SAAWA,EAC3B9G,EAAWmD,OAAOuD,UAAUvI,KAAK2I,GACjCF,EAAgBC,UAAYA,EACrBG,CAAQ,IAEbG,EAAKR,EAELS,EAAYD,EAAGC,UAAYD,EAAGvF,WAEpC,OADAgF,EAAgBE,SAASH,gBAAgBS,UAAYA,EAC9C/D,CAAM,EAOjBgE,OAAS7J,GAEEyD,GAAM,KACT,MAAMnB,EAASD,EAAOC,OAChBqH,EAAK3J,EACL4J,EAAYD,EAAGC,UAAYD,EAAGC,WAAa5J,EAAYoE,WACvD5B,EAAaF,EAAOC,YAAYC,WAChC0G,EAAY,GAClB,IAAIO,EAAQ,CACRK,gBAAiBtH,EAAWsH,iBAEhC,KAAOL,EAAMK,iBAAiB,CAC1B,MACMR,EADiBG,EAAMK,gBAAgBnE,OAAOuD,UACpBa,MAAKT,IACjCJ,EAAUvI,KAAK2I,GAEf,GADyBA,EAASH,gBAAgBS,YAAcA,EAE5D,OAAO,CACX,IAEJ,GAAIN,EAAU,CACVA,EAAStB,MAAQP,EAAU6B,EAASE,UACpC,MAAMhH,EAAaF,EAAOC,YAAYC,WAGtC,OAFAA,EAAWmD,OAAOuD,UAAUvI,KAAK2I,GACjCA,EAASI,SAAS/I,KAAK6B,GAChB8G,EAASE,QACpB,CACAC,EAAQA,EAAMK,eAClB,CACA,MAAME,EAAM,8BAA8BhK,EAAYjD,QAAQiD,IAE9D,MADAuE,QAAQQ,KAAK,GAAGiF,yBAA4Bd,GACtC,IAAIjG,MAAM+G,EAAI,KC7EzB,SAASC,EAAWC,EAC3BC,GACI,MAAMC,EAAaF,EAAY/M,UACzBkN,EAAaF,EAAYhN,UACzBmN,EAAOF,GAAYlN,KAAOgN,EAC1BK,EAAOF,EAAWnN,IAClBsN,EAAWF,EAAKG,QAChBC,EAAWP,EAAYM,SAAWF,EAAKE,QAC7C,GAAID,EAAS5L,SAAW8L,EAAS9L,OAC7B,OAAO,EAGX,IAD2B4L,EAASxM,OAAM,CAAC2M,EAAQhM,IAAU+L,EAAS/L,KAAWgM,IAE7E,OAAO,EAIX,OAAOC,EAFSV,EAAYzL,QAAU6L,EAAK7L,OAC3B0L,EAAY1L,QAAU8L,EAAK9L,OAE/C,CACO,SAASmM,EAAgBC,EAASC,GAErC,KAD2BD,EAAQjM,SAAWkM,EAAQlM,QAElD,OAAO,EAcX,QAZqBkM,EAAQ9M,OAAM,CAACf,EAAO0B,KACvC,MAAMiL,EAAYiB,EAAQlM,GAE1B,GADoB1B,aAAiBwI,UAAYmE,aAAqBnE,SACrD,CAEb,SADoBxI,EAAMmH,aAAewF,EAAUxF,WAKvD,CACA,OAAO,CAAI,GAMnB,CC9BO,SAAS2G,EAAgBvI,EAAYwI,GACxC,MAAMjI,EAASV,EAAOU,OAChBnE,EAASmE,EAAOnE,OACtB,IAAK,IAAID,EAAQ,EAAGA,EAAQC,IAAUD,EAClCoE,EAAOpE,GAAOgE,aAAaH,EAAYwI,EAE/C,CAEO,SAASC,EAAezI,EAAYsH,GACvC,MAAM/G,EAASV,EAAOU,OAChBnE,EAASmE,EAAOnE,OACtB,IAAK,IAAID,EAAQ,EAAGA,EAAQC,IAAUD,EAClCoE,EAAOpE,GAAOkE,YAAYL,EAAYsH,GAE1CzH,EAAOC,OAAO4I,WAAW3L,KAAKuK,EAClC,CAUO,SAASqB,EAAiB3I,EAAYsH,GACzC,MAAM/G,EAASV,EAAOU,OAChBnE,EAASmE,EAAOnE,OACtB,IAAK,IAAID,EAAQ,EAAGA,EAAQC,IAAUD,EAClCoE,EAAOpE,GAAOmE,cAAcN,EAAYsH,GAK5C,GAHAtH,EAAWmD,OAAOyF,SAAU,EAC5B5I,EAAW6I,iBAAkB,EAEzBvB,EAAiB,CACjBA,EAAgBnE,OAAO2F,UAAYxB,EAAgBnE,OAAO2F,UAAUC,QAAOC,GAASA,IAAUhJ,EAAWmD,OAAO8F,SAChH,MAAM9F,EAASnD,EAAWmD,OAC1BA,EAAOuD,UAAUwC,SAAQpC,GAAYA,EAASI,SAASgC,SAAQ,CAACF,EAAO7M,KAC/D6M,EAAM7F,SAAWA,GACjB2D,EAASI,SAASlJ,OAAO7B,EAAO,EACpC,KAER,CACJ,CCnDO,SAASgN,EAAcC,EAAeC,EAAalO,EAASqN,GAC/D,MAAMc,EAAiBF,EAAcjG,OAAOoG,aAkBhD,SAA0BvJ,EAC1BwJ,EAAeH,GACX,MAAMI,EAAmBJ,GAAa/B,gBAChCoC,EAAsBD,GAAoBD,EAChD,GAAIH,EAAa,CACb,GAAIA,IAAgBrJ,EAAY,CAC5B,MAAM2J,EAAYN,EAAYvJ,OAAOmB,MAC/BnB,EAASE,EAAWF,OAC1BE,EAAWmD,OAASkG,EAAYlG,OAChCrD,EAAOmB,MAAM7E,OAAS,EACtB0D,EAAOmB,MAAM9C,QAAQwL,EACzB,CACA,ODND,SAAyB3J,EAAYsH,GACxC,MAAM/G,EAASV,EAAOU,OAChBnE,EAASmE,EAAOnE,OACtB,IAAK,IAAID,EAAQ,EAAGA,EAAQC,IAAUD,EAClCoE,EAAOpE,GAAOiE,aAAaJ,EAAYsH,EAE/C,CCAesC,CAAgB5J,EAAYqJ,EACvC,CAEOd,EAAgBvI,EAAY0J,EACvC,CAjCIG,CAAiBT,EAAeZ,EAAca,GAI9C,IAAIS,GAAY7H,EAHEmH,EAAczO,UAENsH,SACFmH,EAAejO,GAQvC,OANAsN,EAAeW,EAAeZ,GAC9BY,EAAcjG,OAAOC,OAAS0G,GACzBT,GAAeb,GAChBA,EAAarF,OAAO2F,UAAU3K,KAAK2L,GAGnCA,EAAU3G,OAAOoG,YAAcD,EAAiB,EACzCF,EAAcjG,OAAOC,OAEzB0G,CACX,CCpBO,SAASC,EAAiBC,GAEdA,EAAc7G,OAAO8F,OAC7BgB,UACPD,EAAc7G,OAAO+G,QAAU,CAAC,CACpC,CCEO,SAASC,EAAeC,EAC/BC,GAOI,IAAIC,EAAcF,EACdG,EAAkBF,EAEtB,GAAuB,iBAAZ,EAAsB,CAC7B,IAAKA,EACD,OAAO,EAGXC,EAAc,IAAIF,GAElBG,EAAkB,IAAKF,GAAkB,IAmBzC,IAlB0BC,EAAY9O,OAAM,CAACf,EAAO0B,KAChD,IAAIqO,EAAUD,EAAgBpO,GAC9B,GAAI1B,GAA4B,iBAAZ,EAAsB,CACtC,MAAMgQ,EAAiB,IAAKhQ,GACtBiQ,EAAkB,IAAKF,GAAW,CAAC,GACnCG,EAAU9Q,OAAO+Q,QAAQH,GAAgBjP,OAAM,EAAE7B,EAAKc,KACjDoQ,EAAapQ,EAAOiQ,EAAgB/Q,IAAM,YACtC8Q,EAAe9Q,UACf+Q,EAAgB/Q,EAAI,MAGnC,OAAOgR,CACX,CACA,OAAOE,EAAapQ,EAAO+P,GAAS,KAChCF,EAAYtM,OAAO7B,EAAO,GAC1BoO,EAAgBvM,OAAO7B,EAAO,EAAE,GAClC,IAGF,OAAO,CAEf,CAGA,OAAO,CACX,CAEA,SAAS0O,EAAapQ,EAAO+P,EAASM,GAClC,KAAMrQ,aAAiBwI,UACnB,QAAO4C,EAAUpL,EAAO+P,IAAW,EAGvC,KADkBA,aACSvH,UACvB,OAAO,EAGX,MAAM8H,EAAkBP,GAASlI,SAC7ByI,IACAP,EAAUO,GAEGtQ,EAAM6H,WAEnB7H,EAAQA,EAAM6H,UAIlB,OAFoB7H,EAAMmH,aACJ4I,EAAQ5I,YAE1BkJ,IACO,IAEXA,IACO,EACX,CC7EO,SAASE,EAAiBhL,EAAY7E,EAC7C8P,GACA,OAAEC,IAEE,MAAMC,EAAahQ,EACbiQ,EAAcD,EAAWnL,WACzBqJ,EAAc+B,GAAajI,OAAO8F,aAAUlF,EAElD,OAAIsF,GADeA,EASvB,SAAgCrJ,EAAY7E,EAC5CkO,GAEI,GAAIlO,aAAmB8H,SAAU,CAC7B,MAAMoI,EAAalQ,EAAQkO,GAG3B,OAFAA,EAAYiC,SAASD,GACrBlQ,EAAQ6E,WAAaqL,EACdA,CACX,CAGA,OAFAhC,EAAYiC,SAAStL,GACrB7E,EAAQ6E,WAAaA,EACdA,CACX,CAnBeuL,CAAuBvL,EAAYmL,EAAY9B,IAE1DrJ,EAAWwL,mBAAmBP,EAAc,CACxCC,WAEGlL,EACX,CJZAH,EAAOC,OAAO4I,WAAa,IAAI7M,OAAQkI,GAAW1H,IACzCuD,KACDvD,EAAaU,MACjB,IKNG,MAAM0O,EAAiB,WACjBC,EAAiB,KAAOD,EAAiB,KACzCE,GAAe,IAAIpG,OAAOmG,EAAgB,KAChD,MAAME,GACT3D,QACAhM,OACApB,UAAYtB,EAAWmB,IAEvBoF,OAAS,CAAC,EACVnF,UACA,WAAA6C,CAAYyK,EAAShM,GACjBwB,KAAKwK,QAAUA,EACfxK,KAAKxB,OAASA,CAClB,CAEA,GAAAtC,CAAIkS,GAEA,OADApO,KAAKqC,OAAO+L,WAAaA,EAClBpO,IACX,CACAyJ,SACA,IAAA4E,CAAK7D,KAAYhM,GAEb,OADAwB,KAAKyJ,SAAW,CAAEe,UAAShM,UACpBwB,IACX,ECvBG,SAASsO,GAAYC,EAASC,GACdA,EAAcC,WACtBjB,aAAae,EAASC,EAAcE,YACnD,CCkEO,SAASC,GAAa3R,GACzB,MAAO,CAAC,SAAU,SAAU,WAAWG,SAASH,EACpD,CACO,SAAS4R,GAAgBrM,EAAYkL,GACxClL,EAAWiK,QAAQ,CACfqC,QAASpB,EAAOqB,YAEpB,MAAMtB,EAAejL,EAAWmD,OAAO8H,aACpBA,EAAaiB,WACrBM,YAAYvB,EAC3B,CAWO,SAAS,GAAiBG,GAC7B,MAAMH,EAAeG,EAAYjI,OAAO8H,aAClC9H,EAASiI,EAAYjI,OACrBsJ,EAAiBtJ,EAAOuJ,YAC1BD,IACAV,GAAYd,EAAcwB,UACnBtJ,EAAOuJ,YAEtB,CChGO,SAASC,GAAalS,GACzB,GAAIA,QACA,OAAOlB,EAAWwK,UAEtB,MAAM6I,SAAc,EACpB,GAAInS,aAAiBwI,SACjB,OAAO1J,EAAWsT,SAEtB,GAAa,WAATD,EAAmB,CACnB,GAAInS,aAAiB6K,KACjB,OAAO/L,EAAWuT,KAEtB,GAAIV,GAAaQ,GACb,OAAOA,EAEX,MAAM/R,EAAYJ,EAAMI,UACxB,GAAIA,EAAW,CAMX,GALiB,CACbtB,EAAWyB,aACXzB,EAAWoB,UACXpB,EAAWmB,KACbE,SAASC,GAEP,OAAOA,CAEf,CACA,GAAIS,EAAWb,GACX,OAAOlB,EAAWwT,SAEtB,GAAI7R,EAAkBT,GAClB,OAAOlB,EAAW4B,OAE1B,CACA,OAAO5B,EAAWyT,OACtB,CClCO,SAASC,GAAgBhR,GAC5B,OAAOA,EAAOQ,KAAKhC,IACf,MAAMC,EAAMD,EACZ,OAAQkS,GAAalS,IACjB,KAAKlB,EAAWyB,aAEZ,OAAOiK,EADcxK,EACS2P,OAClC,KAAK7Q,EAAWmB,IAChB,KAAKnB,EAAWoB,UACZ,OAAOsS,GAAgBvS,EAAIuB,QAC/B,KAAK1C,EAAWwT,SACZ,OAAOE,GAAgBvS,GAE/B,OAAOuK,EAAUxK,EAAM,GAE/B,CClBO,SAASyS,GAAsBpE,EAAWqE,EAAU,IACvD,IAAK,IAAIhR,EAAQ2M,EAAU1M,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACxD,MAAMiR,EAAOtE,EAAU3M,GACvBgR,EAAQhP,KAAKiP,GACbtE,EAAU9K,OAAO7B,EAAO,GACxB+Q,GAAsBE,EAAKjK,OAAO2F,UAAWqE,EACjD,CACA,OAAOA,CACX,CCLO,MAAME,GACTjD,MACAvP,UAAY,YACZyS,OACArL,QACAsL,qBACA7S,IACAwM,SAAW,IAAI7H,EAAa,IAC5BwM,WACA,WAAArO,CAAY4M,GACR3M,KAAK2M,MAAQA,CACjB,CACA,GAAAzQ,CAAIkS,GAEA,OADApO,KAAKoO,WAAaA,EACXpO,IACX,CACA,IAAAqO,CAAK7D,KAAYhM,GACb,MACMuR,ECnBP,SAA+BtG,EAAUuG,GAC5C,GAAIvS,EAAkBgM,GAClB,OAAOA,EAGX,GAAI5L,EADa4L,GAGb,OADAuG,EAAgBF,sBAAuB,EAChC,IAAIlO,EAAa6H,GAE5B,MAAMwG,EAAMxG,EACZ,OAAIwG,GACAD,EAAgBF,sBAAuB,EACvCG,EAAI5N,OAAO+L,WAAa,EACjB,IAAIxM,EAAa,CAACqO,MAE7BD,EAAgBF,sBAAuB,EAChC,IAAIlO,EAAa,IAC5B,CDE6BsO,CADJ,IAAI/B,GAAI3D,EAAShM,GACmBwB,MAErD,OADAA,KAAKyJ,SAAWsG,EACT/P,IACX,EEFJ,SAASmQ,GAAcnT,EAAO+N,GAC1B,MAAM9N,EAAMD,EACZ,IAAIE,EAAYD,EAAIC,UACfA,IACDA,EAAY,IAAI0S,GAAgB,IAChC1S,EAAUD,IAAMA,EAChBA,EAAIC,UAAYA,GAEpB,MAAMQ,EAAU,IAAIkE,EAAa1E,GAGjC,OAFAQ,EAAQ6E,WAAa,IAAI6N,GAAWlT,EAAW6N,EAAcrN,GAC7DqN,EAAarF,OAAO2F,UAAU3K,KAAKhD,EAAQ6E,YACpC7E,CACX,CC9BO,SAAS2S,GAAiB7C,GAC7B,MAAMyB,EAAcqB,SAASC,eAAe,IACtC9B,EAAajB,EAAaiB,WAGhC,OAFAA,EAAWjB,aAAayB,EAAazB,GACrCiB,EAAWM,YAAYvB,GAChByB,CACX,CCVO,SAASuB,GAAiB1T,EAAME,EAAOyT,GAC1C,MAAMC,EAAQ5T,EAAK6T,MAAM,KAMzB,GAJiB,UAAbD,EAAM,KACND,EAAQG,MAAMF,EAAM,IAAM1T,GAGb,UAAb0T,EAAM,GAEN,GADAA,EAAM5R,QACF9B,EACA,IAAK,IAAI0B,EAAQ,EAAGA,EAAQgS,EAAM/R,SAAUD,EACxC+R,EAAQI,UAAUpQ,IAAIiQ,EAAMhS,SAIhC,IAAK,IAAIA,EAAQ,EAAGA,EAAQgS,EAAM/R,SAAUD,EACxC+R,EAAQI,UAAUC,OAAOJ,EAAMhS,GAI/C,CCfA,MAAMqS,IAAW,EAYV,SAASC,GAAehU,EAAOuF,EAAY0O,EAAQxP,GACtD,MAAMxE,EAAMiU,GAAkB3O,GACxBuE,EAAS9J,EAAMmU,KAAKF,GAC1BhU,EAAIyI,OAAO0L,OAASL,GAEpB,OAEJ,SAA0B9T,EAAKoU,GAE3B,UADOpU,EAAIyI,OAAO0L,OACdnU,EAAIyI,OAAO4L,QAAQ3S,OAAQ,CAC3B,IAAI4S,EASJ,OARAtU,EAAIyI,OAAO4L,QAAQ7F,SAAQ6F,IACvB,MAAME,EAAQF,EACdC,EAAaE,GAA2BD,EAAM3H,gBAAiB2H,EAAOA,EAAM9T,QAAS8T,EAAM9L,OAAO8H,cAAc,GAChHvQ,EAAIyI,OAAOC,OAAS4L,EACpBtU,EAAIyI,OAAO4L,QAAQ/Q,OAAO,EAAG,EAAE,IAEnCtD,EAAIyI,OAAO4L,QAAQ3S,OAAS,EAErB+S,GAA0BL,EAAgBE,EAAYA,EAAW7L,OAC5E,CACA,MAAME,EAWV,SAA+B+L,EAAMN,EAAgB3L,GACjD,GAAIA,EAAOyF,QACP,MAAO,eAGX,OADAyG,GAAiBD,GAAM,GAChBD,GAA0BL,EAAgBM,EAAMjM,EAC3D,CAjBmBmM,CAAsB5U,EAAIyI,OAAOC,OAAQ0L,EAAgBpU,EAAIyI,QAC5E,OAAOE,CACX,CAlBWkM,CAAiB7U,EADD6J,KAAUrF,GAErC,CAkBA,SAASyP,GAAkB3O,GAEvB,GAAIA,EAAWrF,UAAUE,YAActB,EAAWoB,UAAW,CAEzD,OAAOgU,GADO3O,EAAWsH,gBAE7B,CACA,OAAOtH,CACX,CAQA,SAASmP,GAA0BL,EAAgBM,EAAMjM,GACrD,OAAI2L,aAA0BpQ,SAC1B0Q,EAAKjM,OAAO0L,OAASL,GACdM,EAAepP,MAAK,YAChB0P,EAAKjM,OAAO0L,OACf1L,EAAOyF,iBAGJwG,EAAKjM,OAAO0L,OACnBQ,GAAiBlM,EAAOC,QAAQ,IAHrB,2BAOZ,cACX,CCnEA,MAAMoM,GAAY,gBACZC,GAAU,QAChB,SAASC,GAASjV,GACd,OAAOA,GAASA,EAAMkV,OAAOH,KAAc,GAAK/U,EAAMkV,OAAOF,KAAY,CAC7E,CACO,SAASG,GAAiBC,EAAUpV,EAC3CuO,EAAO8G,EAAOtH,EAAcuH,GACxB,GAAIL,GAASjV,GACT,OAuBR,SAAoCoV,EAAUpV,EAC9CuO,EAAO8G,EAAOtH,EAAcuH,GAExB,MAAM1M,EAAS2M,GAA2BF,EAAOrV,GACjD,OAAOwV,GAAqBJ,EAAUxM,EAAQ2F,EAAOR,EAAcuH,EACvE,CA5BeG,CAA2BL,EAAUpV,EAAOuO,EAAO8G,EAAOtH,EAAcuH,GAEnF,GAAIL,GAASG,GAAW,CAEpB,IAAIvR,EAEJ,MAAMP,EAHsBiS,GAA2BF,EAAOD,GAG9BxU,WAAWZ,IACnCA,IAAU6D,KA0B1B,SAA6B6R,EAAW7R,EAAW0K,EAAOR,EAAcuH,GACpE,GAAIzR,GAAaA,GAAa6R,EAC1B,GAA2B,iBAAhB,EACPnH,EAAMoH,gBAAgB9R,QAErB,GAAIA,aAAqBzE,OAC1B,IAAK,MAAMU,KAAQ+D,EACf0K,EAAMoH,gBAAgB7V,GAIlC,GAA2B,iBAAhB,EAA0B,CACjC,IAAK4V,EAAU/T,OACX,OAGJ,YADA6T,GAAqBE,EAAW,GAAInH,EAAOR,EAAcuH,EAE7D,CACA,GAAII,aAAqBtW,OACrB,IAAK,MAAMU,KAAQ4V,EACfF,GAAqB1V,EAAM4V,EAAU5V,GAAOyO,EAAOR,EAAcuH,EAG7E,CA9CYM,CAAoB5V,EAAO6D,EAAW0K,EAAOR,EAAcuH,GAC3DzR,EAAY7D,EAAK,IAIrB,OAFA+N,EAAarF,OAAO3G,cAAc2B,KAAKJ,QACvCiL,EAAMoH,gBAAgBP,EAE1B,CAGA,OADkBS,GAAcT,GAErB5B,GAAiB4B,EAAUpV,EAAOuO,QAD7C,CAGJ,CAOA,SAASgH,GAA2BF,EAAOrV,GAEvC,OAAOqV,EADMrV,EAAM8V,QAAQ,IAAK,IAAInC,MAAM,IAAIoC,UAAUC,KAAK,IAAIF,QAAQ,IAAK,IAAInC,MAAM,IAAIoC,UAAUC,KAAK,IAE/G,CAyBA,SAASR,GAAqBJ,EAAUxM,EAAQ2F,EAAOR,EAAcuH,GACjE,MAAMW,EAAYJ,GAAcT,GAChC,GAAIxM,aAAkBJ,SAAU,CAC5B,MAAM0N,EAAS,YAAazR,GAExB,OADgBmE,EAAO2F,EAAO9J,EAElC,EACA8J,EAAM6G,GAAUc,OAASA,CAC7B,CAEA,GAAIzV,EAAkBmI,GAAtB,CAEI,IAAI/E,EADJ0K,EAAMoH,gBAAgBP,GAEtB,MAAM9T,EAAY6U,GAEVA,aAAwB3N,SAsDxC,SAAqBuF,EAAcoI,EAAc5H,EAAO6G,EAAUa,EAAWX,GACzE,MAAM9N,EAAUuG,EAAa7N,UAAUsH,QACjCI,EAAaJ,GAASI,WACtBwO,EAAYxO,GAAYwO,UACzBA,IACDD,EDxID,SAA6BnW,EAAOuF,GAEvC,GAAIvF,EAAMqW,gBACN,OAAOrW,EAEGoF,EAAOC,OAAOC,YAA5B,MACMgR,EAAkB,CAAC7C,EAAShP,IAASuP,GAAehU,EAAOuF,EAAYkO,EAAShP,GAGtF,OADA6R,EAAgB3O,YAAc3H,EACvBsW,CACX,CC8HuBC,CAAoBJ,EAAcpI,IAErD,OAAOyI,GAA6BL,EAAc5H,EAAO6G,EAAUa,EAAWX,EAClF,CA7DuBmB,CAAY1I,EAAcoI,EAAc5H,EAAO6G,EAAUa,EAAWX,GAG3EzR,IAAcsS,EACPtS,GAEXA,EAAYsS,EACLK,GAA6BL,EAAc5H,EAAO6G,EAAUa,EAAWX,IAG5EhS,EAAMsF,EAAOhI,UAAUU,GAE7ByM,EAAarF,OAAO3G,cAAc2B,KAAKJ,EAE3C,MACAgS,EAAS/G,EAAO6G,EAAUxM,EAG9B,CACA,SAAS4N,GAA6BL,EAAc5H,EAAO6G,EAAUa,EAAWX,GAC5E,GAAIa,aAAwB3N,SAAU,CAClC,MAAMkO,EAAM,YAAajS,GACrB,OAAO0R,EAAa5H,EAAO9J,EAC/B,EAQA,OANAiS,EAAI/O,YAAcwO,EACD,kBAAbf,IACAA,EAAW,mBAGf7G,EAAM6G,GAAYsB,EAEtB,CACA,GAAIT,EAEA,YADAzC,GAAiB4B,EAAUe,EAAc5H,GAG7C,GAAI4H,EAEA,YADAb,EAAS/G,EAAO6G,EAAUe,GAGV,MAAC7M,GAAW,EAAO,MAAMnJ,SAASgW,GAElD5H,EAAMoH,gBAAgBP,GAI1BE,EAAS/G,EAAO6G,EAAUe,EAC9B,CAEA,SAASN,GAAcT,GACnB,OAAOA,EAASF,OAAO,uBAAyB,CACpD,CCvIA,SAASyB,GAAkBlD,EAAS3T,EAAME,GACtCyT,EAAQmD,aAAa9W,EAAME,EAC/B,CACA,SAAS6W,GAAmBpD,EAAS3T,EAAME,GACvCyT,EAAQ3T,GAAQE,CACpB,CACO,SAAS8W,GAAsBvI,EAAO8G,EAAOtH,GAChD,MAAMgJ,EAAYxI,EAAMyI,oBACxB,IAAI1B,EAAWqB,GACf,IAAK,IAAIjV,EAAQ,EAAGA,EAAQqV,EAAUpV,SAAUD,EAAO,CACnD,MAAM0T,EAAW2B,EAAUrV,GACJ,UAAnB6M,EAAM0I,UAAqC,UAAb7B,IAC9BE,EAAWuB,IAGf1B,GAAiBC,EADH7G,EAAM2I,aAAa9B,GACC7G,EAAO8G,EAAOtH,EAAcuH,GAC9DA,EAAWqB,EACf,CACJ,CClBO,MAAMQ,GAAqB,6FCE3B,SAASC,GAAWlX,EAAWsQ,EAAczC,EACpDrN,GACI,IAAI6E,EAAa7E,EAAQ6E,WAWzB,OATKA,IACDA,EAAa8R,GAAyBnX,EAAW6N,EAAcrN,IAEnEA,EAAQ6E,WAAaA,EACrBA,EAAWsH,gBAAkBkB,EAE7BxI,EAAWwL,mBAAmBP,EAAc,CACxCC,OAAQ,CAAE6G,MAAO,EAAGxF,QAAS,KAE1BvM,CACX,CACO,SAASgS,GAAiBtX,GAC7B,MAAMC,EAAYsX,KAGlB,OAFAtX,EAAUD,IAAMA,EAChBA,EAAIC,UAAYA,EACTA,CACX,CACO,SAASsX,KACZ,MAAMC,EAAO,CACThL,SAAU,IAAI7H,EAAa,IAE3B+K,MAAO,GACP+H,OAAO,EACPtX,UAAW,YACXyS,QAAQ,EACRxB,KAAM,IAAMoG,EACZvY,IAAK,IAAMuY,GAEf,OAAOA,CACX,CAEO,SAASJ,GAAyBnX,EAAW6N,EAAcrN,GAC9D,MAAM6E,EAAa,IAAI6N,GAAWlT,EAAW6N,EAAcrN,GAG3D,OAFAiX,GAAgBpS,EAAYwI,EAAcrN,GAC1CqN,EAAarF,OAAO2F,UAAU3K,KAAK6B,GAC5BA,CACX,CACO,SAASoS,GAAgBpS,EAAYwI,EAAcrN,GACtD6E,EAAWmD,OAAO8F,OAASjJ,EAC3BA,EAAWmD,OAAOC,OAASpD,EAE3BA,EAAWsH,gBAAkBkB,EAC7BrN,EAAQ6E,WAAaA,CACzB,CC3CO,SAASqS,GAAgBlX,EAASV,EACzCwQ,EACAzC,EAAc8J,GACV,MAAMhW,EAASkM,EAAalM,OAC5B,IAAIiW,EAAYpX,EAAQoX,UAAYpX,EAAQoX,WAAa,GACpDpX,EAAQuR,aA4FjB,SAA2BzB,EAAc9P,GACrC,GAA8B,aAA1B8P,EAAayG,SAEb,YADAvW,EAAQuR,YAAczB,GAG1B,MAAMyB,EAAcvR,EAAQuR,YAAcqB,SAASC,eAAe,IAC5D9B,EAAajB,EAAaiB,WAChCA,EAAWjB,aAAayB,EAAazB,GACrCiB,EAAWM,YAAYvB,EAC3B,CApGQuH,CAAkBvH,EAAc9P,GAEpC,MAAMsX,EAAsBtX,EAAQuR,YACpC,IAAIH,EAAU,EAEdgG,EAAYpX,EAAQoX,UAAYpX,EAAQoX,UAAUxJ,QAAO,CAACvG,EAAMrG,KAI5D,GAHkB1B,EAAM2B,OAAS,EACtBD,EAAQoQ,EAKf,OAFAmG,GAAiBH,EAAWpW,EAAOmW,KACjC/F,GACK,EAEX,MAAMoG,EAASlY,EAAM0B,EAAQoQ,GACvBqG,EAAW3X,EAAW0X,GAC5B,IAEIE,EAFAnY,EAAMiY,EACNhY,EAAYgY,EAAOhY,UAEnBiY,EACAC,EAAiBnY,EAAIoF,OAAO+L,YAG5BlR,EAAYgY,EACZjY,EAAMC,EAAUD,IAChBmY,EAAiBlY,EAAUkR,YAG/B,MAEMiH,GA0Fd,SAAuBC,EAAQC,GAC3B,GAAID,IAAWC,EACX,OAAO,EAIX,GAFmBD,aAAkBxX,OAASyX,aAAkBzX,OAC7BwX,EAAO3W,QAAU4W,EAAO5W,OAEvD,OAAO2W,EAAOvX,OAAM,CAACgH,EAAMrG,IAAUqG,GAAQwQ,EAAO7W,KAExD,OAAO,CACX,CApG6B8W,CAAcJ,EAFnBrQ,EAAKxC,WAAWrF,UAAUD,IACXoF,OAAO+L,YAEtC,OAAIiH,IACAJ,GAAiBH,EAAWpW,EAAOmW,KACjC/F,GACK,EAEA,IAEf,MAAMnQ,EAAS3B,EAAM2B,OACrB,IAAK,IAAID,EAAQ,EAAGA,EAAQC,IAAUD,EAAO,CACzC,MAAMqG,EAAO/H,EAAM0B,GACb0H,EAAW0O,EAAUpW,GACrB+W,EAAkBrP,GAAU7D,WAC5B2S,EAASnQ,EACToQ,EAAW3X,EAAW0X,GACtBQ,EAAc,IAAI9T,OAAa0E,GACrC,IACI/D,EADArF,EAAYgY,EAAOhY,UAavB,GAXIiY,GACKjY,IACDA,EAAYqX,GAAiBW,IAEjC3S,EAAa,IAAI6N,GAAWlT,EAAW6N,EAAc2K,KAGrDxY,EAAYgY,EACZ3S,EAAaoT,GAAkBzY,EAAW6N,EAAc2K,IAGxDD,EAAiB,CACjBd,GAAgBpS,EAAYwI,EAAc0K,EAAgB/X,SAC1D,MAAMgI,EAAS+P,EAAgB/P,OAC/BnD,EAAWmD,OAASA,EACpBA,EAAOC,OAASpD,CACpB,CAIA,KADe,eADHrF,EAAUD,KAAOiY,GACM7S,QACtB,CACT,MAAMY,EAAU,CACZ2S,SAAUrT,EAAWsT,cAAcnL,OACnCnH,MAAOvG,GAELkG,EAAU,oEAChBoB,QAAQC,MAAMrB,EAASD,GAEvB,MADY,IAAIG,EAAgBF,EAASD,EAE7C,CAEA,GADoB6R,EAAUnW,OAASD,EACvC,CACwB0H,EAAS7D,WACEmD,OACL8F,OACnBqC,SAAStL,EAEpB,MACAuT,GAAuBd,EAAqBzS,EAAY7D,EAAOmW,EAASC,GACxE/J,EAAarF,OAAO2F,UAAU3K,KAAK6B,EACvC,CACA,OAAO1D,CACX,CAWA,SAASiX,GAAuB5P,EAAQ3D,EAAY7D,EAAOmW,EAASC,GAChE,MAAMjU,EAAY,CACd0B,aAAY7D,SAGhBoW,EAAUpU,KAAKG,GACf,MAAM4M,EAAS,CACX6G,MAAOO,EAAQpH,OAAO6G,MAAQ5V,EAC9BoQ,QAAS+F,EAAQpH,OAAOqB,SAEtBiH,EAAWzF,SAAS0F,yBACpBC,EAAa3F,SAAS4F,cAAc,YAC1CH,EAASI,YAAYF,GACrB1T,EAAWwL,mBAAmBkI,EAC9B,CAAExI,WACavH,EAAOuI,WACfjB,aAAauI,EAAU7P,EAClC,CAaA,SAASyP,GAAkBzY,EAAW6N,EAAc2K,GAChD,MAAMnT,EAAa8R,GAAyBnX,EAAW6N,EAAc2K,GAErE,OADAhK,EAAcnJ,EAAYA,EAAYmT,EAAa3K,GAC5CxI,CACX,CACA,SAAS0S,GAAiBH,EAAWpW,EAAOmW,GACxC,MAAMlD,EAAOmD,EAAUpW,GAEvBkQ,GADmB+C,EAAKpP,WACIsS,EAAQpH,QACpCkE,EAAKxG,SAAU,IACb0J,EAAQpH,OAAOqB,OACrB,CC1JO,SAASsH,GAAqBpZ,EACrCqZ,GACI,MAAMC,EAASD,EAAe5H,WAExB8H,EAAWjG,SAASC,eAAevT,GAIzC,OAHAsZ,EAAO9I,aAAa+I,EAAUF,GAE9BC,EAAOvH,YAAYsH,GACZE,CACX,CACO,SAASC,GAAcxZ,GAE1B,MAAI,MAACsJ,GAAW,EAAO,MAAMnJ,SAASH,GAC3B,GAEJA,CACX,CChBO,SAASyZ,GAAoBzZ,EAAOU,EAC3C8P,GACI9P,EAAQ8P,aAAeA,EACvB,MAAMtH,EAASxI,EAAQqK,OAASyF,EAEhC,GAAI9P,EAAQmD,YAAc7D,GAAS,cAAeU,EAC9C,OAEJA,EAAQmD,UAAY7D,EACpB,MAAM0Z,EAAcF,GAAcxZ,GAE5B2Z,EAAWjZ,EAAQqK,MACzB,GAAI4O,EAEA,YADAA,EAASC,YAAcF,GAI3B,MAAM3O,EAAQqO,GAAqBM,EAAaxQ,GAChDxI,EAAQqK,MAAQA,CACpB,CClBO,SAAS8O,GAAsBrS,EAAS9G,EAASqN,GACpD,MAAM7N,EAAY,IAAI0S,GAAgB,IACtC1S,EAAUE,UAAY,YACtB,MAAMmF,EAAa8R,GAAyBnX,EAAW6N,EAAcrN,GAErE,MAAMoZ,EAAO,KACT5Z,EAAUD,IAAcuH,IACjBjC,GAMX,OAJArF,EAAUsH,QAAUsS,EACpBA,EAAKlS,WAAakS,EAClBA,EAAK1D,WAAY,EACjB0D,EAAKlS,WAAWC,SAAWL,EACpBjC,CACX,CCRO,SAASwU,GAAyB/Z,EAAOU,EAChD8P,EACAzC,EACA8J,GAEI,OADkB3F,GAAalS,IAE3B,KAAKlB,EAAWoB,UAEZ,YADAkX,GAAWpX,EAAOwQ,EAAczC,EAAcrN,GAElD,KAAK5B,EAAWmB,IACZ,MAAMA,EAAMD,EACZ,IAAIE,EAAYD,EAAIC,UAKpB,OAJKA,IACDA,EAAYqX,GAAiBtX,SAEjCmX,GAAWlX,EAAWsQ,EAAczC,EAAcrN,GAEtD,KAAK5B,EAAWwT,SACZ,OAAOsF,GAAgBlX,EAASV,EAAOwQ,EAAczC,EAAc8J,GACvE,KAAK/Y,EAAWyB,aAEZ,OADmByZ,GAAwBha,EAAOU,EAAS8P,EAAczC,EAAc8J,GAE3F,KAAK/Y,EAAWsT,SACZ,MAAM6H,EAAIja,EACV,GAAIia,EAAE7D,UAAW,CACb,MAAM7Q,EAAasU,GAAsBI,EAAGvZ,EAASqN,GAGrD,OAFAW,EAAcnJ,EAAYA,EAAY7E,EAASqN,QAC/CqJ,GAAW7R,EAAWrF,UAAWsQ,EAAczC,EAAcrN,EAEjE,GFhBL,SAAkCV,EAAOU,EAChD8P,GACI9P,EAAQmD,UAAY7D,EACpB,MAEM+K,EAAQqO,GAFMI,GAAcxZ,GAEcwQ,GAChD9P,EAAQqK,MAAQA,CACpB,CEYImP,CAAyBla,EAAOU,EAAS8P,EAC7C,CCxCA,MAAM0E,GAAS,IAAIpK,OAAO,kFCYnB,SAASqP,GAAoBzZ,EAASV,EAAO+N,EAAcyC,GAC9D,MAAME,EAAahQ,EACb0Z,EAAYlI,GAAalS,GAG/B,GpBbG,SAA8BU,EACrC6B,EAAUiO,EAAc4J,GACpB,MAAMC,EAAiB3Z,EACjB4Z,EAAe,cAAeD,EAC9BxW,EAAYwW,EAAexW,UAEjC,GAAIyW,GAAgBzW,IAActB,EAAU,CAExC,MAAMgY,SAAiB,EACvB,QAAI5I,GAAa4I,WAAmB,IAAgBA,MAGhDhY,aAAoBiG,UAAY3E,aAAqB2E,YAgEjE,SAA4BgI,EAC5B9P,GACI,MAAMqK,EAAQrK,EAAQqK,MAChBuO,EAASvO,EAAM0G,WAErB6H,EAAO9I,aAAaA,EAAczF,GAClCuO,EAAOvH,YAAYhH,UACZrK,EAAQqK,aACRrK,EAAQmD,SACnB,CAtEQ2W,CAAmBhK,EAAc6J,GAC1B,uBACX,CACA,MAAMI,EAAe/Z,EACfga,EAAWD,EAAa3C,UAE9B,GAAI4C,GAAYN,IAActb,EAAWwT,SAAU,CAC/C,MAAMN,EAAiByI,EAAaxI,mBAC7BwI,EAAa3C,iBACb2C,EAAaxI,YACpBX,GAAYd,EAAcwB,GAC1B,IAAK,IAAItQ,EAAQgZ,EAAS/Y,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACvD,MAAM,WAAE6D,GAAemV,EAAShZ,GAChCkQ,GAAgBrM,EAAY,CAAE+R,MAAO,EAAGxF,QAAS,GACrD,CACA,MAAO,OACX,CACA,MACMnB,EADajQ,EACY6E,WAE/B,GAAIoL,EAAa,CACb,MAAMgK,EAAa5a,EAAYwC,GAG/B,OAFqBxC,EAAYW,EAAQmC,SAErB8X,GAEX3N,EAHMzK,EAGaoO,KAEpB,GAAiBA,GACjBrB,EAAiBqB,GAEV,GAIXyJ,IAActb,EAAWyB,gBAGzBgC,IAAYA,EAAS6T,aAIzB,GAAiBzF,GAEjBrB,EAAiBqB,GAEV,gBACX,CAEJ,CoBrDIiK,CAAqBla,EAASV,EAAOwQ,EAAc4J,GAE/CA,IAActb,EAAWyB,aACzB,OAgFR,SAAkCL,EAAWwQ,EAAYF,EAAczC,GAEnE,IAAK2C,EAAWnL,WAKZ,OAJAyU,GAAwB9Z,EAAWwQ,EAAYF,EAC/CzC,EAAc,CACV0C,OAAQ,CAAE6G,MAAO,EAAGxF,QAAS,KAE1BpB,EAEX,MAAMnL,EAAa,IAAI6N,GAAWlT,EAAW6N,EAAc2C,GACrDmK,EAAanK,EAAWnL,WACxBqJ,EAAciM,EAAWnS,OAAOC,OACtC,IAAIiG,EAUA,OAJA,GAAiBiM,GACjBb,GAAwB9Z,EAAWwQ,EAAYF,EAAczC,EAAc,CACvE0C,OAAQ,CAAE6G,MAAO,EAAGxF,QAAS,KAE1BpB,EAVM,CACb,MAAMoK,EAAclM,EAAYvJ,OAAOmB,MACvCjB,EAAWF,OAAOmB,MAAM7E,OAAS,EACjC4D,EAAWF,OAAOmB,MAAM9C,QAAQoX,EACpC,CAYA,OAJAvV,EAAWmD,OAASmS,EAAWnS,OAC/BgI,EAAWnL,WAAaA,EACxBkP,GAA2B1G,EAAcxI,EACzCmL,EAAYF,GACLE,CACX,CA7GeqK,CAAyB/a,EAAO0Q,EAAYF,EAAczC,GAIrE,GADmB2C,EAAWnL,WAE1B,OAAI6U,IAActb,EAAWsT,UAwCrC,SAAwB1R,EAASV,EAAO+N,GACpC,MAAM4C,EAAcjQ,EAAQ6E,WAC5B,IAAIrF,EAAYF,EAChB,MAAMgb,EAAUxa,EAAWR,GAC3B,GAAIgb,EAAS,CACT,MAAM/a,EAAMD,EACZE,EAAYD,EAAIC,UACXA,IACDA,EAAY,IAAI0S,GAAgB,IAChC1S,EAAUD,IAAMA,EAChBA,EAAIC,UAAYA,EAExB,CACA,MAAM+a,EAAe,IAAI7H,GAAWlT,EAAW6N,EAAcrN,GAGzDsa,IACAC,EAAavS,OAASiI,EAAYjI,QAEtC,MAAMwS,EAAYlb,GAASgN,EAAW2D,EAAasK,GAC/C5a,EAAeL,IACf2X,GAAgBsD,EAAclN,EAAcrN,GAEhD,GAAIwa,EAEA,YADAvK,EAAYE,SAASoK,GAGzB,GAAIC,EAAW,CAIX,OAAO9D,GAAWlX,EAFHyQ,EAAYjI,OACC8H,aACezC,EAAcrN,EAC7D,CACO+Y,GAAoBzZ,EAAOU,EAASA,EAAQ8P,aACvD,CAvEQ2K,CAAeza,EAASV,EAAO+N,GAFpB2C,EAKf,OAAQ0J,GACJ,KAAKtb,EAAWwT,SAMZ,OALAsF,GAAgBlX,EAASV,EAAOwQ,EAChCzC,EAAc,CAAE0C,OAAQ,CAChB6G,MAAO,EACPxF,QAAS,KAEVpR,EACX,KAAK5B,EAAWoB,UAEZ,OADAkX,GAAWpX,EAAOwQ,EAAczC,EAAc2C,GACvCA,EACX,KAAK5R,EAAWmB,IACZ,MAAMA,EAAMD,EACZ,IAAIE,EAAYD,EAAIC,UAOpB,OANKA,IACDA,EAAYsX,KACZvX,EAAIC,UAAYA,EAChBA,EAAUD,IAAMA,GAEpBmX,GAAWlX,EAAWsQ,EAAczC,EAAc2C,GAC3CA,EACX,KAAK5R,EAAW4B,QACZ,OAAOV,EAEX,KAAKlB,EAAWsT,SAIZ,OAHK1R,EAAQqK,QACTrK,EAAQqK,MAAQsI,GAAiB7C,IAE9B9P,EAIf,OADA+Y,GAAoBzZ,EAAOU,EAAS8P,GAC7BE,CACX,CCxDO,SAAS0K,GAAoB5K,EACpCf,EACA1B,EACA0C,GACI,IAAKD,EAAa6K,aAAa,OAC3B,OAEJ,MAAMC,EAAe9K,EAAa0G,aAAa,MAC/C,GAAIoE,GAAcC,UAAU,EAAGvK,EAAerP,UAAYqP,EACtD,OAEJ,MAAMwK,EAAkB/L,EAAQ6L,GAGhC,GAFkBhb,EAAekb,EAAgB3Y,SAAWhC,EAAW2a,EAAgBxb,OAGnF,MAAO,CACHsb,eACAvN,eACArN,QAAS8a,EACThL,gBAGRiL,GAAoBjL,EAAcgL,EAAiBzN,EAAc0C,EAErE,CACO,SAASgL,GAAoBjL,EAAc9P,EAASqN,EAAc0C,GACrE,IAAIiL,GAAS,EACb,MAAMC,EAAW3b,IACb,GAAI0b,EAEA,YADAvB,GAAoBzZ,EAASV,EAAO+N,EAAcyC,GAItDuJ,GADkB/Z,EACkBU,EAAS8P,EAAczC,EAAc,CACrE0C,OAAQ,IAAKA,KAEjBiL,GAAS,CAAI,EAEjB,IAAIE,EAAmBD,EACvB,MACMrY,EAAM5C,EAAQE,WADFZ,GAAU4b,EAAiB5b,KAG7C,GAAIwQ,EAAaiB,WAAY,CACzB,MAAM1G,EAAQrK,EAAQqK,MAAQsI,GAAiB7C,GAC/CoL,EAAmB3B,IACf,MAAMxI,EAAa1G,EAAM0G,WACzBA,EAAWjB,aAAaA,EAAczF,GACtC0G,EAAWM,YAAYhH,UAChBrK,EAAQqK,MACf6Q,EAAmBD,EACnBA,EAAQ1B,EAAE,CAElB,CACAlM,EAAarF,OAAO3G,cAAc2B,KAAKJ,EAC3C,CAEO,SAASuY,GAAcC,EAAKjE,EAASpI,EAAS1B,GACjD,IAAK+N,EAAI5E,aACL,OAIY,aADA4E,EAAI7E,UFlEjB,SAA2B8E,EAAUtM,EAAS1B,GACjD,MAAM/N,EAAQ+b,EAAS/b,MACvB,GAAIA,EAAMkV,OAAOA,KAAW,EAAG,CAC3B,MAAM8G,EAAQhc,EAAMgc,MAAM,qBAEpBC,EAAU,KADFD,EAAQA,EAAM,GAAK,IACH,IAC9BD,EAAS/b,MAAQ,GACjB+b,EAASnF,aAAa,iBAAkBqF,GACxC,MAAM3G,EAAW,CAAC4G,EAAMC,EAAOnc,IAAU+b,EAAS/b,MAAQA,EAC1DmV,GAAiB,iBAAkB8G,EACnCF,EAAUtM,EAAS1B,EAAcuH,EACrC,CACJ,CEwDQ8G,CAAkBN,EAAKrM,EAAS1B,GAEpC,IAAIsO,EAAOxE,EAAQpH,OAAO6G,MAC1B+E,ECzEG,SAA0B3K,EAAajB,GAC1C,MAAM6L,EAAmB5K,EAAY6K,OACrC,IAAKD,EACD,OAAO7L,EAAO6G,MAElB,MAAMkF,EAAaF,EAAiB3U,YACpC,IAAK6U,EACD,OAAO/L,EAAO6G,MAElB,MAAMmF,EAASD,EAAW7U,YAC1B,OAAK8U,GAILA,EADc,CAAEC,OAAQhL,EAAaG,QAASpB,EAAO6G,UAE5C7G,EAAO6G,OAJL7G,EAAO6G,KAKtB,CDyDWqF,CAAiBb,EAAKjE,EAAQpH,QAAU4L,EAC3BP,EAAIc,QAEhBd,EAAIT,aAAa,cACjBS,EAAIc,QAEJd,EAAIT,aAAa,eACjBS,EAAIe,UAGZ,MAAMpQ,EAAWqP,EAAIrP,SACrB,GAAIA,EACA,IAAK,IAAI/K,EAAQ+K,EAAS9K,OAAS,EAAGD,GAAS,IAAKA,EAAO,CAMvDma,GALcpP,EAAS/K,GACJ,IACZmW,EACHpH,OAAQoH,EAAQpH,QAEahB,EAAS1B,EAC9C,CAER,CE7FO,SAAS+O,GAA4BrN,EAASlK,EAAYsS,EAASpL,GAEtE,MAAMgE,EAASoH,EAAQpH,OACjB5O,EAAS,GACTkb,EAAgB,GAEtB,IAAK,IAAIrb,EADW+K,EAAS9K,OACE,EAAGD,GAAS,IAAKA,EAAO,CACnD,MAAM6M,EAAQ9B,EAAS/K,GACjBnB,EAAe6a,GAAoB7M,EAAOkB,EAASlK,EAAYkL,GAErE,GAAIlQ,EACAwc,EAAcrZ,KAAKnD,QAGvB,GAAIgO,EAAM9B,SACN,IAAK,IAAI/K,EAAQ6M,EAAM9B,SAAS9K,OAAS,EAAGD,GAAS,IAAKA,EAAO,CAC7D,MAAMsb,EAAWzO,EAAM9B,SAAS/K,GAEhC,GAAIub,GAAoBD,GAAW,CAC/B,MAAMzc,EAAe6a,GAAoB4B,EAAUvN,EAASlK,EAAYkL,GACpElQ,GACAwc,EAAcrZ,KAAKnD,EAE3B,CACA,MAAQsB,OAAQqb,EAAYH,cAAeI,GAAqBL,GAA4BrN,EAASlK,EAAYsS,EAASmF,EAASvQ,UACnI5K,EAAO6B,QAAQwZ,GACfH,EAAcrZ,QAAQyZ,EAC1B,CAER,CACA,MAAO,CAAEtb,SAAQkb,gBACrB,CACA,SAASE,GAAoB1O,GAEzB,MADqC,aAAlBA,EAAM6O,cAEiB9T,IAAtCiF,EAAM2I,aAAa,qBACW5N,IAA9BiF,EAAM2I,aAAa,MAC3B,CCjCO,SAASmG,GAAmBC,EACnC7N,EACA8N,EAAuBxP,EAAc8J,GACjC,MAAMhW,EAAS,GACTkb,EAAgB,GAChBnU,EAAS2U,EAAsBC,cAC/B5E,EAAW0E,EAAU7Q,SAAS,GAC9BA,EAAWmM,EAAS6E,QAAQhR,SAClC,GAAI7D,EAAOiD,KAAKlK,OAAQ,CACpB,MAAQE,OAAQqb,EAAYH,cAAeW,GAAsBZ,GAA4BrN,EAAS1B,EAAc8J,EAASpL,GAC7H5K,EAAO6B,QAAQwZ,GACfH,EAAcrZ,QAAQga,EAC1B,CAGA,OAFA5G,GAAsB8B,EAAUnJ,EAAS1B,GACzC4P,GAA0BlR,EAAUgD,EAAS1B,GACtC,CAAElM,SAAQkb,gBACrB,CACA,SAASY,GAA0BlR,EAAUgD,EAAS1B,GAClD,IAAK,IAAIrM,EAAQ+K,EAAS9K,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACvD,MAAM6M,EAAQ9B,EAAS/K,GACvBoV,GAAsBvI,EAAOkB,EAAS1B,GAClCQ,EAAM9B,UACNkR,GAA0BpP,EAAM9B,SAAUgD,EAAS1B,EAE3D,CACJ,CACO,SAAS6P,GAAkBlQ,GAC9B,MAAM9E,EZ7BH,SAAgCgQ,GACnC,MAAM/M,EAAO,GAWb,MAAO,CAAE6B,OAVMkL,EAAS9C,QAAQqB,IAAoB,CAAC6E,EAAO6B,KACxD,GAAI7B,EAAM8B,WAAW,KAEjB,OAAO9B,EAEX,MACM+B,EADWF,EAAWtC,UAAU,EAAGsC,EAAWlc,OAAS,GAG7D,OADAkK,EAAKnI,KAAKqa,GACH,iCAAiCA,gBAAiB,IAE5ClS,OACrB,CYgBmBmS,CAAuBtQ,GAEtC,OADA9E,EAAO8E,OAAS9E,EAAO8E,OAAOoI,QAAQ5E,GAAcF,GAC7CpI,CACX,CCjCO,SAASqV,GAAwBX,EAAW9M,EAAcjL,EAAYkK,EAASoI,GAClF,MAAMhW,ECHH,SAAqBqc,EAAW1N,GACnC,MAAM3O,EAAS,GAEf,IAAI6P,EADawM,EAAUzR,SAAS,GACTgR,QAAQU,WACnC,MAAMpF,EAAWzF,SAAS0F,yBAC1B,KAAOtH,GAAa,CAChB,MAAM0M,EAAkB1M,EAAYA,YACpC7P,EAAO6B,KAAKgO,GACZqH,EAASI,YAAYzH,GACrBA,EAAc0M,CAClB,CACI5N,EAAaiB,YACMjB,EAAaiB,WACrBjB,aAAauI,EAAUvI,GAEtC,OAAO3O,CACX,CDbmBwc,CAAYf,EAAW9M,GACtC,IAAK3O,EAAOF,OACR,OAAOE,EAEX,IAAK,IAAIH,EAAQG,EAAOF,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACrD,MAAMqJ,EAAQlJ,EAAOH,GACrBma,GAAc9Q,EAAO8M,EAASpI,EAASlK,GACvCA,EAAW1D,OAAO6B,KAAKqH,EAC3B,CACA,OAAOlJ,CACX,CEEA,MAAMyc,GAAe,IAAIxT,OAAOkG,EAAgB,KAEzC,MAAMuN,GACTre,UACAQ,QACA8d,OAAQ,EACRC,WACAjR,QACAhM,OACAkd,YAEArZ,OAAS,CACLmB,MAAO,IAEX3E,OAAS,GAET6G,OAAS,CACLiW,SAAU,IAAIvd,EACdqO,QAAS,CAAC,EACVxD,UAAW,GAEX6C,YAAa,EACb/M,cAAe,GACfyM,OAAQxL,KACRsR,QAAS,GACTjG,UAAW,IAEfD,iBAAkB,EAClB,WAAArL,CAAY7C,EAAWQ,EAASmP,GAC5B7M,KAAK9C,UAAYA,EACjB8C,KAAKtC,QAAUA,EACf,MAAMiP,EAAQzP,EAAUyP,MACxB3M,KAAK0b,YAAc1b,KAAK4b,aAAajP,EAAOE,EAChD,CACA,YAAA+O,CAAajP,EAAOE,GAChB,MACMgP,EADW7b,KAAK9C,UAAUuM,SACNzM,MACpB8e,EAAenP,EAAM3N,KAAI2N,GAASnF,EAAUmF,KAClD,OAAO3M,KAAK0b,YAAc,CACtBK,OAAQpP,EACRmP,eACAE,UAAWnP,EACXoP,oBAAqBJ,EAAS7c,KAAIiR,GACVT,GAAgBS,EAAIzR,UAIpD,CAEA,kBAAAuP,CAAmBP,EAAcqH,EAAU,CACvCpH,OAAQ,CAAE6G,MAAO,EAAGxF,QAAS,KAE7B,MAAMpR,EAAUsC,KAAKtC,QACfgI,EAAS1F,KAAK0F,OACpBA,EAAO8H,aAAeA,EACjB9H,EAAOuJ,apBtEb,SAA2BvJ,GAC9B,MAAM8H,EAAe9H,EAAO8H,aACrB9H,EAAOuJ,YAAcoB,GAAiB7C,EACjD,CoBoEY0O,CAAkBxW,GAEtB,MAAMsJ,EAAiBtJ,EAAOuJ,YAC9BvJ,EAAO8F,OAASxL,KAChB0F,EAAOC,OAAS3F,KAChBtC,EAAQ6E,WAAavC,KACrBA,KAAKoL,iBAAkB,EACvB,MAAMqB,EAAUzM,KAAKmc,SACfvG,EAAW5V,KAAK6V,cAChBuG,EAAmB9L,SAAS0F,yBAC5BqG,EAAW/L,SAAS4F,cAAc,YACxCmG,EAASC,UAAY1G,EAASlL,OAC9B0R,EAAiBjG,YAAYkG,GAE7B,MAAM,cAAEtC,GAAkBM,GAAmB+B,EAAkB3P,EAASmJ,EAAU5V,KAClF,CACIyN,OAAQoH,EAAQpH,SAEpBwN,GAAwBmB,EAAkBpN,EAAgBhP,KAC1DyM,EAASoI,GAET,MAAMlW,EAASob,EAAcpb,OAC7B,IAAK,IAAID,EAAQ,EAAGA,EAAQC,IAAUD,EAAO,CACzC,MAAMnB,EAAewc,EAAcrb,GACnC+Z,GAAoBlb,EAAaiQ,aAAcjQ,EAAaG,QAASH,EAAawN,aAAc8J,EAAQpH,QACxGwN,GAAwBmB,EAAkB7e,EAAaiQ,aAAcjQ,EAAawN,aAAc0B,EAASoI,EAC7G,CACJ,CACA,WAAAgB,GACI,MAAM0G,EAAUvc,KAAK9C,UAAUD,IACzBuN,EAAUxK,KAAKwK,SAAW+R,EAAQ/R,QAClChM,EAASwB,KAAKxB,QAAU+d,EAAQ/d,OAOhCgc,EAAgBI,GANPpQ,EAAQxL,KAAI,CAAC0L,EAAQhM,KACbgM,EAAOoI,QAAQwI,GAAcrN,IAChBzP,EAAOG,OAASD,EAAQ,IAAIsP,IAAiBtP,KAAW,KAC3DoU,QAAQ,QAAS,KAAKA,QAAQ,QAAS,OAErEE,KAAK,KAER,MAAO,CACHwH,gBACA9P,OAAQ8P,EAAc9P,OACtBF,UACAhM,SACAiO,QAASzM,KAAK0F,OAAO+G,SAAW,CAAC,EAEzC,CACA,MAAA0P,GACI,OAAOnc,KAAKwc,cAAcxc,KAAK0F,OAAO+G,QAC1C,CACA,aAAA+P,CAAc/P,GACV,MAAM8P,EAAUvc,KAAK9C,UAAUD,IACzBuN,EAAUxK,KAAKwK,SAAW+R,EAAQ/R,QAClChM,EAASwB,KAAKxB,QAAU+d,EAAQ/d,OAuBtC,OAtBAgM,EAAQiB,SAAQ,CAACgR,EAAS/d,KAEtB,KADiBF,EAAOG,OAASD,GAE7B,OAEJ,MAAM4Z,EAAetK,EAAiBtP,EAChC1B,EAAQwB,EAAOE,GAGrB,GADe4Z,KAAgB7L,EACnB,CACR,GAAIzM,KAAK0F,OAAOyF,QAAS,CACrB,MAAM8M,EAAgBjb,GAASA,EAAMuF,WACrC,GAAI0V,EAEA,OADAA,EAAazL,UACNC,CAEf,CACA,OC7IT,SAA2BA,EAAS6L,EAActb,GACrD,MAAMU,EAAU+O,EAAQ6L,GACpB7a,EAAkBT,IAItBU,EAAQ4B,KAAKtC,EAEjB,CDqIuB0f,CAAkBjQ,EAAS6L,EAActb,EACpD,CAEAyP,EAAQ6L,GrB5Ib,SAAyBtb,EAAO+N,GAEnC,OADkBmE,GAAalS,IAE3B,KAAKlB,EAAWyB,aAEZ,OADmB,IAAIqE,EAAa5E,GAExC,KAAKlB,EAAWoB,UAGZ,OAAOiT,GAFWnT,EACIC,IACI8N,GAC9B,KAAKjP,EAAWmB,IACZ,OAAOkT,GAAcnT,EAAO+N,GAChC,KAAKjP,EAAW4B,QACZ,OAAOV,EAEf,OAAO,IAAI4E,EAAa5E,EAC5B,CqB4HoC2f,CAAgB3f,EAAOgD,KAAK,IAEjDyM,CACX,CACA,QAAAoB,CAAStL,GACL,MAAMqa,EAAUra,EAAWrF,UAAUD,IACrC+C,KAAK6c,aAAaD,EAAQpS,QAASoS,EAAQpe,OAC/C,CACA,YAAAqe,CAAarS,EAAShM,GAClBwB,KAAKwK,QAAUA,EACfxK,KAAK8c,aAAate,EACtB,CACA,YAAAse,CAAate,GAET,OADAwB,KAAKxB,OAASA,EACPwB,KAAKwc,cAAcxc,KAAK0F,OAAO+G,QAC1C,CACA,OAAAD,CAAQqI,EAAU,CACdhG,QAAS,EACTkO,UAAU,IAEV,MAAMC,GAAgBnI,EAAQkI,SACxBrX,EAAS1F,KAAK0F,OACdhI,EAAUsC,KAAKtC,QACf2N,EAAYwJ,EAAQkI,SAAW,GAAKtN,GAAsBzP,KAAK0F,OAAO2F,WACxE2R,GAAgB1f,EAAe0C,KAAK9C,aACpCwI,EAAOiW,SAASrc,OAChB4L,EAAiBlL,KAAMA,OAE3BA,KAAKid,uBAEL,IAAK,IAAIve,EAAQ2M,EAAU1M,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACxD,MAAM6M,EAAQF,EAAU3M,GAClBwe,EAAY3R,EAAM7F,cACjBwX,EAAUvX,OACjBuX,EAAU/R,SAAU,EAChB7N,EAAeiO,EAAMrO,YACrBgO,EAAiBK,EAAOA,EAEhC,CACA,IAAI4R,EAIJ,GAA8B,aAFTzX,EAAO8H,aAEXyG,SAAyB,CAClBvO,EAAOuJ,eACN,eAAgBjP,KAAKqC,UACjCwS,EAAQkI,UACT,GAAiB/c,MAG7B,CACA,GAAIgd,EAAc,CACd,MAAM,QAAEnO,EAAO,QAAEuO,GAAYpd,KAAKqd,cAAcxI,GAChDA,EAAQhG,QAAUA,EACduO,IACAD,EAAcC,EAEtB,MAEIpd,KAAKqd,gBAkBT,cAfO3X,EAAOuJ,YACdvJ,EAAO+G,QAAU,CAAC,SACX/G,EAAO8F,cACP9F,EAAOC,OACd3F,KAAK0F,OAAO2F,UAAU1M,OAAS,SACxBjB,EAAQ6E,WAEX4a,EADAA,EACcA,EAAYlb,MAAKqb,UAC3B,MAAMC,EAAWlS,EAAUrM,KAAIiR,GAAOA,EAAIzD,QAAQ,CAAEqC,QAAS,EAAGkO,UAAU,MAC1E,OAAO9b,QAAQO,IAAI+b,EAAS,IAIlBtc,QAAQO,IAAI6J,EAAUrM,KAAIiR,GAAOA,EAAIzD,QAAQ,CAAEqC,QAAS,EAAGkO,UAAU,OAEhFI,EAAYlb,MAAK,IAAM4S,EAAQhG,SAC1C,CACA,aAAAwO,EAAc,QAAExO,GAAY,CACxBA,QAAS,IAET,MAAM2O,EAAY,IAAIxd,KAAKnB,QAC3BmB,KAAKnB,OAAOF,OAAS,EACrB,MAAM4e,EAAWC,EAAUxe,KAAI+I,GAAS/H,KAAKyd,kBAAkB1V,EAAO8G,KAAUvD,QAAOtN,GAAKA,IAEtF0f,EAAa1d,KAAK0F,OAAO+G,QAC/B,IAAK,MAAM3P,KAAQ4gB,EAAY,CAC3B,MACM3V,EADQ2V,EAAW5gB,GACLiL,MAChBA,GAAO0G,YACP1G,EAAM0G,WAAWM,YAAYhH,EAErC,CACA,OAAIwV,EAAS5e,OACF,CAAEye,QAASnc,QAAQO,IAAI+b,GAAW1O,WAEtC,CAAEA,UACb,CAEA,iBAAA4O,CAAkB1V,EAAO8G,GACrB,IAAIuO,EACJ,MAAMO,EAAY5V,EACd4V,EAAUC,YACVR,EEzPL,SAA6B1O,EAAaG,GAC7C,MAAMgP,EAAsBnP,EAAYkP,UACxC,IAAKC,EACD,OAEJ,MAAMC,EAAgBD,EAAoBlZ,YAC1C,IAAKmZ,EACD,OAEJ,MAAMC,EAAYD,EAAcnZ,YAChC,IAAKoZ,EACD,OAGJ,OAAOA,EADO,CAAErE,OAAQhL,EAAaG,WAEzC,CF0OsBmP,CAAoBL,EAAW9O,IAE7C,MAAMvP,EAAO,KACT,MAAMmP,EAAa1G,EAAM0G,WACrBA,GACAA,EAAWM,YAAYhH,GAE3B,MAAMgD,EAAe/K,KAAK6J,gBACtBkB,IAEAA,EAAalM,OAASkM,EAAalM,OAAOyM,QAAO2S,GAAgBA,IAAiBlW,IACtF,EAEJ,OAAIqV,aAAmBnc,QACZmc,EAAQnb,KAAK3C,IAGpBA,IAEG8d,EACX,CACA,oBAAAH,GACI,MAAMlc,EAAOf,KAAK0F,OAAO3G,cACzB,IAAK,IAAIL,EAAQqC,EAAKpC,OAAS,EAAGD,GAAS,IAAKA,EAC5CqC,EAAKrC,GAAO0B,cAEhBW,EAAKpC,OAAS,CAClB,EAEG,MAAMyR,WAAmBmL,GAC5Bre,UACA2M,gBACAnM,QACAwgB,QACA1C,OAAQ,EACR,WAAAzb,CAAY7C,EACZ2M,EAAiBnM,EAASmP,EAAaqR,EAAU,GAC7Crc,MAAM3E,EAAWQ,EAASmP,GAC1B7M,KAAK9C,UAAYA,EACjB8C,KAAK6J,gBAAkBA,EACvB7J,KAAKtC,QAAUA,EACfsC,KAAKke,QAAUA,CACnB,CACA,gBAAAC,GACI,IAAIlhB,EAAM+C,KACV,KAAO/C,EAAI4M,iBACP5M,EAAMA,EAAI4M,gBAEd,OAAO5M,CACX,EGtSG,SAAS+Z,GAAwB9Z,EAAWQ,EAAS8P,EAAczC,EAAc8J,GAGpF,IAAyB,IAArB3X,EAAU2S,OAAiB,CAC3B,MACMhL,EADU3H,EAAUsH,QACDI,WAAWC,SACpC,IAAI/H,EAAO+H,EAAS/H,MAAQ+H,EAAS9E,aAAajD,KACrC,aAATA,IACAA,OAAOwJ,GAEX,MAAM8X,EAAQthB,GAAQ+H,EAASV,WAAWoU,UAAU,EAAG,KAEvD,MADc,IAAIvV,MAAM,uGAAuGob,QAEnI,CACA,MAAM7b,EAAa,IAAI6N,GAAWlT,EAAW6N,EAAcrN,GAC3D,IAAI2O,EAAY3O,EAAQ6E,YACTA,EAAWmD,OAAS2G,GAAW3G,QAAUnD,EAAWmD,QAC5D8H,aAAeA,EAEtB,IADkBnB,EACJ,CAEVA,ECxBD,SAAgC3O,EAAS2O,EAAWtB,GACvD,MAAMsT,EAAYtT,EAAalM,OAAOG,KAAI+I,GAASA,IAGnD,GAFAsE,EAAYiS,GAAkBjS,EAAW3O,EAAQ6E,WACjD7E,EAASqN,GACLA,EAAalM,OAAOF,OAAS0f,EAAU1f,OAAQ,CAC/C,MAAM4f,EAAWxT,EAAalM,OAAOyM,QAAOkT,IAAWH,EAAUvU,MAAK/B,GAASA,IAAUyW,MACzFnS,EAAUxN,OAAO6B,QAAQ6d,EAC7B,CACA,OAAOlS,CACX,CDeoBoS,CAAuB/gB,EADnB2O,GAAa9J,EACwBwI,EACzD,CACA,MAAM6C,EAAaL,EAAiBlB,EAAW3O,EAC/C8P,EACAqH,GAGA,OADA9J,EAAarF,OAAO2F,UAAU3K,KAAKkN,GAC5BvB,CACX,CE5BO,SAAS2P,GAAUrP,EAAOhB,EAAe+S,GAC5C,OAAO/R,EAAM3N,KAAIvC,GAGd,SAAmBA,EAAMsO,EAAc2T,EAAY/S,GACtD,GAAI5O,EAAYN,KAAUA,EACtB,OAAOA,EAEX,IAAKsO,EACD,OAAOtO,EAEX,OAAOkiB,GAAUliB,EAAMsO,EAAc2T,EAAY/S,EACrD,CAX6BiT,CAAUniB,EAAMkP,EAAc9B,gBAAiB6U,EAAY/S,IACxF,CAWO,SAASgT,GAAU3hB,EAAO+N,EAAc2T,EAAY/S,EAAejN,EAAOmgB,EAASC,EAAO,IAC7F,GAAI9hB,aAAiBwI,SACjB,OA8CD,SAAqBxI,EAAO+N,EAAc2T,EAAY/S,EAAe7O,EAAM+hB,GAC9E,MAAME,EAAS/hB,EAAM+hB,OAErB,GAAIA,EACA,OAAO/hB,EAEX,MAAM8Z,EAAO,IAAIrV,IAASqV,EAAKiI,UAAUtd,GAUzC,OARAqV,EAAKiI,OAAS,IAAItd,IAWf,SAA2Bsd,EAAQC,EAAUjU,EACpD/G,GACI,MAAM2B,EAASoF,EAAarF,OAAOC,OAE7BsZ,OAAkC3Y,IAAxBnE,IAKVyD,EAASmZ,KAAUC,GAInBE,EAAM,KAER,IAAgB,IAAZD,EAAmB,CAEnB,MAAME,EAAaxZ,EAAOtD,OAAOmB,MAAMzF,OAAMyF,IACzC,MAAM3C,EAAY2C,EAAM3C,UAClBtE,EAAMiH,EAAMjH,MAElB,OADc6L,EAAUZ,EAAU3G,GAAYtE,EAClC,IAEhB,GAAI4iB,EACA,OAAOvZ,CAEf,CAEA,OADAgM,GAAiBjM,GAAQ,GAClBC,CAAM,EAEjB,GAAIqZ,EACA,OAAOC,IAGX,OADA9c,EAAOC,OAAO4I,WAAW9J,WAAW+d,GAC7BtZ,CACX,CA7CewZ,CAAkBtI,EAAKra,KAAMgF,EAAMsJ,EAAc+L,EAAK4H,YAEjE5H,EAAKjS,SAAW7H,EAChB8Z,EAAKra,KAAOO,EACZ8Z,EAAK4H,WAAaA,EAElBtiB,OAAOijB,OAAOvI,EAAM9Z,GACb8Z,CACX,CA/DewI,CAAYtiB,EAAO+N,EAAc2T,GAE5C,GAAII,EAAK3hB,SAASH,GACd,OAAOA,EAGX,GADA8hB,EAAKpe,KAAK1D,GACa,iBAAZ,IAAyBA,EAChC,OAAOA,EAEX,GAAIA,aAAiBc,MAAO,CACxB,IAAK,IAAIY,EAAQ1B,EAAM2B,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACpD,MAAM6gB,EAAWviB,EAAM0B,GAEvB,GADA1B,EAAM0B,GAASigB,GAAUY,EAAUxU,EAAc2T,EAAY/S,EAAejN,EAAO1B,EAAO8hB,GACtFS,aAAoB/Z,SAAU,CAC9B,GAAI+Z,EAASR,OACT,SAEJS,GAAe9gB,EAAO6gB,EAAUviB,EAAO2O,EAC3C,CACJ,CACA,OAAO3O,CACX,CACA,IAAK,MAAMF,KAAQE,EAAO,CACtB,MAAMuiB,EAAWviB,EAAMF,GACjB8I,EAAS+Y,GAAUY,EAAUxU,EAAc2T,EAAY/S,EAAe7O,EAAME,EAAO8hB,GACnFW,EAAYrjB,OAAOsjB,yBAAyB1iB,EAAOF,IAAOgD,IAChE,IAAI2f,IAGJziB,EAAMF,GAAQ8I,EACVA,aAAkBJ,UAAU,CAC5B,GAAI+Z,EAASR,OACT,SAEJS,GAAe1iB,EAAMyiB,EAAUviB,EAAO2O,EAC1C,CACJ,CACA,OAAO3O,CACX,CACA,SAASwiB,GAAe9gB,EAAOihB,EAAWd,EAASlT,GAC3CgU,GAAWZ,QAIfpT,EAAcjG,OAAOiW,SAASxa,YAAW,IAAM0d,EAAQngB,GAASihB,GACpE,CC3DO,SAASlO,GAA2B1G,EAAcxI,EACzD7E,EAAS8P,EAAcoS,GAAW,GAC9B,IAAIjS,EAAcjQ,EAAQ6E,YAAYmD,OAAOC,OAC7C,MAAMka,EAAalS,EAAYzQ,UAAUsH,QACnCsb,EAAavd,EAAWrF,UAAUsH,QACxC,IAAI0T,GAAY,EAChB,GAAI2H,GAAcC,EAAY,CAI1B5H,EAHoB2H,EAAWjb,WAAWC,WACtBib,EAAWlb,WAAWC,QAG9C,CACA,MAAM3H,EAAYqF,EAAWrF,UAC7B,IAAKgb,EAAW,CAEZ5L,EADsBqB,EAAYjI,OAAO8F,QAKzC,OAHmBwL,GAAwB9Z,EAAWQ,EAAS8P,EAAczC,EAAc,CACvF0C,OAAQ,CAAE6G,MAAO,EAAGxF,QAAS,IAGrC,CACK,CACD,MAAMiR,EC3BP,SAA8BpS,EAAahC,EAAeqU,GAC7D,MAEMC,EAAevT,EAFDsT,EAAarT,MACVgB,EAAY+N,YAAYI,cAK/C,GAAImE,EACA,OAAOA,EAEX,MAAMC,EAAgBxT,EAAeiB,EAAY+N,YAAYI,aAAcnQ,EAAc+P,YAAYI,cACrG,GAAIoE,EACA,OAAOA,EAEX,MAAMC,EAIH,SAAwB5T,EAAeZ,GAC1C,MAAMyU,EAAoB7T,EAAcmP,YAAYO,oBAC9CoE,EAAqB1U,EAAc+P,YAAYO,oBAKrD,OAJkBmE,EAAkBriB,OAAM,CAAC+B,EAAKpB,KAC5C,MAAMV,EAAIqiB,EAAmB3hB,GAC7B,OAAOoB,EAAI/B,OAAM,CAACgH,EAAMrG,IAAUqG,IAAS/G,EAAEU,IAAO,KAE7B,CAC/B,CAZwB4hB,CAAe3S,EAAahC,GAEhD,OAAOwU,CACX,CDU2BI,CAAqB5S,EAAapL,EAAYrF,GAEjE,IAAK6iB,EAAY,CACb,MAEMlT,EAwElB,SAA2Be,EAAYD,EAAa5C,EAAcyV,GAC9D,MAAM7a,EAASgI,EAAYjI,OAAOC,OAClC,IAAKA,EAAQ,CAET,MAAMnC,EAAQuH,EAAa1I,OAAOmB,MAClCgd,EAAc7hB,OAAS,EACvB,MAAMkO,EAAcmP,GAAUwE,EAAe5S,EAAYpK,GAGzD,OAFAgd,EAAc9f,QAAQmM,GACtBe,EAAW8N,YAAYM,UAAYnP,EAC5B2T,CACX,CACA7S,EAAchI,GAAUgI,EACxB,MAAM8S,EAAkB9S,EAAY+N,YAC9BgF,EAAkBD,EAAgBzE,UAClC2E,EAAW,GACjB,IAAK,IAAIjiB,EAAQ8hB,EAAc7hB,OAAS,EAAGD,GAAS,IAAKA,EAAO,CAC5D,MAAMjC,EAAO+jB,EAAc9hB,GAErBa,EAAWqhB,GADCF,EAAgBhiB,GACgBjC,EAAMmR,EAAY7C,GACpE4V,EAASjgB,KAAKnB,EAClB,CAEA,OADAqO,EAAW8N,YAAYM,UAAY2E,EAC5BA,CACX,CA/FgCE,CAAkBte,EAAYoL,EAAa5C,EAF9C7N,EAAUyP,OAQ3B,OAJApK,EAAWmZ,YAAYM,UAAYnP,EAEnCc,EAAY+N,YAAYI,aAAevZ,EAAWmZ,YAAYI,aAC9DnO,EAAY+N,YAAYO,oBAAsB1Z,EAAWmZ,YAAYO,oBAC9DtO,CACX,CACJ,CACA,MAAMnC,EAASmC,EAAYjI,OAAO8F,OAClC,GAAIjJ,EAAWmD,OAAO0L,OAElB,OADA7O,EAAWmD,OAAO4L,QAAQ5Q,KAAK6B,GACxBA,EAIX,OAEJ,SAAwB7E,EAAS8N,EAAQtO,EAAWkJ,EAAUwH,EAAYsK,GACtE,IAAIvK,EAAcjQ,EAAQ6E,WAa1B,GAAIiJ,GAAUtO,EAAUuM,SAAS5J,OAAOlB,OAAQ,CACzB6M,EAAOtO,UAAUuM,SACzBnK,KAAKpC,EAAUuM,SAAS5J,OACvC,CAEA,MAAMihB,EAAY5I,GAAalO,EAAW5D,EAAUwH,GACpD,GAAIkT,EAAW,CACX,MAAMC,EAAYpT,EAAYjI,OAAO8F,OAGrC,OAFA9N,EAAQ6E,WAAaqL,EACrBmT,EAAUlT,SAASD,GACZA,CACX,CAEIsK,GAAavK,IACRvH,EAASV,OAAOyF,SACjBmB,EAAiBlG,GAQrBwH,EAAWlI,OAAO+G,QAAU,CAAC,GAGjC,OAEJ,SAAqBmB,EAAYoT,EAAiBzU,EAAe7O,GAU7D,OATAkQ,EAAWG,mBAAmBiT,EAAiB,CAC3CvT,OAAQ,CAAE6G,MAAO,EAAGxF,QAAS,KAEjClB,EAAWlI,OAAO8F,OAASoC,EAC3BA,EAAWlI,OAAOC,OAASiI,EAC3BrB,EAAc7G,OAAO8F,OAASoC,EAC9BrB,EAAc7G,OAAOC,OAASiI,EAC9BlQ,EAAQ6E,WAAaqL,EACrBlQ,EAAQ6E,WAAWsH,gBAAgBnE,OAAO2F,UAAU3K,KAAKkN,GAClDA,CACX,CAbWqT,CAAYrT,EAAYA,EAAWlI,OAAO8H,aAAcI,EAAYlQ,EAC/E,CA3CWwjB,CAAexjB,EAAS8N,EAAQtO,EAFtByQ,EAAYjI,OAAOC,OACjBiM,GAAiBrP,EAAYqd,GACwB1H,EAC5E,CA+EA,SAAS0I,GAAsBO,EAAW1kB,EAAMmR,EAAY7C,EAAc+T,EAAO,IAC7E,GAAIqC,aAAqB3b,SAAU,CAE/B,GAAI/I,EAAKsiB,OAEL,OADAoC,EAAUpC,OAAStiB,EAAKsiB,OACjBtiB,EAEX,MACM2kB,EADcrW,EAAarF,OACCC,OAAOtD,OAAOmB,MAGhD,OAFA2d,EAAU1kB,KAAOA,EACjB0kB,EAAUzC,WAAa0C,EAChBD,CACX,CAEA,GAAIrC,EAAK3hB,SAASV,GACd,OAAOA,EAGX,GADAqiB,EAAKpe,KAAKjE,GACY,iBAAX,IAAwBA,EAC/B,OAAOA,EAEX,GAAIA,aAAgBqB,MAAO,CACvB,IAAK,IAAIY,EAAQjC,EAAKkC,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACnD,MAAMV,EAAIvB,EAAKiC,GACfjC,EAAKiC,GAASkiB,GAAsBO,EAAUziB,GAAQV,EAAG4P,EAAY7C,EAAc+T,EACvF,CACA,OAAOriB,CACX,CACA,QAAkB6J,IAAd6a,EACA,OAAO1kB,EAEX,IAAK,MAAMK,KAAQL,EAAM,CACrB,MAAM8iB,EAAW9iB,EAAKK,GAChB8I,EAASgb,GAAsBO,EAAUrkB,GAAOyiB,EAAU3R,EAAY7C,EAAc+T,GACpFW,EAAYrjB,OAAOsjB,yBAAyBjjB,EAAMK,IAAOgD,IAC3D2f,IAGJhjB,EAAKK,GAAQ8I,EACjB,CACA,OAAOnJ,CACX,CEvKO,SAAS6hB,GAAkB3S,EAAegC,EACjDjQ,EACAqN,GACI,MAAMsB,EAAYX,EAAcC,EAAegC,EAAajQ,EAASqN,IAClD4C,GAAe3D,EAAW2D,EAAatB,MCLvD,SAA2BsB,EAClCtB,EACA3O,GACI,MAAM2jB,EAAY1T,EAAYjI,OACxB8H,EAAe6T,EAAU7T,aAEzB9H,EAAS2G,EAAU3G,OAAS,IAAK2b,IHmKpC,SAAuB1T,EAAaC,GACtBD,EAAYjI,OAAOiW,SACpChO,EAAYjI,OAAOuD,UAAUwC,SAAQpC,IACjCA,EAASI,SAASgC,SAAQ,CAACF,EAAO7M,KAE9B,GADuBiP,EAAYjI,OAAOiW,WAAapQ,EAAM7F,OAAOiW,SAIhE,OAFAtS,EAASI,SAASlJ,OAAO7B,EAAO,QAChC2K,EAASI,SAAS/I,KAAKkN,EAE3B,GACF,GAEV,CG9KI0T,CAAc3T,EAAatB,GAC3BC,EAAiBqB,GACjBjI,EAAO8H,aAAeA,SACf9H,EAAOyF,QACdzF,EAAO8F,OAASa,EAChB3G,EAAOC,OAAS0G,EAChB3O,EAAQ6E,WAAa8J,EACrB,MAAMkV,EAAclV,EAAU3G,OAAOuJ,aAAaR,WAC5C+S,EAAehU,EAAaiB,WAC9B8S,GAAeC,GACfA,EAAazS,YAAYvB,EAEjC,CDZQiU,CAAkB9T,EAAatB,EAAW3O,GAC1C2O,EAAU3G,OAAO8F,OAASa,GAE9B,MAAML,EAAmB2B,GAAa9D,gBAEtC,OADAwC,EAAUxC,gBAAmBkB,GAAgBiB,EACtCK,CACX,CEbO,SAASqV,GAAsBC,EAAYtY,GAC9C,MAAMuY,EAgBV,SAA6Brf,EAAY8G,EAAUhH,EAAS,IACxDA,EAAO3B,KAAK,CACR6B,aACAuJ,YAAavJ,EAAWmD,OAAOoG,YAC/BzC,aAEJ,MAAMgC,EAAYhC,EAASI,SAC3B,IAAK,IAAI/K,EAAQ2M,EAAU1M,OAAS,EAAGD,GAAS,IAAKA,EACjD2D,EAAO3B,KAAK,CACR6B,WAAY8I,EAAU3M,GACtBoN,YAAaT,EAAU3M,GAAOgH,OAAOoG,YACrCzC,aAGR,OAAOhH,CACX,CA/B6Bwf,CAAoBF,EAAYtY,GACzD,IAAK,IAAI3K,EAAQkjB,EAAiBjjB,OAAS,EAAGD,GAAS,IAAKA,EAAO,CAC/D,MAAM,WAAE6D,EAAU,YAAEuJ,EAAW,SAAEzC,GAAauY,EAAiBljB,GAC/D,GAAI6D,EAAWmD,OAAOyF,QAClB,SAEgBW,IAAgBvJ,EAAWmD,OAAOoG,cAElDzC,EAAStB,MAAQP,EAAU6B,EAASE,UACpCqI,GAAiBrP,EAAWmD,OAAOC,QACnC,GAGR,CACJ,CCbO,SAASmc,GAAkBC,EAClCnU,EACA7C,EACArN,GACI,MAAMiQ,EAAcjQ,EAAQ6E,WACtBmD,EAASiI,EAAYjI,OAE3BkI,EAAWlI,OAASA,EACpB,MAAMsc,EAAiBtc,EAAOoG,aCV3B,SAA8BvJ,GACjC,MACM0f,EADS1f,EAAWmD,OACUuD,UAAUqC,QAAOjC,IAAajB,EAAUiB,EAASE,SAAUF,EAAStB,SAExG,IAAK,IAAIrJ,EAAQujB,EAAqBtjB,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACnE,MAAM2K,EAAW4Y,EAAqBvjB,GAEtCgjB,GADcrY,EAASG,MACMH,GAC7BA,EAAStB,MAAQP,EAAU6B,EAASE,SACxC,CACJ,CDCI2Y,CAAqBH,GAErB,MAAMnW,EAAclG,EAAOC,OAE3B,GADmBqc,IAAmBtc,EAAOoG,YAGzC,OADAiW,EAAcrc,OAAO8F,OAAOqC,SAASjC,GAC9BA,EAEX,MACMS,EAAYiS,GAAkB1Q,EADhBhC,GAAe+B,GAAejI,EAAO8F,OACI9N,EAASqN,GAChES,EAAS9F,EAAO8F,QAAUuW,EAKhC,OAJI/X,EAAW4B,EAAaS,KACxB3O,EAAQ6E,WAAa8J,EACrBb,EAAOqC,SAASxB,IAEbA,CACX,CE1BO,SAASuF,GAAiBrP,EACjCqd,GACI,MAAMla,EAASnD,EAAWmD,OACpBxI,EAAYqF,EAAWrF,UAE7B,IAAKA,EAAUsH,QAAS,CACpB,MAAM2d,EAAW5f,EAAWsH,gBAE5B,QADEnE,EAAOoG,YACLqW,EAASzc,OAAOyF,QACT5I,EAEJqP,GAAiBuQ,EAASzc,OAAOC,QAAQ,EACpD,CACA,GAAIpD,EAAWmD,OAAO0L,OAElB,OADA7O,EAAWmD,OAAO4L,QAAQ5Q,KAAK6B,GACxBA,EAEX,MAAM7E,EAAU6E,EAAW7E,QACrB8N,EAASjJ,EAAWmD,OAAO8F,OACjC,IAAIT,EACAqX,GAAiB,EAErB,GADuBxC,GAAYrd,IAE/BwI,EAAexI,EAAWsH,gBACtBkB,GAAc,CAGdqX,GAAkBha,EAFDlL,EAAUyP,MACPpK,EAAWmZ,YAAYI,aAE/C,CAEJ,MAAM7e,EAAM6kB,GAAkBtW,EAAQjJ,EAAYwI,EAClDrN,GACA,GAAIqN,GAAgBqX,EAAgB,CAGhC,OADAxQ,GADwB7G,EAAarF,OAAOC,QACV,GAC3B1I,CACX,CACA,OAAOA,CACX,CCvCe,SAASolB,GAAoB9f,EAAYjE,EAAU0F,KAAavC,GAC3E,MAAM+B,EAAQjB,EAAWF,OAAOmB,MAEhCwB,EAAWxB,EAAOQ,GAElB,MAAMse,EAAehkB,KAAYmD,GAcjC,OAZAuD,EAAWhB,EAAUR,GACrBoO,GAAiBrP,GACjB,GACI+f,aAAwBrhB,SACxBqhB,EAAaC,SAAQ,KAEjBvd,EAAWhB,EAAUR,GACrBoO,GAAiBrP,GACjB,EAAM,IAIP+f,CACX,CClBA,IAAIE,GAAiBlkB,GAAa,CAACmkB,EAAGC,EAAGC,EAAGC,EAAGC,EAAGC,KAC9C,MAAM,IAAIxf,EAAkB,kFAAkF,EAE3G,MAAMyf,GAAgB,IAAMP,GAC7BQ,GAAiBR,GAWhB,SAASlkB,GAASA,GACrB,MAAMiE,EAAaJ,IACnB,IAAKI,EAAY,CAEb,MADc,IAAIe,EAAkB,gKAExC,CACA,MAAMU,EAAW5B,EAAOC,OAAOC,YAAYiB,MAQ3C,MAPgB,IAAI9B,IACMc,EAAWmD,OAAOqd,cAE7BV,GAAoB9f,EAAYjE,EAAU0F,KAAavC,GAE3DnD,KAAYmD,EAG3B,CACA,SAASwhB,GAAW1gB,GAChB,MAAMyB,EAAW5B,EAAOC,OAAOC,YAAYiB,MAC3Cif,GAAiBlkB,GACG,IAAImD,IACMc,EAAWmD,OAAOqd,cAE7BV,GAAoB9f,EAAYjE,EAAU0F,KAAavC,GAE3DnD,KAAYmD,EAI/B,CC7CO,SAASgY,GAAOnb,GACnBkF,EAAMlF,EACV,CCFO,SAASyf,GAAUzf,GACtBkF,GAAM,KACF,MAAMjB,EAAaJ,IACnBI,GAAYmD,OAAOiW,SAASxa,WAAW7C,EAAS,GAExD,CCNA,SAAS4kB,GAAqBC,GAC1B/gB,EAAOC,OAAO+gB,uBAAyBD,CAC3C,CACO,SAAS1Z,KAGZ,OAFmBrH,EAAOC,OAAO+gB,uBACLlmB,UAAUuM,QAE1C,CHCArH,EAAO,CACHM,aAAcH,GAAc0gB,GAAW1gB,GACvCI,aAAcJ,GAAc0gB,GAAW1gB,GACvCK,YAAaL,IAETA,EAAWmD,OAAOqd,eAAgB,EAClCP,GAAgBQ,EAAc,IGNtC5gB,EAAO,CACHM,aAAcH,GAAc2gB,GAAqB3gB,GACjDI,aAAcJ,GAAc2gB,GAAqB3gB,KCX9C,MAAM8gB,GAAO,GCCb,SAAShV,GAAK7D,KAAYhM,GAC7B,OAAO,IAAI2P,GAAI3D,EAAShM,EAC5B,CCEA,IAAI8kB,GAAW,EAIR,SAASrmB,GAAIM,GAEhB,MAAMqH,EAAa,YAAwB+H,GACvC,MAAMzP,EAAY,IAAI0S,GAAgBjD,GACtCzP,EAAUE,UAAYtB,EAAWyB,aAEjC,MAAMgmB,ECLP,SAAoBrmB,EAAW0I,GAClC,MAAM8Y,EAAatc,EAAOC,OAAOC,YAAYiB,MA2D7C,OAzDgB,SAAUigB,EAAgB9lB,GACtC,MAAMgI,EAAS8d,EAAe9d,SAC5BA,EAAOoG,YACT,MAAMiE,EAAe7S,EAAUuM,SACzBqL,EAAYpP,EAAO8F,QAAQtO,UAAUuM,SAASqL,UAChDA,IACA/E,EAAa+E,UAAYA,GAG7B,MAAM2O,EAAmB7d,EAAOf,SAChC,IAAI8H,EAAQzP,EAAUyP,MAEtB,MACME,EADiB2W,EAAe9H,YAAYM,WACZA,GAAUrP,EAAO6W,EAAgB9E,GAClD/R,EAAM3N,KAAI2N,GAASnF,EAAUmF,KAElD,IAAI1P,EAAMwmB,KAAoB5W,GAC1B5P,aAAeuI,WACfvI,EAAMA,KAELA,GAAOA,EAAIG,YAActB,EAAWmB,MACrCA,EAAMoR,EAAK,GAAGpR,KAElBA,EAAIC,UAAYA,EAChBA,EAAUD,IAAMA,EAChBA,EAAIoF,OAAO+L,WAAalR,EAAUkR,WAClC,MAAM7L,EAAa,IAAI6N,GAAWlT,EAAWsmB,EAAe3Z,gBAAiBnM,EAASmP,EAAanH,EAAOoG,aAC1GvJ,EAAWmD,OAASA,EACpB,MAAMge,EAAWthB,EAAOC,OAAOC,YAAYiB,MAE3C,GADAhB,EAAWF,OAAOmB,MAAM9C,QAAQgjB,GAC5BxmB,EAAU4S,qBAAsB,CAChC,MAAM9S,EAAQ+S,EAAa/S,MAC3B,IAAK,IAAI0B,EAAQ1B,EAAM2B,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACpD,MAAMuR,EAAMjT,EAAM0B,GACZF,EAASyR,EAAIzR,OACnB,IAAK,IAAIE,EAAQF,EAAOG,OAAS,EAAGD,GAAS,IAAKA,EAAO,CACrD,MAAM1B,EAAQwB,EAAOE,GACrB,KAAM1B,aAAiBwI,UACnB,SAEJ,MAAMme,EAAc1T,EAAIzR,OAAOE,GAC3BilB,EAAYtQ,kBAIhBpD,EAAIzR,OAAOE,GAAS,YAAa+C,GAC7B,MAAMsJ,EAAexI,EAAWsH,gBAChC,OAAOmH,GAAehU,EACtB+N,EAAc/K,KACdyB,EACJ,EACAkiB,EAAYtQ,iBAAkB,EAClC,CACJ,CACJ,CACA,OAAO9Q,CACX,CAEJ,CDxD6BqhB,CAAW1mB,EAAW0H,GAM3C,OALK2e,EAAa3e,aACd2e,EAAa3e,WAAaA,GAE9B1H,EAAU2S,QAAS,EACnB3S,EAAUsH,QAAU+e,EACbrmB,CACV,EAED0H,EAAWC,SAAWtH,EACtBqH,EAAW+E,UAAYpM,EAAa4G,WACpC,MAAMlH,EAAMM,EAQZ,OAPAqH,EAAW8P,OAAQ,EACnB9P,EAAWC,SAAW5H,EAEtBA,EAAIomB,KAAOA,GACXpmB,EAAImF,OAASA,EACbnF,EAAI4mB,SAAWP,KACfD,GAAK3iB,KAAKkE,GACHA,CACX,CAEA3H,GAAImW,UAAY,IAAIzG,KAChB,MAAM,IAAI3J,MAAM,4GAA4G,EAKhI/F,GAAI6mB,MAASC,IACT,MAAM,IAAI/gB,MAAM,qHAAqH,EAKzI/F,GAAI+mB,IAAOC,IACP,MAAM,IAAIjhB,MAAM,qHAAqH,EAEzI5G,OAAOC,eAAeY,GAAK,YAAa,CACpC,GAAA6C,CAAIokB,GACAA,EAAkB9Q,WAAY,CAClC,IEpDJ,MAAM+Q,GAAc,GAQb,SAASC,GAAWJ,EAC3BvT,EAAS9D,GACL,MAAM0X,EAAcF,GAAY9jB,WAAUikB,GAAUA,EAAO7T,UAAYA,IACnE4T,GAAe,IACfF,GAAYE,GAAa9hB,WAAWiK,UACpC2X,GAAY5jB,OAAO8jB,EAAa,GAEhC/f,QAAQQ,KAAK,8DAA+D,CAAE2L,aAGlF,MAEMlO,EA0BH,SAAoBrF,GACvB,IAAI0Q,EAAa,CAAC,EAElB,MAAMlQ,EAAU,IAAIkE,EAAagM,GACjCA,EAAa,IAAI2N,GAAere,EAAWQ,GAC3CA,EAAQ4B,KAAKpC,GACbQ,EAAQ6E,WAAaqL,EACrB9C,EAAgB8C,OAAYtH,GAE5B,MAAM9B,EAAUtH,EAAUsH,QACpBjC,EAAaiC,EAAQoJ,EAAYlQ,GAEvC,OADAsN,EAAe4C,EAAYrL,GACpBA,CACX,CAvCuBgiB,CAFHP,EAAIrX,IAGpBpK,EAAWkZ,WAAahL,EACxBlO,EAAWiZ,OAAQ,EACnBjZ,EAAWmD,OAAO8V,OAAQ,EAC1B,MAAMgJ,EAAclU,SAAS4F,cAAc,YAC3CsO,EAAY5Q,aAAa,KAAM,WAAauQ,GAAYxlB,QACxD6lB,EAAY5Q,aAAa,iBAAkBuQ,GAAYxlB,OAAOwF,YAC9D,MAAM4R,EAAWzF,SAAS0F,yBAc1B,OAbAD,EAASI,YAAYqO,GACrB/T,EAAQjE,QAAU8Q,gBACR/a,EAAWiK,UACjB,MAAMgB,EAAejL,EAAWmD,OAAO8H,aACpBA,EAAaiB,WACrBM,YAAYvB,EAAa,EAExCjL,EAAWwL,mBAAmByW,GAC9BjiB,EAAWmD,OAAO8F,OAASjJ,EAC3BA,EAAWmD,OAAOC,OAASpD,EAC3BkO,EAAQrO,OAAS4hB,EAAInf,SAASzC,OAC9B+hB,GAAYzjB,KAAK,CAAE+P,UAASlO,eAC5BkO,EAAQ0F,YAAYJ,GACb,CACHxT,aACA8gB,KAAMW,EAAInf,SAASwe,KAE3B,CC5BO,MAAMoB,GAAM,CACfL,WAAU,qBAAmB,oBAAkB,GAC/C1Y,cAAa,G","sources":["webpack://taggedjs/webpack/bootstrap","webpack://taggedjs/./ts/tag/ValueTypes.enum.ts","webpack://taggedjs/webpack/runtime/define property getters","webpack://taggedjs/webpack/runtime/hasOwnProperty shorthand","webpack://taggedjs/./ts/tag/tag.types.ts","webpack://taggedjs/./ts/isInstance.ts","webpack://taggedjs/./ts/subject/combineLatest.function.ts","webpack://taggedjs/./ts/subject/subject.utils.ts","webpack://taggedjs/./ts/subject/Subject.class.ts","webpack://taggedjs/./ts/subject/ValueSubject.ts","webpack://taggedjs/./ts/subject/will.functions.ts","webpack://taggedjs/./ts/tag/getSupportInCycle.function.ts","webpack://taggedjs/./ts/state/setUse.function.ts","webpack://taggedjs/./ts/errors.ts","webpack://taggedjs/./ts/state/state.utils.ts","webpack://taggedjs/./ts/state/syncStates.function.ts","webpack://taggedjs/./ts/state/state.function.ts","webpack://taggedjs/./ts/state/watch.function.ts","webpack://taggedjs/./ts/state/subject.function.ts","webpack://taggedjs/./ts/state/letState.function.ts","webpack://taggedjs/./ts/state/letProp.function.ts","webpack://taggedjs/./ts/deepFunctions.ts","webpack://taggedjs/./ts/state/providers.ts","webpack://taggedjs/./ts/tag/isLikeTags.function.ts","webpack://taggedjs/./ts/tag/tagRunner.ts","webpack://taggedjs/./ts/tag/render/renderTagOnly.function.ts","webpack://taggedjs/./ts/tag/destroyTag.function.ts","webpack://taggedjs/./ts/tag/hasPropChanges.function.ts","webpack://taggedjs/./ts/tag/update/processTagResult.function.ts","webpack://taggedjs/./ts/tag/Tag.class.ts","webpack://taggedjs/./ts/insertAfter.function.ts","webpack://taggedjs/./ts/tag/checkDestroyPrevious.function.ts","webpack://taggedjs/./ts/tag/getValueType.function.ts","webpack://taggedjs/./ts/tag/cloneValueArray.function.ts","webpack://taggedjs/./ts/tag/destroy.support.ts","webpack://taggedjs/./ts/tag/TemplaterResult.class.ts","webpack://taggedjs/./ts/tag/kidsToTagArraySubject.function.ts","webpack://taggedjs/./ts/tag/update/processNewValue.function.ts","webpack://taggedjs/./ts/tag/setTagPlaceholder.function.ts","webpack://taggedjs/./ts/interpolations/specialAttribute.ts","webpack://taggedjs/./ts/interpolations/bindSubjectCallback.function.ts","webpack://taggedjs/./ts/interpolations/processAttribute.function.ts","webpack://taggedjs/./ts/interpolations/interpolateAttributes.ts","webpack://taggedjs/./ts/interpolations/interpolations.ts","webpack://taggedjs/./ts/tag/update/processTag.function.ts","webpack://taggedjs/./ts/tag/update/processTagArray.ts","webpack://taggedjs/./ts/updateBeforeTemplate.function.ts","webpack://taggedjs/./ts/tag/update/processRegularValue.function.ts","webpack://taggedjs/./ts/tag/update/oneRenderToTagSupport.function.ts","webpack://taggedjs/./ts/tag/update/processFirstSubjectValue.function.ts","webpack://taggedjs/./ts/interpolations/scanTextAreaValue.function.ts","webpack://taggedjs/./ts/tag/update/updateExistingValue.function.ts","webpack://taggedjs/./ts/interpolations/interpolateTemplate.ts","webpack://taggedjs/./ts/interpolations/elementInitCheck.ts","webpack://taggedjs/./ts/interpolations/interpolateContentTemplates.ts","webpack://taggedjs/./ts/interpolations/interpolateElement.ts","webpack://taggedjs/./ts/interpolations/afterInterpolateElement.function.ts","webpack://taggedjs/./ts/render.ts","webpack://taggedjs/./ts/tag/TagSupport.class.ts","webpack://taggedjs/./ts/tag/update/updateContextItem.function.ts","webpack://taggedjs/./ts/tag/elementDestroyCheck.function.ts","webpack://taggedjs/./ts/tag/update/processSubjectComponent.function.ts","webpack://taggedjs/./ts/tag/render/renderSubjectComponent.function.ts","webpack://taggedjs/./ts/alterProp.function.ts","webpack://taggedjs/./ts/tag/update/updateExistingTagComponent.function.ts","webpack://taggedjs/./ts/tag/hasTagSupportChanged.function.ts","webpack://taggedjs/./ts/tag/render/renderWithSupport.function.ts","webpack://taggedjs/./ts/tag/render/destroyUnlikeTags.function.ts","webpack://taggedjs/./ts/state/handleProviderChanges.function.ts","webpack://taggedjs/./ts/tag/render/renderExistingTag.function.ts","webpack://taggedjs/./ts/state/providersChangeCheck.function.ts","webpack://taggedjs/./ts/tag/render/renderTagSupport.function.ts","webpack://taggedjs/./ts/state/callbackStateUpdate.function.ts","webpack://taggedjs/./ts/state/callbackMaker.function.ts","webpack://taggedjs/./ts/state/onInit.ts","webpack://taggedjs/./ts/state/onDestroy.ts","webpack://taggedjs/./ts/state/children.ts","webpack://taggedjs/./ts/tag/tag.utils.ts","webpack://taggedjs/./ts/tag/html.ts","webpack://taggedjs/./ts/tag/tag.ts","webpack://taggedjs/./ts/tag/getTagWrap.function.ts","webpack://taggedjs/./ts/tag/tagElement.ts","webpack://taggedjs/./ts/index.ts"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","export var ValueTypes;\n(function (ValueTypes) {\n    ValueTypes[\"unknown\"] = \"unknown\";\n    ValueTypes[\"tag\"] = \"tag\";\n    ValueTypes[\"templater\"] = \"templater\";\n    ValueTypes[\"tagComponent\"] = \"tag-component\";\n    ValueTypes[\"tagArray\"] = \"tag-array\";\n    ValueTypes[\"subject\"] = \"subject\";\n    ValueTypes[\"date\"] = \"date\";\n    ValueTypes[\"string\"] = \"string\";\n    ValueTypes[\"boolean\"] = \"boolean\";\n    ValueTypes[\"function\"] = \"function\";\n    ValueTypes[\"undefined\"] = \"undefined\";\n})(ValueTypes || (ValueTypes = {}));\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","export class RouteQuery {\n    get(name) {\n        return 'todo';\n    }\n}\n","import { ValueTypes } from './tag/ValueTypes.enum.js';\nexport function isStaticTag(value) {\n    return [\n        ValueTypes.tag,\n        ValueTypes.templater,\n    ].includes(value?.tagJsType);\n}\nexport function isTagTemplater(value) {\n    return value?.tagJsType === ValueTypes.templater;\n}\n// TODO: whats the difference between isTagClass and isTagComponent\nexport function isTagComponent(value) {\n    return value?.tagJsType === ValueTypes.tagComponent;\n}\nexport function isTagClass(value) {\n    return value?.tagJsType === ValueTypes.tag;\n}\n// isSubjectLike\nexport function isSubjectInstance(subject) {\n    return (subject?.isSubject === true || subject?.subscribe) ? true : false; // subject?.isSubject === true || \n}\nexport function isTagArray(value) {\n    return value instanceof Array && value.every(x => [\n        ValueTypes.tag, ValueTypes.templater, ValueTypes.tag, ValueTypes.tagComponent\n    ].includes(x?.tagJsType));\n}\n","import { Subject } from './Subject.class.js';\nexport function combineLatest(subjects) {\n    const output = new Subject();\n    const subscribe = (callback) => {\n        const valuesSeen = [];\n        const values = [];\n        const setValue = (x, index) => {\n            valuesSeen[index] = true;\n            values[index] = x;\n            const countMatched = valuesSeen.length === subjects.length;\n            if (!countMatched) {\n                return;\n            }\n            for (let index = valuesSeen.length - 1; index >= 0; --index) {\n                if (!valuesSeen[index]) {\n                    return;\n                }\n            }\n            // everyone has reported values\n            callback(values, subscription);\n        };\n        const clones = [...subjects];\n        const firstSub = clones.shift();\n        const subscription = firstSub.subscribe(x => setValue(x, 0));\n        const subscriptions = clones.map((subject, index) => subject.subscribe(x => setValue(x, index + 1)));\n        subscription.subscriptions = subscriptions;\n        return subscription;\n    };\n    output.subscribeWith = subscribe;\n    return output;\n}\n","import { Subject } from './Subject.class.js';\nfunction removeSubFromArray(subscribers, callback) {\n    const index = subscribers.findIndex(sub => sub.callback === callback);\n    if (index !== -1) {\n        subscribers.splice(index, 1);\n    }\n}\nexport function getSubscription(subject, callback, subscribers) {\n    const countSubject = Subject.globalSubCount$;\n    Subject.globalSubCount$.next(countSubject._value + 1);\n    const subscription = () => {\n        subscription.unsubscribe();\n    };\n    subscription.callback = callback;\n    subscription.subscriptions = [];\n    // Return a function to unsubscribe from the BehaviorSubject\n    subscription.unsubscribe = () => {\n        removeSubFromArray(subscribers, callback); // each will be called when update comes in\n        // removeSubFromArray(Subject.globalSubs, callback) // 🔬 testing\n        Subject.globalSubCount$.next(countSubject._value - 1);\n        // any double unsubscribes will be ignored\n        subscription.unsubscribe = () => subscription;\n        // unsubscribe from any combined subjects\n        const subscriptions = subscription.subscriptions;\n        for (let index = subscriptions.length - 1; index >= 0; --index) {\n            subscriptions[index].unsubscribe();\n        }\n        return subscription;\n    };\n    subscription.add = (sub) => {\n        subscription.subscriptions.push(sub);\n        return subscription;\n    };\n    subscription.next = (value) => {\n        callback(value, subscription);\n    };\n    return subscription;\n}\nexport function runPipedMethods(value, methods, onComplete) {\n    const cloneMethods = [...methods];\n    const firstMethod = cloneMethods.shift();\n    const next = (newValue) => {\n        if (cloneMethods.length) {\n            return runPipedMethods(newValue, cloneMethods, onComplete);\n        }\n        onComplete(newValue);\n    };\n    let handler = next;\n    const setHandler = (x) => handler = x;\n    const pipeUtils = { setHandler, next };\n    const methodResponse = firstMethod(value, pipeUtils);\n    handler(methodResponse);\n}\n","import { isSubjectInstance } from '../isInstance.js';\nimport { combineLatest } from './combineLatest.function.js';\nimport { getSubscription, runPipedMethods } from './subject.utils.js';\nexport class Subject {\n    value;\n    onSubscription;\n    // private?\n    methods = [];\n    isSubject = true;\n    // private?\n    subscribers = [];\n    subscribeWith;\n    _value;\n    // this is overwritten by constructor at runtime. However having it helps editors know of its existence\n    set; // `subject.set = x` equal to `subject.next(x)`\n    constructor(value, \n    // private?\n    onSubscription) {\n        this.value = value;\n        this.onSubscription = onSubscription;\n        this._value = value;\n        defineValueOn(this);\n    }\n    subscribe(callback) {\n        const subscription = getSubscription(this, callback, this.subscribers);\n        // are we within a pipe?\n        const subscribeWith = this.subscribeWith;\n        if (subscribeWith) {\n            // are we in a pipe?\n            if (this.methods.length) {\n                const orgCallback = callback;\n                callback = (value) => {\n                    runPipedMethods(value, this.methods, lastValue => orgCallback(lastValue, subscription));\n                };\n            }\n            return subscribeWith(callback);\n        }\n        this.subscribers.push(subscription);\n        if (this.onSubscription) {\n            this.onSubscription(subscription);\n        }\n        return subscription;\n    }\n    next(value) {\n        this._value = value;\n        this.emit();\n    }\n    emit() {\n        const value = this._value;\n        // Notify all subscribers with the new value\n        const subs = [...this.subscribers]; // subs may change as we call callbacks\n        const length = subs.length;\n        for (let index = 0; index < length; ++index) {\n            const sub = subs[index];\n            sub.callback(value, sub);\n        }\n    }\n    toPromise() {\n        return new Promise(res => {\n            this.subscribe((x, subscription) => {\n                subscription.unsubscribe();\n                res(x);\n            });\n        });\n    }\n    /** like toPromise but faster */\n    toCallback(callback) {\n        const subscription = this.subscribe((x, _subscription) => {\n            subscription.unsubscribe();\n            callback(x);\n        });\n        return this;\n    }\n    pipe(...operations) {\n        const subject = new Subject(this._value);\n        subject.setMethods(operations);\n        subject.subscribeWith = (x) => this.subscribe(x);\n        subject.next = x => this.next(x);\n        return subject;\n    }\n    setMethods(operations) {\n        this.methods = operations;\n    }\n    static all(args) {\n        const switched = args.map(arg => {\n            if (isSubjectInstance(arg))\n                return arg;\n            // Call the callback immediately with the current value\n            const x = new Subject(arg, subscription => {\n                subscription.next(arg);\n                return subscription;\n            });\n            return x;\n        });\n        return combineLatest(switched);\n    }\n    static globalSubCount$ = new Subject(0); // for ease of debugging\n}\nexport function defineValueOn(subject) {\n    Object.defineProperty(subject, 'value', {\n        // supports subject.value = x\n        set(value) {\n            subject._value = value;\n            subject.emit();\n        },\n        // supports subject.value\n        get() {\n            return subject._value;\n        }\n    });\n    Object.defineProperty(subject, 'set', {\n        // supports subject.set = x\n        set: (value) => subject.next(value),\n        // supports subject.set(x)\n        get: () => (x) => subject.next(x),\n    });\n}\n","import { Subject, defineValueOn } from './Subject.class.js';\nexport class ValueSubject extends Subject {\n    value;\n    constructor(value) {\n        super(value);\n        this.value = value;\n        defineValueOn(this);\n    }\n    subscribe(callback) {\n        const subscription = super.subscribe(callback);\n        // Call the callback immediately with the current value\n        callback(this._value, subscription);\n        return subscription;\n    }\n}\n","export function willCallback(callback) {\n    return ((lastValue, utils) => {\n        utils.setHandler(() => {\n            return undefined;\n        });\n        callback(lastValue, utils.next);\n    });\n}\n/** .pipe( promise((x) => Promise.resolve(44)) ) */\nexport function willPromise(callback) {\n    return ((lastValue, utils) => {\n        utils.setHandler(() => {\n            return undefined;\n        }); // do nothing on initial return\n        const result = callback(lastValue);\n        result.then(x => utils.next(x));\n    });\n}\n/** .pipe( willSubscribe((x) => new ValueSubject(44)) ) */\nexport const willSubscribe = (callback) => {\n    return ((lastValue, utils) => {\n        utils.setHandler(() => {\n            return undefined;\n        }); // do nothing on initial return\n        const result = callback(lastValue);\n        const subscription = result.subscribe(x => {\n            subscription.unsubscribe();\n            utils.next(x);\n        });\n    });\n};\n","import { setUse } from '../state/index.js';\nexport function getSupportInCycle() {\n    return setUse.memory.stateConfig.tagSupport;\n}\n","const tagUse = [];\nexport function setUse(use) {\n    // must provide defaults\n    const useMe = {\n        beforeRender: use.beforeRender || (() => undefined),\n        beforeRedraw: use.beforeRedraw || (() => undefined),\n        afterRender: use.afterRender || (() => undefined),\n        beforeDestroy: use.beforeDestroy || (() => undefined),\n    };\n    setUse.tagUse.push(useMe);\n}\nsetUse.tagUse = tagUse;\nsetUse.memory = {};\n","export class TagError extends Error {\n    details;\n    constructor(message, errorCode, details = {}) {\n        super(message);\n        this.name = TagError.name;\n        this.details = { ...details, errorCode };\n    }\n}\nexport class ArrayNoKeyError extends TagError {\n    constructor(message, details) {\n        super(message, 'array-no-key-error', details);\n        this.name = ArrayNoKeyError.name;\n    }\n}\nexport class StateMismatchError extends TagError {\n    constructor(message, details) {\n        super(message, 'state-mismatch-error', details);\n        this.name = StateMismatchError.name;\n    }\n}\nexport class SyncCallbackError extends TagError {\n    constructor(message, details) {\n        super(message, 'sync-callback-error', details);\n        this.name = SyncCallbackError.name;\n    }\n}\n","import { StateMismatchError } from '../errors.js';\nimport { setUse } from './setUse.function.js';\nsetUse.memory.stateConfig = {\n    array: [], // state memory on the first render\n    // rearray: [] as State,\n};\nconst beforeRender = (tagSupport) => initState(tagSupport);\nsetUse({\n    beforeRender,\n    beforeRedraw: beforeRender,\n    afterRender: (tagSupport) => {\n        const memory = tagSupport.memory;\n        const config = setUse.memory.stateConfig;\n        const rearray = config.rearray;\n        if (rearray.length) {\n            if (rearray.length !== config.array.length) {\n                const message = `States lengths have changed ${rearray.length} !== ${config.array.length}. State tracking requires the same amount of function calls every render. Typically this errors is thrown when a state like function call occurs only for certain conditions or when a function is intended to be wrapped with a tag() call`;\n                const wrapper = tagSupport.templater?.wrapper;\n                const details = {\n                    oldStates: config.array,\n                    newStates: config.rearray,\n                    tagFunction: wrapper.parentWrap.original,\n                };\n                const error = new StateMismatchError(message, details);\n                console.warn(message, details);\n                throw error;\n            }\n        }\n        delete config.rearray; // clean up any previous runs\n        delete config.tagSupport;\n        memory.state.length = 0;\n        memory.state.push(...config.array);\n        const state = memory.state;\n        for (let index = state.length - 1; index >= 0; --index) {\n            const item = state[index];\n            item.lastValue = getStateValue(item); // set last values\n        }\n        config.array = [];\n    }\n});\nexport function getStateValue(state) {\n    const callback = state.callback;\n    if (!callback) {\n        return state.defaultValue;\n    }\n    const [value, checkValue] = getCallbackValue(callback);\n    if (checkValue !== StateEchoBack) {\n        const message = 'letState function incorrectly used. Second item in array is not setting expected value.\\n\\n' +\n            'For \"let\" state use `let name = state(default)(x => [name, name = x])`\\n\\n' +\n            'For \"const\" state use `const name = state(default)()`\\n\\n' +\n            'Problem state:\\n' + (callback ? callback.toString() : JSON.stringify(state)) + '\\n';\n        console.error(message, { state, callback, value, checkValue });\n        throw new Error(message);\n    }\n    return value;\n}\nexport class StateEchoBack {\n}\nfunction initState(tagSupport) {\n    const memory = tagSupport.memory;\n    const state = memory.state;\n    const config = setUse.memory.stateConfig;\n    config.rearray = [];\n    const stateLength = state?.length;\n    if (stateLength) {\n        for (let index = 0; index < stateLength; ++index) {\n            getStateValue(state[index]);\n        }\n        config.rearray.push(...state);\n    }\n    config.tagSupport = tagSupport;\n}\nexport function getCallbackValue(callback) {\n    const oldState = callback(StateEchoBack); // get value and set to undefined\n    const [value] = oldState;\n    const [checkValue] = callback(value); // set back to original value\n    return [value, checkValue];\n}\n","export function syncStates(stateFrom, stateTo) {\n    for (let index = stateFrom.length - 1; index >= 0; --index) {\n        const state = stateFrom[index];\n        const fromValue = state.get();\n        const callback = stateTo[index].callback;\n        if (callback) {\n            callback(fromValue); // set the value\n        }\n        stateTo[index].lastValue = fromValue; // record the value\n    }\n}\n","import { setUse } from './setUse.function.js';\nimport { getStateValue } from './state.utils.js';\nimport { syncStates } from './syncStates.function.js';\n/** Used for variables that need to remain the same variable during render passes */\nexport function state(defaultValue) {\n    const config = setUse.memory.stateConfig;\n    let getSetMethod;\n    const rearray = config.rearray;\n    const restate = rearray[config.array.length];\n    if (restate) {\n        let oldValue = getStateValue(restate);\n        getSetMethod = ((x) => [oldValue, oldValue = x]);\n        const push = {\n            get: () => getStateValue(push),\n            callback: getSetMethod,\n            lastValue: oldValue,\n            defaultValue: restate.defaultValue,\n        };\n        config.array.push(push);\n        return oldValue;\n    }\n    // State first time run\n    const defaultFn = defaultValue instanceof Function ? defaultValue : () => defaultValue;\n    let initValue = defaultFn();\n    // the state is actually intended to be a function\n    if (initValue instanceof Function) {\n        const oldState = config.array;\n        const tagSupport = config.tagSupport;\n        const original = initValue;\n        initValue = ((...args) => {\n            const global = tagSupport.global;\n            const newest = global.newest;\n            const newState = newest.memory.state;\n            syncStates(newState, oldState);\n            const result = original(...args);\n            syncStates(oldState, newState);\n            return result;\n        });\n        initValue.original = original;\n    }\n    getSetMethod = ((x) => [initValue, initValue = x]);\n    const push = {\n        get: () => getStateValue(push),\n        callback: getSetMethod,\n        lastValue: initValue,\n        defaultValue: initValue,\n    };\n    config.array.push(push);\n    return initValue;\n}\n","import { ValueSubject } from '../subject/index.js';\nimport { getSupportInCycle } from '../tag/getSupportInCycle.function.js';\nimport { setUse } from './setUse.function.js';\nimport { state } from './state.function.js';\nimport { syncStates } from './syncStates.function.js';\n/**\n * When an item in watch array changes, callback function will be triggered. Triggers on initial watch setup. TIP: try watch.noInit()\n * @param currentValues T[]\n * @param callback WatchCallback\n * @returns T[]\n */\nexport const watch = ((currentValues, callback) => {\n    return setupWatch(currentValues, callback);\n});\nconst defaultFinally = (x) => x;\nfunction newWatch(setup) {\n    const method = (currentValues, callback) => {\n        return setupWatch(currentValues, callback, setup);\n    };\n    method.setup = setup;\n    defineOnMethod(() => method, method);\n    return method;\n}\n/**\n * puts above functionality together\n * @param currentValues values being watched\n * @param callback (currentValue, previousValues) => resolveToValue\n * @param param2\n * @returns\n */\nconst setupWatch = (currentValues, callback, { init, before = () => true, final = defaultFinally, } = {}) => {\n    let previous = state({\n        pastResult: undefined,\n        values: undefined,\n    });\n    const previousValues = previous.values;\n    // First time running watch?\n    if (previousValues === undefined) {\n        if (!before(currentValues)) {\n            previous.values = currentValues;\n            return previous.pastResult; // do not continue\n        }\n        const castedInit = init || callback;\n        const result = castedInit(currentValues, previousValues);\n        previous.pastResult = final(result);\n        previous.values = currentValues;\n        return previous.pastResult;\n    }\n    const allExact = currentValues.every((item, index) => item === previousValues[index]);\n    if (allExact) {\n        return previous.pastResult;\n    }\n    if (!before(currentValues)) {\n        previous.values = currentValues;\n        return previous.pastResult; // do not continue\n    }\n    const result = callback(currentValues, previousValues);\n    previous.pastResult = final(result);\n    previousValues.length = 0;\n    previousValues.push(...currentValues);\n    return previous.pastResult;\n};\nfunction defineOnMethod(getWatch, attachTo) {\n    Object.defineProperty(attachTo, 'noInit', {\n        get() {\n            const watch = getWatch();\n            watch.setup.init = () => undefined;\n            return watch;\n        },\n    });\n    Object.defineProperty(attachTo, 'asSubject', {\n        get() {\n            const oldWatch = getWatch();\n            const firstSupport = state(() => getSupportInCycle());\n            const subject = state(() => new ValueSubject(undefined));\n            const method = (currentValues, callback) => {\n                setupWatch(currentValues, (currentValues, previousValues) => {\n                    const nowTagSupport = getSupportInCycle();\n                    const setTo = callback(currentValues, previousValues);\n                    if (nowTagSupport !== firstSupport) {\n                        const newestState = setUse.memory.stateConfig.array;\n                        syncStates(newestState, firstSupport.memory.state);\n                    }\n                    subject.next(setTo);\n                }, oldWatch.setup);\n                return subject;\n            };\n            method.setup = oldWatch.setup;\n            defineOnMethod(() => method, method);\n            return method;\n        },\n    });\n    Object.defineProperty(attachTo, 'truthy', {\n        get() {\n            const watch = getWatch();\n            watch.setup.before = (currentValues) => currentValues.every(x => x);\n            return watch;\n        },\n    });\n    return attachTo;\n}\ndefineOnMethod(() => newWatch({}), watch);\n","import { Subject, ValueSubject } from '../subject/index.js';\nimport { getSupportInCycle } from '../tag/getSupportInCycle.function.js';\nimport { setUse } from './setUse.function.js';\nimport { state } from './state.function.js';\nimport { syncStates } from './syncStates.function.js';\n/** Create a Subject that on updates will sync state values to keep chained functions using latest variables */\nexport function subject(value, onSubscription) {\n    const oldestState = state(() => setUse.memory.stateConfig.array);\n    const nowTagSupport = getSupportInCycle();\n    return state(() => {\n        const subject = new Subject(value, onSubscription).pipe(x => {\n            syncStates(nowTagSupport.memory.state, oldestState);\n            return x;\n        });\n        return subject;\n    });\n}\nsubject._value = (value) => {\n    const oldestState = state(() => setUse.memory.stateConfig.array);\n    const nowTagSupport = getSupportInCycle();\n    return state(() => {\n        const subject = new ValueSubject(value).pipe(x => {\n            syncStates(nowTagSupport.memory.state, oldestState);\n            return x;\n        });\n        return subject;\n    });\n};\nfunction all(args) {\n    const oldestState = state(() => setUse.memory.stateConfig.array);\n    const nowTagSupport = getSupportInCycle();\n    return Subject.all(args).pipe(x => {\n        syncStates(nowTagSupport.memory.state, oldestState);\n        return x;\n    });\n}\nsubject.all = all;\n","import { getStateValue } from './state.utils.js';\nimport { setUse } from './setUse.function.js';\n/** Used for variables that need to remain the same variable during render passes. If defaultValue is a function it is called only once, its return value is first state, and let value can changed */\nexport function letState(defaultValue) {\n    const config = setUse.memory.stateConfig;\n    const rearray = config.rearray;\n    let getSetMethod;\n    const restate = rearray[config.array.length];\n    if (restate) {\n        let oldValue = getStateValue(restate);\n        getSetMethod = ((x) => [oldValue, oldValue = x]);\n        const push = {\n            get: () => getStateValue(push),\n            callback: getSetMethod,\n            lastValue: oldValue,\n            defaultValue: restate.defaultValue,\n        };\n        config.array.push(push);\n        return makeStateResult(oldValue, push);\n    }\n    // State first time run\n    const defaultFn = defaultValue instanceof Function ? defaultValue : () => defaultValue;\n    let initValue = defaultFn();\n    getSetMethod = ((x) => [initValue, initValue = x]);\n    const push = {\n        get: () => getStateValue(push),\n        callback: getSetMethod,\n        lastValue: initValue,\n        defaultValue: initValue,\n    };\n    config.array.push(push);\n    return makeStateResult(initValue, push);\n}\nfunction makeStateResult(initValue, push) {\n    // return initValue\n    const result = (y) => {\n        push.callback = y || (x => [initValue, initValue = x]);\n        return initValue;\n    };\n    return result;\n}\n","import { letState } from './letState.function.js';\nimport { watch } from './watch.function.js';\n/**\n * Enables the ability to maintain a change to a props value until the prop itself changes\n * @param prop typically the name of an existing prop\n * @returns immediately call the returned function: letProp(y)(x => [y, y=x])\n */\nexport function letProp(prop) {\n    return getSetProp => {\n        let myProp = letState(prop)(getSetProp);\n        watch([prop], () => getSetProp(myProp = prop));\n        getSetProp(myProp); // always reset to my value and right await so that the old prop value never slips through\n        return myProp;\n    };\n}\n","export function deepClone(obj) {\n    return makeDeepClone(obj, new WeakMap());\n}\nfunction makeDeepClone(obj, visited) {\n    // If obj is a primitive type or null, return it directly\n    if (obj === null || typeof obj !== 'object') {\n        return obj;\n    }\n    // If obj is already visited, return the cloned reference\n    if (visited.has(obj)) {\n        return visited.get(obj);\n    }\n    // Handle special cases like Date and RegExp\n    if (obj instanceof Date) {\n        return new Date(obj);\n    }\n    if (obj instanceof RegExp) {\n        return new RegExp(obj);\n    }\n    // Create an empty object or array with the same prototype\n    const clone = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));\n    // Register the cloned object to avoid cyclic references\n    visited.set(obj, clone);\n    // Clone each property or element of the object or array\n    if (Array.isArray(obj)) {\n        for (let i = 0; i < obj.length; i++) {\n            clone[i] = makeDeepClone(obj[i], visited);\n        }\n    }\n    else {\n        for (const key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                clone[key] = makeDeepClone(obj[key], visited);\n            }\n        }\n    }\n    return clone;\n}\nexport function deepEqual(obj1, obj2) {\n    return isDeepEqual(obj1, obj2, new WeakMap());\n}\nfunction isDeepEqual(obj1, obj2, visited) {\n    const directEqual = obj1 === obj2;\n    if (directEqual || isSameFunctions(obj1, obj2)) {\n        return true;\n    }\n    // If obj is already visited, return the cloned reference\n    if (visited.has(obj1)) {\n        return true;\n    }\n    if (typeof obj1 === 'object' && typeof obj2 === 'object') {\n        // both are dates and were already determined not the same\n        if (obj1 instanceof Date && obj2 instanceof Date) {\n            return obj1.getTime() === obj2.getTime();\n        }\n        // Register the cloned object to avoid cyclic references\n        visited.set(obj1, 0);\n        // Check if obj1 and obj2 are both arrays\n        if (Array.isArray(obj1) && Array.isArray(obj2)) {\n            return isArrayDeepEqual(obj1, obj2, visited);\n        }\n        else if (Array.isArray(obj1) || Array.isArray(obj2)) {\n            // One is an array, and the other is not\n            return false;\n        }\n        return isObjectDeepEqual(obj1, obj2, visited);\n    }\n    return false;\n}\nfunction isObjectDeepEqual(obj1, obj2, visited) {\n    const keys1 = Object.keys(obj1);\n    const keys2 = Object.keys(obj2);\n    if (keys1.length === 0 && keys2.length === 0) {\n        return true;\n    }\n    if (keys1.length !== keys2.length) {\n        return false;\n    }\n    for (const key of keys1) {\n        const keyFound = keys2.includes(key);\n        if (!keyFound || !isDeepEqual(obj1[key], obj2[key], visited)) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction isArrayDeepEqual(obj1, obj2, visited) {\n    if (obj1.length !== obj2.length) {\n        return false;\n    }\n    for (let i = 0; i < obj1.length; i++) {\n        if (!isDeepEqual(obj1[i], obj2[i], visited)) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction isSameFunctions(fn0, fn1) {\n    const bothFunction = fn0 instanceof Function && fn1 instanceof Function;\n    return bothFunction && fn0.toString() === fn1.toString();\n}\n","import { deepClone } from '../deepFunctions.js';\nimport { setUse } from './setUse.function.js';\nimport { state } from './state.function.js';\nexport const providers = {\n    create: (constructMethod) => {\n        const stateDiffMemory = state(() => ({ stateDiff: 0, provider: undefined }));\n        // mimic how many states were called the first time\n        if (stateDiffMemory.stateDiff) {\n            for (let x = stateDiffMemory.stateDiff; x > 0; --x) {\n                state(undefined);\n            }\n            const result = state(undefined);\n            return result;\n        }\n        const result = state(() => {\n            const memory = setUse.memory;\n            const stateConfig = memory.stateConfig;\n            const oldStateCount = stateConfig.array.length;\n            // Providers with provider requirements just need to use providers.create() and providers.inject()\n            const instance = 'prototype' in constructMethod ? new constructMethod() : constructMethod();\n            const tagSupport = stateConfig.tagSupport;\n            const stateDiff = stateConfig.array.length - oldStateCount;\n            const provider = {\n                constructMethod,\n                instance,\n                clone: deepClone(instance),\n                stateDiff,\n                owner: tagSupport,\n                children: [],\n            };\n            stateDiffMemory.provider = provider;\n            tagSupport.global.providers.push(provider);\n            stateDiffMemory.stateDiff = stateDiff;\n            return instance;\n        });\n        const cm = constructMethod;\n        // const compareTo = cm.compareTo = cm.compareTo || cm.toString()\n        const compareTo = cm.compareTo = cm.toString();\n        stateDiffMemory.provider.constructMethod.compareTo = compareTo;\n        return result;\n    },\n    /**\n     * @template T\n     * @param {(new (...args: any[]) => T) | () => T} constructor\n     * @returns {T}\n     */\n    inject: (constructor) => {\n        // find once, return same every time after\n        return state(() => {\n            const memory = setUse.memory;\n            const cm = constructor;\n            const compareTo = cm.compareTo = cm.compareTo || constructor.toString();\n            const tagSupport = memory.stateConfig.tagSupport;\n            const providers = [];\n            let owner = {\n                ownerTagSupport: tagSupport.ownerTagSupport\n            };\n            while (owner.ownerTagSupport) {\n                const ownerProviders = owner.ownerTagSupport.global.providers;\n                const provider = ownerProviders.find(provider => {\n                    providers.push(provider);\n                    const constructorMatch = provider.constructMethod.compareTo === compareTo;\n                    if (constructorMatch) {\n                        return true;\n                    }\n                });\n                if (provider) {\n                    provider.clone = deepClone(provider.instance); // keep a copy of the latest before any change occur\n                    const tagSupport = memory.stateConfig.tagSupport;\n                    tagSupport.global.providers.push(provider);\n                    provider.children.push(tagSupport);\n                    return provider.instance;\n                }\n                owner = owner.ownerTagSupport; // cause reloop checking next parent\n            }\n            const msg = `Could not inject provider: ${constructor.name} ${constructor}`;\n            console.warn(`${msg}. Available providers`, providers);\n            throw new Error(msg);\n        });\n    }\n};\n","export function isLikeTags(tagSupport0, // new\ntagSupport1) {\n    const templater0 = tagSupport0.templater;\n    const templater1 = tagSupport1.templater;\n    const tag0 = templater0?.tag || tagSupport0;\n    const tag1 = templater1.tag;\n    const strings0 = tag0.strings;\n    const strings1 = tagSupport1.strings || tag1.strings;\n    if (strings0.length !== strings1.length) {\n        return false;\n    }\n    const everyStringMatched = strings0.every((string, index) => strings1[index] === string);\n    if (!everyStringMatched) {\n        return false;\n    }\n    const values0 = tagSupport0.values || tag0.values;\n    const values1 = tagSupport1.values || tag1.values;\n    return isLikeValueSets(values0, values1);\n}\nexport function isLikeValueSets(values0, values1) {\n    const valuesLengthsMatch = values0.length === values1.length;\n    if (!valuesLengthsMatch) {\n        return false;\n    }\n    const allVarsMatch = values1.every((value, index) => {\n        const compareTo = values0[index];\n        const isFunctions = value instanceof Function && compareTo instanceof Function;\n        if (isFunctions) {\n            const stringMatch = value.toString() === compareTo.toString();\n            if (stringMatch) {\n                return true;\n            }\n            return false;\n        }\n        return true; // deepEqual(value, compareTo)\n    });\n    if (allVarsMatch) {\n        return true;\n    }\n    return false;\n}\n","import { setUse } from '../state/index.js';\nimport { Subject } from '../subject/index.js';\nimport { getSupportInCycle } from './getSupportInCycle.function.js';\n// Emits event at the end of a tag being rendered. Use tagClosed$.toPromise() to render a tag after a current tag is done rendering\nsetUse.memory.tagClosed$ = new Subject(undefined, subscription => {\n    if (!getSupportInCycle()) {\n        subscription.next(); // we are not currently processing so process now\n    }\n});\n// Life cycle 1\nexport function runBeforeRender(tagSupport, ownerSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].beforeRender(tagSupport, ownerSupport);\n    }\n}\n// Life cycle 2\nexport function runAfterRender(tagSupport, ownerTagSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].afterRender(tagSupport, ownerTagSupport);\n    }\n    setUse.memory.tagClosed$.next(ownerTagSupport);\n}\n// Life cycle 3\nexport function runBeforeRedraw(tagSupport, ownerTagSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].beforeRedraw(tagSupport, ownerTagSupport);\n    }\n}\n// Life cycle 4 - end of life\nexport function runBeforeDestroy(tagSupport, ownerTagSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].beforeDestroy(tagSupport, ownerTagSupport);\n    }\n    tagSupport.global.deleted = true;\n    tagSupport.hasLiveElements = false;\n    // remove me from my parents\n    if (ownerTagSupport) {\n        ownerTagSupport.global.childTags = ownerTagSupport.global.childTags.filter(child => child !== tagSupport.global.oldest);\n        const global = tagSupport.global;\n        global.providers.forEach(provider => provider.children.forEach((child, index) => {\n            if (child.global === global) {\n                provider.children.splice(index, 1);\n            }\n        }));\n    }\n}\n","import { runBeforeRedraw, runBeforeRender } from '../tagRunner.js';\nimport { runAfterRender } from '../tagRunner.js';\nexport function renderTagOnly(newTagSupport, prevSupport, subject, ownerSupport) {\n    const oldRenderCount = newTagSupport.global.renderCount;\n    beforeWithRender(newTagSupport, ownerSupport, prevSupport);\n    const templater = newTagSupport.templater;\n    // NEW TAG CREATED HERE\n    const wrapper = templater.wrapper;\n    let reSupport = wrapper(newTagSupport, subject);\n    /* AFTER */\n    runAfterRender(newTagSupport, ownerSupport);\n    newTagSupport.global.newest = reSupport;\n    if (!prevSupport && ownerSupport) {\n        ownerSupport.global.childTags.push(reSupport);\n    }\n    // When we rendered, only 1 render should have taken place OTHERWISE rendering caused another render and that is the latest instead\n    if (reSupport.global.renderCount > oldRenderCount + 1) {\n        return newTagSupport.global.newest;\n    }\n    return reSupport;\n}\nfunction beforeWithRender(tagSupport, // new\nparentSupport, prevSupport) {\n    const lastOwnerSupport = prevSupport?.ownerTagSupport;\n    const runtimeOwnerSupport = lastOwnerSupport || parentSupport;\n    if (prevSupport) {\n        if (prevSupport !== tagSupport) {\n            const lastState = prevSupport.memory.state;\n            const memory = tagSupport.memory;\n            tagSupport.global = prevSupport.global;\n            memory.state.length = 0;\n            memory.state.push(...lastState);\n        }\n        return runBeforeRedraw(tagSupport, prevSupport);\n    }\n    // first time render\n    return runBeforeRender(tagSupport, runtimeOwnerSupport);\n}\n","export function destroyTagMemory(oldTagSupport) {\n    // must destroy oldest which is tag with elements on stage\n    const oldest = oldTagSupport.global.oldest;\n    oldest.destroy();\n    oldTagSupport.global.context = {};\n}\n","import { deepEqual } from '../deepFunctions.js';\n/**\n *\n * @param props\n * @param pastCloneProps\n * @returns WHEN number then props have changed. WHEN false props have not changed\n */\nexport function hasPropChanges(props, // natural props\npastCloneProps) {\n    /*\n    const isCommonEqual = props === undefined && props === compareToProps\n    if(isCommonEqual) {\n      return false\n    }\n    */\n    let castedProps = props;\n    let castedPastProps = pastCloneProps;\n    // check all prop functions match\n    if (typeof (props) === 'object') {\n        if (!pastCloneProps) {\n            return 3;\n        }\n        // castedProps = {...props}\n        castedProps = [...props];\n        // castedPastProps = {...(pastCloneProps || {})}\n        castedPastProps = [...(pastCloneProps || [])];\n        const allFunctionsMatch = castedProps.every((value, index) => {\n            let compare = castedPastProps[index];\n            if (value && typeof (value) === 'object') {\n                const subCastedProps = { ...value };\n                const subCompareProps = { ...compare || {} };\n                const matched = Object.entries(subCastedProps).every(([key, value]) => {\n                    return compareProps(value, subCompareProps[key], () => {\n                        delete subCastedProps[key]; // its a function and not needed to be compared\n                        delete subCompareProps[key]; // its a function and not needed to be compared\n                    });\n                });\n                return matched;\n            }\n            return compareProps(value, compare, () => {\n                castedProps.splice(index, 1);\n                castedPastProps.splice(index, 1);\n            });\n        });\n        if (!allFunctionsMatch) {\n            return 6; // a change has been detected by function comparisons\n        }\n    }\n    // const isEqual = deepEqual(castedPastProps, castedProps)\n    // return isEqual ? false : 7 // if equal then no changes\n    return false;\n}\n/** returning a number means true good comparison */\nfunction compareProps(value, compare, onDelete) {\n    if (!(value instanceof Function)) {\n        return deepEqual(value, compare) ? 4 : false;\n    }\n    const compareFn = compare;\n    if (!(compareFn instanceof Function)) {\n        return false; // its a function now but was not before\n    }\n    // ensure we are comparing apples to apples as function get wrapped\n    const compareOriginal = compare?.original;\n    if (compareOriginal) {\n        compare = compareOriginal;\n    }\n    const original = value.original;\n    if (original) {\n        value = value.original;\n    }\n    const valueString = value.toString();\n    const compareString = compare.toString();\n    if (valueString === compareString) {\n        onDelete();\n        return 3; // both are function the same\n    }\n    onDelete();\n    return 5;\n}\n","/** checks if previous support exists on subject or as a last global support. If first render, calls builder. Otherwise calls tagSupport.updateBy() */\nexport function processTagResult(tagSupport, subject, // used for recording past and current value\ninsertBefore, // <template end interpolate />\n{ counts, }) {\n    // *if appears we already have seen\n    const subjectTag = subject;\n    const lastSupport = subjectTag.tagSupport;\n    const prevSupport = lastSupport?.global.oldest || undefined;\n    const justUpdate = prevSupport;\n    if (prevSupport && justUpdate) {\n        return processTagResultUpdate(tagSupport, subjectTag, prevSupport);\n    }\n    tagSupport.buildBeforeElement(insertBefore, {\n        counts,\n    });\n    return tagSupport;\n}\nfunction processTagResultUpdate(tagSupport, subject, // used for recording past and current value\nprevSupport) {\n    // components\n    if (subject instanceof Function) {\n        const newSupport = subject(prevSupport);\n        prevSupport.updateBy(newSupport);\n        subject.tagSupport = newSupport;\n        return newSupport;\n    }\n    prevSupport.updateBy(tagSupport);\n    subject.tagSupport = tagSupport;\n    return tagSupport;\n}\n","import { ValueTypes } from './ValueTypes.enum.js';\nexport const variablePrefix = '__tagvar';\nexport const escapeVariable = '--' + variablePrefix + '--';\nexport const escapeSearch = new RegExp(escapeVariable, 'g');\nexport class Tag {\n    strings;\n    values;\n    tagJsType = ValueTypes.tag;\n    // present only when an array. Populated by Tag.key()\n    memory = {};\n    templater;\n    constructor(strings, values) {\n        this.strings = strings;\n        this.values = values;\n    }\n    /** Used for array, such as array.map(), calls aka array.map(x => html``.key(x)) */\n    key(arrayValue) {\n        this.memory.arrayValue = arrayValue;\n        return this;\n    }\n    children;\n    html(strings, ...values) {\n        this.children = { strings, values };\n        return this;\n    }\n}\n","// Function to insert element after reference element\nexport function insertAfter(newNode, referenceNode) {\n    const parentNode = referenceNode.parentNode;\n    parentNode.insertBefore(newNode, referenceNode.nextSibling);\n}\n","import { isStaticTag } from '../isInstance.js';\nimport { isLikeTags } from './isLikeTags.function.js';\nimport { destroyTagMemory } from './destroyTag.function.js';\nimport { insertAfter } from '../insertAfter.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nexport function checkDestroyPrevious(subject, // existing.value is the old value\nnewValue, insertBefore, valueType) {\n    const displaySubject = subject;\n    const hasLastValue = 'lastValue' in displaySubject;\n    const lastValue = displaySubject.lastValue; // TODO: we maybe able to use displaySubject.value and remove concept of lastValue\n    // was simple value but now something bigger\n    if (hasLastValue && lastValue !== newValue) {\n        // below is faster than using getValueType\n        const newType = typeof (newValue);\n        if (isSimpleType(newType) && typeof (lastValue) === newType) {\n            return false;\n        }\n        if (newValue instanceof Function && lastValue instanceof Function) {\n            return false;\n        }\n        destroySimpleValue(insertBefore, displaySubject);\n        return 'changed-simple-value';\n    }\n    const arraySubject = subject;\n    const wasArray = arraySubject.lastArray;\n    // no longer an array\n    if (wasArray && valueType !== ValueTypes.tagArray) {\n        const placeholderElm = arraySubject.placeholder;\n        delete arraySubject.lastArray;\n        delete arraySubject.placeholder;\n        insertAfter(insertBefore, placeholderElm);\n        for (let index = wasArray.length - 1; index >= 0; --index) {\n            const { tagSupport } = wasArray[index];\n            destroyArrayTag(tagSupport, { added: 0, removed: 0 });\n        }\n        return 'array';\n    }\n    const tagSubject = subject;\n    const lastSupport = tagSubject.tagSupport;\n    // no longer tag or component?\n    if (lastSupport) {\n        const isValueTag = isStaticTag(newValue);\n        const isSubjectTag = isStaticTag(subject._value);\n        const newTag = newValue;\n        if (isSubjectTag && isValueTag) {\n            // its a different tag now\n            if (!isLikeTags(newTag, lastSupport)) {\n                // put template back down\n                restoreTagMarker(lastSupport);\n                destroyTagMemory(lastSupport);\n                // delete lastSupport.global.deleted // ???\n                return 2;\n            }\n            return false;\n        }\n        if (valueType === ValueTypes.tagComponent) {\n            return false; // its still a tag component\n        }\n        if (newValue && newValue.oneRender) {\n            return false;\n        }\n        // put template back down\n        restoreTagMarker(lastSupport);\n        // destroy old component, value is not a component\n        destroyTagMemory(lastSupport);\n        // delete lastSupport.global.deleted // ???\n        return 'different-tag';\n    }\n    return false;\n}\nexport function isSimpleType(value) {\n    return ['string', 'number', 'boolean'].includes(value);\n}\nexport function destroyArrayTag(tagSupport, counts) {\n    tagSupport.destroy({\n        stagger: counts.removed++,\n    });\n    const insertBefore = tagSupport.global.insertBefore;\n    const parentNode = insertBefore.parentNode;\n    parentNode.removeChild(insertBefore);\n}\nfunction destroySimpleValue(insertBefore, // always a template tag\nsubject) {\n    const clone = subject.clone;\n    const parent = clone.parentNode;\n    // 1 put the template back down\n    parent.insertBefore(insertBefore, clone);\n    parent.removeChild(clone);\n    delete subject.clone;\n    delete subject.lastValue;\n}\nexport function restoreTagMarker(lastSupport) {\n    const insertBefore = lastSupport.global.insertBefore;\n    const global = lastSupport.global;\n    const placeholderElm = global.placeholder;\n    if (placeholderElm) {\n        insertAfter(insertBefore, placeholderElm);\n        delete global.placeholder;\n    }\n}\n","import { isSimpleType } from './checkDestroyPrevious.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nimport { isSubjectInstance, isTagArray } from '../isInstance.js';\nexport function getValueType(value) {\n    if (value === undefined || value === null) {\n        return ValueTypes.undefined;\n    }\n    const type = typeof (value);\n    if (value instanceof Function) {\n        return ValueTypes.function;\n    }\n    if (type === 'object') {\n        if (value instanceof Date) {\n            return ValueTypes.date;\n        }\n        if (isSimpleType(type)) {\n            return type;\n        }\n        const tagJsType = value.tagJsType;\n        if (tagJsType) {\n            const included = [\n                ValueTypes.tagComponent,\n                ValueTypes.templater,\n                ValueTypes.tag,\n            ].includes(tagJsType);\n            if (included) {\n                return tagJsType;\n            }\n        }\n        if (isTagArray(value)) {\n            return ValueTypes.tagArray;\n        }\n        if (isSubjectInstance(value)) {\n            return ValueTypes.subject;\n        }\n    }\n    return ValueTypes.unknown;\n}\n","import { deepClone } from '../deepFunctions.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nimport { getValueType } from './getValueType.function.js';\nexport function cloneValueArray(values) {\n    return values.map((value) => {\n        const tag = value;\n        switch (getValueType(value)) {\n            case ValueTypes.tagComponent:\n                const tagComponent = value;\n                return deepClone(tagComponent.props);\n            case ValueTypes.tag:\n            case ValueTypes.templater:\n                return cloneValueArray(tag.values);\n            case ValueTypes.tagArray:\n                return cloneValueArray(tag);\n        }\n        return deepClone(value);\n    });\n}\n","export function getChildTagsToDestroy(childTags, allTags = []) {\n    for (let index = childTags.length - 1; index >= 0; --index) {\n        const cTag = childTags[index];\n        allTags.push(cTag);\n        childTags.splice(index, 1);\n        getChildTagsToDestroy(cTag.global.childTags, allTags);\n    }\n    return allTags;\n}\n","import { Tag } from './Tag.class.js';\nimport { ValueSubject } from '../subject/index.js';\nimport { kidsToTagArraySubject } from './kidsToTagArraySubject.function.js';\nexport class TemplaterResult {\n    props;\n    tagJsType = 'templater';\n    tagged;\n    wrapper;\n    madeChildIntoSubject;\n    tag;\n    children = new ValueSubject([]);\n    arrayValue; // used for tag components used in arrays\n    constructor(props) {\n        this.props = props;\n    }\n    key(arrayValue) {\n        this.arrayValue = arrayValue;\n        return this;\n    }\n    html(strings, ...values) {\n        const children = new Tag(strings, values);\n        const childSubject = kidsToTagArraySubject(children, this);\n        this.children = childSubject;\n        return this;\n    }\n}\n","import { isSubjectInstance, isTagArray } from '../isInstance.js';\nimport { ValueSubject } from '../subject/ValueSubject.js';\nexport function kidsToTagArraySubject(children, templaterResult) {\n    if (isSubjectInstance(children)) {\n        return children;\n    }\n    const kidArray = children;\n    if (isTagArray(kidArray)) {\n        templaterResult.madeChildIntoSubject = true; // was converted into a subject\n        return new ValueSubject(children);\n    }\n    const kid = children;\n    if (kid) {\n        templaterResult.madeChildIntoSubject = true; // was converted into a subject\n        kid.memory.arrayValue = 0;\n        return new ValueSubject([kid]);\n    }\n    templaterResult.madeChildIntoSubject = true; // was converted into a subject\n    return new ValueSubject([]);\n}\n","import { ValueSubject } from '../../subject/ValueSubject.js';\nimport { TemplaterResult } from '../TemplaterResult.class.js';\nimport { TagSupport } from '../TagSupport.class.js';\nimport { ValueTypes } from '../ValueTypes.enum.js';\nimport { getValueType } from '../getValueType.function.js';\nexport function processNewValue(value, ownerSupport) {\n    const valueType = getValueType(value);\n    switch (valueType) {\n        case ValueTypes.tagComponent:\n            const tagSubject = new ValueSubject(value);\n            return tagSubject;\n        case ValueTypes.templater:\n            const templater = value;\n            const tag = templater.tag;\n            return processNewTag(tag, ownerSupport);\n        case ValueTypes.tag:\n            return processNewTag(value, ownerSupport);\n        case ValueTypes.subject:\n            return value;\n    }\n    return new ValueSubject(value);\n}\nfunction processNewTag(value, ownerSupport) {\n    const tag = value;\n    let templater = tag.templater;\n    if (!templater) {\n        templater = new TemplaterResult([]);\n        templater.tag = tag;\n        tag.templater = templater;\n    }\n    const subject = new ValueSubject(templater);\n    subject.tagSupport = new TagSupport(templater, ownerSupport, subject);\n    ownerSupport.global.childTags.push(subject.tagSupport);\n    return subject;\n}\n","export function setTagPlaceholder(global) {\n    const insertBefore = global.insertBefore;\n    return global.placeholder = swapInsertBefore(insertBefore);\n}\nexport function swapInsertBefore(insertBefore) {\n    const placeholder = document.createTextNode('');\n    const parentNode = insertBefore.parentNode;\n    parentNode.insertBefore(placeholder, insertBefore);\n    parentNode.removeChild(insertBefore);\n    return placeholder;\n}\n","export function specialAttribute(name, value, element) {\n    const names = name.split('.');\n    // style.position = \"absolute\"\n    if (names[0] === 'style') {\n        element.style[names[1]] = value;\n    }\n    // Example: class.width-full = \"true\"\n    if (names[0] === 'class') {\n        names.shift();\n        if (value) {\n            for (let index = 0; index < names.length; ++index) {\n                element.classList.add(names[index]);\n            }\n        }\n        else {\n            for (let index = 0; index < names.length; ++index) {\n                element.classList.remove(names[index]);\n            }\n        }\n    }\n}\n","/** File largely responsible for reacting to element events, such as onclick */\nimport { setUse } from '../state/setUse.function.js';\nimport { ValueTypes } from '../tag/ValueTypes.enum.js';\nimport { renderTagSupport } from '../tag/render/renderTagSupport.function.js';\nimport { updateExistingTagComponent } from '../tag/update/updateExistingTagComponent.function.js';\nconst useLocks = true;\nexport function bindSubjectCallback(value, tagSupport) {\n    // Is this children? No override needed\n    if (value.isChildOverride) {\n        return value;\n    }\n    const state = setUse.memory.stateConfig;\n    const subjectFunction = (element, args) => runTagCallback(value, tagSupport, element, args);\n    // link back to original. Mostly used for <div oninit ondestroy> animations\n    subjectFunction.tagFunction = value;\n    return subjectFunction;\n}\nexport function runTagCallback(value, tagSupport, bindTo, args) {\n    const tag = findTagToCallback(tagSupport);\n    const method = value.bind(bindTo);\n    tag.global.locked = useLocks; // prevent another render from re-rendering this tag\n    const callbackResult = method(...args);\n    return afterTagCallback(tag, callbackResult);\n}\nfunction afterTagCallback(tag, callbackResult) {\n    delete tag.global.locked;\n    if (tag.global.blocked.length) {\n        let lastResult;\n        tag.global.blocked.forEach(blocked => {\n            const block = blocked;\n            lastResult = updateExistingTagComponent(block.ownerTagSupport, block, block.subject, block.global.insertBefore, true);\n            tag.global.newest = lastResult;\n            tag.global.blocked.splice(0, 1);\n        });\n        tag.global.blocked.length = 0;\n        // return lastResult\n        return checkAfterCallbackPromise(callbackResult, lastResult, lastResult.global);\n    }\n    const result = renderCallbackSupport(tag.global.newest, callbackResult, tag.global);\n    return result;\n}\nfunction findTagToCallback(tagSupport) {\n    // If we are NOT a component than we need to render my owner instead\n    if (tagSupport.templater.tagJsType === ValueTypes.templater) {\n        const owner = tagSupport.ownerTagSupport;\n        return findTagToCallback(owner);\n    }\n    return tagSupport;\n}\nfunction renderCallbackSupport(last, callbackResult, global) {\n    if (global.deleted) {\n        return 'no-data-ever'; // || last.global.deleted\n    }\n    renderTagSupport(last, true);\n    return checkAfterCallbackPromise(callbackResult, last, global);\n}\nfunction checkAfterCallbackPromise(callbackResult, last, global) {\n    if (callbackResult instanceof Promise) {\n        last.global.locked = useLocks;\n        return callbackResult.then(() => {\n            delete last.global.locked;\n            if (global.deleted) {\n                return 'promise-no-data-ever'; // tag was deleted during event processing\n            }\n            delete last.global.locked;\n            renderTagSupport(global.newest, true);\n            return 'promise-no-data-ever';\n        });\n    }\n    return 'no-data-ever';\n}\n","import { specialAttribute } from './specialAttribute.js';\nimport { isSubjectInstance } from '../isInstance.js';\nimport { bindSubjectCallback } from './bindSubjectCallback.function.js';\nconst startRegX = /^\\s*{__tagvar/;\nconst endRegX = /}\\s*$/;\nfunction isTagVar(value) {\n    return value && value.search(startRegX) >= 0 && value.search(endRegX) >= 0;\n}\nexport function processAttribute(attrName, value, // current attribute value by using .getAttribute\nchild, scope, ownerSupport, howToSet) {\n    if (isTagVar(value)) {\n        return processScopedNameValueAttr(attrName, value, child, scope, ownerSupport, howToSet);\n    }\n    if (isTagVar(attrName)) {\n        const contextValueSubject = getContextValueByVarString(scope, attrName);\n        let lastValue;\n        // the above callback gets called immediately since its a ValueSubject()\n        const sub = contextValueSubject.subscribe((value) => {\n            if (value === lastValue) {\n                return; // value did not change\n            }\n            processNameOnlyAttr(value, lastValue, child, ownerSupport, howToSet);\n            lastValue = value;\n        });\n        ownerSupport.global.subscriptions.push(sub); // this is where unsubscribe is picked up\n        child.removeAttribute(attrName);\n        return;\n    }\n    // Non dynamic\n    const isSpecial = isSpecialAttr(attrName);\n    if (isSpecial) {\n        return specialAttribute(attrName, value, child);\n    }\n}\nfunction processScopedNameValueAttr(attrName, value, // {__tagVarN}\nchild, scope, ownerSupport, howToSet) {\n    // get the code inside the brackets like \"variable0\" or \"{variable0}\"\n    const result = getContextValueByVarString(scope, value);\n    return processNameValueAttr(attrName, result, child, ownerSupport, howToSet);\n}\nfunction getContextValueByVarString(scope, value) {\n    const code = value.replace('{', '').split('').reverse().join('').replace('}', '').split('').reverse().join('');\n    return scope[code];\n}\nfunction processNameOnlyAttr(attrValue, lastValue, child, ownerSupport, howToSet) {\n    if (lastValue && lastValue != attrValue) {\n        if (typeof (lastValue) === 'string') {\n            child.removeAttribute(lastValue);\n        }\n        else if (lastValue instanceof Object) {\n            for (const name in lastValue) {\n                child.removeAttribute(name);\n            }\n        }\n    }\n    if (typeof (attrValue) === 'string') {\n        if (!attrValue.length) {\n            return;\n        }\n        processNameValueAttr(attrValue, '', child, ownerSupport, howToSet);\n        return;\n    }\n    if (attrValue instanceof Object) {\n        for (const name in attrValue) {\n            processNameValueAttr(name, attrValue[name], child, ownerSupport, howToSet);\n        }\n    }\n}\nfunction processNameValueAttr(attrName, result, child, ownerSupport, howToSet) {\n    const isSpecial = isSpecialAttr(attrName);\n    if (result instanceof Function) {\n        const action = function (...args) {\n            const result2 = result(child, args);\n            return result2;\n        };\n        child[attrName].action = action;\n    }\n    // Most every variable comes in here since everything is made a ValueSubject\n    if (isSubjectInstance(result)) {\n        child.removeAttribute(attrName);\n        let lastValue;\n        const callback = (newAttrValue) => {\n            // should the function be wrapped so every time its called we re-render?\n            if (newAttrValue instanceof Function) {\n                return callbackFun(ownerSupport, newAttrValue, child, attrName, isSpecial, howToSet);\n            }\n            // TODO: we maybe able to block higher before instance of check\n            if (lastValue === newAttrValue) {\n                return lastValue;\n            }\n            lastValue = newAttrValue;\n            return processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet);\n        };\n        // 🗞️ Subscribe. Above callback called immediately since its a ValueSubject()\n        const sub = result.subscribe(callback);\n        // Record subscription for later unsubscribe when element destroyed\n        ownerSupport.global.subscriptions.push(sub);\n        return;\n    }\n    howToSet(child, attrName, result);\n    // child.setAttribute(attrName, result.value)\n    return;\n}\nfunction processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet) {\n    if (newAttrValue instanceof Function) {\n        const fun = function (...args) {\n            return newAttrValue(child, args);\n        };\n        // access to original function\n        fun.tagFunction = newAttrValue;\n        if (attrName === 'ondoubleclick') {\n            attrName = 'ondblclick';\n        }\n        ;\n        child[attrName] = fun;\n        return;\n    }\n    if (isSpecial) {\n        specialAttribute(attrName, newAttrValue, child);\n        return;\n    }\n    if (newAttrValue) {\n        howToSet(child, attrName, newAttrValue);\n        return;\n    }\n    const isDeadValue = [undefined, false, null].includes(newAttrValue);\n    if (isDeadValue) {\n        child.removeAttribute(attrName);\n        return;\n    }\n    // value is 0\n    howToSet(child, attrName, newAttrValue);\n}\n/** Looking for (class | style) followed by a period */\nfunction isSpecialAttr(attrName) {\n    return attrName.search(/^(class|style)(\\.)/) >= 0;\n}\nfunction callbackFun(ownerSupport, newAttrValue, child, attrName, isSpecial, howToSet) {\n    const wrapper = ownerSupport.templater.wrapper;\n    const parentWrap = wrapper?.parentWrap;\n    const oneRender = parentWrap?.oneRender;\n    if (!oneRender) {\n        newAttrValue = bindSubjectCallback(newAttrValue, ownerSupport);\n    }\n    return processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet);\n}\n","import { processAttribute } from './processAttribute.function.js';\nfunction howToSetAttribute(element, name, value) {\n    element.setAttribute(name, value);\n}\nfunction howToSetInputValue(element, name, value) {\n    element[name] = value;\n}\nexport function interpolateAttributes(child, scope, ownerSupport) {\n    const attrNames = child.getAttributeNames();\n    let howToSet = howToSetAttribute;\n    for (let index = 0; index < attrNames.length; ++index) {\n        const attrName = attrNames[index];\n        if (child.nodeName === 'INPUT' && attrName === 'value') {\n            howToSet = howToSetInputValue;\n        }\n        const value = child.getAttribute(attrName);\n        processAttribute(attrName, value, child, scope, ownerSupport, howToSet);\n        howToSet = howToSetAttribute; // put back\n    }\n}\n","// support arrow functions in attributes\nexport const interpolateReplace = /(?:<[^>]*?(?:(?:\\s+\\w+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^>\\s]+)))*\\s*)\\/?>)|({__tagvar[^}]+})/g;\n/** replaces ${x} with <template id=\"x-start\"></template><template id=\"x-end\"></template> */\nexport function interpolateToTemplates(template) {\n    const keys = [];\n    const string = template.replace(interpolateReplace, (match, expression) => {\n        if (match.startsWith('<')) {\n            // If the match is an HTML tag, don't replace\n            return match;\n        }\n        const noBraces = expression.substring(1, expression.length - 1);\n        const id = noBraces;\n        keys.push(id);\n        return `<template interpolate end id=\"${id}\"></template>`;\n    });\n    return { string, keys };\n}\n","import { TagSupport } from '../TagSupport.class.js';\nimport { ValueSubject } from '../../subject/index.js';\n/** When first time render, adds to owner childTags */\nexport function processTag(templater, insertBefore, ownerSupport, // owner\nsubject) {\n    let tagSupport = subject.tagSupport;\n    // first time seeing this tag?\n    if (!tagSupport) {\n        tagSupport = newTagSupportByTemplater(templater, ownerSupport, subject);\n    }\n    subject.tagSupport = tagSupport;\n    tagSupport.ownerTagSupport = ownerSupport;\n    // ++tagSupport.global.renderCount\n    tagSupport.buildBeforeElement(insertBefore, {\n        counts: { added: 0, removed: 0 },\n    });\n    return tagSupport;\n}\nexport function tagFakeTemplater(tag) {\n    const templater = getFakeTemplater();\n    templater.tag = tag;\n    tag.templater = templater;\n    return templater;\n}\nexport function getFakeTemplater() {\n    const fake = {\n        children: new ValueSubject([]), // no children\n        // props: {} as Props,\n        props: [],\n        isTag: true,\n        tagJsType: 'templater',\n        tagged: false,\n        html: () => fake,\n        key: () => fake,\n    };\n    return fake;\n}\n/** Create TagSupport for a tag component */\nexport function newTagSupportByTemplater(templater, ownerSupport, subject) {\n    const tagSupport = new TagSupport(templater, ownerSupport, subject);\n    setupNewSupport(tagSupport, ownerSupport, subject);\n    ownerSupport.global.childTags.push(tagSupport);\n    return tagSupport;\n}\nexport function setupNewSupport(tagSupport, ownerSupport, subject) {\n    tagSupport.global.oldest = tagSupport;\n    tagSupport.global.newest = tagSupport;\n    // asking me to render will cause my parent to render\n    tagSupport.ownerTagSupport = ownerSupport;\n    subject.tagSupport = tagSupport;\n}\n","import { ValueSubject } from '../../subject/ValueSubject.js';\nimport { ArrayNoKeyError } from '../../errors.js';\nimport { destroyArrayTag } from '../checkDestroyPrevious.function.js';\nimport { newTagSupportByTemplater, setupNewSupport, tagFakeTemplater } from './processTag.function.js';\nimport { TagSupport } from '../TagSupport.class.js';\nimport { isTagClass } from '../../isInstance.js';\nimport { renderTagOnly } from '../render/renderTagOnly.function.js';\nexport function processTagArray(subject, value, // arry of Tag classes\ninsertBefore, // <template end interpolate />\nownerSupport, options) {\n    const clones = ownerSupport.clones; // []\n    let lastArray = subject.lastArray = subject.lastArray || [];\n    if (!subject.placeholder) {\n        setPlaceholderElm(insertBefore, subject);\n    }\n    const runtimeInsertBefore = subject.placeholder; // || insertBefore\n    let removed = 0;\n    /** 🗑️ remove previous items first */\n    lastArray = subject.lastArray = subject.lastArray.filter((item, index) => {\n        const newLength = value.length - 1;\n        const at = index - removed;\n        const lessLength = newLength < at;\n        if (lessLength) {\n            destroyArrayItem(lastArray, index, options);\n            ++removed;\n            return false;\n        }\n        const subTag = value[index - removed];\n        const tagClass = isTagClass(subTag);\n        let tag = subTag;\n        let templater = subTag.templater;\n        let prevArrayValue;\n        if (tagClass) {\n            prevArrayValue = tag.memory.arrayValue;\n        }\n        else {\n            templater = subTag;\n            tag = templater.tag;\n            prevArrayValue = templater.arrayValue;\n        }\n        // const tag = subTag?.templater.tag as Tag\n        const lastTag = item.tagSupport.templater.tag;\n        const lastArrayValue = lastTag.memory.arrayValue;\n        const destroyItem = !areLikeValues(prevArrayValue, lastArrayValue);\n        if (destroyItem) {\n            destroyArrayItem(lastArray, index, options);\n            ++removed;\n            return false;\n        }\n        return true;\n    });\n    const length = value.length;\n    for (let index = 0; index < length; ++index) {\n        const item = value[index];\n        const previous = lastArray[index];\n        const previousSupport = previous?.tagSupport;\n        const subTag = item;\n        const tagClass = isTagClass(subTag);\n        const itemSubject = new ValueSubject(undefined);\n        let templater = subTag.templater;\n        let tagSupport;\n        if (tagClass) {\n            if (!templater) {\n                templater = tagFakeTemplater(subTag);\n            }\n            tagSupport = new TagSupport(templater, ownerSupport, itemSubject);\n        }\n        else {\n            templater = subTag;\n            tagSupport = setupNewTemplater(templater, ownerSupport, itemSubject);\n        }\n        // share global between old and new\n        if (previousSupport) {\n            setupNewSupport(tagSupport, ownerSupport, previousSupport.subject);\n            const global = previousSupport.global;\n            tagSupport.global = global;\n            global.newest = tagSupport;\n        }\n        // check for html``.key()\n        const tag = templater.tag || subTag;\n        const keySet = 'arrayValue' in tag.memory;\n        if (!keySet) {\n            const details = {\n                template: tagSupport.getTemplate().string,\n                array: value,\n            };\n            const message = 'Use html`...`.key(item) instead of html`...` to template an Array';\n            console.error(message, details);\n            const err = new ArrayNoKeyError(message, details);\n            throw err;\n        }\n        const couldBeSame = lastArray.length > index;\n        if (couldBeSame) {\n            const prevSupport = previous.tagSupport;\n            const prevGlobal = prevSupport.global;\n            const oldest = prevGlobal.oldest;\n            oldest.updateBy(tagSupport);\n            continue;\n        }\n        processAddTagArrayItem(runtimeInsertBefore, tagSupport, index, options, lastArray);\n        ownerSupport.global.childTags.push(tagSupport);\n    }\n    return clones;\n}\nfunction setPlaceholderElm(insertBefore, subject) {\n    if (insertBefore.nodeName !== 'TEMPLATE') {\n        subject.placeholder = insertBefore;\n        return;\n    }\n    const placeholder = subject.placeholder = document.createTextNode('');\n    const parentNode = insertBefore.parentNode;\n    parentNode.insertBefore(placeholder, insertBefore);\n    parentNode.removeChild(insertBefore);\n}\nfunction processAddTagArrayItem(before, tagSupport, index, options, lastArray) {\n    const lastValue = {\n        tagSupport, index\n    };\n    // Added to previous array\n    lastArray.push(lastValue);\n    const counts = {\n        added: options.counts.added + index,\n        removed: options.counts.removed,\n    };\n    const fragment = document.createDocumentFragment();\n    const newTempElm = document.createElement('template');\n    fragment.appendChild(newTempElm);\n    tagSupport.buildBeforeElement(newTempElm, // before,\n    { counts });\n    const parent = before.parentNode;\n    parent.insertBefore(fragment, before);\n}\n/** compare two values. If both values are arrays then the items will be compared */\nfunction areLikeValues(valueA, valueB) {\n    if (valueA === valueB) {\n        return true;\n    }\n    const bothArrays = valueA instanceof Array && valueB instanceof Array;\n    const matchLengths = bothArrays && valueA.length == valueB.length;\n    if (matchLengths) {\n        return valueA.every((item, index) => item == valueB[index]);\n    }\n    return false;\n}\nfunction setupNewTemplater(templater, ownerSupport, itemSubject) {\n    const tagSupport = newTagSupportByTemplater(templater, ownerSupport, itemSubject);\n    renderTagOnly(tagSupport, tagSupport, itemSubject, ownerSupport);\n    return tagSupport;\n}\nfunction destroyArrayItem(lastArray, index, options) {\n    const last = lastArray[index];\n    const tagSupport = last.tagSupport;\n    destroyArrayTag(tagSupport, options.counts);\n    last.deleted = true;\n    ++options.counts.removed;\n}\n","// Function to update the value of x\nexport function updateBeforeTemplate(value, // value should be casted before calling here\nlastFirstChild) {\n    const parent = lastFirstChild.parentNode;\n    // Insert the new value (never use innerHTML here)\n    const textNode = document.createTextNode(value); // never innerHTML\n    parent.insertBefore(textNode, lastFirstChild);\n    /* remove existing nodes */\n    parent.removeChild(lastFirstChild);\n    return textNode;\n}\nexport function castTextValue(value) {\n    // mimic React skipping to display EXCEPT for true does display on page\n    if ([undefined, false, null].includes(value)) { // || value === true\n        return '';\n    }\n    return value;\n}\n","import { castTextValue, updateBeforeTemplate } from '../../updateBeforeTemplate.function.js';\nexport function processRegularValue(value, subject, // could be tag via subject.tag\ninsertBefore) {\n    subject.insertBefore = insertBefore;\n    const before = subject.clone || insertBefore; // Either the template is on the doc OR its the first element we last put on doc\n    // matches but also was defined at some point\n    if (subject.lastValue === value && 'lastValue' in subject) {\n        return; // no need to update display, its the same\n    }\n    subject.lastValue = value;\n    const castedValue = castTextValue(value);\n    // replace existing string?\n    const oldClone = subject.clone;\n    if (oldClone) {\n        oldClone.textContent = castedValue;\n        return;\n    }\n    // Processing of regular values\n    const clone = updateBeforeTemplate(castedValue, before);\n    subject.clone = clone; // remember single element put down, for future updates\n}\nexport function processFirstRegularValue(value, subject, // could be tag via subject.tag\ninsertBefore) {\n    subject.lastValue = value;\n    const castedValue = castTextValue(value);\n    // Processing of regular values\n    const clone = updateBeforeTemplate(castedValue, insertBefore);\n    subject.clone = clone; // remember single element put down, for future updates \n}\n","import { TemplaterResult } from '../TemplaterResult.class.js';\nimport { newTagSupportByTemplater } from './processTag.function.js';\nexport function oneRenderToTagSupport(wrapper, subject, ownerSupport) {\n    const templater = new TemplaterResult([]);\n    templater.tagJsType = 'oneRender';\n    const tagSupport = newTagSupportByTemplater(templater, ownerSupport, subject);\n    let tag;\n    const wrap = () => {\n        templater.tag = tag || (wrapper());\n        return tagSupport;\n    };\n    templater.wrapper = wrap;\n    wrap.parentWrap = wrap;\n    wrap.oneRender = true;\n    wrap.parentWrap.original = wrapper;\n    return tagSupport;\n}\n","import { processSubjectComponent } from './processSubjectComponent.function.js';\nimport { processTagArray } from './processTagArray.js';\nimport { processFirstRegularValue } from './processRegularValue.function.js';\nimport { processTag, tagFakeTemplater } from './processTag.function.js';\nimport { renderTagOnly } from '../render/renderTagOnly.function.js';\nimport { ValueTypes } from '../ValueTypes.enum.js';\nimport { oneRenderToTagSupport } from './oneRenderToTagSupport.function.js';\nimport { getValueType } from '../getValueType.function.js';\nexport function processFirstSubjectValue(value, subject, // could be tag via result.tag\ninsertBefore, // <template end interpolate /> (will be removed)\nownerSupport, // owner\noptions) {\n    const valueType = getValueType(value);\n    switch (valueType) {\n        case ValueTypes.templater:\n            processTag(value, insertBefore, ownerSupport, subject);\n            return;\n        case ValueTypes.tag:\n            const tag = value;\n            let templater = tag.templater;\n            if (!templater) {\n                templater = tagFakeTemplater(tag);\n            }\n            processTag(templater, insertBefore, ownerSupport, subject);\n            return;\n        case ValueTypes.tagArray:\n            return processTagArray(subject, value, insertBefore, ownerSupport, options);\n        case ValueTypes.tagComponent:\n            const newSupport = processSubjectComponent(value, subject, insertBefore, ownerSupport, options);\n            return newSupport;\n        case ValueTypes.function:\n            const v = value;\n            if (v.oneRender) {\n                const tagSupport = oneRenderToTagSupport(v, subject, ownerSupport);\n                renderTagOnly(tagSupport, tagSupport, subject, ownerSupport);\n                processTag(tagSupport.templater, insertBefore, ownerSupport, subject);\n                return;\n            }\n            break;\n    }\n    processFirstRegularValue(value, subject, insertBefore);\n}\n","import { processAttribute } from './processAttribute.function.js';\nconst search = new RegExp('\\\\s*<template interpolate end id=\"__tagvar(\\\\d{1,4})\"([^>]*)></template>(\\\\s*)');\nexport function scanTextAreaValue(textarea, context, ownerSupport) {\n    const value = textarea.value;\n    if (value.search(search) >= 0) {\n        const match = value.match(/__tagvar(\\d{1,4})/);\n        const token = match ? match[0] : '';\n        const dynamic = '{' + token + '}';\n        textarea.value = '';\n        textarea.setAttribute('text-var-value', dynamic);\n        const howToSet = (_elm, _name, value) => textarea.value = value;\n        processAttribute('text-var-value', dynamic, // realValue, // context[token].value,\n        textarea, context, ownerSupport, howToSet);\n    }\n}\n","import { TagSupport } from '../TagSupport.class.js';\nimport { TemplaterResult } from '../TemplaterResult.class.js';\nimport { isTagClass, isTagTemplater } from '../../isInstance.js';\nimport { processTagArray } from './processTagArray.js';\nimport { updateExistingTagComponent } from './updateExistingTagComponent.function.js';\nimport { processRegularValue } from './processRegularValue.function.js';\nimport { checkDestroyPrevious, restoreTagMarker } from '../checkDestroyPrevious.function.js';\nimport { processSubjectComponent } from './processSubjectComponent.function.js';\nimport { isLikeTags } from '../isLikeTags.function.js';\nimport { getFakeTemplater, processTag, setupNewSupport } from './processTag.function.js';\nimport { swapInsertBefore } from '../setTagPlaceholder.function.js';\nimport { ValueTypes } from '../ValueTypes.enum.js';\nimport { getValueType } from '../getValueType.function.js';\nexport function updateExistingValue(subject, value, ownerSupport, insertBefore) {\n    const subjectTag = subject;\n    const valueType = getValueType(value);\n    checkDestroyPrevious(subject, value, insertBefore, valueType);\n    // handle already seen tag components\n    if (valueType === ValueTypes.tagComponent) {\n        return prepareUpdateToComponent(value, subjectTag, insertBefore, ownerSupport);\n    }\n    // was component but no longer\n    const tagSupport = subjectTag.tagSupport;\n    if (tagSupport) {\n        if (valueType === ValueTypes.function) {\n            return subjectTag; // its a oneRender tag\n        }\n        handleStillTag(subject, value, ownerSupport);\n        return subjectTag;\n    }\n    switch (valueType) {\n        case ValueTypes.tagArray:\n            processTagArray(subject, value, insertBefore, // oldInsertBefore as InsertBefore,\n            ownerSupport, { counts: {\n                    added: 0,\n                    removed: 0,\n                } });\n            return subject;\n        case ValueTypes.templater:\n            processTag(value, insertBefore, ownerSupport, subjectTag);\n            return subjectTag;\n        case ValueTypes.tag:\n            const tag = value;\n            let templater = tag.templater;\n            if (!templater) {\n                templater = getFakeTemplater();\n                tag.templater = templater;\n                templater.tag = tag;\n            }\n            processTag(templater, insertBefore, ownerSupport, subjectTag);\n            return subjectTag;\n        case ValueTypes.subject:\n            return value;\n        // now its a useless function (we don't automatically call functions)\n        case ValueTypes.function:\n            if (!subject.clone) {\n                subject.clone = swapInsertBefore(insertBefore);\n            }\n            return subject;\n    }\n    // This will cause all other values to render\n    processRegularValue(value, subject, insertBefore);\n    return subjectTag;\n}\nfunction handleStillTag(subject, value, ownerSupport) {\n    const lastSupport = subject.tagSupport;\n    let templater = value;\n    const isClass = isTagClass(value);\n    if (isClass) {\n        const tag = value;\n        templater = tag.templater;\n        if (!templater) {\n            templater = new TemplaterResult([]);\n            templater.tag = tag;\n            tag.templater = templater;\n        }\n    }\n    const valueSupport = new TagSupport(templater, ownerSupport, subject);\n    // ??? new\n    // subject.tagSupport = valueSupport\n    if (isClass) {\n        valueSupport.global = lastSupport.global;\n    }\n    const isSameTag = value && isLikeTags(lastSupport, valueSupport);\n    if (isTagTemplater(value)) {\n        setupNewSupport(valueSupport, ownerSupport, subject);\n    }\n    if (isSameTag) {\n        lastSupport.updateBy(valueSupport);\n        return;\n    }\n    if (isSameTag) {\n        // const subjectTag = subject as TagSubject\n        const global = lastSupport.global;\n        const insertBefore = global.insertBefore;\n        return processTag(templater, insertBefore, ownerSupport, subject);\n    }\n    return processRegularValue(value, subject, subject.insertBefore);\n}\nfunction prepareUpdateToComponent(templater, subjectTag, insertBefore, ownerSupport) {\n    // When last value was not a component\n    if (!subjectTag.tagSupport) {\n        processSubjectComponent(templater, subjectTag, insertBefore, // oldInsertBefore as InsertBefore,\n        ownerSupport, {\n            counts: { added: 0, removed: 0 },\n        });\n        return subjectTag;\n    }\n    const tagSupport = new TagSupport(templater, ownerSupport, subjectTag);\n    const subjectSup = subjectTag.tagSupport;\n    const prevSupport = subjectSup.global.newest;\n    if (prevSupport) {\n        const newestState = prevSupport.memory.state;\n        tagSupport.memory.state.length = 0;\n        tagSupport.memory.state.push(...newestState);\n    }\n    else {\n        restoreTagMarker(subjectSup);\n        processSubjectComponent(templater, subjectTag, insertBefore, ownerSupport, {\n            counts: { added: 0, removed: 0 },\n        });\n        return subjectTag;\n    }\n    tagSupport.global = subjectSup.global;\n    subjectTag.tagSupport = tagSupport;\n    updateExistingTagComponent(ownerSupport, tagSupport, // latest value\n    subjectTag, insertBefore);\n    return subjectTag;\n}\n","import { variablePrefix } from '../tag/Tag.class.js';\nimport { elementInitCheck } from './elementInitCheck.js';\nimport { processFirstSubjectValue } from '../tag/update/processFirstSubjectValue.function.js';\nimport { isTagArray, isTagComponent } from '../isInstance.js';\nimport { scanTextAreaValue } from './scanTextAreaValue.function.js';\nimport { updateExistingValue } from '../tag/update/updateExistingValue.function.js';\nimport { swapInsertBefore } from '../tag/setTagPlaceholder.function.js';\nexport function interpolateTemplate(insertBefore, // <template end interpolate /> (will be removed)\ncontext, // variable scope of {`__tagvar${index}`:'x'}\nownerSupport, // Tag class\ncounts) {\n    if (!insertBefore.hasAttribute('end')) {\n        return; // only care about <template end>\n    }\n    const variableName = insertBefore.getAttribute('id');\n    if (variableName?.substring(0, variablePrefix.length) !== variablePrefix) {\n        return; // ignore, not a tagVar\n    }\n    const existingSubject = context[variableName];\n    const isDynamic = isTagComponent(existingSubject._value) || isTagArray(existingSubject.value);\n    // process dynamics later\n    if (isDynamic) {\n        return {\n            variableName,\n            ownerSupport,\n            subject: existingSubject,\n            insertBefore\n        };\n    }\n    subscribeToTemplate(insertBefore, existingSubject, ownerSupport, counts);\n    return;\n}\nexport function subscribeToTemplate(insertBefore, subject, ownerSupport, counts) {\n    let called = false;\n    const onValue = (value) => {\n        if (called) {\n            updateExistingValue(subject, value, ownerSupport, insertBefore);\n            return;\n        }\n        const templater = value;\n        processFirstSubjectValue(templater, subject, insertBefore, ownerSupport, {\n            counts: { ...counts },\n        });\n        called = true;\n    };\n    let mutatingCallback = onValue;\n    const callback = (value) => mutatingCallback(value);\n    const sub = subject.subscribe(callback);\n    // on subscribe, the Subject did NOT emit immediately. Lets pull the template off the document\n    if (insertBefore.parentNode) {\n        const clone = subject.clone = swapInsertBefore(insertBefore);\n        mutatingCallback = v => {\n            const parentNode = clone.parentNode;\n            parentNode.insertBefore(insertBefore, clone);\n            parentNode.removeChild(clone);\n            delete subject.clone;\n            mutatingCallback = onValue; // all future calls will just produce value\n            onValue(v); // calls for rending\n        };\n    }\n    ownerSupport.global.subscriptions.push(sub);\n}\n/** This is the function that enhances elements such as [class.something] and [style.color] OR it fixes elements that alter innerHTML */\nexport function afterElmBuild(elm, options, context, ownerSupport) {\n    if (!elm.getAttribute) {\n        return;\n    }\n    // Elements that alter innerHTML\n    const tagName = elm.nodeName; // elm.tagName\n    if (tagName === 'TEXTAREA') {\n        scanTextAreaValue(elm, context, ownerSupport);\n    }\n    let diff = options.counts.added;\n    diff = elementInitCheck(elm, options.counts) - diff;\n    const hasFocusFun = elm.focus;\n    if (hasFocusFun) {\n        if (elm.hasAttribute('autofocus')) {\n            elm.focus();\n        }\n        if (elm.hasAttribute('autoselect')) {\n            elm.select();\n        }\n    }\n    const children = elm.children;\n    if (children) {\n        for (let index = children.length - 1; index >= 0; --index) {\n            const child = children[index];\n            const subOptions = {\n                ...options,\n                counts: options.counts,\n            };\n            afterElmBuild(child, subOptions, context, ownerSupport);\n        }\n    }\n}\n","export function elementInitCheck(nextSibling, counts) {\n    const onInitDoubleWrap = nextSibling.oninit;\n    if (!onInitDoubleWrap) {\n        return counts.added;\n    }\n    const onInitWrap = onInitDoubleWrap.tagFunction;\n    if (!onInitWrap) {\n        return counts.added;\n    }\n    const onInit = onInitWrap.tagFunction;\n    if (!onInit) {\n        return counts.added;\n    }\n    const event = { target: nextSibling, stagger: counts.added };\n    onInit(event);\n    return ++counts.added;\n}\n","import { interpolateTemplate } from './interpolateTemplate.js';\nexport function interpolateContentTemplates(context, tagSupport, options, children) {\n    // counting for animation stagger computing\n    const counts = options.counts;\n    const clones = [];\n    const tagComponents = [];\n    const childLength = children.length;\n    for (let index = childLength - 1; index >= 0; --index) {\n        const child = children[index];\n        const tagComponent = interpolateTemplate(child, context, tagSupport, counts);\n        // clones.push(...nextClones)\n        if (tagComponent) {\n            tagComponents.push(tagComponent);\n            continue;\n        }\n        if (child.children) {\n            for (let index = child.children.length - 1; index >= 0; --index) {\n                const subChild = child.children[index];\n                // IF <template end /> its a variable to be processed\n                if (isRenderEndTemplate(subChild)) {\n                    const tagComponent = interpolateTemplate(subChild, context, tagSupport, counts);\n                    if (tagComponent) {\n                        tagComponents.push(tagComponent);\n                    }\n                }\n                const { clones: nextClones, tagComponents: nextTagComponent } = interpolateContentTemplates(context, tagSupport, options, subChild.children);\n                clones.push(...nextClones);\n                tagComponents.push(...nextTagComponent);\n            }\n        }\n    }\n    return { clones, tagComponents };\n}\nfunction isRenderEndTemplate(child) {\n    const isTemplate = child.tagName === 'TEMPLATE';\n    return isTemplate &&\n        child.getAttribute('interpolate') !== undefined &&\n        child.getAttribute('end') !== undefined;\n}\n","import { interpolateAttributes } from './interpolateAttributes.js';\nimport { interpolateToTemplates } from './interpolations.js';\nimport { interpolateContentTemplates } from './interpolateContentTemplates.js';\nimport { escapeSearch, variablePrefix } from '../tag/Tag.class.js';\n/** Review elements within an element */\nexport function interpolateElement(container, // element containing innerHTML to review interpolations\ncontext, // variables used to evaluate\ninterpolatedTemplates, ownerSupport, options) {\n    const clones = [];\n    const tagComponents = [];\n    const result = interpolatedTemplates.interpolation;\n    const template = container.children[0];\n    const children = template.content.children;\n    if (result.keys.length) {\n        const { clones: nextClones, tagComponents: nextTagComponents } = interpolateContentTemplates(context, ownerSupport, options, children);\n        clones.push(...nextClones);\n        tagComponents.push(...nextTagComponents);\n    }\n    interpolateAttributes(template, context, ownerSupport);\n    processChildrenAttributes(children, context, ownerSupport);\n    return { clones, tagComponents };\n}\nfunction processChildrenAttributes(children, context, ownerSupport) {\n    for (let index = children.length - 1; index >= 0; --index) {\n        const child = children[index];\n        interpolateAttributes(child, context, ownerSupport);\n        if (child.children) {\n            processChildrenAttributes(child.children, context, ownerSupport);\n        }\n    }\n}\nexport function interpolateString(string) {\n    const result = interpolateToTemplates(string);\n    result.string = result.string.replace(escapeSearch, variablePrefix);\n    return result;\n}\n","import { buildClones } from '../render.js';\nimport { afterElmBuild } from './interpolateTemplate.js';\nexport function afterInterpolateElement(container, insertBefore, tagSupport, context, options) {\n    const clones = buildClones(container, insertBefore);\n    if (!clones.length) {\n        return clones;\n    }\n    for (let index = clones.length - 1; index >= 0; --index) {\n        const clone = clones[index];\n        afterElmBuild(clone, options, context, tagSupport);\n        tagSupport.clones.push(clone);\n    }\n    return clones;\n}\n","export function buildClones(temporary, insertBefore) {\n    const clones = [];\n    const template = temporary.children[0];\n    let nextSibling = template.content.firstChild;\n    const fragment = document.createDocumentFragment();\n    while (nextSibling) {\n        const nextNextSibling = nextSibling.nextSibling;\n        clones.push(nextSibling);\n        fragment.appendChild(nextSibling);\n        nextSibling = nextNextSibling;\n    }\n    if (insertBefore.parentNode) {\n        const parentNode = insertBefore.parentNode;\n        parentNode.insertBefore(fragment, insertBefore);\n    }\n    return clones;\n}\n","import { escapeVariable, variablePrefix } from './Tag.class.js';\nimport { deepClone } from '../deepFunctions.js';\nimport { isTagComponent } from '../isInstance.js';\nimport { cloneValueArray } from './cloneValueArray.function.js';\nimport { restoreTagMarker } from './checkDestroyPrevious.function.js';\nimport { runBeforeDestroy } from './tagRunner.js';\nimport { getChildTagsToDestroy } from './destroy.support.js';\nimport { elementDestroyCheck } from './elementDestroyCheck.function.js';\nimport { updateContextItem } from './update/updateContextItem.function.js';\nimport { processNewValue } from './update/processNewValue.function.js';\nimport { setTagPlaceholder } from './setTagPlaceholder.function.js';\nimport { interpolateElement, interpolateString } from '../interpolations/interpolateElement.js';\nimport { subscribeToTemplate } from '../interpolations/interpolateTemplate.js';\nimport { afterInterpolateElement } from '../interpolations/afterInterpolateElement.function.js';\nimport { Subject } from '../subject/Subject.class.js';\nconst prefixSearch = new RegExp(variablePrefix, 'g');\n/** used only for apps, otherwise use TagSupport */\nexport class BaseTagSupport {\n    templater;\n    subject;\n    isApp = true;\n    appElement; // only seen on this.getAppTagSupport().appElement\n    strings;\n    values;\n    propsConfig;\n    // stays with current render\n    memory = {\n        state: [],\n    };\n    clones = []; // elements on document. Needed at destroy process to know what to destroy\n    // travels with all rerenderings\n    global = {\n        destroy$: new Subject(),\n        context: {}, // populated after reading interpolated.values array converted to an object {variable0, variable:1}\n        providers: [],\n        /** Indicator of re-rending. Saves from double rending something already rendered */\n        renderCount: 0,\n        subscriptions: [],\n        oldest: this,\n        blocked: [], // renders that did not occur because an event was processing\n        childTags: [], // tags on me\n    };\n    hasLiveElements = false;\n    constructor(templater, subject, castedProps) {\n        this.templater = templater;\n        this.subject = subject;\n        const props = templater.props; // natural props\n        this.propsConfig = this.clonePropsBy(props, castedProps);\n    }\n    clonePropsBy(props, castedProps) {\n        const children = this.templater.children; // children tags passed in as arguments\n        const kidValue = children.value;\n        const latestCloned = props.map(props => deepClone(props));\n        return this.propsConfig = {\n            latest: props,\n            latestCloned, // assume its HTML children and then detect\n            castProps: castedProps, //?? castProps(props, this, this.memory.state),\n            lastClonedKidValues: kidValue.map(kid => {\n                const cloneValues = cloneValueArray(kid.values);\n                return cloneValues;\n            })\n        };\n    }\n    /** Function that kicks off actually putting tags down as HTML elements */\n    buildBeforeElement(insertBefore, options = {\n        counts: { added: 0, removed: 0 },\n    }) {\n        const subject = this.subject;\n        const global = this.global;\n        global.insertBefore = insertBefore;\n        if (!global.placeholder) {\n            setTagPlaceholder(global);\n        }\n        const placeholderElm = global.placeholder;\n        global.oldest = this;\n        global.newest = this;\n        subject.tagSupport = this;\n        this.hasLiveElements = true;\n        const context = this.update();\n        const template = this.getTemplate();\n        const elementContainer = document.createDocumentFragment();\n        const tempDraw = document.createElement('template');\n        tempDraw.innerHTML = template.string;\n        elementContainer.appendChild(tempDraw);\n        // Search/replace innerHTML variables but don't interpolate tag components just yet\n        const { tagComponents } = interpolateElement(elementContainer, context, template, this, // ownerSupport,\n        {\n            counts: options.counts\n        });\n        afterInterpolateElement(elementContainer, placeholderElm, this, // ownerSupport\n        context, options);\n        // Any tag components that were found should be processed AFTER the owner processes its elements. Avoid double processing of elements attributes like (oninit)=${}\n        const length = tagComponents.length;\n        for (let index = 0; index < length; ++index) {\n            const tagComponent = tagComponents[index];\n            subscribeToTemplate(tagComponent.insertBefore, tagComponent.subject, tagComponent.ownerSupport, options.counts);\n            afterInterpolateElement(elementContainer, tagComponent.insertBefore, tagComponent.ownerSupport, context, options);\n        }\n    }\n    getTemplate() {\n        const thisTag = this.templater.tag;\n        const strings = this.strings || thisTag.strings;\n        const values = this.values || thisTag.values;\n        const string = strings.map((string, index) => {\n            const safeString = string.replace(prefixSearch, escapeVariable);\n            const endString = safeString + (values.length > index ? `{${variablePrefix}${index}}` : '');\n            const trimString = endString.replace(/>\\s*/g, '>').replace(/\\s*</g, '<');\n            return trimString;\n        }).join('');\n        const interpolation = interpolateString(string);\n        return {\n            interpolation,\n            string: interpolation.string,\n            strings,\n            values,\n            context: this.global.context || {},\n        };\n    }\n    update() {\n        return this.updateContext(this.global.context);\n    }\n    updateContext(context) {\n        const thisTag = this.templater.tag;\n        const strings = this.strings || thisTag.strings;\n        const values = this.values || thisTag.values;\n        strings.forEach((_string, index) => {\n            const hasValue = values.length > index;\n            if (!hasValue) {\n                return;\n            }\n            const variableName = variablePrefix + index;\n            const value = values[index];\n            // is something already there?\n            const exists = variableName in context;\n            if (exists) {\n                if (this.global.deleted) {\n                    const valueSupport = (value && value.tagSupport);\n                    if (valueSupport) {\n                        valueSupport.destroy();\n                        return context; // item was deleted, no need to emit\n                    }\n                }\n                return updateContextItem(context, variableName, value);\n            }\n            // 🆕 First time values below\n            context[variableName] = processNewValue(value, this);\n        });\n        return context;\n    }\n    updateBy(tagSupport) {\n        const tempTag = tagSupport.templater.tag;\n        this.updateConfig(tempTag.strings, tempTag.values);\n    }\n    updateConfig(strings, values) {\n        this.strings = strings;\n        this.updateValues(values);\n    }\n    updateValues(values) {\n        this.values = values;\n        return this.updateContext(this.global.context);\n    }\n    destroy(options = {\n        stagger: 0,\n        byParent: false, // Only destroy clones of direct children\n    }) {\n        const firstDestroy = !options.byParent;\n        const global = this.global;\n        const subject = this.subject;\n        const childTags = options.byParent ? [] : getChildTagsToDestroy(this.global.childTags);\n        if (firstDestroy && isTagComponent(this.templater)) {\n            global.destroy$.next();\n            runBeforeDestroy(this, this);\n        }\n        this.destroySubscriptions();\n        // signify immediately child has been deleted (looked for during event processing)\n        for (let index = childTags.length - 1; index >= 0; --index) {\n            const child = childTags[index];\n            const subGlobal = child.global;\n            delete subGlobal.newest;\n            subGlobal.deleted = true;\n            if (isTagComponent(child.templater)) {\n                runBeforeDestroy(child, child);\n            }\n        }\n        let mainPromise;\n        // HTML DOM manipulation. Put back down the template tag\n        const insertBefore = global.insertBefore;\n        // FIRST DOM Manipulation to cause painting cycle\n        if (insertBefore.nodeName === 'TEMPLATE') {\n            const placeholder = global.placeholder;\n            if (placeholder && !('arrayValue' in this.memory)) {\n                if (!options.byParent) {\n                    restoreTagMarker(this);\n                }\n            }\n        }\n        if (firstDestroy) {\n            const { stagger, promise } = this.destroyClones(options);\n            options.stagger = stagger;\n            if (promise) {\n                mainPromise = promise;\n            }\n        }\n        else {\n            this.destroyClones();\n        }\n        // data reset\n        delete global.placeholder;\n        global.context = {};\n        delete global.oldest; // may not be needed\n        delete global.newest;\n        this.global.childTags.length = 0;\n        delete subject.tagSupport;\n        if (mainPromise) {\n            mainPromise = mainPromise.then(async () => {\n                const promises = childTags.map(kid => kid.destroy({ stagger: 0, byParent: true }));\n                return Promise.all(promises);\n            });\n        }\n        else {\n            mainPromise = Promise.all(childTags.map(kid => kid.destroy({ stagger: 0, byParent: true })));\n        }\n        return mainPromise.then(() => options.stagger);\n    }\n    destroyClones({ stagger } = {\n        stagger: 0,\n    }) {\n        const oldClones = [...this.clones];\n        this.clones.length = 0; // tag maybe used for something else\n        const promises = oldClones.map(clone => this.checkCloneRemoval(clone, stagger)).filter(x => x); // only return promises\n        // check subjects that may have clones attached to them\n        const oldContext = this.global.context;\n        for (const name in oldContext) {\n            const value = oldContext[name];\n            const clone = value.clone;\n            if (clone?.parentNode) {\n                clone.parentNode.removeChild(clone);\n            }\n        }\n        if (promises.length) {\n            return { promise: Promise.all(promises), stagger };\n        }\n        return { stagger };\n    }\n    /** Reviews elements for the presences of ondestroy */\n    checkCloneRemoval(clone, stagger) {\n        let promise;\n        const customElm = clone;\n        if (customElm.ondestroy) {\n            promise = elementDestroyCheck(customElm, stagger);\n        }\n        const next = () => {\n            const parentNode = clone.parentNode;\n            if (parentNode) {\n                parentNode.removeChild(clone);\n            }\n            const ownerSupport = this.ownerTagSupport;\n            if (ownerSupport) {\n                // Sometimes my clones were first registered to my owner, remove them from owner\n                ownerSupport.clones = ownerSupport.clones.filter(compareClone => compareClone !== clone);\n            }\n        };\n        if (promise instanceof Promise) {\n            return promise.then(next);\n        }\n        else {\n            next();\n        }\n        return promise;\n    }\n    destroySubscriptions() {\n        const subs = this.global.subscriptions;\n        for (let index = subs.length - 1; index >= 0; --index) {\n            subs[index].unsubscribe();\n        }\n        subs.length = 0;\n    }\n}\nexport class TagSupport extends BaseTagSupport {\n    templater;\n    ownerTagSupport;\n    subject;\n    version;\n    isApp = false;\n    constructor(templater, // at runtime rendering of a tag, it needs to be married to a new TagSupport()\n    ownerTagSupport, subject, castedProps, version = 0) {\n        super(templater, subject, castedProps);\n        this.templater = templater;\n        this.ownerTagSupport = ownerTagSupport;\n        this.subject = subject;\n        this.version = version;\n    }\n    getAppTagSupport() {\n        let tag = this;\n        while (tag.ownerTagSupport) {\n            tag = tag.ownerTagSupport;\n        }\n        return tag;\n    }\n}\nfunction restoreTagMarkers(support) {\n    restoreTagMarker(support);\n    const childTags = support.global.childTags;\n    for (let index = childTags.length - 1; index >= 0; --index) {\n        restoreTagMarkers(childTags[index].global.oldest);\n    }\n}\n","import { isSubjectInstance } from '../../isInstance.js';\nexport function updateContextItem(context, variableName, value) {\n    const subject = context[variableName];\n    if (isSubjectInstance(value)) {\n        return; // emits on its own\n    }\n    // listeners will evaluate updated values to possibly update display(s)\n    subject.next(value);\n    return;\n}\n","export function elementDestroyCheck(nextSibling, stagger) {\n    const onDestroyDoubleWrap = nextSibling.ondestroy;\n    if (!onDestroyDoubleWrap) {\n        return;\n    }\n    const onDestroyWrap = onDestroyDoubleWrap.tagFunction;\n    if (!onDestroyWrap) {\n        return;\n    }\n    const onDestroy = onDestroyWrap.tagFunction;\n    if (!onDestroy) {\n        return;\n    }\n    const event = { target: nextSibling, stagger };\n    return onDestroy(event);\n}\n","import { processTagResult } from './processTagResult.function.js';\nimport { TagSupport } from '../TagSupport.class.js';\nimport { renderSubjectComponent } from '../render/renderSubjectComponent.function.js';\n/** create new support, connects globals to old support if one, and  */\nexport function processSubjectComponent(templater, subject, insertBefore, ownerSupport, options) {\n    // Check if function component is wrapped in a tag() call\n    // TODO: This below check not needed in production mode\n    if (templater.tagged !== true) {\n        const wrapper = templater.wrapper;\n        const original = wrapper.parentWrap.original;\n        let name = original.name || original.constructor?.name;\n        if (name === 'Function') {\n            name = undefined;\n        }\n        const label = name || original.toString().substring(0, 120);\n        const error = new Error(`Not a tag component. Wrap your function with tag(). Example tag(props => html\\`\\`) on component:\\n\\n${label}\\n\\n`);\n        throw error;\n    }\n    const tagSupport = new TagSupport(templater, ownerSupport, subject);\n    let reSupport = subject.tagSupport;\n    const global = tagSupport.global = reSupport?.global || tagSupport.global;\n    global.insertBefore = insertBefore;\n    const isRender = !reSupport;\n    if (isRender) {\n        const support = reSupport || tagSupport;\n        reSupport = renderSubjectComponent(subject, support, ownerSupport);\n    }\n    const newSupport = processTagResult(reSupport, subject, // The element set here will be removed from document. Also result.tag will be added in here\n    insertBefore, // <template end interpolate /> (will be removed)\n    options);\n    // subject.tagSupport = newSupport\n    ownerSupport.global.childTags.push(newSupport);\n    return reSupport;\n}\n","import { renderWithSupport } from './renderWithSupport.function.js';\nexport function renderSubjectComponent(subject, reSupport, ownerSupport) {\n    const preClones = ownerSupport.clones.map(clone => clone);\n    reSupport = renderWithSupport(reSupport, subject.tagSupport, // existing tag\n    subject, ownerSupport);\n    if (ownerSupport.clones.length > preClones.length) {\n        const myClones = ownerSupport.clones.filter(fClone => !preClones.find(clone => clone === fClone));\n        reSupport.clones.push(...myClones);\n    }\n    return reSupport;\n}\n","import { deepClone, deepEqual } from './deepFunctions.js';\nimport { isStaticTag } from './isInstance.js';\nimport { renderTagSupport } from './tag/render/renderTagSupport.function.js';\nimport { setUse } from './state/index.js';\nimport { getSupportInCycle } from './tag/getSupportInCycle.function.js';\nexport function castProps(props, newTagSupport, stateArray) {\n    return props.map(prop => alterProp(prop, newTagSupport.ownerTagSupport, stateArray, newTagSupport));\n}\n/* Used to rewrite props that are functions. When they are called it should cause parent rendering */\nexport function alterProp(prop, ownerSupport, stateArray, newTagSupport) {\n    if (isStaticTag(prop) || !prop) {\n        return prop;\n    }\n    if (!ownerSupport) {\n        return prop; // no one above me\n    }\n    return checkProp(prop, ownerSupport, stateArray, newTagSupport);\n}\nexport function checkProp(value, ownerSupport, stateArray, newTagSupport, index, newProp, seen = []) {\n    if (value instanceof Function) {\n        return getPropWrap(value, ownerSupport, stateArray, newTagSupport, index, newProp);\n    }\n    if (seen.includes(value)) {\n        return value;\n    }\n    seen.push(value);\n    if (typeof (value) !== 'object' || !value) {\n        return value; // no children to crawl through\n    }\n    if (value instanceof Array) {\n        for (let index = value.length - 1; index >= 0; --index) {\n            const subValue = value[index];\n            value[index] = checkProp(subValue, ownerSupport, stateArray, newTagSupport, index, value, seen);\n            if (subValue instanceof Function) {\n                if (subValue.toCall) {\n                    continue;\n                }\n                afterCheckProp(index, subValue, value, newTagSupport);\n            }\n        }\n        return value;\n    }\n    for (const name in value) {\n        const subValue = value[name];\n        const result = checkProp(subValue, ownerSupport, stateArray, newTagSupport, name, value, seen);\n        const hasSetter = Object.getOwnPropertyDescriptor(value, name)?.set;\n        if (hasSetter) {\n            continue;\n        }\n        value[name] = result;\n        if (result instanceof Function) {\n            if (subValue.toCall) {\n                continue;\n            }\n            afterCheckProp(name, subValue, value, newTagSupport);\n        }\n    }\n    return value;\n}\nfunction afterCheckProp(index, pastValue, newProp, newTagSupport) {\n    if (pastValue?.toCall) {\n        return; // already been done\n    }\n    // restore object to have original function on destroy\n    newTagSupport.global.destroy$.toCallback(() => newProp[index] = pastValue);\n}\nexport function getPropWrap(value, ownerSupport, stateArray, newTagSupport, name, newProp) {\n    const toCall = value.toCall;\n    // already previously converted by a parent?\n    if (toCall) {\n        return value;\n    }\n    const wrap = (...args) => wrap.toCall(...args); // what gets called can switch over parent state changes\n    // Currently, call self but over parent state changes, I may need to call a newer parent tag owner\n    wrap.toCall = (...args) => {\n        return callbackPropOwner(wrap.prop, args, ownerSupport, wrap.stateArray);\n    };\n    wrap.original = value;\n    wrap.prop = value;\n    wrap.stateArray = stateArray;\n    // copy data properties that maybe on source function\n    Object.assign(wrap, value);\n    return wrap;\n}\n/** Function shared by alterProps() and updateExistingTagComponent... TODO: May want to have to functions to reduce cycle checking?  */\nexport function callbackPropOwner(toCall, callWith, ownerSupport, // <-- WHEN called from alterProp its owner OTHERWISE its previous\noldState) {\n    const newest = ownerSupport.global.newest;\n    //const newState = newest.memory.state\n    const noCycle = getSupportInCycle() === undefined;\n    //const sync = noCycle && oldState.length === newState.length\n    //if(sync) {\n    //  syncStates(newState, oldState)\n    //}\n    const result = toCall(...callWith);\n    // if(sync) {\n    //   syncStates(oldState, newState)\n    // }\n    const run = () => {\n        // are we in a rendering cycle? then its being called by alterProps\n        if (noCycle === false) {\n            // appears a prop function was called sync/immediately so lets see if owner changed state\n            const allMatched = newest.memory.state.every(state => {\n                const lastValue = state.lastValue;\n                const get = state.get();\n                const equal = deepEqual(deepClone(lastValue), get);\n                return equal;\n            });\n            if (allMatched) {\n                return result; // owner did not change\n            }\n        }\n        renderTagSupport(newest, true);\n        return result;\n    };\n    if (noCycle) {\n        return run();\n    }\n    setUse.memory.tagClosed$.toCallback(run);\n    return result;\n}\n","import { hasTagSupportChanged } from '../hasTagSupportChanged.function.js';\nimport { processSubjectComponent } from './processSubjectComponent.function.js';\nimport { destroyTagMemory } from '../destroyTag.function.js';\nimport { renderTagSupport } from '../render/renderTagSupport.function.js';\nimport { castProps } from '../../alterProp.function.js';\nimport { isLikeTags } from '../isLikeTags.function.js';\nexport function updateExistingTagComponent(ownerSupport, tagSupport, // lastest\nsubject, insertBefore, renderUp = false) {\n    let lastSupport = subject.tagSupport?.global.newest;\n    const oldWrapper = lastSupport.templater.wrapper;\n    const newWrapper = tagSupport.templater.wrapper;\n    let isSameTag = false;\n    if (oldWrapper && newWrapper) {\n        const oldFunction = oldWrapper.parentWrap.original;\n        const newFunction = newWrapper.parentWrap.original;\n        // string compare both functions\n        isSameTag = oldFunction === newFunction;\n    }\n    const templater = tagSupport.templater;\n    if (!isSameTag) {\n        const oldestSupport = lastSupport.global.oldest;\n        destroyTagMemory(oldestSupport);\n        const newSupport = processSubjectComponent(templater, subject, insertBefore, ownerSupport, {\n            counts: { added: 0, removed: 0 },\n        });\n        return newSupport;\n    }\n    else {\n        const hasChanged = hasTagSupportChanged(lastSupport, tagSupport, templater);\n        // everyhing has matched, no display needs updating.\n        if (!hasChanged) {\n            const newProps = templater.props;\n            // update function refs to use latest references\n            const castedProps = syncFunctionProps(tagSupport, lastSupport, ownerSupport, newProps);\n            // When new tagSupport actually makes call to real function, use these pre casted props\n            tagSupport.propsConfig.castProps = castedProps;\n            // update support to think it has different cloned props\n            lastSupport.propsConfig.latestCloned = tagSupport.propsConfig.latestCloned;\n            lastSupport.propsConfig.lastClonedKidValues = tagSupport.propsConfig.lastClonedKidValues;\n            return lastSupport; // its the same tag component\n        }\n    }\n    const oldest = lastSupport.global.oldest;\n    if (tagSupport.global.locked) {\n        tagSupport.global.blocked.push(tagSupport);\n        return tagSupport;\n    }\n    const previous = lastSupport.global.newest;\n    const newSupport = renderTagSupport(tagSupport, renderUp);\n    return afterTagRender(subject, oldest, templater, previous, newSupport, isSameTag);\n}\nfunction afterTagRender(subject, oldest, templater, previous, newSupport, isSameTag) {\n    let lastSupport = subject.tagSupport;\n    // const oldest = newSupport.global.oldest\n    /*\n    const hasOldest = oldest ? true : false\n    if(!hasOldest) {\n      return buildNewTag(\n        newSupport,\n        insertBefore,\n        lastSupport,\n        subject\n      )\n    }\n    */\n    if (oldest && templater.children._value.length) {\n        const oldKidsSub = oldest.templater.children;\n        oldKidsSub.next(templater.children._value);\n    }\n    // detect if both the function is the same and the return is the same\n    const isLikeTag = isSameTag && isLikeTags(previous, newSupport);\n    if (isLikeTag) {\n        const oldestTag = lastSupport.global.oldest;\n        subject.tagSupport = newSupport;\n        oldestTag.updateBy(newSupport);\n        return newSupport;\n    }\n    // Although function looked the same it returned a different html result\n    if (isSameTag && lastSupport) {\n        if (!previous.global.deleted) {\n            destroyTagMemory(previous);\n        }\n        /*\n        const insertBefore = (previous.global.insertBefore as any)\n        if(insertBefore.parentNode) {\n          insertBefore.parentNode.removeChild(insertBefore)\n        }\n        */\n        newSupport.global.context = {}; // do not share previous outputs\n        // delete newSupport.global.deleted\n    }\n    return buildNewTag(newSupport, newSupport.global.insertBefore, newSupport, subject);\n}\nfunction buildNewTag(newSupport, oldInsertBefore, oldTagSupport, subject) {\n    newSupport.buildBeforeElement(oldInsertBefore, {\n        counts: { added: 0, removed: 0 },\n    });\n    newSupport.global.oldest = newSupport;\n    newSupport.global.newest = newSupport;\n    oldTagSupport.global.oldest = newSupport;\n    oldTagSupport.global.newest = newSupport;\n    subject.tagSupport = newSupport;\n    subject.tagSupport.ownerTagSupport.global.childTags.push(newSupport);\n    return newSupport;\n}\nfunction syncFunctionProps(newSupport, lastSupport, ownerSupport, newPropsArray) {\n    const newest = lastSupport.global.newest;\n    if (!newest) {\n        // const state = ownerSupport.global.oldest.memory.state\n        const state = ownerSupport.memory.state;\n        newPropsArray.length = 0;\n        const castedProps = castProps(newPropsArray, newSupport, state);\n        newPropsArray.push(...castedProps);\n        newSupport.propsConfig.castProps = castedProps;\n        return newPropsArray;\n    }\n    lastSupport = newest || lastSupport;\n    const priorPropConfig = lastSupport.propsConfig;\n    const priorPropsArray = priorPropConfig.castProps;\n    const newArray = [];\n    for (let index = newPropsArray.length - 1; index >= 0; --index) {\n        const prop = newPropsArray[index];\n        const priorProp = priorPropsArray[index];\n        const newValue = syncPriorPropFunction(priorProp, prop, newSupport, ownerSupport);\n        newArray.push(newValue);\n    }\n    newSupport.propsConfig.castProps = newArray;\n    return newArray;\n}\nfunction syncPriorPropFunction(priorProp, prop, newSupport, ownerSupport, seen = []) {\n    if (priorProp instanceof Function) {\n        // the prop i am receiving, is already being monitored/controlled by another parent\n        if (prop.toCall) {\n            priorProp.toCall = prop.toCall;\n            return prop;\n        }\n        const ownerGlobal = ownerSupport.global;\n        const oldOwnerState = ownerGlobal.newest.memory.state;\n        priorProp.prop = prop;\n        priorProp.stateArray = oldOwnerState;\n        return priorProp;\n    }\n    // prevent infinite recursion\n    if (seen.includes(prop)) {\n        return prop;\n    }\n    seen.push(prop);\n    if (typeof (prop) !== 'object' || !prop) {\n        return prop; // no children to crawl through\n    }\n    if (prop instanceof Array) {\n        for (let index = prop.length - 1; index >= 0; --index) {\n            const x = prop[index];\n            prop[index] = syncPriorPropFunction(priorProp[index], x, newSupport, ownerSupport, seen);\n        }\n        return prop;\n    }\n    if (priorProp === undefined) {\n        return prop;\n    }\n    for (const name in prop) {\n        const subValue = prop[name];\n        const result = syncPriorPropFunction(priorProp[name], subValue, newSupport, ownerSupport, seen);\n        const hasSetter = Object.getOwnPropertyDescriptor(prop, name)?.set;\n        if (hasSetter) {\n            continue;\n        }\n        prop[name] = result;\n    }\n    return prop;\n}\nexport function moveProviders(lastSupport, newSupport) {\n    const destroy$ = lastSupport.global.destroy$;\n    lastSupport.global.providers.forEach(provider => {\n        provider.children.forEach((child, index) => {\n            const wasSameGlobals = lastSupport.global.destroy$ === child.global.destroy$;\n            if (wasSameGlobals) {\n                provider.children.splice(index, 1);\n                provider.children.push(newSupport);\n                return;\n            }\n        });\n    });\n}\n","import { hasPropChanges } from './hasPropChanges.function.js';\nexport function hasTagSupportChanged(lastSupport, newTagSupport, newTemplater) {\n    const latestProps = newTemplater.props; // newTagSupport.propsConfig.latest\n    const pastCloneProps = lastSupport.propsConfig.latestCloned;\n    const propsChanged = hasPropChanges(latestProps, pastCloneProps);\n    // const propsChanged = hasPropChanges(lastSupport.templater.props, newTagSupport.templater.props)\n    // const propsChanged = hasPropChanges(lastSupport.propsConfig.latestCloned, newTagSupport.propsConfig.latestCloned)\n    // if no changes detected, no need to continue to rendering further tags\n    if (propsChanged) {\n        return propsChanged;\n    }\n    const propsChanged2 = hasPropChanges(lastSupport.propsConfig.latestCloned, newTagSupport.propsConfig.latestCloned);\n    if (propsChanged2) {\n        return propsChanged2;\n    }\n    const kidsChanged = hasKidsChanged(lastSupport, newTagSupport);\n    // we already know props didn't change and if kids didn't either, than don't render\n    return kidsChanged;\n}\nexport function hasKidsChanged(oldTagSupport, newTagSupport) {\n    const oldCloneKidValues = oldTagSupport.propsConfig.lastClonedKidValues;\n    const newClonedKidValues = newTagSupport.propsConfig.lastClonedKidValues;\n    const everySame = oldCloneKidValues.every((set, index) => {\n        const x = newClonedKidValues[index];\n        return set.every((item, index) => item === x[index]);\n    });\n    return everySame ? false : 9;\n}\n","import { isLikeTags } from '../isLikeTags.function.js';\nimport { renderTagOnly } from './renderTagOnly.function.js';\nimport { destroyUnlikeTags } from './destroyUnlikeTags.function.js';\nexport function renderWithSupport(newTagSupport, lastSupport, // previous\nsubject, // events & memory\nownerSupport) {\n    const reSupport = renderTagOnly(newTagSupport, lastSupport, subject, ownerSupport);\n    const isLikeTag = !lastSupport || isLikeTags(lastSupport, reSupport);\n    if (!isLikeTag) {\n        destroyUnlikeTags(lastSupport, reSupport, subject);\n        reSupport.global.oldest = reSupport;\n    }\n    const lastOwnerSupport = lastSupport?.ownerTagSupport;\n    reSupport.ownerTagSupport = (ownerSupport || lastOwnerSupport);\n    return reSupport;\n}\n","import { destroyTagMemory } from '../destroyTag.function.js';\nimport { moveProviders } from '../update/updateExistingTagComponent.function.js';\nexport function destroyUnlikeTags(lastSupport, // old\nreSupport, // new\nsubject) {\n    const oldGlobal = lastSupport.global;\n    const insertBefore = oldGlobal.insertBefore;\n    // when a tag is destroyed, disconnect the globals\n    const global = reSupport.global = { ...oldGlobal }; // break memory references\n    moveProviders(lastSupport, reSupport);\n    destroyTagMemory(lastSupport);\n    global.insertBefore = insertBefore;\n    delete global.deleted;\n    global.oldest = reSupport;\n    global.newest = reSupport;\n    subject.tagSupport = reSupport;\n    const placeParent = reSupport.global.placeholder?.parentNode;\n    const insertParent = insertBefore.parentNode;\n    if (placeParent && insertParent) {\n        insertParent.removeChild(insertBefore);\n    }\n}\n","import { deepClone } from '../deepFunctions.js';\nimport { renderTagSupport } from '../tag/render/renderTagSupport.function.js';\nexport function handleProviderChanges(appSupport, provider) {\n    const tagsWithProvider = getTagsWithProvider(appSupport, provider);\n    for (let index = tagsWithProvider.length - 1; index >= 0; --index) {\n        const { tagSupport, renderCount, provider } = tagsWithProvider[index];\n        if (tagSupport.global.deleted) {\n            continue; // i was deleted after another tag processed\n        }\n        const notRendered = renderCount === tagSupport.global.renderCount;\n        if (notRendered) {\n            provider.clone = deepClone(provider.instance);\n            renderTagSupport(tagSupport.global.newest, // tagSupport, // tagSupport.global.newest as TagSupport,\n            false);\n            continue;\n        }\n    }\n}\n/** Updates and returns memory of tag providers */\nfunction getTagsWithProvider(tagSupport, provider, memory = []) {\n    memory.push({\n        tagSupport,\n        renderCount: tagSupport.global.renderCount,\n        provider,\n    });\n    const childTags = provider.children;\n    for (let index = childTags.length - 1; index >= 0; --index) {\n        memory.push({\n            tagSupport: childTags[index],\n            renderCount: childTags[index].global.renderCount,\n            provider,\n        });\n    }\n    return memory;\n}\n","import { isLikeTags } from '../isLikeTags.function.js';\nimport { renderWithSupport } from './renderWithSupport.function.js';\nimport { providersChangeCheck } from '../../state/providersChangeCheck.function.js';\n/** Returns true when rendering owner is not needed. Returns false when rendering owner should occur */\nexport function renderExistingTag(oldestSupport, // oldest with elements on html\nnewSupport, // new to be rendered\nownerSupport, // ownerSupport\nsubject) {\n    const lastSupport = subject.tagSupport;\n    const global = lastSupport.global;\n    // share point between renders\n    newSupport.global = global;\n    const preRenderCount = global.renderCount;\n    providersChangeCheck(oldestSupport);\n    // When the providers were checked, a render to myself occurred and I do not need to re-render again\n    const prevSupport = global.newest;\n    const justUpdate = preRenderCount !== global.renderCount;\n    if (justUpdate) {\n        oldestSupport.global.oldest.updateBy(prevSupport);\n        return prevSupport; // already rendered during triggered events\n    }\n    const toRedrawTag = prevSupport || lastSupport || global.oldest;\n    const reSupport = renderWithSupport(newSupport, toRedrawTag, subject, ownerSupport);\n    const oldest = global.oldest || oldestSupport;\n    if (isLikeTags(prevSupport, reSupport)) {\n        subject.tagSupport = reSupport;\n        oldest.updateBy(reSupport);\n    }\n    return reSupport;\n}\n","import { deepClone, deepEqual } from '../deepFunctions.js';\nimport { handleProviderChanges } from './handleProviderChanges.function.js';\nexport function providersChangeCheck(tagSupport) {\n    const global = tagSupport.global;\n    const providersWithChanges = global.providers.filter(provider => !deepEqual(provider.instance, provider.clone));\n    // reset clones\n    for (let index = providersWithChanges.length - 1; index >= 0; --index) {\n        const provider = providersWithChanges[index];\n        const owner = provider.owner;\n        handleProviderChanges(owner, provider);\n        provider.clone = deepClone(provider.instance);\n    }\n}\n","import { deepEqual } from '../../deepFunctions.js';\nimport { renderExistingTag } from './renderExistingTag.function.js';\n/** Main function used by all other callers to render/update display of a tag component */\nexport function renderTagSupport(tagSupport, // must be latest/newest state render\nrenderUp) {\n    const global = tagSupport.global;\n    const templater = tagSupport.templater;\n    // is it just a vanilla tag, not component?\n    if (!templater.wrapper) { // || isTagTemplater(templater) \n        const ownerTag = tagSupport.ownerTagSupport;\n        ++global.renderCount;\n        if (ownerTag.global.deleted) {\n            return tagSupport;\n        }\n        return renderTagSupport(ownerTag.global.newest, true);\n    }\n    if (tagSupport.global.locked) {\n        tagSupport.global.blocked.push(tagSupport);\n        return tagSupport;\n    }\n    const subject = tagSupport.subject;\n    const oldest = tagSupport.global.oldest;\n    let ownerSupport;\n    let selfPropChange = false;\n    const shouldRenderUp = renderUp && tagSupport;\n    if (shouldRenderUp) {\n        ownerSupport = tagSupport.ownerTagSupport;\n        if (ownerSupport) {\n            const nowProps = templater.props;\n            const latestProps = tagSupport.propsConfig.latestCloned;\n            selfPropChange = !deepEqual(nowProps, latestProps);\n        }\n    }\n    const tag = renderExistingTag(oldest, tagSupport, ownerSupport, // useTagSupport,\n    subject);\n    if (ownerSupport && selfPropChange) {\n        const ownerTagSupport = ownerSupport.global.newest;\n        renderTagSupport(ownerTagSupport, true);\n        return tag;\n    }\n    return tag;\n}\n","import { renderTagSupport } from '../tag/render/renderTagSupport.function.js';\nimport { syncStates } from './syncStates.function.js';\nexport default function callbackStateUpdate(tagSupport, callback, oldState, ...args) {\n    const state = tagSupport.memory.state;\n    // ensure that the oldest has the latest values first\n    syncStates(state, oldState);\n    // run the callback\n    const maybePromise = callback(...args);\n    // send the oldest state changes into the newest\n    syncStates(oldState, state);\n    renderTagSupport(tagSupport, // tagSupport.global.newest as TagSupport,\n    false);\n    if (maybePromise instanceof Promise) {\n        maybePromise.finally(() => {\n            // send the oldest state changes into the newest\n            syncStates(oldState, state);\n            renderTagSupport(tagSupport, // tagSupport.global.newest as TagSupport,\n            false);\n        });\n    }\n    // return undefined as T\n    return maybePromise;\n}\n","import { setUse } from './setUse.function.js';\nimport { SyncCallbackError } from '../errors.js';\nimport { getSupportInCycle } from '../tag/getSupportInCycle.function.js';\nimport callbackStateUpdate from './callbackStateUpdate.function.js';\nlet innerCallback = (callback) => (a, b, c, d, e, f) => {\n    throw new SyncCallbackError('Callback function was called immediately in sync and must instead be call async');\n};\nexport const callbackMaker = () => innerCallback;\nconst originalGetter = innerCallback; // callbackMaker\nsetUse({\n    beforeRender: tagSupport => initMemory(tagSupport),\n    beforeRedraw: tagSupport => initMemory(tagSupport),\n    afterRender: tagSupport => {\n        ;\n        tagSupport.global.callbackMaker = true;\n        innerCallback = originalGetter; // prevent crossing callbacks with another tag\n    },\n});\n/** Wrap a function that will be called back. After the wrapper and function are called, a rendering cycle will update display */\nexport function callback(callback) {\n    const tagSupport = getSupportInCycle();\n    if (!tagSupport) {\n        const error = new SyncCallbackError('callback() was called outside of synchronous rendering. Use `callback = callbackMaker()` to create a callback that could be called out of sync with rendering');\n        throw error;\n    }\n    const oldState = setUse.memory.stateConfig.array;\n    const trigger = (...args) => {\n        const callbackMaker = tagSupport.global.callbackMaker;\n        if (callbackMaker) {\n            return callbackStateUpdate(tagSupport, callback, oldState, ...args);\n        }\n        return callback(...args);\n    };\n    return trigger;\n}\nfunction initMemory(tagSupport) {\n    const oldState = setUse.memory.stateConfig.array;\n    innerCallback = (callback) => {\n        const trigger = (...args) => {\n            const callbackMaker = tagSupport.global.callbackMaker;\n            if (callbackMaker) {\n                return callbackStateUpdate(tagSupport, callback, oldState, ...args);\n            }\n            return callback(...args);\n        };\n        return trigger;\n    };\n}\n","import { state } from './state.function.js';\n/** runs a callback function one time and never again. Same as calling state(() => ...) */\nexport function onInit(callback) {\n    state(callback);\n}\n","import { getSupportInCycle } from \"../tag/getSupportInCycle.function.js\";\nimport { state } from \"./state.function.js\";\nexport function onDestroy(callback) {\n    state(() => {\n        const tagSupport = getSupportInCycle();\n        tagSupport?.global.destroy$.toCallback(callback);\n    });\n}\n","import { setUse } from './setUse.function.js';\nfunction setCurrentTagSupport(support) {\n    setUse.memory.childrenCurrentSupport = support;\n}\nexport function children() {\n    const tagSupport = setUse.memory.childrenCurrentSupport;\n    const children = tagSupport.templater.children;\n    return children;\n}\nsetUse({\n    beforeRender: tagSupport => setCurrentTagSupport(tagSupport),\n    beforeRedraw: tagSupport => setCurrentTagSupport(tagSupport),\n});\n","export const tags = [];\n","import { Tag } from './Tag.class.js';\nexport function html(strings, ...values) {\n    return new Tag(strings, values);\n}\n","import { setUse } from '../state/index.js';\nimport { TemplaterResult } from './TemplaterResult.class.js';\nimport { tags } from './tag.utils.js';\nimport { getTagWrap } from './getTagWrap.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nlet tagCount = 0;\n/** Wraps a function tag in a state manager and calls wrapped function on event cycles\n * For single rendering, no event cycles, use: tag.renderOnce = (props) => html``\n */\nexport function tag(tagComponent) {\n    /** function developer triggers */\n    const parentWrap = (function tagWrapper(...props) {\n        const templater = new TemplaterResult(props);\n        templater.tagJsType = ValueTypes.tagComponent;\n        // attach memory back to original function that contains developer display logic\n        const innerTagWrap = getTagWrap(templater, parentWrap);\n        if (!innerTagWrap.parentWrap) {\n            innerTagWrap.parentWrap = parentWrap;\n        }\n        templater.tagged = true;\n        templater.wrapper = innerTagWrap;\n        return templater;\n    }) // we override the function provided and pretend original is what's returned\n    ;\n    parentWrap.original = tagComponent;\n    parentWrap.compareTo = tagComponent.toString();\n    const tag = tagComponent;\n    parentWrap.isTag = true;\n    parentWrap.original = tag;\n    // group tags together and have hmr pickup\n    tag.tags = tags;\n    tag.setUse = setUse;\n    tag.tagIndex = tagCount++; // needed for things like HMR\n    tags.push(parentWrap);\n    return parentWrap;\n}\n/** Used to create a tag component that renders once and has no addition rendering cycles */\ntag.oneRender = (...props) => {\n    throw new Error('Do not call function tag.oneRender but instead set it as: `(props) => tag.oneRender = (state) => html`` `');\n};\n/** Use to structure and define a browser tag route handler\n * Example: export default tag.route = (routeProps: RouteProps) => (state) => html``\n */\ntag.route = (routeProps) => {\n    throw new Error('Do not call function tag.route but instead set it as: `tag.route = (routeProps: RouteProps) => (state) => html`` `');\n};\n/** Use to structure and define a browser tag route handler\n * Example: export default tag.route = (routeProps: RouteProps) => (state) => html``\n */\ntag.app = (routeTag) => {\n    throw new Error('Do not call function tag.route but instead set it as: `tag.route = (routeProps: RouteProps) => (state) => html`` `');\n};\nObject.defineProperty(tag, 'oneRender', {\n    set(oneRenderFunction) {\n        oneRenderFunction.oneRender = true;\n    },\n});\n","import { runTagCallback } from '../interpolations/bindSubjectCallback.function.js';\nimport { deepClone } from '../deepFunctions.js';\nimport { TagSupport } from './TagSupport.class.js';\nimport { castProps } from '../alterProp.function.js';\nimport { setUse } from '../state/setUse.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nimport { html } from './html.js';\n/** creates/returns a function that when called then calls the original component function\n * Gets used as templater.wrapper()\n */\nexport function getTagWrap(templater, result) {\n    const stateArray = setUse.memory.stateConfig.array;\n    // this function gets called by taggedjs\n    const wrapper = function (lastTagSupport, subject) {\n        const global = lastTagSupport.global;\n        ++global.renderCount;\n        const childSubject = templater.children;\n        const lastArray = global.oldest?.templater.children.lastArray;\n        if (lastArray) {\n            childSubject.lastArray = lastArray;\n        }\n        // result.original\n        const originalFunction = result.original; // (innerTagWrap as any).original as unknown as TagComponent\n        let props = templater.props;\n        // When defined, this must be an update where my new props have already been made for me\n        const preCastedProps = lastTagSupport.propsConfig.castProps;\n        const castedProps = preCastedProps || castProps(props, lastTagSupport, stateArray);\n        const latestCloned = props.map(props => deepClone(props)); // castedProps\n        // CALL ORIGINAL COMPONENT FUNCTION\n        let tag = originalFunction(...castedProps);\n        if (tag instanceof Function) {\n            tag = tag();\n        }\n        if (!tag || tag.tagJsType !== ValueTypes.tag) {\n            tag = html `${tag}`; // component returned a non-component value\n        }\n        tag.templater = templater;\n        templater.tag = tag;\n        tag.memory.arrayValue = templater.arrayValue; // tag component could have been used in array.map\n        const tagSupport = new TagSupport(templater, lastTagSupport.ownerTagSupport, subject, castedProps, global.renderCount);\n        tagSupport.global = global;\n        const nowState = setUse.memory.stateConfig.array;\n        tagSupport.memory.state.push(...nowState);\n        if (templater.madeChildIntoSubject) {\n            const value = childSubject.value;\n            for (let index = value.length - 1; index >= 0; --index) {\n                const kid = value[index];\n                const values = kid.values;\n                for (let index = values.length - 1; index >= 0; --index) {\n                    const value = values[index];\n                    if (!(value instanceof Function)) {\n                        continue;\n                    }\n                    const valuesValue = kid.values[index];\n                    if (valuesValue.isChildOverride) {\n                        continue; // already overwritten\n                    }\n                    // all functions need to report to me\n                    kid.values[index] = function (...args) {\n                        const ownerSupport = tagSupport.ownerTagSupport;\n                        return runTagCallback(value, // callback\n                        ownerSupport, this, // bindTo\n                        args);\n                    };\n                    valuesValue.isChildOverride = true;\n                }\n            }\n        }\n        return tagSupport;\n    };\n    return wrapper;\n}\n","import { BaseTagSupport } from './TagSupport.class.js';\nimport { runAfterRender, runBeforeRender } from './tagRunner.js';\nimport { ValueSubject } from '../subject/ValueSubject.js';\nconst appElements = [];\n/**\n *\n * @param app taggedjs tag\n * @param element HTMLElement\n * @param props object\n * @returns\n */\nexport function tagElement(app, // (...args: unknown[]) => TemplaterResult,\nelement, props) {\n    const appElmIndex = appElements.findIndex(appElm => appElm.element === element);\n    if (appElmIndex >= 0) {\n        appElements[appElmIndex].tagSupport.destroy();\n        appElements.splice(appElmIndex, 1);\n        // an element already had an app on it\n        console.warn('Found and destroyed app element already rendered to element', { element });\n    }\n    // Create the app which returns [props, runOneTimeFunction]\n    const wrapper = app(props);\n    // have a function setup and call the tagWrapper with (props, {update, async, on})\n    const tagSupport = runWrapper(wrapper);\n    tagSupport.appElement = element;\n    tagSupport.isApp = true;\n    tagSupport.global.isApp = true;\n    const templateElm = document.createElement('template');\n    templateElm.setAttribute('id', 'app-tag-' + appElements.length);\n    templateElm.setAttribute('app-tag-detail', appElements.length.toString());\n    const fragment = document.createDocumentFragment();\n    fragment.appendChild(templateElm);\n    element.destroy = async () => {\n        await tagSupport.destroy();\n        const insertBefore = tagSupport.global.insertBefore;\n        const parentNode = insertBefore.parentNode;\n        parentNode.removeChild(insertBefore);\n    };\n    tagSupport.buildBeforeElement(templateElm);\n    tagSupport.global.oldest = tagSupport;\n    tagSupport.global.newest = tagSupport;\n    element.setUse = app.original.setUse;\n    appElements.push({ element, tagSupport });\n    element.appendChild(fragment);\n    return {\n        tagSupport,\n        tags: app.original.tags,\n    };\n}\nexport function runWrapper(templater) {\n    let newSupport = {};\n    // TODO: A fake subject may become a problem\n    const subject = new ValueSubject(newSupport);\n    newSupport = new BaseTagSupport(templater, subject);\n    subject.next(templater);\n    subject.tagSupport = newSupport;\n    runBeforeRender(newSupport, undefined);\n    // Call the apps function for our tag templater\n    const wrapper = templater.wrapper;\n    const tagSupport = wrapper(newSupport, subject);\n    runAfterRender(newSupport, tagSupport);\n    return tagSupport;\n}\n","export * from './tag/index.js';\nexport * from './errors.js';\nexport * from './subject.types.js';\nexport * from './isInstance.js';\nexport * from './state/index.js';\nexport * from './subject/index.js';\nexport * from './tag/TagSupport.class.js';\nexport * from './interpolations/ElementTargetEvent.interface.js';\nexport * from './interpolations/interpolateElement.js';\nexport * from './interpolations/InsertBefore.type.js';\nexport { tagElement } from './tag/tagElement.js';\nexport { Tag, variablePrefix } from './tag/Tag.class.js';\nexport { runBeforeRender } from './tag/tagRunner.js';\nexport { renderTagSupport } from './tag/render/renderTagSupport.function.js';\nexport { renderWithSupport } from './tag/render/renderWithSupport.function.js';\nexport { isLikeValueSets } from './tag/isLikeTags.function.js';\nimport { renderTagOnly } from './tag/render/renderTagOnly.function.js';\nimport { renderTagSupport } from './tag/render/renderTagSupport.function.js';\nimport { renderWithSupport } from './tag/render/renderWithSupport.function.js';\nimport { tagElement } from './tag/tagElement.js';\nexport const hmr = {\n    tagElement, renderWithSupport, renderTagSupport,\n    renderTagOnly,\n};\n"],"names":["ValueTypes","__webpack_require__","exports","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","RouteQuery","name","isStaticTag","value","tag","templater","includes","tagJsType","isTagTemplater","isTagComponent","tagComponent","isTagClass","isSubjectInstance","subject","isSubject","subscribe","isTagArray","Array","every","x","combineLatest","subjects","output","Subject","subscribeWith","callback","valuesSeen","values","setValue","index","length","subscription","clones","shift","subscriptions","map","runPipedMethods","methods","onComplete","cloneMethods","firstMethod","next","newValue","handler","methodResponse","setHandler","onSubscription","subscribers","_value","set","constructor","this","defineValueOn","countSubject","globalSubCount$","unsubscribe","findIndex","sub","splice","removeSubFromArray","add","push","getSubscription","orgCallback","lastValue","emit","subs","toPromise","Promise","res","toCallback","_subscription","pipe","operations","setMethods","all","args","arg","static","ValueSubject","super","willCallback","utils","willPromise","then","willSubscribe","getSupportInCycle","setUse","memory","stateConfig","tagSupport","use","useMe","beforeRender","beforeRedraw","afterRender","beforeDestroy","tagUse","TagError","Error","details","message","errorCode","ArrayNoKeyError","StateMismatchError","SyncCallbackError","array","state","config","rearray","stateLength","getStateValue","initState","defaultValue","checkValue","oldState","StateEchoBack","getCallbackValue","toString","JSON","stringify","console","error","wrapper","oldStates","newStates","tagFunction","parentWrap","original","warn","item","syncStates","stateFrom","stateTo","fromValue","getSetMethod","restate","oldValue","initValue","Function","newState","global","newest","result","watch","currentValues","setupWatch","defaultFinally","init","before","final","previous","pastResult","undefined","previousValues","defineOnMethod","getWatch","attachTo","setup","oldWatch","firstSupport","method","nowTagSupport","setTo","oldestState","letState","makeStateResult","y","letProp","getSetProp","myProp","deepClone","makeDeepClone","WeakMap","visited","has","Date","RegExp","clone","isArray","create","getPrototypeOf","i","deepEqual","obj1","obj2","isDeepEqual","fn0","fn1","getTime","isArrayDeepEqual","keys1","keys","keys2","isObjectDeepEqual","newWatch","providers","constructMethod","stateDiffMemory","stateDiff","provider","oldStateCount","instance","owner","children","cm","compareTo","inject","ownerTagSupport","find","msg","isLikeTags","tagSupport0","tagSupport1","templater0","templater1","tag0","tag1","strings0","strings","strings1","string","isLikeValueSets","values0","values1","runBeforeRender","ownerSupport","runAfterRender","tagClosed$","runBeforeDestroy","deleted","hasLiveElements","childTags","filter","child","oldest","forEach","renderTagOnly","newTagSupport","prevSupport","oldRenderCount","renderCount","parentSupport","lastOwnerSupport","runtimeOwnerSupport","lastState","runBeforeRedraw","beforeWithRender","reSupport","destroyTagMemory","oldTagSupport","destroy","context","hasPropChanges","props","pastCloneProps","castedProps","castedPastProps","compare","subCastedProps","subCompareProps","matched","entries","compareProps","onDelete","compareOriginal","processTagResult","insertBefore","counts","subjectTag","lastSupport","newSupport","updateBy","processTagResultUpdate","buildBeforeElement","variablePrefix","escapeVariable","escapeSearch","Tag","arrayValue","html","insertAfter","newNode","referenceNode","parentNode","nextSibling","isSimpleType","destroyArrayTag","stagger","removed","removeChild","placeholderElm","placeholder","getValueType","type","function","date","tagArray","unknown","cloneValueArray","getChildTagsToDestroy","allTags","cTag","TemplaterResult","tagged","madeChildIntoSubject","childSubject","templaterResult","kid","kidsToTagArraySubject","processNewTag","TagSupport","swapInsertBefore","document","createTextNode","specialAttribute","element","names","split","style","classList","remove","useLocks","runTagCallback","bindTo","findTagToCallback","bind","locked","callbackResult","blocked","lastResult","block","updateExistingTagComponent","checkAfterCallbackPromise","last","renderTagSupport","renderCallbackSupport","afterTagCallback","startRegX","endRegX","isTagVar","search","processAttribute","attrName","scope","howToSet","getContextValueByVarString","processNameValueAttr","processScopedNameValueAttr","attrValue","removeAttribute","processNameOnlyAttr","isSpecialAttr","replace","reverse","join","isSpecial","action","newAttrValue","oneRender","isChildOverride","subjectFunction","bindSubjectCallback","processAttributeSubjectValue","callbackFun","fun","howToSetAttribute","setAttribute","howToSetInputValue","interpolateAttributes","attrNames","getAttributeNames","nodeName","getAttribute","interpolateReplace","processTag","newTagSupportByTemplater","added","tagFakeTemplater","getFakeTemplater","fake","isTag","setupNewSupport","processTagArray","options","lastArray","setPlaceholderElm","runtimeInsertBefore","destroyArrayItem","subTag","tagClass","prevArrayValue","destroyItem","valueA","valueB","areLikeValues","previousSupport","itemSubject","setupNewTemplater","template","getTemplate","processAddTagArrayItem","fragment","createDocumentFragment","newTempElm","createElement","appendChild","updateBeforeTemplate","lastFirstChild","parent","textNode","castTextValue","processRegularValue","castedValue","oldClone","textContent","oneRenderToTagSupport","wrap","processFirstSubjectValue","processSubjectComponent","v","processFirstRegularValue","updateExistingValue","valueType","displaySubject","hasLastValue","newType","destroySimpleValue","arraySubject","wasArray","isValueTag","checkDestroyPrevious","subjectSup","newestState","prepareUpdateToComponent","isClass","valueSupport","isSameTag","handleStillTag","interpolateTemplate","hasAttribute","variableName","substring","existingSubject","subscribeToTemplate","called","onValue","mutatingCallback","afterElmBuild","elm","textarea","match","dynamic","_elm","_name","scanTextAreaValue","diff","onInitDoubleWrap","oninit","onInitWrap","onInit","target","elementInitCheck","focus","select","interpolateContentTemplates","tagComponents","subChild","isRenderEndTemplate","nextClones","nextTagComponent","tagName","interpolateElement","container","interpolatedTemplates","interpolation","content","nextTagComponents","processChildrenAttributes","interpolateString","expression","startsWith","id","interpolateToTemplates","afterInterpolateElement","temporary","firstChild","nextNextSibling","buildClones","prefixSearch","BaseTagSupport","isApp","appElement","propsConfig","destroy$","clonePropsBy","kidValue","latestCloned","latest","castProps","lastClonedKidValues","setTagPlaceholder","update","elementContainer","tempDraw","innerHTML","thisTag","updateContext","_string","updateContextItem","processNewValue","tempTag","updateConfig","updateValues","byParent","firstDestroy","destroySubscriptions","subGlobal","mainPromise","promise","destroyClones","async","promises","oldClones","checkCloneRemoval","oldContext","customElm","ondestroy","onDestroyDoubleWrap","onDestroyWrap","onDestroy","elementDestroyCheck","compareClone","version","getAppTagSupport","label","preClones","renderWithSupport","myClones","fClone","renderSubjectComponent","stateArray","checkProp","alterProp","newProp","seen","toCall","callWith","noCycle","run","allMatched","callbackPropOwner","assign","getPropWrap","subValue","afterCheckProp","hasSetter","getOwnPropertyDescriptor","pastValue","renderUp","oldWrapper","newWrapper","hasChanged","newTemplater","propsChanged","propsChanged2","kidsChanged","oldCloneKidValues","newClonedKidValues","hasKidsChanged","hasTagSupportChanged","newPropsArray","priorPropConfig","priorPropsArray","newArray","syncPriorPropFunction","syncFunctionProps","isLikeTag","oldestTag","oldInsertBefore","buildNewTag","afterTagRender","priorProp","oldOwnerState","oldGlobal","moveProviders","placeParent","insertParent","destroyUnlikeTags","handleProviderChanges","appSupport","tagsWithProvider","getTagsWithProvider","renderExistingTag","oldestSupport","preRenderCount","providersWithChanges","providersChangeCheck","ownerTag","selfPropChange","callbackStateUpdate","maybePromise","finally","innerCallback","a","b","c","d","e","f","callbackMaker","originalGetter","initMemory","setCurrentTagSupport","support","childrenCurrentSupport","tags","tagCount","innerTagWrap","lastTagSupport","originalFunction","nowState","valuesValue","getTagWrap","tagIndex","route","routeProps","app","routeTag","oneRenderFunction","appElements","tagElement","appElmIndex","appElm","runWrapper","templateElm","hmr"],"sourceRoot":""}
+{"version":3,"file":"bundle.js","mappings":"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","sources":["webpack://taggedjs/webpack/bootstrap","webpack://taggedjs/./ts/tag/ValueTypes.enum.ts","webpack://taggedjs/webpack/runtime/define property getters","webpack://taggedjs/webpack/runtime/hasOwnProperty shorthand","webpack://taggedjs/./ts/tag/tag.types.ts","webpack://taggedjs/./ts/isInstance.ts","webpack://taggedjs/./ts/subject/combineLatest.function.ts","webpack://taggedjs/./ts/subject/subject.utils.ts","webpack://taggedjs/./ts/subject/Subject.class.ts","webpack://taggedjs/./ts/subject/ValueSubject.ts","webpack://taggedjs/./ts/subject/will.functions.ts","webpack://taggedjs/./ts/tag/getSupportInCycle.function.ts","webpack://taggedjs/./ts/state/setUse.function.ts","webpack://taggedjs/./ts/errors.ts","webpack://taggedjs/./ts/state/state.utils.ts","webpack://taggedjs/./ts/state/syncStates.function.ts","webpack://taggedjs/./ts/state/state.function.ts","webpack://taggedjs/./ts/state/watch.function.ts","webpack://taggedjs/./ts/state/subject.function.ts","webpack://taggedjs/./ts/state/letState.function.ts","webpack://taggedjs/./ts/state/letProp.function.ts","webpack://taggedjs/./ts/deepFunctions.ts","webpack://taggedjs/./ts/state/providers.ts","webpack://taggedjs/./ts/tag/isLikeTags.function.ts","webpack://taggedjs/./ts/tag/tagRunner.ts","webpack://taggedjs/./ts/tag/render/renderTagOnly.function.ts","webpack://taggedjs/./ts/tag/Tag.class.ts","webpack://taggedjs/./ts/tag/destroyTag.function.ts","webpack://taggedjs/./ts/insertAfter.function.ts","webpack://taggedjs/./ts/tag/checkDestroyPrevious.function.ts","webpack://taggedjs/./ts/tag/getValueType.function.ts","webpack://taggedjs/./ts/tag/cloneValueArray.function.ts","webpack://taggedjs/./ts/tag/destroy.support.ts","webpack://taggedjs/./ts/tag/TemplaterResult.class.ts","webpack://taggedjs/./ts/tag/kidsToTagArraySubject.function.ts","webpack://taggedjs/./ts/tag/update/processNewValue.function.ts","webpack://taggedjs/./ts/tag/setTagPlaceholder.function.ts","webpack://taggedjs/./ts/interpolations/specialAttribute.ts","webpack://taggedjs/./ts/tag/hasPropChanges.function.ts","webpack://taggedjs/./ts/tag/update/processTagResult.function.ts","webpack://taggedjs/./ts/tag/update/processSubjectComponent.function.ts","webpack://taggedjs/./ts/tag/render/renderSubjectComponent.function.ts","webpack://taggedjs/./ts/alterProp.function.ts","webpack://taggedjs/./ts/tag/update/updateExistingTagComponent.function.ts","webpack://taggedjs/./ts/tag/hasTagSupportChanged.function.ts","webpack://taggedjs/./ts/interpolations/bindSubjectCallback.function.ts","webpack://taggedjs/./ts/interpolations/processAttribute.function.ts","webpack://taggedjs/./ts/interpolations/interpolateAttributes.ts","webpack://taggedjs/./ts/interpolations/interpolations.ts","webpack://taggedjs/./ts/tag/update/processTag.function.ts","webpack://taggedjs/./ts/tag/update/processTagArray.ts","webpack://taggedjs/./ts/updateBeforeTemplate.function.ts","webpack://taggedjs/./ts/tag/update/processRegularValue.function.ts","webpack://taggedjs/./ts/tag/update/oneRenderToTagSupport.function.ts","webpack://taggedjs/./ts/tag/update/processFirstSubjectValue.function.ts","webpack://taggedjs/./ts/interpolations/scanTextAreaValue.function.ts","webpack://taggedjs/./ts/tag/update/updateExistingValue.function.ts","webpack://taggedjs/./ts/interpolations/interpolateTemplate.ts","webpack://taggedjs/./ts/interpolations/elementInitCheck.ts","webpack://taggedjs/./ts/interpolations/interpolateContentTemplates.ts","webpack://taggedjs/./ts/interpolations/interpolateElement.ts","webpack://taggedjs/./ts/interpolations/afterInterpolateElement.function.ts","webpack://taggedjs/./ts/render.ts","webpack://taggedjs/./ts/tag/TagSupport.class.ts","webpack://taggedjs/./ts/tag/update/updateContextItem.function.ts","webpack://taggedjs/./ts/tag/elementDestroyCheck.function.ts","webpack://taggedjs/./ts/tag/render/softDestroySupport.function.ts","webpack://taggedjs/./ts/tag/render/destroyUnlikeTags.function.ts","webpack://taggedjs/./ts/tag/render/renderWithSupport.function.ts","webpack://taggedjs/./ts/state/handleProviderChanges.function.ts","webpack://taggedjs/./ts/tag/render/renderExistingTag.function.ts","webpack://taggedjs/./ts/state/providersChangeCheck.function.ts","webpack://taggedjs/./ts/tag/render/renderTagSupport.function.ts","webpack://taggedjs/./ts/state/callbackStateUpdate.function.ts","webpack://taggedjs/./ts/state/callbackMaker.function.ts","webpack://taggedjs/./ts/state/onInit.ts","webpack://taggedjs/./ts/state/onDestroy.ts","webpack://taggedjs/./ts/state/children.ts","webpack://taggedjs/./ts/tag/tag.utils.ts","webpack://taggedjs/./ts/tag/html.ts","webpack://taggedjs/./ts/tag/tag.ts","webpack://taggedjs/./ts/tag/getTagWrap.function.ts","webpack://taggedjs/./ts/tag/tagElement.ts","webpack://taggedjs/./ts/index.ts"],"sourcesContent":["// The require scope\nvar __webpack_require__ = {};\n\n","export var ValueTypes;\n(function (ValueTypes) {\n    ValueTypes[\"unknown\"] = \"unknown\";\n    ValueTypes[\"tag\"] = \"tag\";\n    ValueTypes[\"templater\"] = \"templater\";\n    ValueTypes[\"tagComponent\"] = \"tag-component\";\n    ValueTypes[\"tagArray\"] = \"tag-array\";\n    ValueTypes[\"subject\"] = \"subject\";\n    ValueTypes[\"date\"] = \"date\";\n    ValueTypes[\"string\"] = \"string\";\n    ValueTypes[\"boolean\"] = \"boolean\";\n    ValueTypes[\"function\"] = \"function\";\n    ValueTypes[\"undefined\"] = \"undefined\";\n})(ValueTypes || (ValueTypes = {}));\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","export class RouteQuery {\n    get(name) {\n        return 'todo';\n    }\n}\n","import { ValueTypes } from './tag/ValueTypes.enum.js';\nexport function isStaticTag(value) {\n    return [\n        ValueTypes.tag,\n        ValueTypes.templater,\n    ].includes(value?.tagJsType);\n}\nexport function isTagTemplater(value) {\n    return value?.tagJsType === ValueTypes.templater;\n}\n// TODO: whats the difference between isTagClass and isTagComponent\nexport function isTagComponent(value) {\n    return value?.tagJsType === ValueTypes.tagComponent;\n}\nexport function isTagClass(value) {\n    return value?.tagJsType === ValueTypes.tag;\n}\n// isSubjectLike\nexport function isSubjectInstance(subject) {\n    return (subject?.isSubject === true || subject?.subscribe) ? true : false; // subject?.isSubject === true || \n}\nexport function isTagArray(value) {\n    return value instanceof Array && value.every(x => [\n        ValueTypes.tag, ValueTypes.templater, ValueTypes.tag, ValueTypes.tagComponent\n    ].includes(x?.tagJsType));\n}\n","import { Subject } from './Subject.class.js';\nexport function combineLatest(subjects) {\n    const output = new Subject();\n    const subscribe = (callback) => {\n        const valuesSeen = [];\n        const values = [];\n        const setValue = (x, index) => {\n            valuesSeen[index] = true;\n            values[index] = x;\n            const countMatched = valuesSeen.length === subjects.length;\n            if (!countMatched) {\n                return;\n            }\n            for (let index = valuesSeen.length - 1; index >= 0; --index) {\n                if (!valuesSeen[index]) {\n                    return;\n                }\n            }\n            // everyone has reported values\n            callback(values, subscription);\n        };\n        const clones = [...subjects];\n        const firstSub = clones.shift();\n        const subscription = firstSub.subscribe(x => setValue(x, 0));\n        const subscriptions = clones.map((subject, index) => subject.subscribe(x => setValue(x, index + 1)));\n        subscription.subscriptions = subscriptions;\n        return subscription;\n    };\n    output.subscribeWith = subscribe;\n    return output;\n}\n","import { Subject } from './Subject.class.js';\nfunction removeSubFromArray(subscribers, callback) {\n    const index = subscribers.findIndex(sub => sub.callback === callback);\n    if (index !== -1) {\n        subscribers.splice(index, 1);\n    }\n}\nexport function getSubscription(subject, callback, subscribers) {\n    const countSubject = Subject.globalSubCount$;\n    Subject.globalSubCount$.next(countSubject._value + 1);\n    const subscription = () => {\n        subscription.unsubscribe();\n    };\n    subscription.callback = callback;\n    subscription.subscriptions = [];\n    // Return a function to unsubscribe from the BehaviorSubject\n    subscription.unsubscribe = () => {\n        removeSubFromArray(subscribers, callback); // each will be called when update comes in\n        // removeSubFromArray(Subject.globalSubs, callback) // 🔬 testing\n        Subject.globalSubCount$.next(countSubject._value - 1);\n        // any double unsubscribes will be ignored\n        subscription.unsubscribe = () => subscription;\n        // unsubscribe from any combined subjects\n        const subscriptions = subscription.subscriptions;\n        for (let index = subscriptions.length - 1; index >= 0; --index) {\n            subscriptions[index].unsubscribe();\n        }\n        return subscription;\n    };\n    subscription.add = (sub) => {\n        subscription.subscriptions.push(sub);\n        return subscription;\n    };\n    subscription.next = (value) => {\n        callback(value, subscription);\n    };\n    return subscription;\n}\nexport function runPipedMethods(value, methods, onComplete) {\n    const cloneMethods = [...methods];\n    const firstMethod = cloneMethods.shift();\n    const next = (newValue) => {\n        if (cloneMethods.length) {\n            return runPipedMethods(newValue, cloneMethods, onComplete);\n        }\n        onComplete(newValue);\n    };\n    let handler = next;\n    const setHandler = (x) => handler = x;\n    const pipeUtils = { setHandler, next };\n    const methodResponse = firstMethod(value, pipeUtils);\n    handler(methodResponse);\n}\n","import { isSubjectInstance } from '../isInstance.js';\nimport { combineLatest } from './combineLatest.function.js';\nimport { getSubscription, runPipedMethods } from './subject.utils.js';\nexport class Subject {\n    value;\n    onSubscription;\n    // private?\n    methods = [];\n    isSubject = true;\n    // private?\n    subscribers = [];\n    subscribeWith;\n    _value;\n    // this is overwritten by constructor at runtime. However having it helps editors know of its existence\n    set; // `subject.set = x` equal to `subject.next(x)`\n    constructor(value, \n    // private?\n    onSubscription) {\n        this.value = value;\n        this.onSubscription = onSubscription;\n        this._value = value;\n        defineValueOn(this);\n    }\n    subscribe(callback) {\n        const subscription = getSubscription(this, callback, this.subscribers);\n        // are we within a pipe?\n        const subscribeWith = this.subscribeWith;\n        if (subscribeWith) {\n            // are we in a pipe?\n            if (this.methods.length) {\n                const orgCallback = callback;\n                callback = (value) => {\n                    runPipedMethods(value, this.methods, lastValue => orgCallback(lastValue, subscription));\n                };\n            }\n            return subscribeWith(callback);\n        }\n        this.subscribers.push(subscription);\n        if (this.onSubscription) {\n            this.onSubscription(subscription);\n        }\n        return subscription;\n    }\n    next(value) {\n        this._value = value;\n        this.emit();\n    }\n    emit() {\n        const value = this._value;\n        // Notify all subscribers with the new value\n        const subs = [...this.subscribers]; // subs may change as we call callbacks\n        const length = subs.length;\n        for (let index = 0; index < length; ++index) {\n            const sub = subs[index];\n            sub.callback(value, sub);\n        }\n    }\n    toPromise() {\n        return new Promise(res => {\n            this.subscribe((x, subscription) => {\n                subscription.unsubscribe();\n                res(x);\n            });\n        });\n    }\n    /** like toPromise but faster */\n    toCallback(callback) {\n        const subscription = this.subscribe((x, _subscription) => {\n            subscription.unsubscribe();\n            callback(x);\n        });\n        return this;\n    }\n    pipe(...operations) {\n        const subject = new Subject(this._value);\n        subject.setMethods(operations);\n        subject.subscribeWith = (x) => this.subscribe(x);\n        subject.next = x => this.next(x);\n        return subject;\n    }\n    setMethods(operations) {\n        this.methods = operations;\n    }\n    static all(args) {\n        const switched = args.map(arg => {\n            if (isSubjectInstance(arg))\n                return arg;\n            // Call the callback immediately with the current value\n            const x = new Subject(arg, subscription => {\n                subscription.next(arg);\n                return subscription;\n            });\n            return x;\n        });\n        return combineLatest(switched);\n    }\n    static globalSubCount$ = new Subject(0); // for ease of debugging\n}\nexport function defineValueOn(subject) {\n    Object.defineProperty(subject, 'value', {\n        // supports subject.value = x\n        set(value) {\n            subject._value = value;\n            subject.emit();\n        },\n        // supports subject.value\n        get() {\n            return subject._value;\n        }\n    });\n    Object.defineProperty(subject, 'set', {\n        // supports subject.set = x\n        set: (value) => subject.next(value),\n        // supports subject.set(x)\n        get: () => (x) => subject.next(x),\n    });\n}\n","import { Subject, defineValueOn } from './Subject.class.js';\nexport class ValueSubject extends Subject {\n    value;\n    constructor(value) {\n        super(value);\n        this.value = value;\n        defineValueOn(this);\n    }\n    subscribe(callback) {\n        const subscription = super.subscribe(callback);\n        // Call the callback immediately with the current value\n        callback(this._value, subscription);\n        return subscription;\n    }\n}\n","export function willCallback(callback) {\n    return ((lastValue, utils) => {\n        utils.setHandler(() => {\n            return undefined;\n        });\n        callback(lastValue, utils.next);\n    });\n}\n/** .pipe( promise((x) => Promise.resolve(44)) ) */\nexport function willPromise(callback) {\n    return ((lastValue, utils) => {\n        utils.setHandler(() => {\n            return undefined;\n        }); // do nothing on initial return\n        const result = callback(lastValue);\n        result.then(x => utils.next(x));\n    });\n}\n/** .pipe( willSubscribe((x) => new ValueSubject(44)) ) */\nexport const willSubscribe = (callback) => {\n    return ((lastValue, utils) => {\n        utils.setHandler(() => {\n            return undefined;\n        }); // do nothing on initial return\n        const result = callback(lastValue);\n        const subscription = result.subscribe(x => {\n            subscription.unsubscribe();\n            utils.next(x);\n        });\n    });\n};\n","import { setUse } from '../state/index.js';\nexport function getSupportInCycle() {\n    return setUse.memory.stateConfig.tagSupport;\n}\n","const tagUse = [];\nexport function setUse(use) {\n    // must provide defaults\n    const useMe = {\n        beforeRender: use.beforeRender || (() => undefined),\n        beforeRedraw: use.beforeRedraw || (() => undefined),\n        afterRender: use.afterRender || (() => undefined),\n        beforeDestroy: use.beforeDestroy || (() => undefined),\n    };\n    setUse.tagUse.push(useMe);\n}\nsetUse.tagUse = tagUse;\nsetUse.memory = {};\n","export class TagError extends Error {\n    details;\n    constructor(message, errorCode, details = {}) {\n        super(message);\n        this.name = TagError.name;\n        this.details = { ...details, errorCode };\n    }\n}\nexport class ArrayNoKeyError extends TagError {\n    constructor(message, details) {\n        super(message, 'array-no-key-error', details);\n        this.name = ArrayNoKeyError.name;\n    }\n}\nexport class StateMismatchError extends TagError {\n    constructor(message, details) {\n        super(message, 'state-mismatch-error', details);\n        this.name = StateMismatchError.name;\n    }\n}\nexport class SyncCallbackError extends TagError {\n    constructor(message, details) {\n        super(message, 'sync-callback-error', details);\n        this.name = SyncCallbackError.name;\n    }\n}\n","import { StateMismatchError } from '../errors.js';\nimport { setUse } from './setUse.function.js';\nsetUse.memory.stateConfig = {\n    array: [], // state memory on the first render\n    // rearray: [] as State,\n};\nconst beforeRender = (tagSupport) => initState(tagSupport);\nsetUse({\n    beforeRender,\n    beforeRedraw: beforeRender,\n    afterRender: (tagSupport) => {\n        const memory = tagSupport.memory;\n        const config = setUse.memory.stateConfig;\n        const rearray = config.rearray;\n        if (rearray.length) {\n            if (rearray.length !== config.array.length) {\n                const message = `States lengths have changed ${rearray.length} !== ${config.array.length}. State tracking requires the same amount of function calls every render. Typically this errors is thrown when a state like function call occurs only for certain conditions or when a function is intended to be wrapped with a tag() call`;\n                const wrapper = tagSupport.templater?.wrapper;\n                const details = {\n                    oldStates: config.array,\n                    newStates: config.rearray,\n                    tagFunction: wrapper.parentWrap.original,\n                };\n                const error = new StateMismatchError(message, details);\n                console.warn(message, details);\n                throw error;\n            }\n        }\n        delete config.rearray; // clean up any previous runs\n        delete config.tagSupport;\n        memory.state.length = 0;\n        memory.state.push(...config.array);\n        const state = memory.state;\n        for (let index = state.length - 1; index >= 0; --index) {\n            const item = state[index];\n            item.lastValue = getStateValue(item); // set last values\n        }\n        config.array = [];\n    }\n});\nexport function getStateValue(state) {\n    const callback = state.callback;\n    if (!callback) {\n        return state.defaultValue;\n    }\n    const [value, checkValue] = getCallbackValue(callback);\n    if (checkValue !== StateEchoBack) {\n        const message = 'letState function incorrectly used. Second item in array is not setting expected value.\\n\\n' +\n            'For \"let\" state use `let name = state(default)(x => [name, name = x])`\\n\\n' +\n            'For \"const\" state use `const name = state(default)()`\\n\\n' +\n            'Problem state:\\n' + (callback ? callback.toString() : JSON.stringify(state)) + '\\n';\n        console.error(message, { state, callback, value, checkValue });\n        throw new Error(message);\n    }\n    return value;\n}\nexport class StateEchoBack {\n}\nfunction initState(tagSupport) {\n    const memory = tagSupport.memory;\n    const state = memory.state;\n    const config = setUse.memory.stateConfig;\n    config.rearray = [];\n    const stateLength = state?.length;\n    if (stateLength) {\n        for (let index = 0; index < stateLength; ++index) {\n            getStateValue(state[index]);\n        }\n        config.rearray.push(...state);\n    }\n    config.tagSupport = tagSupport;\n}\nexport function getCallbackValue(callback) {\n    const oldState = callback(StateEchoBack); // get value and set to undefined\n    const [value] = oldState;\n    const [checkValue] = callback(value); // set back to original value\n    return [value, checkValue];\n}\n","export function syncStates(stateFrom, stateTo) {\n    for (let index = stateFrom.length - 1; index >= 0; --index) {\n        const state = stateFrom[index];\n        const fromValue = state.get();\n        const callback = stateTo[index].callback;\n        if (callback) {\n            callback(fromValue); // set the value\n        }\n        stateTo[index].lastValue = fromValue; // record the value\n    }\n}\n","import { setUse } from './setUse.function.js';\nimport { getStateValue } from './state.utils.js';\nimport { syncStates } from './syncStates.function.js';\n/** Used for variables that need to remain the same variable during render passes */\nexport function state(defaultValue) {\n    const config = setUse.memory.stateConfig;\n    let getSetMethod;\n    const rearray = config.rearray;\n    const restate = rearray[config.array.length];\n    if (restate) {\n        let oldValue = getStateValue(restate);\n        getSetMethod = ((x) => [oldValue, oldValue = x]);\n        const push = {\n            get: () => getStateValue(push),\n            callback: getSetMethod,\n            lastValue: oldValue,\n            defaultValue: restate.defaultValue,\n        };\n        config.array.push(push);\n        return oldValue;\n    }\n    // State first time run\n    const defaultFn = defaultValue instanceof Function ? defaultValue : () => defaultValue;\n    let initValue = defaultFn();\n    // the state is actually intended to be a function\n    if (initValue instanceof Function) {\n        const oldState = config.array;\n        const tagSupport = config.tagSupport;\n        const original = initValue;\n        initValue = ((...args) => {\n            const global = tagSupport.global;\n            const newest = global.newest;\n            const newState = newest.memory.state;\n            syncStates(newState, oldState);\n            const result = original(...args);\n            syncStates(oldState, newState);\n            return result;\n        });\n        initValue.original = original;\n    }\n    getSetMethod = ((x) => [initValue, initValue = x]);\n    const push = {\n        get: () => getStateValue(push),\n        callback: getSetMethod,\n        lastValue: initValue,\n        defaultValue: initValue,\n    };\n    config.array.push(push);\n    return initValue;\n}\n","import { ValueSubject } from '../subject/index.js';\nimport { getSupportInCycle } from '../tag/getSupportInCycle.function.js';\nimport { setUse } from './setUse.function.js';\nimport { state } from './state.function.js';\nimport { syncStates } from './syncStates.function.js';\n/**\n * When an item in watch array changes, callback function will be triggered. Triggers on initial watch setup. TIP: try watch.noInit()\n * @param currentValues T[]\n * @param callback WatchCallback\n * @returns T[]\n */\nexport const watch = ((currentValues, callback) => {\n    return setupWatch(currentValues, callback);\n});\nconst defaultFinally = (x) => x;\nfunction newWatch(setup) {\n    const method = (currentValues, callback) => {\n        return setupWatch(currentValues, callback, setup);\n    };\n    method.setup = setup;\n    defineOnMethod(() => method, method);\n    return method;\n}\n/**\n * puts above functionality together\n * @param currentValues values being watched\n * @param callback (currentValue, previousValues) => resolveToValue\n * @param param2\n * @returns\n */\nconst setupWatch = (currentValues, callback, { init, before = () => true, final = defaultFinally, } = {}) => {\n    let previous = state({\n        pastResult: undefined,\n        values: undefined,\n    });\n    const previousValues = previous.values;\n    // First time running watch?\n    if (previousValues === undefined) {\n        if (!before(currentValues)) {\n            previous.values = currentValues;\n            return previous.pastResult; // do not continue\n        }\n        const castedInit = init || callback;\n        const result = castedInit(currentValues, previousValues);\n        previous.pastResult = final(result);\n        previous.values = currentValues;\n        return previous.pastResult;\n    }\n    const allExact = currentValues.every((item, index) => item === previousValues[index]);\n    if (allExact) {\n        return previous.pastResult;\n    }\n    if (!before(currentValues)) {\n        previous.values = currentValues;\n        return previous.pastResult; // do not continue\n    }\n    const result = callback(currentValues, previousValues);\n    previous.pastResult = final(result);\n    previousValues.length = 0;\n    previousValues.push(...currentValues);\n    return previous.pastResult;\n};\nfunction defineOnMethod(getWatch, attachTo) {\n    Object.defineProperty(attachTo, 'noInit', {\n        get() {\n            const watch = getWatch();\n            watch.setup.init = () => undefined;\n            return watch;\n        },\n    });\n    Object.defineProperty(attachTo, 'asSubject', {\n        get() {\n            const oldWatch = getWatch();\n            const firstSupport = state(() => getSupportInCycle());\n            const subject = state(() => new ValueSubject(undefined));\n            const method = (currentValues, callback) => {\n                setupWatch(currentValues, (currentValues, previousValues) => {\n                    const nowTagSupport = getSupportInCycle();\n                    const setTo = callback(currentValues, previousValues);\n                    if (nowTagSupport !== firstSupport) {\n                        const newestState = setUse.memory.stateConfig.array;\n                        syncStates(newestState, firstSupport.memory.state);\n                    }\n                    subject.next(setTo);\n                }, oldWatch.setup);\n                return subject;\n            };\n            method.setup = oldWatch.setup;\n            defineOnMethod(() => method, method);\n            return method;\n        },\n    });\n    Object.defineProperty(attachTo, 'truthy', {\n        get() {\n            const watch = getWatch();\n            watch.setup.before = (currentValues) => currentValues.every(x => x);\n            return watch;\n        },\n    });\n    return attachTo;\n}\ndefineOnMethod(() => newWatch({}), watch);\n","import { Subject, ValueSubject } from '../subject/index.js';\nimport { getSupportInCycle } from '../tag/getSupportInCycle.function.js';\nimport { setUse } from './setUse.function.js';\nimport { state } from './state.function.js';\nimport { syncStates } from './syncStates.function.js';\n/** Create a Subject that on updates will sync state values to keep chained functions using latest variables */\nexport function subject(value, onSubscription) {\n    const oldestState = state(() => setUse.memory.stateConfig.array);\n    const nowTagSupport = getSupportInCycle();\n    return state(() => {\n        const subject = new Subject(value, onSubscription).pipe(x => {\n            syncStates(nowTagSupport.memory.state, oldestState);\n            return x;\n        });\n        return subject;\n    });\n}\nsubject._value = (value) => {\n    const oldestState = state(() => setUse.memory.stateConfig.array);\n    const nowTagSupport = getSupportInCycle();\n    return state(() => {\n        const subject = new ValueSubject(value).pipe(x => {\n            syncStates(nowTagSupport.memory.state, oldestState);\n            return x;\n        });\n        return subject;\n    });\n};\nfunction all(args) {\n    const oldestState = state(() => setUse.memory.stateConfig.array);\n    const nowTagSupport = getSupportInCycle();\n    return Subject.all(args).pipe(x => {\n        syncStates(nowTagSupport.memory.state, oldestState);\n        return x;\n    });\n}\nsubject.all = all;\n","import { getStateValue } from './state.utils.js';\nimport { setUse } from './setUse.function.js';\n/** Used for variables that need to remain the same variable during render passes. If defaultValue is a function it is called only once, its return value is first state, and let value can changed */\nexport function letState(defaultValue) {\n    const config = setUse.memory.stateConfig;\n    const rearray = config.rearray;\n    let getSetMethod;\n    const restate = rearray[config.array.length];\n    if (restate) {\n        let oldValue = getStateValue(restate);\n        getSetMethod = ((x) => [oldValue, oldValue = x]);\n        const push = {\n            get: () => getStateValue(push),\n            callback: getSetMethod,\n            lastValue: oldValue,\n            defaultValue: restate.defaultValue,\n        };\n        config.array.push(push);\n        return makeStateResult(oldValue, push);\n    }\n    // State first time run\n    const defaultFn = defaultValue instanceof Function ? defaultValue : () => defaultValue;\n    let initValue = defaultFn();\n    getSetMethod = ((x) => [initValue, initValue = x]);\n    const push = {\n        get: () => getStateValue(push),\n        callback: getSetMethod,\n        lastValue: initValue,\n        defaultValue: initValue,\n    };\n    config.array.push(push);\n    return makeStateResult(initValue, push);\n}\nfunction makeStateResult(initValue, push) {\n    // return initValue\n    const result = (y) => {\n        push.callback = y || (x => [initValue, initValue = x]);\n        return initValue;\n    };\n    return result;\n}\n","import { letState } from './letState.function.js';\nimport { watch } from './watch.function.js';\n/**\n * Enables the ability to maintain a change to a props value until the prop itself changes\n * @param prop typically the name of an existing prop\n * @returns immediately call the returned function: letProp(y)(x => [y, y=x])\n */\nexport function letProp(prop) {\n    return getSetProp => {\n        let myProp = letState(prop)(getSetProp);\n        watch([prop], () => getSetProp(myProp = prop));\n        getSetProp(myProp); // always reset to my value and right await so that the old prop value never slips through\n        return myProp;\n    };\n}\n","export function deepClone(obj) {\n    return makeDeepClone(obj, new WeakMap());\n}\nfunction makeDeepClone(obj, visited) {\n    // If obj is a primitive type or null, return it directly\n    if (obj === null || typeof obj !== 'object') {\n        return obj;\n    }\n    // If obj is already visited, return the cloned reference\n    if (visited.has(obj)) {\n        return visited.get(obj);\n    }\n    // Handle special cases like Date and RegExp\n    if (obj instanceof Date) {\n        return new Date(obj);\n    }\n    if (obj instanceof RegExp) {\n        return new RegExp(obj);\n    }\n    // Create an empty object or array with the same prototype\n    const clone = Array.isArray(obj) ? [] : Object.create(Object.getPrototypeOf(obj));\n    // Register the cloned object to avoid cyclic references\n    visited.set(obj, clone);\n    // Clone each property or element of the object or array\n    if (Array.isArray(obj)) {\n        for (let i = 0; i < obj.length; i++) {\n            clone[i] = makeDeepClone(obj[i], visited);\n        }\n    }\n    else {\n        for (const key in obj) {\n            if (obj.hasOwnProperty(key)) {\n                clone[key] = makeDeepClone(obj[key], visited);\n            }\n        }\n    }\n    return clone;\n}\nexport function deepEqual(obj1, obj2) {\n    return isDeepEqual(obj1, obj2, new WeakMap());\n}\nfunction isDeepEqual(obj1, obj2, visited) {\n    const directEqual = obj1 === obj2;\n    if (directEqual || isSameFunctions(obj1, obj2)) {\n        return true;\n    }\n    // If obj is already visited, return the cloned reference\n    if (visited.has(obj1)) {\n        return true;\n    }\n    if (typeof obj1 === 'object' && typeof obj2 === 'object') {\n        // both are dates and were already determined not the same\n        if (obj1 instanceof Date && obj2 instanceof Date) {\n            return obj1.getTime() === obj2.getTime();\n        }\n        // Register the cloned object to avoid cyclic references\n        visited.set(obj1, 0);\n        // Check if obj1 and obj2 are both arrays\n        if (Array.isArray(obj1) && Array.isArray(obj2)) {\n            return isArrayDeepEqual(obj1, obj2, visited);\n        }\n        else if (Array.isArray(obj1) || Array.isArray(obj2)) {\n            // One is an array, and the other is not\n            return false;\n        }\n        return isObjectDeepEqual(obj1, obj2, visited);\n    }\n    return false;\n}\nfunction isObjectDeepEqual(obj1, obj2, visited) {\n    const keys1 = Object.keys(obj1);\n    const keys2 = Object.keys(obj2);\n    if (keys1.length === 0 && keys2.length === 0) {\n        return true;\n    }\n    if (keys1.length !== keys2.length) {\n        return false;\n    }\n    for (const key of keys1) {\n        const keyFound = keys2.includes(key);\n        if (!keyFound || !isDeepEqual(obj1[key], obj2[key], visited)) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction isArrayDeepEqual(obj1, obj2, visited) {\n    if (obj1.length !== obj2.length) {\n        return false;\n    }\n    for (let i = 0; i < obj1.length; i++) {\n        if (!isDeepEqual(obj1[i], obj2[i], visited)) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction isSameFunctions(fn0, fn1) {\n    const bothFunction = fn0 instanceof Function && fn1 instanceof Function;\n    return bothFunction && fn0.toString() === fn1.toString();\n}\n","import { deepClone } from '../deepFunctions.js';\nimport { setUse } from './setUse.function.js';\nimport { state } from './state.function.js';\nexport const providers = {\n    create: (constructMethod) => {\n        const stateDiffMemory = state(() => ({ stateDiff: 0, provider: undefined }));\n        // mimic how many states were called the first time\n        if (stateDiffMemory.stateDiff) {\n            for (let x = stateDiffMemory.stateDiff; x > 0; --x) {\n                state(undefined);\n            }\n            const result = state(undefined);\n            return result;\n        }\n        const result = state(() => {\n            const memory = setUse.memory;\n            const stateConfig = memory.stateConfig;\n            const oldStateCount = stateConfig.array.length;\n            // Providers with provider requirements just need to use providers.create() and providers.inject()\n            const instance = 'prototype' in constructMethod ? new constructMethod() : constructMethod();\n            const tagSupport = stateConfig.tagSupport;\n            const stateDiff = stateConfig.array.length - oldStateCount;\n            const provider = {\n                constructMethod,\n                instance,\n                clone: deepClone(instance),\n                stateDiff,\n                owner: tagSupport,\n                children: [],\n            };\n            stateDiffMemory.provider = provider;\n            tagSupport.global.providers.push(provider);\n            stateDiffMemory.stateDiff = stateDiff;\n            return instance;\n        });\n        const cm = constructMethod;\n        // const compareTo = cm.compareTo = cm.compareTo || cm.toString()\n        const compareTo = cm.compareTo = cm.toString();\n        stateDiffMemory.provider.constructMethod.compareTo = compareTo;\n        return result;\n    },\n    /**\n     * @template T\n     * @param {(new (...args: any[]) => T) | () => T} constructor\n     * @returns {T}\n     */\n    inject: (constructor) => {\n        // find once, return same every time after\n        return state(() => {\n            const memory = setUse.memory;\n            const cm = constructor;\n            const compareTo = cm.compareTo = cm.compareTo || constructor.toString();\n            const tagSupport = memory.stateConfig.tagSupport;\n            const providers = [];\n            let owner = {\n                ownerTagSupport: tagSupport.ownerTagSupport\n            };\n            while (owner.ownerTagSupport) {\n                const ownerProviders = owner.ownerTagSupport.global.providers;\n                const provider = ownerProviders.find(provider => {\n                    providers.push(provider);\n                    const constructorMatch = provider.constructMethod.compareTo === compareTo;\n                    if (constructorMatch) {\n                        return true;\n                    }\n                });\n                if (provider) {\n                    provider.clone = deepClone(provider.instance); // keep a copy of the latest before any change occur\n                    const tagSupport = memory.stateConfig.tagSupport;\n                    tagSupport.global.providers.push(provider);\n                    provider.children.push(tagSupport);\n                    return provider.instance;\n                }\n                owner = owner.ownerTagSupport; // cause reloop checking next parent\n            }\n            const msg = `Could not inject provider: ${constructor.name} ${constructor}`;\n            console.warn(`${msg}. Available providers`, providers);\n            throw new Error(msg);\n        });\n    }\n};\n","export function isLikeTags(tagSupport0, // new\ntagSupport1) {\n    const templater0 = tagSupport0.templater;\n    const templater1 = tagSupport1.templater;\n    const tag0 = templater0?.tag || tagSupport0;\n    const tag1 = templater1.tag;\n    const strings0 = tag0.strings;\n    const strings1 = tagSupport1.strings || tag1.strings;\n    if (strings0.length !== strings1.length) {\n        return false;\n    }\n    const everyStringMatched = strings0.every((string, index) => strings1[index] === string);\n    if (!everyStringMatched) {\n        return false;\n    }\n    const values0 = tagSupport0.values || tag0.values;\n    const values1 = tagSupport1.values || tag1.values;\n    return isLikeValueSets(values0, values1);\n}\nexport function isLikeValueSets(values0, values1) {\n    const valuesLengthsMatch = values0.length === values1.length;\n    if (!valuesLengthsMatch) {\n        return false;\n    }\n    const allVarsMatch = values1.every((value, index) => {\n        const compareTo = values0[index];\n        const isFunctions = value instanceof Function && compareTo instanceof Function;\n        if (isFunctions) {\n            const stringMatch = value.toString() === compareTo.toString();\n            if (stringMatch) {\n                return true;\n            }\n            return false;\n        }\n        return true; // deepEqual(value, compareTo)\n    });\n    if (allVarsMatch) {\n        return true;\n    }\n    return false;\n}\n","import { setUse } from '../state/index.js';\nimport { Subject } from '../subject/index.js';\nimport { getSupportInCycle } from './getSupportInCycle.function.js';\n// Emits event at the end of a tag being rendered. Use tagClosed$.toPromise() to render a tag after a current tag is done rendering\nsetUse.memory.tagClosed$ = new Subject(undefined, subscription => {\n    if (!getSupportInCycle()) {\n        subscription.next(); // we are not currently processing so process now\n    }\n});\n// Life cycle 1\nexport function runBeforeRender(tagSupport, ownerSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].beforeRender(tagSupport, ownerSupport);\n    }\n}\n// Life cycle 2\nexport function runAfterRender(tagSupport, ownerTagSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].afterRender(tagSupport, ownerTagSupport);\n    }\n    setUse.memory.tagClosed$.next(ownerTagSupport);\n}\n// Life cycle 3\nexport function runBeforeRedraw(tagSupport, ownerTagSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].beforeRedraw(tagSupport, ownerTagSupport);\n    }\n}\n// Life cycle 4 - end of life\nexport function runBeforeDestroy(tagSupport, ownerTagSupport) {\n    const tagUse = setUse.tagUse;\n    const length = tagUse.length;\n    for (let index = 0; index < length; ++index) {\n        tagUse[index].beforeDestroy(tagSupport, ownerTagSupport);\n    }\n    tagSupport.global.deleted = true;\n    tagSupport.hasLiveElements = false;\n    // remove me from my parents\n    if (ownerTagSupport) {\n        ownerTagSupport.global.childTags = ownerTagSupport.global.childTags.filter(child => child !== tagSupport.global.oldest);\n        const global = tagSupport.global;\n        global.providers.forEach(provider => provider.children.forEach((child, index) => {\n            if (child.global === global) {\n                provider.children.splice(index, 1);\n            }\n        }));\n    }\n}\n","import { runBeforeRedraw, runBeforeRender } from '../tagRunner.js';\nimport { runAfterRender } from '../tagRunner.js';\nexport function renderTagOnly(newTagSupport, prevSupport, subject, ownerSupport) {\n    const oldRenderCount = newTagSupport.global.renderCount;\n    beforeWithRender(newTagSupport, ownerSupport, prevSupport);\n    const templater = newTagSupport.templater;\n    // NEW TAG CREATED HERE\n    const wrapper = templater.wrapper;\n    let reSupport = wrapper(newTagSupport, subject);\n    /* AFTER */\n    runAfterRender(newTagSupport, ownerSupport);\n    newTagSupport.global.newest = reSupport;\n    if (!prevSupport && ownerSupport) {\n        ownerSupport.global.childTags.push(reSupport);\n    }\n    // When we rendered, only 1 render should have taken place OTHERWISE rendering caused another render and that is the latest instead\n    if (reSupport.global.renderCount > oldRenderCount + 1) {\n        return newTagSupport.global.newest;\n    }\n    return reSupport;\n}\nfunction beforeWithRender(tagSupport, // new\nparentSupport, prevSupport) {\n    const lastOwnerSupport = prevSupport?.ownerTagSupport;\n    const runtimeOwnerSupport = lastOwnerSupport || parentSupport;\n    if (prevSupport) {\n        if (prevSupport !== tagSupport) {\n            const lastState = prevSupport.memory.state;\n            const memory = tagSupport.memory;\n            tagSupport.global = prevSupport.global;\n            memory.state.length = 0;\n            memory.state.push(...lastState);\n        }\n        return runBeforeRedraw(tagSupport, prevSupport);\n    }\n    // first time render\n    return runBeforeRender(tagSupport, runtimeOwnerSupport);\n}\n","import { ValueTypes } from './ValueTypes.enum.js';\nexport const variablePrefix = '__tagvar';\nexport const escapeVariable = '--' + variablePrefix + '--';\nexport const escapeSearch = new RegExp(escapeVariable, 'g');\nexport class Tag {\n    strings;\n    values;\n    tagJsType = ValueTypes.tag;\n    // present only when an array. Populated by Tag.key()\n    memory = {};\n    templater;\n    constructor(strings, values) {\n        this.strings = strings;\n        this.values = values;\n    }\n    /** Used for array, such as array.map(), calls aka array.map(x => html``.key(x)) */\n    key(arrayValue) {\n        this.memory.arrayValue = arrayValue;\n        return this;\n    }\n    children;\n    html(strings, ...values) {\n        this.children = { strings, values };\n        return this;\n    }\n}\n","export function destroyTagMemory(oldTagSupport) {\n    // must destroy oldest which is tag with elements on stage\n    const oldest = oldTagSupport.global.oldest;\n    oldest.destroy();\n    oldTagSupport.global.context = {};\n}\n","// Function to insert element after reference element\nexport function insertAfter(newNode, referenceNode) {\n    const parentNode = referenceNode.parentNode;\n    parentNode.insertBefore(newNode, referenceNode.nextSibling);\n}\n","import { isStaticTag } from '../isInstance.js';\nimport { isLikeTags } from './isLikeTags.function.js';\nimport { destroyTagMemory } from './destroyTag.function.js';\nimport { insertAfter } from '../insertAfter.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nexport function checkDestroyPrevious(subject, // existing.value is the old value\nnewValue, insertBefore, valueType) {\n    const displaySubject = subject;\n    const hasLastValue = 'lastValue' in displaySubject;\n    const lastValue = displaySubject.lastValue; // TODO: we maybe able to use displaySubject.value and remove concept of lastValue\n    // was simple value but now something bigger\n    if (hasLastValue && lastValue !== newValue) {\n        // below is faster than using getValueType\n        const newType = typeof (newValue);\n        if (isSimpleType(newType) && typeof (lastValue) === newType) {\n            return false;\n        }\n        if (newValue instanceof Function && lastValue instanceof Function) {\n            return false;\n        }\n        destroySimpleValue(insertBefore, displaySubject);\n        return 'changed-simple-value';\n    }\n    const arraySubject = subject;\n    const wasArray = arraySubject.lastArray;\n    // no longer an array\n    if (wasArray && valueType !== ValueTypes.tagArray) {\n        const placeholderElm = arraySubject.placeholder;\n        delete arraySubject.lastArray;\n        delete arraySubject.placeholder;\n        insertAfter(insertBefore, placeholderElm);\n        for (let index = wasArray.length - 1; index >= 0; --index) {\n            const { tagSupport } = wasArray[index];\n            destroyArrayTag(tagSupport, { added: 0, removed: 0 });\n        }\n        return 'array';\n    }\n    const tagSubject = subject;\n    const lastSupport = tagSubject.tagSupport;\n    // no longer tag or component?\n    if (lastSupport) {\n        const isValueTag = isStaticTag(newValue);\n        const isSubjectTag = isStaticTag(subject._value);\n        const newTag = newValue;\n        if (isSubjectTag && isValueTag) {\n            // its a different tag now\n            if (!isLikeTags(newTag, lastSupport)) {\n                // put template back down\n                restoreTagMarker(lastSupport);\n                destroyTagMemory(lastSupport);\n                // delete lastSupport.global.deleted // ???\n                return 2;\n            }\n            return false;\n        }\n        if (valueType === ValueTypes.tagComponent) {\n            return false; // its still a tag component\n        }\n        if (newValue && newValue.oneRender) {\n            return false;\n        }\n        // put template back down\n        restoreTagMarker(lastSupport);\n        // destroy old component, value is not a component\n        destroyTagMemory(lastSupport);\n        // delete lastSupport.global.deleted // ???\n        return 'different-tag';\n    }\n    return false;\n}\nexport function isSimpleType(value) {\n    return ['string', 'number', 'boolean'].includes(value);\n}\nexport function destroyArrayTag(tagSupport, counts) {\n    tagSupport.destroy({\n        stagger: counts.removed++,\n    });\n    const insertBefore = tagSupport.global.insertBefore;\n    const parentNode = insertBefore.parentNode;\n    parentNode.removeChild(insertBefore);\n}\nfunction destroySimpleValue(insertBefore, // always a template tag\nsubject) {\n    const clone = subject.clone;\n    const parent = clone.parentNode;\n    // 1 put the template back down\n    parent.insertBefore(insertBefore, clone);\n    parent.removeChild(clone);\n    delete subject.clone;\n    delete subject.lastValue;\n}\nexport function restoreTagMarker(lastSupport) {\n    const insertBefore = lastSupport.global.insertBefore;\n    const global = lastSupport.global;\n    const placeholderElm = global.placeholder;\n    if (placeholderElm) {\n        insertAfter(insertBefore, placeholderElm);\n        delete global.placeholder;\n    }\n}\n","import { isSimpleType } from './checkDestroyPrevious.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nimport { isSubjectInstance, isTagArray } from '../isInstance.js';\nexport function getValueType(value) {\n    if (value === undefined || value === null) {\n        return ValueTypes.undefined;\n    }\n    const type = typeof (value);\n    if (value instanceof Function) {\n        return ValueTypes.function;\n    }\n    if (type === 'object') {\n        if (value instanceof Date) {\n            return ValueTypes.date;\n        }\n        if (isSimpleType(type)) {\n            return type;\n        }\n        const tagJsType = value.tagJsType;\n        if (tagJsType) {\n            const included = [\n                ValueTypes.tagComponent,\n                ValueTypes.templater,\n                ValueTypes.tag,\n            ].includes(tagJsType);\n            if (included) {\n                return tagJsType;\n            }\n        }\n        if (isTagArray(value)) {\n            return ValueTypes.tagArray;\n        }\n        if (isSubjectInstance(value)) {\n            return ValueTypes.subject;\n        }\n    }\n    return ValueTypes.unknown;\n}\n","import { deepClone } from '../deepFunctions.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nimport { getValueType } from './getValueType.function.js';\nexport function cloneValueArray(values) {\n    return values.map((value) => {\n        const tag = value;\n        switch (getValueType(value)) {\n            case ValueTypes.tagComponent:\n                const tagComponent = value;\n                return deepClone(tagComponent.props);\n            case ValueTypes.tag:\n            case ValueTypes.templater:\n                return cloneValueArray(tag.values);\n            case ValueTypes.tagArray:\n                return cloneValueArray(tag);\n        }\n        return deepClone(value);\n    });\n}\n","export function getChildTagsToDestroy(childTags, allTags = []) {\n    for (let index = childTags.length - 1; index >= 0; --index) {\n        const cTag = childTags[index];\n        allTags.push(cTag);\n        childTags.splice(index, 1);\n        getChildTagsToDestroy(cTag.global.childTags, allTags);\n    }\n    return allTags;\n}\n","import { Tag } from './Tag.class.js';\nimport { ValueSubject } from '../subject/index.js';\nimport { kidsToTagArraySubject } from './kidsToTagArraySubject.function.js';\nexport class TemplaterResult {\n    props;\n    tagJsType = 'templater';\n    tagged;\n    wrapper;\n    madeChildIntoSubject;\n    tag;\n    children = new ValueSubject([]);\n    arrayValue; // used for tag components used in arrays\n    constructor(props) {\n        this.props = props;\n    }\n    key(arrayValue) {\n        this.arrayValue = arrayValue;\n        return this;\n    }\n    html(strings, ...values) {\n        const children = new Tag(strings, values);\n        const childSubject = kidsToTagArraySubject(children, this);\n        this.children = childSubject;\n        return this;\n    }\n}\n","import { isSubjectInstance, isTagArray } from '../isInstance.js';\nimport { ValueSubject } from '../subject/ValueSubject.js';\nexport function kidsToTagArraySubject(children, templaterResult) {\n    if (isSubjectInstance(children)) {\n        return children;\n    }\n    const kidArray = children;\n    if (isTagArray(kidArray)) {\n        templaterResult.madeChildIntoSubject = true; // was converted into a subject\n        return new ValueSubject(children);\n    }\n    const kid = children;\n    if (kid) {\n        templaterResult.madeChildIntoSubject = true; // was converted into a subject\n        kid.memory.arrayValue = 0;\n        return new ValueSubject([kid]);\n    }\n    templaterResult.madeChildIntoSubject = true; // was converted into a subject\n    return new ValueSubject([]);\n}\n","import { ValueSubject } from '../../subject/ValueSubject.js';\nimport { TemplaterResult } from '../TemplaterResult.class.js';\nimport { TagSupport } from '../TagSupport.class.js';\nimport { ValueTypes } from '../ValueTypes.enum.js';\nimport { getValueType } from '../getValueType.function.js';\nexport function processNewValue(value, ownerSupport) {\n    const valueType = getValueType(value);\n    switch (valueType) {\n        case ValueTypes.tagComponent:\n            const tagSubject = new ValueSubject(value);\n            return tagSubject;\n        case ValueTypes.templater:\n            const templater = value;\n            const tag = templater.tag;\n            return processNewTag(tag, ownerSupport);\n        case ValueTypes.tag:\n            return processNewTag(value, ownerSupport);\n        case ValueTypes.subject:\n            return value;\n    }\n    return new ValueSubject(value);\n}\nfunction processNewTag(value, ownerSupport) {\n    const tag = value;\n    let templater = tag.templater;\n    if (!templater) {\n        templater = new TemplaterResult([]);\n        templater.tag = tag;\n        tag.templater = templater;\n    }\n    const subject = new ValueSubject(templater);\n    subject.tagSupport = new TagSupport(templater, ownerSupport, subject);\n    ownerSupport.global.childTags.push(subject.tagSupport);\n    return subject;\n}\n","export function setTagPlaceholder(global) {\n    const insertBefore = global.insertBefore;\n    return global.placeholder = swapInsertBefore(insertBefore);\n}\nexport function swapInsertBefore(insertBefore) {\n    const placeholder = document.createTextNode('');\n    const parentNode = insertBefore.parentNode;\n    parentNode.insertBefore(placeholder, insertBefore);\n    parentNode.removeChild(insertBefore);\n    return placeholder;\n}\n","export function specialAttribute(name, value, element) {\n    const names = name.split('.');\n    // style.position = \"absolute\"\n    if (names[0] === 'style') {\n        element.style[names[1]] = value;\n    }\n    // Example: class.width-full = \"true\"\n    if (names[0] === 'class') {\n        names.shift();\n        if (value) {\n            for (let index = 0; index < names.length; ++index) {\n                element.classList.add(names[index]);\n            }\n        }\n        else {\n            for (let index = 0; index < names.length; ++index) {\n                element.classList.remove(names[index]);\n            }\n        }\n    }\n}\n","import { deepEqual } from '../deepFunctions.js';\n/**\n *\n * @param props\n * @param pastCloneProps\n * @returns WHEN number then props have changed. WHEN false props have not changed\n */\nexport function hasPropChanges(props, // natural props\npastCloneProps) {\n    /*\n    const isCommonEqual = props === undefined && props === compareToProps\n    if(isCommonEqual) {\n      return false\n    }\n    */\n    let castedProps = props;\n    let castedPastProps = pastCloneProps;\n    // check all prop functions match\n    if (typeof (props) === 'object') {\n        if (!pastCloneProps) {\n            return 3;\n        }\n        // castedProps = {...props}\n        castedProps = [...props];\n        // castedPastProps = {...(pastCloneProps || {})}\n        castedPastProps = [...(pastCloneProps || [])];\n        const allFunctionsMatch = castedProps.every((value, index) => {\n            let compare = castedPastProps[index];\n            if (value && typeof (value) === 'object') {\n                const subCastedProps = { ...value };\n                const subCompareProps = { ...compare || {} };\n                const matched = Object.entries(subCastedProps).every(([key, value]) => {\n                    return compareProps(value, subCompareProps[key], () => {\n                        delete subCastedProps[key]; // its a function and not needed to be compared\n                        delete subCompareProps[key]; // its a function and not needed to be compared\n                    });\n                });\n                return matched;\n            }\n            return compareProps(value, compare, () => {\n                castedProps.splice(index, 1);\n                castedPastProps.splice(index, 1);\n            });\n        });\n        if (!allFunctionsMatch) {\n            return 6; // a change has been detected by function comparisons\n        }\n    }\n    // const isEqual = deepEqual(castedPastProps, castedProps)\n    // return isEqual ? false : 7 // if equal then no changes\n    return false;\n}\n/** returning a number means true good comparison */\nfunction compareProps(value, compare, onDelete) {\n    if (!(value instanceof Function)) {\n        return deepEqual(value, compare) ? 4 : false;\n    }\n    const compareFn = compare;\n    if (!(compareFn instanceof Function)) {\n        return false; // its a function now but was not before\n    }\n    // ensure we are comparing apples to apples as function get wrapped\n    const compareOriginal = compare?.original;\n    if (compareOriginal) {\n        compare = compareOriginal;\n    }\n    const original = value.original;\n    if (original) {\n        value = value.original;\n    }\n    const valueString = value.toString();\n    const compareString = compare.toString();\n    if (valueString === compareString) {\n        onDelete();\n        return 3; // both are function the same\n    }\n    onDelete();\n    return 5;\n}\n","/** checks if previous support exists on subject or as a last global support. If first render, calls builder. Otherwise calls tagSupport.updateBy() */\nexport function processTagResult(tagSupport, subject, // used for recording past and current value\ninsertBefore, // <template end interpolate />\n{ counts, }) {\n    // *if appears we already have seen\n    const subjectTag = subject;\n    const lastSupport = subjectTag.tagSupport;\n    const prevSupport = lastSupport?.global.oldest || undefined;\n    const justUpdate = prevSupport;\n    if (prevSupport && justUpdate) {\n        return processTagResultUpdate(tagSupport, subjectTag, prevSupport);\n    }\n    tagSupport.buildBeforeElement(insertBefore, {\n        counts,\n    });\n    return tagSupport;\n}\nfunction processTagResultUpdate(tagSupport, subject, // used for recording past and current value\nprevSupport) {\n    // components\n    if (subject instanceof Function) {\n        const newSupport = subject(prevSupport);\n        prevSupport.updateBy(newSupport);\n        subject.tagSupport = newSupport;\n        return newSupport;\n    }\n    prevSupport.updateBy(tagSupport);\n    subject.tagSupport = tagSupport;\n    return tagSupport;\n}\n","import { processTagResult } from './processTagResult.function.js';\nimport { TagSupport } from '../TagSupport.class.js';\nimport { renderSubjectComponent } from '../render/renderSubjectComponent.function.js';\n/** create new support, connects globals to old support if one, and  */\nexport function processSubjectComponent(templater, subject, insertBefore, ownerSupport, options) {\n    // Check if function component is wrapped in a tag() call\n    // TODO: This below check not needed in production mode\n    if (templater.tagged !== true) {\n        const wrapper = templater.wrapper;\n        const original = wrapper.parentWrap.original;\n        let name = original.name || original.constructor?.name;\n        if (name === 'Function') {\n            name = undefined;\n        }\n        const label = name || original.toString().substring(0, 120);\n        const error = new Error(`Not a tag component. Wrap your function with tag(). Example tag(props => html\\`\\`) on component:\\n\\n${label}\\n\\n`);\n        throw error;\n    }\n    const tagSupport = new TagSupport(templater, ownerSupport, subject);\n    let reSupport = subject.tagSupport;\n    const global = tagSupport.global = reSupport?.global || tagSupport.global;\n    global.insertBefore = insertBefore;\n    const isRender = !reSupport;\n    if (isRender) {\n        const support = reSupport || tagSupport;\n        reSupport = renderSubjectComponent(subject, support, ownerSupport);\n    }\n    const newSupport = processTagResult(reSupport, subject, // The element set here will be removed from document. Also result.tag will be added in here\n    insertBefore, // <template end interpolate /> (will be removed)\n    options);\n    // subject.tagSupport = newSupport\n    ownerSupport.global.childTags.push(newSupport);\n    return reSupport;\n}\n","import { renderWithSupport } from './renderWithSupport.function.js';\nexport function renderSubjectComponent(subject, reSupport, ownerSupport) {\n    const preClones = ownerSupport.clones.map(clone => clone);\n    reSupport = renderWithSupport(reSupport, subject.tagSupport, // existing tag\n    subject, ownerSupport);\n    if (ownerSupport.clones.length > preClones.length) {\n        const myClones = ownerSupport.clones.filter(fClone => !preClones.find(clone => clone === fClone));\n        reSupport.clones.push(...myClones);\n    }\n    return reSupport;\n}\n","import { deepClone, deepEqual } from './deepFunctions.js';\nimport { isStaticTag } from './isInstance.js';\nimport { renderTagSupport } from './tag/render/renderTagSupport.function.js';\nimport { setUse } from './state/index.js';\nimport { getSupportInCycle } from './tag/getSupportInCycle.function.js';\nexport function castProps(props, newTagSupport, stateArray) {\n    return props.map(prop => alterProp(prop, newTagSupport.ownerTagSupport, stateArray, newTagSupport));\n}\n/* Used to rewrite props that are functions. When they are called it should cause parent rendering */\nexport function alterProp(prop, ownerSupport, stateArray, newTagSupport) {\n    if (isStaticTag(prop) || !prop) {\n        return prop;\n    }\n    if (!ownerSupport) {\n        return prop; // no one above me\n    }\n    return checkProp(prop, ownerSupport, stateArray, newTagSupport);\n}\nexport function checkProp(value, ownerSupport, stateArray, newTagSupport, index, newProp, seen = []) {\n    if (value instanceof Function) {\n        return getPropWrap(value, ownerSupport, stateArray, newTagSupport, index, newProp);\n    }\n    if (seen.includes(value)) {\n        return value;\n    }\n    seen.push(value);\n    if (typeof (value) !== 'object' || !value) {\n        return value; // no children to crawl through\n    }\n    if (value instanceof Array) {\n        for (let index = value.length - 1; index >= 0; --index) {\n            const subValue = value[index];\n            value[index] = checkProp(subValue, ownerSupport, stateArray, newTagSupport, index, value, seen);\n            if (subValue instanceof Function) {\n                if (subValue.toCall) {\n                    continue;\n                }\n                afterCheckProp(index, subValue, value, newTagSupport);\n            }\n        }\n        return value;\n    }\n    for (const name in value) {\n        const subValue = value[name];\n        const result = checkProp(subValue, ownerSupport, stateArray, newTagSupport, name, value, seen);\n        const hasSetter = Object.getOwnPropertyDescriptor(value, name)?.set;\n        if (hasSetter) {\n            continue;\n        }\n        value[name] = result;\n        if (result instanceof Function) {\n            if (subValue.toCall) {\n                continue;\n            }\n            afterCheckProp(name, subValue, value, newTagSupport);\n        }\n    }\n    return value;\n}\nfunction afterCheckProp(index, pastValue, newProp, newTagSupport) {\n    if (pastValue?.toCall) {\n        return; // already been done\n    }\n    // restore object to have original function on destroy\n    newTagSupport.global.destroy$.toCallback(() => newProp[index] = pastValue);\n}\nexport function getPropWrap(value, ownerSupport, stateArray, newTagSupport, name, newProp) {\n    const toCall = value.toCall;\n    // already previously converted by a parent?\n    if (toCall) {\n        return value;\n    }\n    const wrap = (...args) => wrap.toCall(...args); // what gets called can switch over parent state changes\n    // Currently, call self but over parent state changes, I may need to call a newer parent tag owner\n    wrap.toCall = (...args) => {\n        return callbackPropOwner(wrap.prop, args, ownerSupport, wrap.stateArray);\n    };\n    wrap.original = value;\n    wrap.prop = value;\n    wrap.stateArray = stateArray;\n    // copy data properties that maybe on source function\n    Object.assign(wrap, value);\n    return wrap;\n}\n/** Function shared by alterProps() and updateExistingTagComponent... TODO: May want to have to functions to reduce cycle checking?  */\nexport function callbackPropOwner(toCall, callWith, ownerSupport, // <-- WHEN called from alterProp its owner OTHERWISE its previous\noldState) {\n    const newest = ownerSupport.global.newest;\n    //const newState = newest.memory.state\n    const noCycle = getSupportInCycle() === undefined;\n    //const sync = noCycle && oldState.length === newState.length\n    //if(sync) {\n    //  syncStates(newState, oldState)\n    //}\n    const result = toCall(...callWith);\n    // if(sync) {\n    //   syncStates(oldState, newState)\n    // }\n    const run = () => {\n        // are we in a rendering cycle? then its being called by alterProps\n        if (noCycle === false) {\n            // appears a prop function was called sync/immediately so lets see if owner changed state\n            const allMatched = newest.memory.state.every(state => {\n                const lastValue = state.lastValue;\n                const get = state.get();\n                const equal = deepEqual(deepClone(lastValue), get);\n                return equal;\n            });\n            if (allMatched) {\n                return result; // owner did not change\n            }\n        }\n        renderTagSupport(newest, true);\n        return result;\n    };\n    if (noCycle) {\n        return run();\n    }\n    setUse.memory.tagClosed$.toCallback(run);\n    return result;\n}\n","import { hasTagSupportChanged } from '../hasTagSupportChanged.function.js';\nimport { processSubjectComponent } from './processSubjectComponent.function.js';\nimport { destroyTagMemory } from '../destroyTag.function.js';\nimport { renderTagSupport } from '../render/renderTagSupport.function.js';\nimport { castProps } from '../../alterProp.function.js';\nimport { isLikeTags } from '../isLikeTags.function.js';\nexport function updateExistingTagComponent(ownerSupport, tagSupport, // lastest\nsubject, insertBefore, renderUp = false) {\n    let lastSupport = subject.tagSupport?.global.newest;\n    const oldWrapper = lastSupport.templater.wrapper;\n    const newWrapper = tagSupport.templater.wrapper;\n    let isSameTag = false;\n    if (oldWrapper && newWrapper) {\n        const oldFunction = oldWrapper.parentWrap.original;\n        const newFunction = newWrapper.parentWrap.original;\n        // string compare both functions\n        isSameTag = oldFunction === newFunction;\n    }\n    const templater = tagSupport.templater;\n    if (!isSameTag) {\n        const oldestSupport = lastSupport.global.oldest;\n        destroyTagMemory(oldestSupport);\n        const newSupport = processSubjectComponent(templater, subject, insertBefore, ownerSupport, {\n            counts: { added: 0, removed: 0 },\n        });\n        return newSupport;\n    }\n    else {\n        const hasChanged = hasTagSupportChanged(lastSupport, tagSupport, templater);\n        // everyhing has matched, no display needs updating.\n        if (!hasChanged) {\n            const newProps = templater.props;\n            // update function refs to use latest references\n            const castedProps = syncFunctionProps(tagSupport, lastSupport, ownerSupport, newProps);\n            // When new tagSupport actually makes call to real function, use these pre casted props\n            tagSupport.propsConfig.castProps = castedProps;\n            // update support to think it has different cloned props\n            lastSupport.propsConfig.latestCloned = tagSupport.propsConfig.latestCloned;\n            lastSupport.propsConfig.lastClonedKidValues = tagSupport.propsConfig.lastClonedKidValues;\n            return lastSupport; // its the same tag component\n        }\n    }\n    const oldest = lastSupport.global.oldest;\n    if (tagSupport.global.locked) {\n        tagSupport.global.blocked.push(tagSupport);\n        return tagSupport;\n    }\n    const previous = lastSupport.global.newest;\n    const newSupport = renderTagSupport(tagSupport, renderUp);\n    return afterTagRender(subject, oldest, templater, previous, newSupport, isSameTag);\n}\nfunction afterTagRender(subject, oldest, templater, previous, newSupport, isSameTag) {\n    let lastSupport = subject.tagSupport;\n    // const oldest = newSupport.global.oldest\n    /*\n    const hasOldest = oldest ? true : false\n    if(!hasOldest) {\n      return buildNewTag(\n        newSupport,\n        insertBefore,\n        lastSupport,\n        subject\n      )\n    }\n    */\n    if (oldest && templater.children._value.length) {\n        const oldKidsSub = oldest.templater.children;\n        oldKidsSub.next(templater.children._value);\n    }\n    // detect if both the function is the same and the return is the same\n    const isLikeTag = isSameTag && isLikeTags(previous, newSupport);\n    if (isLikeTag) {\n        const oldestTag = lastSupport.global.oldest;\n        subject.tagSupport = newSupport;\n        oldestTag.updateBy(newSupport);\n        return newSupport;\n    }\n    // Although function looked the same it returned a different html result\n    if (isSameTag && lastSupport) {\n        if (!previous.global.deleted) {\n            destroyTagMemory(previous);\n        }\n        /*\n        const insertBefore = (previous.global.insertBefore as any)\n        if(insertBefore.parentNode) {\n          insertBefore.parentNode.removeChild(insertBefore)\n        }\n        */\n        newSupport.global.context = {}; // do not share previous outputs\n        // delete newSupport.global.deleted\n    }\n    return buildNewTag(newSupport, newSupport.global.insertBefore, newSupport, subject);\n}\nfunction buildNewTag(newSupport, oldInsertBefore, oldTagSupport, subject) {\n    newSupport.buildBeforeElement(oldInsertBefore, {\n        counts: { added: 0, removed: 0 },\n    });\n    newSupport.global.oldest = newSupport;\n    newSupport.global.newest = newSupport;\n    oldTagSupport.global.oldest = newSupport;\n    oldTagSupport.global.newest = newSupport;\n    subject.tagSupport = newSupport;\n    subject.tagSupport.ownerTagSupport.global.childTags.push(newSupport);\n    return newSupport;\n}\nfunction syncFunctionProps(newSupport, lastSupport, ownerSupport, newPropsArray) {\n    const newest = lastSupport.global.newest;\n    if (!newest) {\n        // const state = ownerSupport.global.oldest.memory.state\n        const state = ownerSupport.memory.state;\n        newPropsArray.length = 0;\n        const castedProps = castProps(newPropsArray, newSupport, state);\n        newPropsArray.push(...castedProps);\n        newSupport.propsConfig.castProps = castedProps;\n        return newPropsArray;\n    }\n    lastSupport = newest || lastSupport;\n    const priorPropConfig = lastSupport.propsConfig;\n    const priorPropsArray = priorPropConfig.castProps;\n    const newArray = [];\n    for (let index = newPropsArray.length - 1; index >= 0; --index) {\n        const prop = newPropsArray[index];\n        const priorProp = priorPropsArray[index];\n        const newValue = syncPriorPropFunction(priorProp, prop, newSupport, ownerSupport);\n        newArray.push(newValue);\n    }\n    newSupport.propsConfig.castProps = newArray;\n    return newArray;\n}\nfunction syncPriorPropFunction(priorProp, prop, newSupport, ownerSupport, seen = []) {\n    if (priorProp instanceof Function) {\n        // the prop i am receiving, is already being monitored/controlled by another parent\n        if (prop.toCall) {\n            priorProp.toCall = prop.toCall;\n            return prop;\n        }\n        const ownerGlobal = ownerSupport.global;\n        const oldOwnerState = ownerGlobal.newest.memory.state;\n        priorProp.prop = prop;\n        priorProp.stateArray = oldOwnerState;\n        return priorProp;\n    }\n    // prevent infinite recursion\n    if (seen.includes(prop)) {\n        return prop;\n    }\n    seen.push(prop);\n    if (typeof (prop) !== 'object' || !prop) {\n        return prop; // no children to crawl through\n    }\n    if (prop instanceof Array) {\n        for (let index = prop.length - 1; index >= 0; --index) {\n            const x = prop[index];\n            prop[index] = syncPriorPropFunction(priorProp[index], x, newSupport, ownerSupport, seen);\n        }\n        return prop;\n    }\n    if (priorProp === undefined) {\n        return prop;\n    }\n    for (const name in prop) {\n        const subValue = prop[name];\n        const result = syncPriorPropFunction(priorProp[name], subValue, newSupport, ownerSupport, seen);\n        const hasSetter = Object.getOwnPropertyDescriptor(prop, name)?.set;\n        if (hasSetter) {\n            continue;\n        }\n        prop[name] = result;\n    }\n    return prop;\n}\nexport function moveProviders(lastSupport, newSupport) {\n    const destroy$ = lastSupport.global.destroy$;\n    lastSupport.global.providers.forEach(provider => {\n        provider.children.forEach((child, index) => {\n            const wasSameGlobals = lastSupport.global.destroy$ === child.global.destroy$;\n            if (wasSameGlobals) {\n                provider.children.splice(index, 1);\n                provider.children.push(newSupport);\n                return;\n            }\n        });\n    });\n}\n","import { hasPropChanges } from './hasPropChanges.function.js';\nexport function hasTagSupportChanged(lastSupport, newTagSupport, newTemplater) {\n    const latestProps = newTemplater.props; // newTagSupport.propsConfig.latest\n    const pastCloneProps = lastSupport.propsConfig.latestCloned;\n    const propsChanged = hasPropChanges(latestProps, pastCloneProps);\n    // const propsChanged = hasPropChanges(lastSupport.templater.props, newTagSupport.templater.props)\n    // const propsChanged = hasPropChanges(lastSupport.propsConfig.latestCloned, newTagSupport.propsConfig.latestCloned)\n    // if no changes detected, no need to continue to rendering further tags\n    if (propsChanged) {\n        return propsChanged;\n    }\n    const propsChanged2 = hasPropChanges(lastSupport.propsConfig.latestCloned, newTagSupport.propsConfig.latestCloned);\n    if (propsChanged2) {\n        return propsChanged2;\n    }\n    const kidsChanged = hasKidsChanged(lastSupport, newTagSupport);\n    // we already know props didn't change and if kids didn't either, than don't render\n    return kidsChanged;\n}\nexport function hasKidsChanged(oldTagSupport, newTagSupport) {\n    const oldCloneKidValues = oldTagSupport.propsConfig.lastClonedKidValues;\n    const newClonedKidValues = newTagSupport.propsConfig.lastClonedKidValues;\n    const everySame = oldCloneKidValues.every((set, index) => {\n        const x = newClonedKidValues[index];\n        return set.every((item, index) => item === x[index]);\n    });\n    return everySame ? false : 9;\n}\n","/** File largely responsible for reacting to element events, such as onclick */\nimport { setUse } from '../state/setUse.function.js';\nimport { ValueTypes } from '../tag/ValueTypes.enum.js';\nimport { renderTagSupport } from '../tag/render/renderTagSupport.function.js';\nimport { updateExistingTagComponent } from '../tag/update/updateExistingTagComponent.function.js';\nconst useLocks = true;\nexport function bindSubjectCallback(value, tagSupport) {\n    // Is this children? No override needed\n    if (value.isChildOverride) {\n        return value;\n    }\n    const state = setUse.memory.stateConfig;\n    const subjectFunction = (element, args) => runTagCallback(value, tagSupport, element, args);\n    // link back to original. Mostly used for <div oninit ondestroy> animations\n    subjectFunction.tagFunction = value;\n    return subjectFunction;\n}\nexport function runTagCallback(value, tagSupport, bindTo, args) {\n    const tag = findTagToCallback(tagSupport);\n    const method = value.bind(bindTo);\n    tag.global.locked = useLocks; // prevent another render from re-rendering this tag\n    const callbackResult = method(...args);\n    return afterTagCallback(tag, callbackResult);\n}\nfunction afterTagCallback(tag, callbackResult) {\n    delete tag.global.locked;\n    if (tag.global.blocked.length) {\n        let lastResult;\n        tag.global.blocked.forEach(blocked => {\n            const block = blocked;\n            lastResult = updateExistingTagComponent(block.ownerTagSupport, block, block.subject, block.global.insertBefore, true);\n            tag.global.newest = lastResult;\n            tag.global.blocked.splice(0, 1);\n        });\n        tag.global.blocked.length = 0;\n        // return lastResult\n        return checkAfterCallbackPromise(callbackResult, lastResult, lastResult.global);\n    }\n    const result = renderCallbackSupport(tag.global.newest, callbackResult, tag.global);\n    return result;\n}\nfunction findTagToCallback(tagSupport) {\n    // If we are NOT a component than we need to render my owner instead\n    if (tagSupport.templater.tagJsType === ValueTypes.templater) {\n        const owner = tagSupport.ownerTagSupport;\n        return findTagToCallback(owner);\n    }\n    return tagSupport;\n}\nfunction renderCallbackSupport(last, callbackResult, global) {\n    if (global.deleted) {\n        return 'no-data-ever'; // || last.global.deleted\n    }\n    renderTagSupport(last, true);\n    return checkAfterCallbackPromise(callbackResult, last, global);\n}\nfunction checkAfterCallbackPromise(callbackResult, last, global) {\n    if (callbackResult instanceof Promise) {\n        last.global.locked = useLocks;\n        return callbackResult.then(() => {\n            delete last.global.locked;\n            if (global.deleted) {\n                return 'promise-no-data-ever'; // tag was deleted during event processing\n            }\n            delete last.global.locked;\n            renderTagSupport(global.newest, true);\n            return 'promise-no-data-ever';\n        });\n    }\n    return 'no-data-ever';\n}\n","import { specialAttribute } from './specialAttribute.js';\nimport { isSubjectInstance } from '../isInstance.js';\nimport { bindSubjectCallback } from './bindSubjectCallback.function.js';\nconst startRegX = /^\\s*{__tagvar/;\nconst endRegX = /}\\s*$/;\nfunction isTagVar(value) {\n    return value && value.search(startRegX) >= 0 && value.search(endRegX) >= 0;\n}\nexport function processAttribute(attrName, value, // current attribute value by using .getAttribute\nchild, scope, ownerSupport, howToSet) {\n    if (isTagVar(value)) {\n        return processScopedNameValueAttr(attrName, value, child, scope, ownerSupport, howToSet);\n    }\n    if (isTagVar(attrName)) {\n        const contextValueSubject = getContextValueByVarString(scope, attrName);\n        let lastValue;\n        // the above callback gets called immediately since its a ValueSubject()\n        const sub = contextValueSubject.subscribe((value) => {\n            if (value === lastValue) {\n                return; // value did not change\n            }\n            processNameOnlyAttr(value, lastValue, child, ownerSupport, howToSet);\n            lastValue = value;\n        });\n        ownerSupport.global.subscriptions.push(sub); // this is where unsubscribe is picked up\n        child.removeAttribute(attrName);\n        return;\n    }\n    // Non dynamic\n    const isSpecial = isSpecialAttr(attrName);\n    if (isSpecial) {\n        return specialAttribute(attrName, value, child);\n    }\n}\nfunction processScopedNameValueAttr(attrName, value, // {__tagVarN}\nchild, scope, ownerSupport, howToSet) {\n    // get the code inside the brackets like \"variable0\" or \"{variable0}\"\n    const result = getContextValueByVarString(scope, value);\n    return processNameValueAttr(attrName, result, child, ownerSupport, howToSet);\n}\nfunction getContextValueByVarString(scope, value) {\n    const code = value.replace('{', '').split('').reverse().join('').replace('}', '').split('').reverse().join('');\n    return scope[code];\n}\nfunction processNameOnlyAttr(attrValue, lastValue, child, ownerSupport, howToSet) {\n    if (lastValue && lastValue != attrValue) {\n        if (typeof (lastValue) === 'string') {\n            child.removeAttribute(lastValue);\n        }\n        else if (lastValue instanceof Object) {\n            for (const name in lastValue) {\n                child.removeAttribute(name);\n            }\n        }\n    }\n    if (typeof (attrValue) === 'string') {\n        if (!attrValue.length) {\n            return;\n        }\n        processNameValueAttr(attrValue, '', child, ownerSupport, howToSet);\n        return;\n    }\n    if (attrValue instanceof Object) {\n        for (const name in attrValue) {\n            processNameValueAttr(name, attrValue[name], child, ownerSupport, howToSet);\n        }\n    }\n}\nfunction processNameValueAttr(attrName, result, child, ownerSupport, howToSet) {\n    const isSpecial = isSpecialAttr(attrName);\n    if (result instanceof Function) {\n        const action = function (...args) {\n            const result2 = result(child, args);\n            return result2;\n        };\n        child[attrName].action = action;\n    }\n    // Most every variable comes in here since everything is made a ValueSubject\n    if (isSubjectInstance(result)) {\n        child.removeAttribute(attrName);\n        let lastValue;\n        const callback = (newAttrValue) => {\n            // should the function be wrapped so every time its called we re-render?\n            if (newAttrValue instanceof Function) {\n                return callbackFun(ownerSupport, newAttrValue, child, attrName, isSpecial, howToSet);\n            }\n            // TODO: we maybe able to block higher before instance of check\n            if (lastValue === newAttrValue) {\n                return lastValue;\n            }\n            lastValue = newAttrValue;\n            return processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet);\n        };\n        // 🗞️ Subscribe. Above callback called immediately since its a ValueSubject()\n        const sub = result.subscribe(callback);\n        // Record subscription for later unsubscribe when element destroyed\n        ownerSupport.global.subscriptions.push(sub);\n        return;\n    }\n    howToSet(child, attrName, result);\n    // child.setAttribute(attrName, result.value)\n    return;\n}\nfunction processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet) {\n    if (newAttrValue instanceof Function) {\n        const fun = function (...args) {\n            return newAttrValue(child, args);\n        };\n        // access to original function\n        fun.tagFunction = newAttrValue;\n        if (attrName === 'ondoubleclick') {\n            attrName = 'ondblclick';\n        }\n        ;\n        child[attrName] = fun;\n        return;\n    }\n    if (isSpecial) {\n        specialAttribute(attrName, newAttrValue, child);\n        return;\n    }\n    if (newAttrValue) {\n        howToSet(child, attrName, newAttrValue);\n        return;\n    }\n    const isDeadValue = [undefined, false, null].includes(newAttrValue);\n    if (isDeadValue) {\n        child.removeAttribute(attrName);\n        return;\n    }\n    // value is 0\n    howToSet(child, attrName, newAttrValue);\n}\n/** Looking for (class | style) followed by a period */\nfunction isSpecialAttr(attrName) {\n    return attrName.search(/^(class|style)(\\.)/) >= 0;\n}\nfunction callbackFun(ownerSupport, newAttrValue, child, attrName, isSpecial, howToSet) {\n    const wrapper = ownerSupport.templater.wrapper;\n    const parentWrap = wrapper?.parentWrap;\n    const oneRender = parentWrap?.oneRender;\n    if (!oneRender) {\n        newAttrValue = bindSubjectCallback(newAttrValue, ownerSupport);\n    }\n    return processAttributeSubjectValue(newAttrValue, child, attrName, isSpecial, howToSet);\n}\n","import { processAttribute } from './processAttribute.function.js';\nfunction howToSetAttribute(element, name, value) {\n    element.setAttribute(name, value);\n}\nfunction howToSetInputValue(element, name, value) {\n    element[name] = value;\n}\nexport function interpolateAttributes(child, scope, ownerSupport) {\n    const attrNames = child.getAttributeNames();\n    let howToSet = howToSetAttribute;\n    for (let index = 0; index < attrNames.length; ++index) {\n        const attrName = attrNames[index];\n        if (child.nodeName === 'INPUT' && attrName === 'value') {\n            howToSet = howToSetInputValue;\n        }\n        const value = child.getAttribute(attrName);\n        processAttribute(attrName, value, child, scope, ownerSupport, howToSet);\n        howToSet = howToSetAttribute; // put back\n    }\n}\n","// support arrow functions in attributes\nexport const interpolateReplace = /(?:<[^>]*?(?:(?:\\s+\\w+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^>\\s]+)))*\\s*)\\/?>)|({__tagvar[^}]+})/g;\n/** replaces ${x} with <template id=\"x-start\"></template><template id=\"x-end\"></template> */\nexport function interpolateToTemplates(template) {\n    const keys = [];\n    const string = template.replace(interpolateReplace, (match, expression) => {\n        if (match.startsWith('<')) {\n            // If the match is an HTML tag, don't replace\n            return match;\n        }\n        const noBraces = expression.substring(1, expression.length - 1);\n        const id = noBraces;\n        keys.push(id);\n        return `<template interpolate end id=\"${id}\"></template>`;\n    });\n    return { string, keys };\n}\n","import { TagSupport } from '../TagSupport.class.js';\nimport { ValueSubject } from '../../subject/index.js';\n/** When first time render, adds to owner childTags */\nexport function processTag(templater, insertBefore, ownerSupport, // owner\nsubject) {\n    let tagSupport = subject.tagSupport;\n    // first time seeing this tag?\n    if (!tagSupport) {\n        tagSupport = newTagSupportByTemplater(templater, ownerSupport, subject);\n    }\n    subject.tagSupport = tagSupport;\n    tagSupport.ownerTagSupport = ownerSupport;\n    // ++tagSupport.global.renderCount\n    tagSupport.buildBeforeElement(insertBefore, {\n        counts: { added: 0, removed: 0 },\n    });\n    return tagSupport;\n}\nexport function tagFakeTemplater(tag) {\n    const templater = getFakeTemplater();\n    templater.tag = tag;\n    tag.templater = templater;\n    return templater;\n}\nexport function getFakeTemplater() {\n    const fake = {\n        children: new ValueSubject([]), // no children\n        // props: {} as Props,\n        props: [],\n        isTag: true,\n        tagJsType: 'templater',\n        tagged: false,\n        html: () => fake,\n        key: () => fake,\n    };\n    return fake;\n}\n/** Create TagSupport for a tag component */\nexport function newTagSupportByTemplater(templater, ownerSupport, subject) {\n    const tagSupport = new TagSupport(templater, ownerSupport, subject);\n    setupNewSupport(tagSupport, ownerSupport, subject);\n    ownerSupport.global.childTags.push(tagSupport);\n    return tagSupport;\n}\nexport function setupNewSupport(tagSupport, ownerSupport, subject) {\n    tagSupport.global.oldest = tagSupport;\n    tagSupport.global.newest = tagSupport;\n    // asking me to render will cause my parent to render\n    tagSupport.ownerTagSupport = ownerSupport;\n    subject.tagSupport = tagSupport;\n}\n","import { ValueSubject } from '../../subject/ValueSubject.js';\nimport { ArrayNoKeyError } from '../../errors.js';\nimport { destroyArrayTag } from '../checkDestroyPrevious.function.js';\nimport { newTagSupportByTemplater, setupNewSupport, tagFakeTemplater } from './processTag.function.js';\nimport { TagSupport } from '../TagSupport.class.js';\nimport { isTagClass } from '../../isInstance.js';\nimport { renderTagOnly } from '../render/renderTagOnly.function.js';\nexport function processTagArray(subject, value, // arry of Tag classes\ninsertBefore, // <template end interpolate />\nownerSupport, options) {\n    const clones = ownerSupport.clones; // []\n    let lastArray = subject.lastArray = subject.lastArray || [];\n    if (!subject.placeholder) {\n        setPlaceholderElm(insertBefore, subject);\n    }\n    const runtimeInsertBefore = subject.placeholder; // || insertBefore\n    let removed = 0;\n    /** 🗑️ remove previous items first */\n    lastArray = subject.lastArray = subject.lastArray.filter((item, index) => {\n        const newLength = value.length - 1;\n        const at = index - removed;\n        const lessLength = newLength < at;\n        if (lessLength) {\n            destroyArrayItem(lastArray, index, options);\n            ++removed;\n            return false;\n        }\n        const subTag = value[index - removed];\n        const tagClass = isTagClass(subTag);\n        let tag = subTag;\n        let templater = subTag.templater;\n        let prevArrayValue;\n        if (tagClass) {\n            prevArrayValue = tag.memory.arrayValue;\n        }\n        else {\n            templater = subTag;\n            tag = templater.tag;\n            prevArrayValue = templater.arrayValue;\n        }\n        // const tag = subTag?.templater.tag as Tag\n        const lastTag = item.tagSupport.templater.tag;\n        const lastArrayValue = lastTag.memory.arrayValue;\n        const destroyItem = !areLikeValues(prevArrayValue, lastArrayValue);\n        if (destroyItem) {\n            destroyArrayItem(lastArray, index, options);\n            ++removed;\n            return false;\n        }\n        return true;\n    });\n    const length = value.length;\n    for (let index = 0; index < length; ++index) {\n        const item = value[index];\n        const previous = lastArray[index];\n        const previousSupport = previous?.tagSupport;\n        const subTag = item;\n        const tagClass = isTagClass(subTag);\n        const itemSubject = new ValueSubject(undefined);\n        let templater = subTag.templater;\n        let tagSupport;\n        if (tagClass) {\n            if (!templater) {\n                templater = tagFakeTemplater(subTag);\n            }\n            tagSupport = new TagSupport(templater, ownerSupport, itemSubject);\n        }\n        else {\n            templater = subTag;\n            tagSupport = setupNewTemplater(templater, ownerSupport, itemSubject);\n        }\n        // share global between old and new\n        if (previousSupport) {\n            setupNewSupport(tagSupport, ownerSupport, previousSupport.subject);\n            const global = previousSupport.global;\n            tagSupport.global = global;\n            global.newest = tagSupport;\n        }\n        // check for html``.key()\n        const tag = templater.tag || subTag;\n        const keySet = 'arrayValue' in tag.memory;\n        if (!keySet) {\n            const details = {\n                template: tagSupport.getTemplate().string,\n                array: value,\n            };\n            const message = 'Use html`...`.key(item) instead of html`...` to template an Array';\n            console.error(message, details);\n            const err = new ArrayNoKeyError(message, details);\n            throw err;\n        }\n        const couldBeSame = lastArray.length > index;\n        if (couldBeSame) {\n            const prevSupport = previous.tagSupport;\n            const prevGlobal = prevSupport.global;\n            const oldest = prevGlobal.oldest;\n            oldest.updateBy(tagSupport);\n            continue;\n        }\n        processAddTagArrayItem(runtimeInsertBefore, tagSupport, index, options, lastArray);\n        ownerSupport.global.childTags.push(tagSupport);\n    }\n    return clones;\n}\nfunction setPlaceholderElm(insertBefore, subject) {\n    if (insertBefore.nodeName !== 'TEMPLATE') {\n        subject.placeholder = insertBefore;\n        return;\n    }\n    const placeholder = subject.placeholder = document.createTextNode('');\n    const parentNode = insertBefore.parentNode;\n    parentNode.insertBefore(placeholder, insertBefore);\n    parentNode.removeChild(insertBefore);\n}\nfunction processAddTagArrayItem(before, tagSupport, index, options, lastArray) {\n    const lastValue = {\n        tagSupport, index\n    };\n    // Added to previous array\n    lastArray.push(lastValue);\n    const counts = {\n        added: options.counts.added + index,\n        removed: options.counts.removed,\n    };\n    const fragment = document.createDocumentFragment();\n    const newTempElm = document.createElement('template');\n    fragment.appendChild(newTempElm);\n    tagSupport.buildBeforeElement(newTempElm, // before,\n    { counts });\n    const parent = before.parentNode;\n    parent.insertBefore(fragment, before);\n}\n/** compare two values. If both values are arrays then the items will be compared */\nfunction areLikeValues(valueA, valueB) {\n    if (valueA === valueB) {\n        return true;\n    }\n    const bothArrays = valueA instanceof Array && valueB instanceof Array;\n    const matchLengths = bothArrays && valueA.length == valueB.length;\n    if (matchLengths) {\n        return valueA.every((item, index) => item == valueB[index]);\n    }\n    return false;\n}\nfunction setupNewTemplater(templater, ownerSupport, itemSubject) {\n    const tagSupport = newTagSupportByTemplater(templater, ownerSupport, itemSubject);\n    renderTagOnly(tagSupport, tagSupport, itemSubject, ownerSupport);\n    return tagSupport;\n}\nfunction destroyArrayItem(lastArray, index, options) {\n    const last = lastArray[index];\n    const tagSupport = last.tagSupport;\n    destroyArrayTag(tagSupport, options.counts);\n    last.deleted = true;\n    ++options.counts.removed;\n}\n","// Function to update the value of x\nexport function updateBeforeTemplate(value, // value should be casted before calling here\nlastFirstChild) {\n    const parent = lastFirstChild.parentNode;\n    // Insert the new value (never use innerHTML here)\n    const textNode = document.createTextNode(value); // never innerHTML\n    parent.insertBefore(textNode, lastFirstChild);\n    /* remove existing nodes */\n    parent.removeChild(lastFirstChild);\n    return textNode;\n}\nexport function castTextValue(value) {\n    // mimic React skipping to display EXCEPT for true does display on page\n    if ([undefined, false, null].includes(value)) { // || value === true\n        return '';\n    }\n    return value;\n}\n","import { castTextValue, updateBeforeTemplate } from '../../updateBeforeTemplate.function.js';\nexport function processRegularValue(value, subject, // could be tag via subject.tag\ninsertBefore) {\n    subject.insertBefore = insertBefore;\n    const before = subject.clone || insertBefore; // Either the template is on the doc OR its the first element we last put on doc\n    // matches but also was defined at some point\n    if (subject.lastValue === value && 'lastValue' in subject) {\n        return; // no need to update display, its the same\n    }\n    subject.lastValue = value;\n    const castedValue = castTextValue(value);\n    // replace existing string?\n    const oldClone = subject.clone;\n    if (oldClone) {\n        oldClone.textContent = castedValue;\n        return;\n    }\n    // Processing of regular values\n    const clone = updateBeforeTemplate(castedValue, before);\n    subject.clone = clone; // remember single element put down, for future updates\n}\nexport function processFirstRegularValue(value, subject, // could be tag via subject.tag\ninsertBefore) {\n    subject.lastValue = value;\n    const castedValue = castTextValue(value);\n    // Processing of regular values\n    const clone = updateBeforeTemplate(castedValue, insertBefore);\n    subject.clone = clone; // remember single element put down, for future updates \n}\n","import { TemplaterResult } from '../TemplaterResult.class.js';\nimport { newTagSupportByTemplater } from './processTag.function.js';\nexport function oneRenderToTagSupport(wrapper, subject, ownerSupport) {\n    const templater = new TemplaterResult([]);\n    templater.tagJsType = 'oneRender';\n    const tagSupport = newTagSupportByTemplater(templater, ownerSupport, subject);\n    let tag;\n    const wrap = () => {\n        templater.tag = tag || (wrapper());\n        return tagSupport;\n    };\n    templater.wrapper = wrap;\n    wrap.parentWrap = wrap;\n    wrap.oneRender = true;\n    wrap.parentWrap.original = wrapper;\n    return tagSupport;\n}\n","import { processSubjectComponent } from './processSubjectComponent.function.js';\nimport { processTagArray } from './processTagArray.js';\nimport { processFirstRegularValue } from './processRegularValue.function.js';\nimport { processTag, tagFakeTemplater } from './processTag.function.js';\nimport { renderTagOnly } from '../render/renderTagOnly.function.js';\nimport { ValueTypes } from '../ValueTypes.enum.js';\nimport { oneRenderToTagSupport } from './oneRenderToTagSupport.function.js';\nimport { getValueType } from '../getValueType.function.js';\nexport function processFirstSubjectValue(value, subject, // could be tag via result.tag\ninsertBefore, // <template end interpolate /> (will be removed)\nownerSupport, // owner\noptions) {\n    const valueType = getValueType(value);\n    switch (valueType) {\n        case ValueTypes.templater:\n            processTag(value, insertBefore, ownerSupport, subject);\n            return;\n        case ValueTypes.tag:\n            const tag = value;\n            let templater = tag.templater;\n            if (!templater) {\n                templater = tagFakeTemplater(tag);\n            }\n            processTag(templater, insertBefore, ownerSupport, subject);\n            return;\n        case ValueTypes.tagArray:\n            return processTagArray(subject, value, insertBefore, ownerSupport, options);\n        case ValueTypes.tagComponent:\n            const newSupport = processSubjectComponent(value, subject, insertBefore, ownerSupport, options);\n            return newSupport;\n        case ValueTypes.function:\n            const v = value;\n            if (v.oneRender) {\n                const tagSupport = oneRenderToTagSupport(v, subject, ownerSupport);\n                renderTagOnly(tagSupport, tagSupport, subject, ownerSupport);\n                processTag(tagSupport.templater, insertBefore, ownerSupport, subject);\n                return;\n            }\n            break;\n    }\n    processFirstRegularValue(value, subject, insertBefore);\n}\n","import { processAttribute } from './processAttribute.function.js';\nconst search = new RegExp('\\\\s*<template interpolate end id=\"__tagvar(\\\\d{1,4})\"([^>]*)></template>(\\\\s*)');\nexport function scanTextAreaValue(textarea, context, ownerSupport) {\n    const value = textarea.value;\n    if (value.search(search) >= 0) {\n        const match = value.match(/__tagvar(\\d{1,4})/);\n        const token = match ? match[0] : '';\n        const dynamic = '{' + token + '}';\n        textarea.value = '';\n        textarea.setAttribute('text-var-value', dynamic);\n        const howToSet = (_elm, _name, value) => textarea.value = value;\n        processAttribute('text-var-value', dynamic, // realValue, // context[token].value,\n        textarea, context, ownerSupport, howToSet);\n    }\n}\n","import { TagSupport } from '../TagSupport.class.js';\nimport { TemplaterResult } from '../TemplaterResult.class.js';\nimport { isTagClass, isTagTemplater } from '../../isInstance.js';\nimport { processTagArray } from './processTagArray.js';\nimport { updateExistingTagComponent } from './updateExistingTagComponent.function.js';\nimport { processRegularValue } from './processRegularValue.function.js';\nimport { checkDestroyPrevious, restoreTagMarker } from '../checkDestroyPrevious.function.js';\nimport { processSubjectComponent } from './processSubjectComponent.function.js';\nimport { isLikeTags } from '../isLikeTags.function.js';\nimport { getFakeTemplater, processTag, setupNewSupport } from './processTag.function.js';\nimport { swapInsertBefore } from '../setTagPlaceholder.function.js';\nimport { ValueTypes } from '../ValueTypes.enum.js';\nimport { getValueType } from '../getValueType.function.js';\nexport function updateExistingValue(subject, value, ownerSupport, insertBefore) {\n    const subjectTag = subject;\n    const valueType = getValueType(value);\n    checkDestroyPrevious(subject, value, insertBefore, valueType);\n    // handle already seen tag components\n    if (valueType === ValueTypes.tagComponent) {\n        return prepareUpdateToComponent(value, subjectTag, insertBefore, ownerSupport);\n    }\n    // was component but no longer\n    const tagSupport = subjectTag.tagSupport;\n    if (tagSupport) {\n        if (valueType === ValueTypes.function) {\n            return subjectTag; // its a oneRender tag\n        }\n        handleStillTag(subject, value, ownerSupport);\n        return subjectTag;\n    }\n    switch (valueType) {\n        case ValueTypes.tagArray:\n            processTagArray(subject, value, insertBefore, // oldInsertBefore as InsertBefore,\n            ownerSupport, { counts: {\n                    added: 0,\n                    removed: 0,\n                } });\n            return subject;\n        case ValueTypes.templater:\n            processTag(value, insertBefore, ownerSupport, subjectTag);\n            return subjectTag;\n        case ValueTypes.tag:\n            const tag = value;\n            let templater = tag.templater;\n            if (!templater) {\n                templater = getFakeTemplater();\n                tag.templater = templater;\n                templater.tag = tag;\n            }\n            processTag(templater, insertBefore, ownerSupport, subjectTag);\n            return subjectTag;\n        case ValueTypes.subject:\n            return value;\n        // now its a useless function (we don't automatically call functions)\n        case ValueTypes.function:\n            if (!subject.clone) {\n                subject.clone = swapInsertBefore(insertBefore);\n            }\n            return subject;\n    }\n    // This will cause all other values to render\n    processRegularValue(value, subject, insertBefore);\n    return subjectTag;\n}\nfunction handleStillTag(subject, value, ownerSupport) {\n    const lastSupport = subject.tagSupport;\n    let templater = value;\n    const isClass = isTagClass(value);\n    if (isClass) {\n        const tag = value;\n        templater = tag.templater;\n        if (!templater) {\n            templater = new TemplaterResult([]);\n            templater.tag = tag;\n            tag.templater = templater;\n        }\n    }\n    const valueSupport = new TagSupport(templater, ownerSupport, subject);\n    // ??? new\n    // subject.tagSupport = valueSupport\n    if (isClass) {\n        valueSupport.global = lastSupport.global;\n    }\n    const isSameTag = value && isLikeTags(lastSupport, valueSupport);\n    if (isTagTemplater(value)) {\n        setupNewSupport(valueSupport, ownerSupport, subject);\n    }\n    if (isSameTag) {\n        lastSupport.updateBy(valueSupport);\n        return;\n    }\n    if (isSameTag) {\n        // const subjectTag = subject as TagSubject\n        const global = lastSupport.global;\n        const insertBefore = global.insertBefore;\n        return processTag(templater, insertBefore, ownerSupport, subject);\n    }\n    return processRegularValue(value, subject, subject.insertBefore);\n}\nfunction prepareUpdateToComponent(templater, subjectTag, insertBefore, ownerSupport) {\n    // When last value was not a component\n    if (!subjectTag.tagSupport) {\n        processSubjectComponent(templater, subjectTag, insertBefore, // oldInsertBefore as InsertBefore,\n        ownerSupport, {\n            counts: { added: 0, removed: 0 },\n        });\n        return subjectTag;\n    }\n    const tagSupport = new TagSupport(templater, ownerSupport, subjectTag);\n    const subjectSup = subjectTag.tagSupport;\n    const prevSupport = subjectSup.global.newest;\n    if (prevSupport) {\n        const newestState = prevSupport.memory.state;\n        tagSupport.memory.state.length = 0;\n        tagSupport.memory.state.push(...newestState);\n    }\n    else {\n        restoreTagMarker(subjectSup);\n        processSubjectComponent(templater, subjectTag, insertBefore, ownerSupport, {\n            counts: { added: 0, removed: 0 },\n        });\n        return subjectTag;\n    }\n    tagSupport.global = subjectSup.global;\n    subjectTag.tagSupport = tagSupport;\n    updateExistingTagComponent(ownerSupport, tagSupport, // latest value\n    subjectTag, insertBefore);\n    return subjectTag;\n}\n","import { variablePrefix } from '../tag/Tag.class.js';\nimport { elementInitCheck } from './elementInitCheck.js';\nimport { processFirstSubjectValue } from '../tag/update/processFirstSubjectValue.function.js';\nimport { isTagArray, isTagComponent } from '../isInstance.js';\nimport { scanTextAreaValue } from './scanTextAreaValue.function.js';\nimport { updateExistingValue } from '../tag/update/updateExistingValue.function.js';\nimport { swapInsertBefore } from '../tag/setTagPlaceholder.function.js';\nexport function interpolateTemplate(insertBefore, // <template end interpolate /> (will be removed)\ncontext, // variable scope of {`__tagvar${index}`:'x'}\nownerSupport, // Tag class\ncounts) {\n    if (!insertBefore.hasAttribute('end')) {\n        return; // only care about <template end>\n    }\n    const variableName = insertBefore.getAttribute('id');\n    if (variableName?.substring(0, variablePrefix.length) !== variablePrefix) {\n        return; // ignore, not a tagVar\n    }\n    const existingSubject = context[variableName];\n    const isDynamic = isTagComponent(existingSubject._value) || isTagArray(existingSubject.value);\n    // process dynamics later\n    if (isDynamic) {\n        return {\n            variableName,\n            ownerSupport,\n            subject: existingSubject,\n            insertBefore\n        };\n    }\n    subscribeToTemplate(insertBefore, existingSubject, ownerSupport, counts);\n    return;\n}\nexport function subscribeToTemplate(insertBefore, subject, ownerSupport, counts) {\n    let called = false;\n    const onValue = (value) => {\n        if (called) {\n            updateExistingValue(subject, value, ownerSupport, insertBefore);\n            return;\n        }\n        const templater = value;\n        processFirstSubjectValue(templater, subject, insertBefore, ownerSupport, {\n            counts: { ...counts },\n        });\n        called = true;\n    };\n    let mutatingCallback = onValue;\n    const callback = (value) => mutatingCallback(value);\n    const sub = subject.subscribe(callback);\n    // on subscribe, the Subject did NOT emit immediately. Lets pull the template off the document\n    if (insertBefore.parentNode) {\n        const clone = subject.clone = swapInsertBefore(insertBefore);\n        mutatingCallback = v => {\n            const parentNode = clone.parentNode;\n            parentNode.insertBefore(insertBefore, clone);\n            parentNode.removeChild(clone);\n            delete subject.clone;\n            mutatingCallback = onValue; // all future calls will just produce value\n            onValue(v); // calls for rending\n        };\n    }\n    ownerSupport.global.subscriptions.push(sub);\n}\n/** This is the function that enhances elements such as [class.something] and [style.color] OR it fixes elements that alter innerHTML */\nexport function afterElmBuild(elm, options, context, ownerSupport) {\n    if (!elm.getAttribute) {\n        return;\n    }\n    // Elements that alter innerHTML\n    const tagName = elm.nodeName; // elm.tagName\n    if (tagName === 'TEXTAREA') {\n        scanTextAreaValue(elm, context, ownerSupport);\n    }\n    let diff = options.counts.added;\n    diff = elementInitCheck(elm, options.counts) - diff;\n    const hasFocusFun = elm.focus;\n    if (hasFocusFun) {\n        if (elm.hasAttribute('autofocus')) {\n            elm.focus();\n        }\n        if (elm.hasAttribute('autoselect')) {\n            elm.select();\n        }\n    }\n    const children = elm.children;\n    if (children) {\n        for (let index = children.length - 1; index >= 0; --index) {\n            const child = children[index];\n            const subOptions = {\n                ...options,\n                counts: options.counts,\n            };\n            afterElmBuild(child, subOptions, context, ownerSupport);\n        }\n    }\n}\n","export function elementInitCheck(nextSibling, counts) {\n    const onInitDoubleWrap = nextSibling.oninit;\n    if (!onInitDoubleWrap) {\n        return counts.added;\n    }\n    const onInitWrap = onInitDoubleWrap.tagFunction;\n    if (!onInitWrap) {\n        return counts.added;\n    }\n    const onInit = onInitWrap.tagFunction;\n    if (!onInit) {\n        return counts.added;\n    }\n    const event = { target: nextSibling, stagger: counts.added };\n    onInit(event);\n    return ++counts.added;\n}\n","import { interpolateTemplate } from './interpolateTemplate.js';\nexport function interpolateContentTemplates(context, tagSupport, options, children) {\n    // counting for animation stagger computing\n    const counts = options.counts;\n    const clones = [];\n    const tagComponents = [];\n    const childLength = children.length;\n    for (let index = childLength - 1; index >= 0; --index) {\n        const child = children[index];\n        const tagComponent = interpolateTemplate(child, context, tagSupport, counts);\n        // clones.push(...nextClones)\n        if (tagComponent) {\n            tagComponents.push(tagComponent);\n            continue;\n        }\n        if (child.children) {\n            for (let index = child.children.length - 1; index >= 0; --index) {\n                const subChild = child.children[index];\n                // IF <template end /> its a variable to be processed\n                if (isRenderEndTemplate(subChild)) {\n                    const tagComponent = interpolateTemplate(subChild, context, tagSupport, counts);\n                    if (tagComponent) {\n                        tagComponents.push(tagComponent);\n                    }\n                }\n                const { clones: nextClones, tagComponents: nextTagComponent } = interpolateContentTemplates(context, tagSupport, options, subChild.children);\n                clones.push(...nextClones);\n                tagComponents.push(...nextTagComponent);\n            }\n        }\n    }\n    return { clones, tagComponents };\n}\nfunction isRenderEndTemplate(child) {\n    const isTemplate = child.tagName === 'TEMPLATE';\n    return isTemplate &&\n        child.getAttribute('interpolate') !== undefined &&\n        child.getAttribute('end') !== undefined;\n}\n","import { interpolateAttributes } from './interpolateAttributes.js';\nimport { interpolateToTemplates } from './interpolations.js';\nimport { interpolateContentTemplates } from './interpolateContentTemplates.js';\nimport { escapeSearch, variablePrefix } from '../tag/Tag.class.js';\n/** Review elements within an element */\nexport function interpolateElement(container, // element containing innerHTML to review interpolations\ncontext, // variables used to evaluate\ninterpolatedTemplates, ownerSupport, options) {\n    const clones = [];\n    const tagComponents = [];\n    const result = interpolatedTemplates.interpolation;\n    const template = container.children[0];\n    const children = template.content.children;\n    if (result.keys.length) {\n        const { clones: nextClones, tagComponents: nextTagComponents } = interpolateContentTemplates(context, ownerSupport, options, children);\n        clones.push(...nextClones);\n        tagComponents.push(...nextTagComponents);\n    }\n    interpolateAttributes(template, context, ownerSupport);\n    processChildrenAttributes(children, context, ownerSupport);\n    return { clones, tagComponents };\n}\nfunction processChildrenAttributes(children, context, ownerSupport) {\n    for (let index = children.length - 1; index >= 0; --index) {\n        const child = children[index];\n        interpolateAttributes(child, context, ownerSupport);\n        if (child.children) {\n            processChildrenAttributes(child.children, context, ownerSupport);\n        }\n    }\n}\nexport function interpolateString(string) {\n    const result = interpolateToTemplates(string);\n    result.string = result.string.replace(escapeSearch, variablePrefix);\n    return result;\n}\n","import { buildClones } from '../render.js';\nimport { afterElmBuild } from './interpolateTemplate.js';\nexport function afterInterpolateElement(container, insertBefore, tagSupport, context, options) {\n    const clones = buildClones(container, insertBefore);\n    if (!clones.length) {\n        return clones;\n    }\n    for (let index = clones.length - 1; index >= 0; --index) {\n        const clone = clones[index];\n        afterElmBuild(clone, options, context, tagSupport);\n        tagSupport.clones.push(clone);\n    }\n    return clones;\n}\n","export function buildClones(temporary, insertBefore) {\n    const clones = [];\n    const template = temporary.children[0];\n    let nextSibling = template.content.firstChild;\n    const fragment = document.createDocumentFragment();\n    while (nextSibling) {\n        const nextNextSibling = nextSibling.nextSibling;\n        clones.push(nextSibling);\n        fragment.appendChild(nextSibling);\n        nextSibling = nextNextSibling;\n    }\n    if (insertBefore.parentNode) {\n        const parentNode = insertBefore.parentNode;\n        parentNode.insertBefore(fragment, insertBefore);\n    }\n    return clones;\n}\n","import { escapeVariable, variablePrefix } from './Tag.class.js';\nimport { deepClone } from '../deepFunctions.js';\nimport { isTagComponent } from '../isInstance.js';\nimport { cloneValueArray } from './cloneValueArray.function.js';\nimport { restoreTagMarker } from './checkDestroyPrevious.function.js';\nimport { runBeforeDestroy } from './tagRunner.js';\nimport { getChildTagsToDestroy } from './destroy.support.js';\nimport { elementDestroyCheck } from './elementDestroyCheck.function.js';\nimport { updateContextItem } from './update/updateContextItem.function.js';\nimport { processNewValue } from './update/processNewValue.function.js';\nimport { setTagPlaceholder } from './setTagPlaceholder.function.js';\nimport { interpolateElement, interpolateString } from '../interpolations/interpolateElement.js';\nimport { subscribeToTemplate } from '../interpolations/interpolateTemplate.js';\nimport { afterInterpolateElement } from '../interpolations/afterInterpolateElement.function.js';\nimport { Subject } from '../subject/Subject.class.js';\nconst prefixSearch = new RegExp(variablePrefix, 'g');\n/** used only for apps, otherwise use TagSupport */\nexport class BaseTagSupport {\n    templater;\n    subject;\n    isApp = true;\n    appElement; // only seen on this.getAppTagSupport().appElement\n    strings;\n    values;\n    propsConfig;\n    // stays with current render\n    memory = {\n        state: [],\n    };\n    clones = []; // elements on document. Needed at destroy process to know what to destroy\n    // travels with all rerenderings\n    global = {\n        destroy$: new Subject(),\n        context: {}, // populated after reading interpolated.values array converted to an object {variable0, variable:1}\n        providers: [],\n        /** Indicator of re-rending. Saves from double rending something already rendered */\n        renderCount: 0,\n        subscriptions: [],\n        oldest: this,\n        blocked: [], // renders that did not occur because an event was processing\n        childTags: [], // tags on me\n    };\n    hasLiveElements = false;\n    constructor(templater, subject, castedProps) {\n        this.templater = templater;\n        this.subject = subject;\n        const props = templater.props; // natural props\n        this.propsConfig = this.clonePropsBy(props, castedProps);\n    }\n    clonePropsBy(props, castedProps) {\n        const children = this.templater.children; // children tags passed in as arguments\n        const kidValue = children.value;\n        const latestCloned = props.map(props => deepClone(props));\n        return this.propsConfig = {\n            latest: props,\n            latestCloned, // assume its HTML children and then detect\n            castProps: castedProps, //?? castProps(props, this, this.memory.state),\n            lastClonedKidValues: kidValue.map(kid => {\n                const cloneValues = cloneValueArray(kid.values);\n                return cloneValues;\n            })\n        };\n    }\n    /** Function that kicks off actually putting tags down as HTML elements */\n    buildBeforeElement(insertBefore, options = {\n        counts: { added: 0, removed: 0 },\n    }) {\n        const subject = this.subject;\n        const global = this.global;\n        global.insertBefore = insertBefore;\n        if (!global.placeholder) {\n            setTagPlaceholder(global);\n        }\n        const placeholderElm = global.placeholder;\n        global.oldest = this;\n        global.newest = this;\n        subject.tagSupport = this;\n        this.hasLiveElements = true;\n        const context = this.update();\n        const template = this.getTemplate();\n        const elementContainer = document.createDocumentFragment();\n        const tempDraw = document.createElement('template');\n        tempDraw.innerHTML = template.string;\n        elementContainer.appendChild(tempDraw);\n        // Search/replace innerHTML variables but don't interpolate tag components just yet\n        const { tagComponents } = interpolateElement(elementContainer, context, template, this, // ownerSupport,\n        {\n            counts: options.counts\n        });\n        afterInterpolateElement(elementContainer, placeholderElm, this, // ownerSupport\n        context, options);\n        // Any tag components that were found should be processed AFTER the owner processes its elements. Avoid double processing of elements attributes like (oninit)=${}\n        const length = tagComponents.length;\n        for (let index = 0; index < length; ++index) {\n            const tagComponent = tagComponents[index];\n            subscribeToTemplate(tagComponent.insertBefore, tagComponent.subject, tagComponent.ownerSupport, options.counts);\n            afterInterpolateElement(elementContainer, tagComponent.insertBefore, tagComponent.ownerSupport, context, options);\n        }\n    }\n    getTemplate() {\n        const thisTag = this.templater.tag;\n        const strings = this.strings || thisTag.strings;\n        const values = this.values || thisTag.values;\n        const string = strings.map((string, index) => {\n            const safeString = string.replace(prefixSearch, escapeVariable);\n            const endString = safeString + (values.length > index ? `{${variablePrefix}${index}}` : '');\n            const trimString = endString.replace(/>\\s*/g, '>').replace(/\\s*</g, '<');\n            return trimString;\n        }).join('');\n        const interpolation = interpolateString(string);\n        return {\n            interpolation,\n            string: interpolation.string,\n            strings,\n            values,\n            context: this.global.context || {},\n        };\n    }\n    update() {\n        return this.updateContext(this.global.context);\n    }\n    updateContext(context) {\n        const thisTag = this.templater.tag;\n        const strings = this.strings || thisTag.strings;\n        const values = this.values || thisTag.values;\n        strings.forEach((_string, index) => {\n            const hasValue = values.length > index;\n            if (!hasValue) {\n                return;\n            }\n            const variableName = variablePrefix + index;\n            const value = values[index];\n            // is something already there?\n            const exists = variableName in context;\n            if (exists) {\n                if (this.global.deleted) {\n                    const valueSupport = (value && value.tagSupport);\n                    if (valueSupport) {\n                        valueSupport.destroy();\n                        return context; // item was deleted, no need to emit\n                    }\n                }\n                return updateContextItem(context, variableName, value);\n            }\n            // 🆕 First time values below\n            context[variableName] = processNewValue(value, this);\n        });\n        return context;\n    }\n    updateBy(tagSupport) {\n        const tempTag = tagSupport.templater.tag;\n        this.updateConfig(tempTag.strings, tempTag.values);\n    }\n    updateConfig(strings, values) {\n        this.strings = strings;\n        this.updateValues(values);\n    }\n    updateValues(values) {\n        this.values = values;\n        return this.updateContext(this.global.context);\n    }\n    destroy(options = {\n        stagger: 0,\n        byParent: false, // Only destroy clones of direct children\n    }) {\n        const firstDestroy = !options.byParent;\n        const global = this.global;\n        const childTags = options.byParent ? [] : getChildTagsToDestroy(this.global.childTags);\n        if (firstDestroy && isTagComponent(this.templater)) {\n            global.destroy$.next();\n            runBeforeDestroy(this, this);\n        }\n        this.destroySubscriptions();\n        // signify immediately child has been deleted (looked for during event processing)\n        for (let index = childTags.length - 1; index >= 0; --index) {\n            const child = childTags[index];\n            const subGlobal = child.global;\n            delete subGlobal.newest;\n            subGlobal.deleted = true;\n            if (isTagComponent(child.templater)) {\n                runBeforeDestroy(child, child);\n            }\n        }\n        let mainPromise;\n        // FIRST DOM Manipulation to cause painting cycle\n        checkRestoreTagMarker(this, options);\n        if (firstDestroy) {\n            const { stagger, promise } = this.destroyClones(options);\n            options.stagger = stagger;\n            if (promise) {\n                mainPromise = promise;\n            }\n        }\n        else {\n            this.destroyClones();\n        }\n        // data reset\n        resetTagSupport(this);\n        if (mainPromise) {\n            mainPromise = mainPromise.then(async () => {\n                const promises = childTags.map(kid => kid.destroy({ stagger: 0, byParent: true }));\n                return Promise.all(promises);\n            });\n        }\n        else {\n            mainPromise = Promise.all(childTags.map(kid => kid.destroy({ stagger: 0, byParent: true })));\n        }\n        return mainPromise.then(() => options.stagger);\n    }\n    destroyClones({ stagger } = {\n        stagger: 0,\n    }) {\n        const oldClones = [...this.clones];\n        this.clones.length = 0; // tag maybe used for something else\n        const promises = oldClones.map(clone => this.checkCloneRemoval(clone, stagger)).filter(x => x); // only return promises\n        // check subjects that may have clones attached to them\n        const oldContext = this.global.context;\n        for (const name in oldContext) {\n            const value = oldContext[name];\n            const clone = value.clone;\n            if (clone?.parentNode) {\n                clone.parentNode.removeChild(clone);\n            }\n        }\n        if (promises.length) {\n            return { promise: Promise.all(promises), stagger };\n        }\n        return { stagger };\n    }\n    /** Reviews elements for the presences of ondestroy */\n    checkCloneRemoval(clone, stagger) {\n        let promise;\n        const customElm = clone;\n        if (customElm.ondestroy) {\n            promise = elementDestroyCheck(customElm, stagger);\n        }\n        const next = () => {\n            const parentNode = clone.parentNode;\n            if (parentNode) {\n                parentNode.removeChild(clone);\n            }\n            const ownerSupport = this.ownerTagSupport;\n            if (ownerSupport) {\n                // Sometimes my clones were first registered to my owner, remove them from owner\n                ownerSupport.clones = ownerSupport.clones.filter(compareClone => compareClone !== clone);\n            }\n        };\n        if (promise instanceof Promise) {\n            return promise.then(next);\n        }\n        else {\n            next();\n        }\n        return promise;\n    }\n    destroySubscriptions() {\n        const subs = this.global.subscriptions;\n        for (let index = subs.length - 1; index >= 0; --index) {\n            subs[index].unsubscribe();\n        }\n        subs.length = 0;\n    }\n}\nexport class TagSupport extends BaseTagSupport {\n    templater;\n    ownerTagSupport;\n    subject;\n    version;\n    isApp = false;\n    constructor(templater, // at runtime rendering of a tag, it needs to be married to a new TagSupport()\n    ownerTagSupport, subject, castedProps, version = 0) {\n        super(templater, subject, castedProps);\n        this.templater = templater;\n        this.ownerTagSupport = ownerTagSupport;\n        this.subject = subject;\n        this.version = version;\n    }\n    getAppTagSupport() {\n        let tag = this;\n        while (tag.ownerTagSupport) {\n            tag = tag.ownerTagSupport;\n        }\n        return tag;\n    }\n}\nexport function checkRestoreTagMarker(support, options) {\n    const global = support.global;\n    // HTML DOM manipulation. Put back down the template tag\n    const insertBefore = global.insertBefore;\n    if (insertBefore.nodeName === 'TEMPLATE') {\n        const placeholder = global.placeholder;\n        if (placeholder && !('arrayValue' in support.memory)) {\n            if (!options.byParent) {\n                restoreTagMarker(support);\n            }\n        }\n    }\n}\nexport function resetTagSupport(support) {\n    const global = support.global;\n    delete global.placeholder;\n    global.context = {};\n    delete global.oldest; // may not be needed\n    delete global.newest;\n    support.global.childTags.length = 0;\n    const subject = support.subject;\n    delete subject.tagSupport;\n}\n","import { isSubjectInstance } from '../../isInstance.js';\nexport function updateContextItem(context, variableName, value) {\n    const subject = context[variableName];\n    if (isSubjectInstance(value)) {\n        return; // emits on its own\n    }\n    // listeners will evaluate updated values to possibly update display(s)\n    subject.next(value);\n    return;\n}\n","export function elementDestroyCheck(nextSibling, stagger) {\n    const onDestroyDoubleWrap = nextSibling.ondestroy;\n    if (!onDestroyDoubleWrap) {\n        return;\n    }\n    const onDestroyWrap = onDestroyDoubleWrap.tagFunction;\n    if (!onDestroyWrap) {\n        return;\n    }\n    const onDestroy = onDestroyWrap.tagFunction;\n    if (!onDestroy) {\n        return;\n    }\n    const event = { target: nextSibling, stagger };\n    return onDestroy(event);\n}\n","import { checkRestoreTagMarker, resetTagSupport } from '../TagSupport.class.js';\nimport { getChildTagsToDestroy } from '../destroy.support.js';\n/** used when a tag swaps content returned */\nexport function softDestroySupport(lastSupport, options = { byParent: false, stagger: 0 }) {\n    lastSupport.global.deleted = true;\n    lastSupport.global.context = {};\n    const childTags = getChildTagsToDestroy(lastSupport.global.childTags);\n    lastSupport.destroySubscriptions();\n    childTags.forEach(child => {\n        const subGlobal = child.global;\n        delete subGlobal.newest;\n        subGlobal.deleted = true;\n    });\n    checkRestoreTagMarker(lastSupport, options);\n    resetTagSupport(lastSupport);\n    lastSupport.destroyClones();\n    childTags.forEach(child => softDestroySupport(child, { byParent: true, stagger: 0 }));\n}\n","import { softDestroySupport } from './softDestroySupport.function.js';\nimport { moveProviders } from '../update/updateExistingTagComponent.function.js';\nexport function destroyUnlikeTags(lastSupport, // old\nreSupport, // new\nsubject) {\n    const oldGlobal = lastSupport.global;\n    const insertBefore = oldGlobal.insertBefore;\n    // when a tag is destroyed, disconnect the globals\n    const global = reSupport.global = { ...oldGlobal }; // break memory references\n    moveProviders(lastSupport, reSupport);\n    // destroyTagMemory(lastSupport)\n    softDestroySupport(lastSupport);\n    lastSupport.global.oldest = reSupport; // any outstanding callbacks/state like activities should refer to replacing tag\n    global.insertBefore = insertBefore;\n    delete global.deleted;\n    global.oldest = reSupport;\n    global.newest = reSupport;\n    subject.tagSupport = reSupport;\n    const placeParent = reSupport.global.placeholder?.parentNode;\n    const insertParent = insertBefore.parentNode;\n    if (placeParent && insertParent) {\n        insertParent.removeChild(insertBefore);\n    }\n}\n","import { isLikeTags } from '../isLikeTags.function.js';\nimport { renderTagOnly } from './renderTagOnly.function.js';\nimport { destroyUnlikeTags } from './destroyUnlikeTags.function.js';\nexport function renderWithSupport(newTagSupport, lastSupport, // previous\nsubject, // events & memory\nownerSupport) {\n    const reSupport = renderTagOnly(newTagSupport, lastSupport, subject, ownerSupport);\n    const isLikeTag = !lastSupport || isLikeTags(lastSupport, reSupport);\n    if (!isLikeTag) {\n        destroyUnlikeTags(lastSupport, reSupport, subject);\n        reSupport.global.oldest = reSupport;\n    }\n    const lastOwnerSupport = lastSupport?.ownerTagSupport;\n    reSupport.ownerTagSupport = (ownerSupport || lastOwnerSupport);\n    return reSupport;\n}\n","import { deepClone } from '../deepFunctions.js';\nimport { renderTagSupport } from '../tag/render/renderTagSupport.function.js';\nexport function handleProviderChanges(appSupport, provider) {\n    const tagsWithProvider = getTagsWithProvider(appSupport, provider);\n    for (let index = tagsWithProvider.length - 1; index >= 0; --index) {\n        const { tagSupport, renderCount, provider } = tagsWithProvider[index];\n        if (tagSupport.global.deleted) {\n            continue; // i was deleted after another tag processed\n        }\n        const notRendered = renderCount === tagSupport.global.renderCount;\n        if (notRendered) {\n            provider.clone = deepClone(provider.instance);\n            renderTagSupport(tagSupport.global.newest, // tagSupport, // tagSupport.global.newest as TagSupport,\n            false);\n            continue;\n        }\n    }\n}\n/** Updates and returns memory of tag providers */\nfunction getTagsWithProvider(tagSupport, provider, memory = []) {\n    memory.push({\n        tagSupport,\n        renderCount: tagSupport.global.renderCount,\n        provider,\n    });\n    const childTags = provider.children;\n    for (let index = childTags.length - 1; index >= 0; --index) {\n        memory.push({\n            tagSupport: childTags[index],\n            renderCount: childTags[index].global.renderCount,\n            provider,\n        });\n    }\n    return memory;\n}\n","import { isLikeTags } from '../isLikeTags.function.js';\nimport { renderWithSupport } from './renderWithSupport.function.js';\nimport { providersChangeCheck } from '../../state/providersChangeCheck.function.js';\n/** Returns true when rendering owner is not needed. Returns false when rendering owner should occur */\nexport function renderExistingTag(oldestSupport, // oldest with elements on html\nnewSupport, // new to be rendered\nownerSupport, // ownerSupport\nsubject) {\n    const lastSupport = subject.tagSupport;\n    const global = lastSupport.global;\n    // share point between renders\n    newSupport.global = global;\n    const preRenderCount = global.renderCount;\n    providersChangeCheck(oldestSupport);\n    // When the providers were checked, a render to myself occurred and I do not need to re-render again\n    const prevSupport = global.newest;\n    const justUpdate = preRenderCount !== global.renderCount;\n    if (justUpdate) {\n        oldestSupport.global.oldest.updateBy(prevSupport);\n        return prevSupport; // already rendered during triggered events\n    }\n    const toRedrawTag = prevSupport || lastSupport || global.oldest;\n    const reSupport = renderWithSupport(newSupport, toRedrawTag, subject, ownerSupport);\n    const oldest = global.oldest || oldestSupport;\n    if (isLikeTags(prevSupport, reSupport)) {\n        subject.tagSupport = reSupport;\n        oldest.updateBy(reSupport);\n    }\n    return reSupport;\n}\n","import { deepClone, deepEqual } from '../deepFunctions.js';\nimport { handleProviderChanges } from './handleProviderChanges.function.js';\nexport function providersChangeCheck(tagSupport) {\n    const global = tagSupport.global;\n    const providersWithChanges = global.providers.filter(provider => !deepEqual(provider.instance, provider.clone));\n    // reset clones\n    for (let index = providersWithChanges.length - 1; index >= 0; --index) {\n        const provider = providersWithChanges[index];\n        const owner = provider.owner;\n        handleProviderChanges(owner, provider);\n        provider.clone = deepClone(provider.instance);\n    }\n}\n","import { deepEqual } from '../../deepFunctions.js';\nimport { renderExistingTag } from './renderExistingTag.function.js';\n/** Main function used by all other callers to render/update display of a tag component */\nexport function renderTagSupport(tagSupport, // must be latest/newest state render\nrenderUp) {\n    const global = tagSupport.global;\n    const templater = tagSupport.templater;\n    // is it just a vanilla tag, not component?\n    if (!templater.wrapper) { // || isTagTemplater(templater) \n        const ownerTag = tagSupport.ownerTagSupport;\n        ++global.renderCount;\n        if (ownerTag.global.deleted) {\n            return tagSupport;\n        }\n        return renderTagSupport(ownerTag.global.newest, true);\n    }\n    if (tagSupport.global.locked) {\n        tagSupport.global.blocked.push(tagSupport);\n        return tagSupport;\n    }\n    const subject = tagSupport.subject;\n    const oldest = tagSupport.global.oldest;\n    let ownerSupport;\n    let selfPropChange = false;\n    const shouldRenderUp = renderUp && tagSupport;\n    if (shouldRenderUp) {\n        ownerSupport = tagSupport.ownerTagSupport;\n        if (ownerSupport) {\n            const nowProps = templater.props;\n            const latestProps = tagSupport.propsConfig.latestCloned;\n            selfPropChange = !deepEqual(nowProps, latestProps);\n        }\n    }\n    const tag = renderExistingTag(oldest, tagSupport, ownerSupport, // useTagSupport,\n    subject);\n    if (ownerSupport && selfPropChange) {\n        const ownerTagSupport = ownerSupport.global.newest;\n        renderTagSupport(ownerTagSupport, true);\n        return tag;\n    }\n    return tag;\n}\n","import { renderTagSupport } from '../tag/render/renderTagSupport.function.js';\nimport { syncStates } from './syncStates.function.js';\nexport default function callbackStateUpdate(tagSupport, callback, oldState, ...args) {\n    const state = tagSupport.memory.state;\n    // ensure that the oldest has the latest values first\n    syncStates(state, oldState);\n    // run the callback\n    const maybePromise = callback(...args);\n    // send the oldest state changes into the newest\n    syncStates(oldState, state);\n    renderTagSupport(tagSupport, // tagSupport.global.newest as TagSupport,\n    false);\n    if (maybePromise instanceof Promise) {\n        maybePromise.finally(() => {\n            // send the oldest state changes into the newest\n            syncStates(oldState, state);\n            renderTagSupport(tagSupport, // tagSupport.global.newest as TagSupport,\n            false);\n        });\n    }\n    // return undefined as T\n    return maybePromise;\n}\n","import { setUse } from './setUse.function.js';\nimport { SyncCallbackError } from '../errors.js';\nimport { getSupportInCycle } from '../tag/getSupportInCycle.function.js';\nimport callbackStateUpdate from './callbackStateUpdate.function.js';\nlet innerCallback = (callback) => (a, b, c, d, e, f) => {\n    throw new SyncCallbackError('Callback function was called immediately in sync and must instead be call async');\n};\nexport const callbackMaker = () => innerCallback;\nconst originalGetter = innerCallback; // callbackMaker\nsetUse({\n    beforeRender: tagSupport => initMemory(tagSupport),\n    beforeRedraw: tagSupport => initMemory(tagSupport),\n    afterRender: tagSupport => {\n        ;\n        tagSupport.global.callbackMaker = true;\n        innerCallback = originalGetter; // prevent crossing callbacks with another tag\n    },\n});\n/** Wrap a function that will be called back. After the wrapper and function are called, a rendering cycle will update display */\nexport function callback(callback) {\n    const tagSupport = getSupportInCycle();\n    if (!tagSupport) {\n        const error = new SyncCallbackError('callback() was called outside of synchronous rendering. Use `callback = callbackMaker()` to create a callback that could be called out of sync with rendering');\n        throw error;\n    }\n    const oldState = setUse.memory.stateConfig.array;\n    const trigger = (...args) => {\n        const callbackMaker = tagSupport.global.callbackMaker;\n        if (callbackMaker) {\n            return callbackStateUpdate(tagSupport, callback, oldState, ...args);\n        }\n        return callback(...args);\n    };\n    return trigger;\n}\nfunction initMemory(tagSupport) {\n    const oldState = setUse.memory.stateConfig.array;\n    innerCallback = (callback) => {\n        const trigger = (...args) => {\n            const callbackMaker = tagSupport.global.callbackMaker;\n            if (callbackMaker) {\n                return callbackStateUpdate(tagSupport, callback, oldState, ...args);\n            }\n            return callback(...args);\n        };\n        return trigger;\n    };\n}\n","import { state } from './state.function.js';\n/** runs a callback function one time and never again. Same as calling state(() => ...) */\nexport function onInit(callback) {\n    state(callback);\n}\n","import { getSupportInCycle } from \"../tag/getSupportInCycle.function.js\";\nimport { state } from \"./state.function.js\";\nexport function onDestroy(callback) {\n    state(() => {\n        const tagSupport = getSupportInCycle();\n        tagSupport?.global.destroy$.toCallback(callback);\n    });\n}\n","import { setUse } from './setUse.function.js';\nfunction setCurrentTagSupport(support) {\n    setUse.memory.childrenCurrentSupport = support;\n}\nexport function children() {\n    const tagSupport = setUse.memory.childrenCurrentSupport;\n    const children = tagSupport.templater.children;\n    return children;\n}\nsetUse({\n    beforeRender: tagSupport => setCurrentTagSupport(tagSupport),\n    beforeRedraw: tagSupport => setCurrentTagSupport(tagSupport),\n});\n","export const tags = [];\n","import { Tag } from './Tag.class.js';\nexport function html(strings, ...values) {\n    return new Tag(strings, values);\n}\n","import { setUse } from '../state/index.js';\nimport { TemplaterResult } from './TemplaterResult.class.js';\nimport { tags } from './tag.utils.js';\nimport { getTagWrap } from './getTagWrap.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nlet tagCount = 0;\n/** Wraps a function tag in a state manager and calls wrapped function on event cycles\n * For single rendering, no event cycles, use: tag.renderOnce = (props) => html``\n */\nexport function tag(tagComponent) {\n    /** function developer triggers */\n    const parentWrap = (function tagWrapper(...props) {\n        const templater = new TemplaterResult(props);\n        templater.tagJsType = ValueTypes.tagComponent;\n        // attach memory back to original function that contains developer display logic\n        const innerTagWrap = getTagWrap(templater, parentWrap);\n        if (!innerTagWrap.parentWrap) {\n            innerTagWrap.parentWrap = parentWrap;\n        }\n        templater.tagged = true;\n        templater.wrapper = innerTagWrap;\n        return templater;\n    }) // we override the function provided and pretend original is what's returned\n    ;\n    parentWrap.original = tagComponent;\n    parentWrap.compareTo = tagComponent.toString();\n    const tag = tagComponent;\n    parentWrap.isTag = true;\n    parentWrap.original = tag;\n    // group tags together and have hmr pickup\n    tag.tags = tags;\n    tag.setUse = setUse;\n    tag.tagIndex = tagCount++; // needed for things like HMR\n    tags.push(parentWrap);\n    return parentWrap;\n}\n/** Used to create a tag component that renders once and has no addition rendering cycles */\ntag.oneRender = (...props) => {\n    throw new Error('Do not call function tag.oneRender but instead set it as: `(props) => tag.oneRender = (state) => html`` `');\n};\n/** Use to structure and define a browser tag route handler\n * Example: export default tag.route = (routeProps: RouteProps) => (state) => html``\n */\ntag.route = (routeProps) => {\n    throw new Error('Do not call function tag.route but instead set it as: `tag.route = (routeProps: RouteProps) => (state) => html`` `');\n};\n/** Use to structure and define a browser tag route handler\n * Example: export default tag.route = (routeProps: RouteProps) => (state) => html``\n */\ntag.app = (routeTag) => {\n    throw new Error('Do not call function tag.route but instead set it as: `tag.route = (routeProps: RouteProps) => (state) => html`` `');\n};\nObject.defineProperty(tag, 'oneRender', {\n    set(oneRenderFunction) {\n        oneRenderFunction.oneRender = true;\n    },\n});\n","import { runTagCallback } from '../interpolations/bindSubjectCallback.function.js';\nimport { deepClone } from '../deepFunctions.js';\nimport { TagSupport } from './TagSupport.class.js';\nimport { castProps } from '../alterProp.function.js';\nimport { setUse } from '../state/setUse.function.js';\nimport { ValueTypes } from './ValueTypes.enum.js';\nimport { html } from './html.js';\n/** creates/returns a function that when called then calls the original component function\n * Gets used as templater.wrapper()\n */\nexport function getTagWrap(templater, result) {\n    const stateArray = setUse.memory.stateConfig.array;\n    // this function gets called by taggedjs\n    const wrapper = function (lastTagSupport, subject) {\n        const global = lastTagSupport.global;\n        ++global.renderCount;\n        const childSubject = templater.children;\n        const lastArray = global.oldest?.templater.children.lastArray;\n        if (lastArray) {\n            childSubject.lastArray = lastArray;\n        }\n        // result.original\n        const originalFunction = result.original; // (innerTagWrap as any).original as unknown as TagComponent\n        let props = templater.props;\n        // When defined, this must be an update where my new props have already been made for me\n        const preCastedProps = lastTagSupport.propsConfig.castProps;\n        const castedProps = preCastedProps || castProps(props, lastTagSupport, stateArray);\n        const latestCloned = props.map(props => deepClone(props)); // castedProps\n        // CALL ORIGINAL COMPONENT FUNCTION\n        let tag = originalFunction(...castedProps);\n        if (tag instanceof Function) {\n            tag = tag();\n        }\n        if (!tag || tag.tagJsType !== ValueTypes.tag) {\n            tag = html `${tag}`; // component returned a non-component value\n        }\n        tag.templater = templater;\n        templater.tag = tag;\n        tag.memory.arrayValue = templater.arrayValue; // tag component could have been used in array.map\n        const tagSupport = new TagSupport(templater, lastTagSupport.ownerTagSupport, subject, castedProps, global.renderCount);\n        tagSupport.global = global;\n        const nowState = setUse.memory.stateConfig.array;\n        tagSupport.memory.state.push(...nowState);\n        if (templater.madeChildIntoSubject) {\n            const value = childSubject.value;\n            for (let index = value.length - 1; index >= 0; --index) {\n                const kid = value[index];\n                const values = kid.values;\n                for (let index = values.length - 1; index >= 0; --index) {\n                    const value = values[index];\n                    if (!(value instanceof Function)) {\n                        continue;\n                    }\n                    const valuesValue = kid.values[index];\n                    if (valuesValue.isChildOverride) {\n                        continue; // already overwritten\n                    }\n                    // all functions need to report to me\n                    kid.values[index] = function (...args) {\n                        const ownerSupport = tagSupport.ownerTagSupport;\n                        return runTagCallback(value, // callback\n                        ownerSupport, this, // bindTo\n                        args);\n                    };\n                    valuesValue.isChildOverride = true;\n                }\n            }\n        }\n        return tagSupport;\n    };\n    return wrapper;\n}\n","import { BaseTagSupport } from './TagSupport.class.js';\nimport { runAfterRender, runBeforeRender } from './tagRunner.js';\nimport { ValueSubject } from '../subject/ValueSubject.js';\nconst appElements = [];\n/**\n *\n * @param app taggedjs tag\n * @param element HTMLElement\n * @param props object\n * @returns\n */\nexport function tagElement(app, // (...args: unknown[]) => TemplaterResult,\nelement, props) {\n    const appElmIndex = appElements.findIndex(appElm => appElm.element === element);\n    if (appElmIndex >= 0) {\n        appElements[appElmIndex].tagSupport.destroy();\n        appElements.splice(appElmIndex, 1);\n        // an element already had an app on it\n        console.warn('Found and destroyed app element already rendered to element', { element });\n    }\n    // Create the app which returns [props, runOneTimeFunction]\n    const wrapper = app(props);\n    // have a function setup and call the tagWrapper with (props, {update, async, on})\n    const tagSupport = runWrapper(wrapper);\n    tagSupport.appElement = element;\n    tagSupport.isApp = true;\n    tagSupport.global.isApp = true;\n    const templateElm = document.createElement('template');\n    templateElm.setAttribute('id', 'app-tag-' + appElements.length);\n    templateElm.setAttribute('app-tag-detail', appElements.length.toString());\n    const fragment = document.createDocumentFragment();\n    fragment.appendChild(templateElm);\n    element.destroy = async () => {\n        await tagSupport.destroy();\n        const insertBefore = tagSupport.global.insertBefore;\n        const parentNode = insertBefore.parentNode;\n        parentNode.removeChild(insertBefore);\n    };\n    tagSupport.buildBeforeElement(templateElm);\n    tagSupport.global.oldest = tagSupport;\n    tagSupport.global.newest = tagSupport;\n    element.setUse = app.original.setUse;\n    appElements.push({ element, tagSupport });\n    element.appendChild(fragment);\n    return {\n        tagSupport,\n        tags: app.original.tags,\n    };\n}\nexport function runWrapper(templater) {\n    let newSupport = {};\n    // TODO: A fake subject may become a problem\n    const subject = new ValueSubject(newSupport);\n    newSupport = new BaseTagSupport(templater, subject);\n    subject.next(templater);\n    subject.tagSupport = newSupport;\n    runBeforeRender(newSupport, undefined);\n    // Call the apps function for our tag templater\n    const wrapper = templater.wrapper;\n    const tagSupport = wrapper(newSupport, subject);\n    runAfterRender(newSupport, tagSupport);\n    return tagSupport;\n}\n","export * from './tag/index.js';\nexport * from './errors.js';\nexport * from './subject.types.js';\nexport * from './isInstance.js';\nexport * from './state/index.js';\nexport * from './subject/index.js';\nexport * from './tag/TagSupport.class.js';\nexport * from './interpolations/ElementTargetEvent.interface.js';\nexport * from './interpolations/interpolateElement.js';\nexport * from './interpolations/InsertBefore.type.js';\nexport { tagElement } from './tag/tagElement.js';\nexport { Tag, variablePrefix } from './tag/Tag.class.js';\nexport { runBeforeRender } from './tag/tagRunner.js';\nexport { renderTagSupport } from './tag/render/renderTagSupport.function.js';\nexport { renderWithSupport } from './tag/render/renderWithSupport.function.js';\nexport { isLikeValueSets } from './tag/isLikeTags.function.js';\nimport { renderTagOnly } from './tag/render/renderTagOnly.function.js';\nimport { renderTagSupport } from './tag/render/renderTagSupport.function.js';\nimport { renderWithSupport } from './tag/render/renderWithSupport.function.js';\nimport { tagElement } from './tag/tagElement.js';\nexport const hmr = {\n    tagElement, renderWithSupport, renderTagSupport,\n    renderTagOnly,\n};\n"],"names":["ValueTypes","__webpack_require__","exports","definition","key","o","Object","defineProperty","enumerable","get","obj","prop","prototype","hasOwnProperty","call","RouteQuery","name","isStaticTag","value","tag","templater","includes","tagJsType","isTagTemplater","isTagComponent","tagComponent","isTagClass","isSubjectInstance","subject","isSubject","subscribe","isTagArray","Array","every","x","combineLatest","subjects","output","Subject","subscribeWith","callback","valuesSeen","values","setValue","index","length","subscription","clones","shift","subscriptions","map","runPipedMethods","methods","onComplete","cloneMethods","firstMethod","next","newValue","handler","methodResponse","setHandler","onSubscription","subscribers","_value","set","constructor","this","defineValueOn","countSubject","globalSubCount$","unsubscribe","findIndex","sub","splice","removeSubFromArray","add","push","getSubscription","orgCallback","lastValue","emit","subs","toPromise","Promise","res","toCallback","_subscription","pipe","operations","setMethods","all","args","arg","static","ValueSubject","super","willCallback","utils","willPromise","then","willSubscribe","getSupportInCycle","setUse","memory","stateConfig","tagSupport","use","useMe","beforeRender","beforeRedraw","afterRender","beforeDestroy","tagUse","TagError","Error","details","message","errorCode","ArrayNoKeyError","StateMismatchError","SyncCallbackError","array","state","config","rearray","stateLength","getStateValue","initState","defaultValue","checkValue","oldState","StateEchoBack","getCallbackValue","toString","JSON","stringify","console","error","wrapper","oldStates","newStates","tagFunction","parentWrap","original","warn","item","syncStates","stateFrom","stateTo","fromValue","getSetMethod","restate","oldValue","initValue","Function","newState","global","newest","result","watch","currentValues","setupWatch","defaultFinally","init","before","final","previous","pastResult","undefined","previousValues","defineOnMethod","getWatch","attachTo","setup","oldWatch","firstSupport","method","nowTagSupport","setTo","oldestState","letState","makeStateResult","y","letProp","getSetProp","myProp","deepClone","makeDeepClone","WeakMap","visited","has","Date","RegExp","clone","isArray","create","getPrototypeOf","i","deepEqual","obj1","obj2","isDeepEqual","fn0","fn1","getTime","isArrayDeepEqual","keys1","keys","keys2","isObjectDeepEqual","newWatch","providers","constructMethod","stateDiffMemory","stateDiff","provider","oldStateCount","instance","owner","children","cm","compareTo","inject","ownerTagSupport","find","msg","isLikeTags","tagSupport0","tagSupport1","templater0","templater1","tag0","tag1","strings0","strings","strings1","string","isLikeValueSets","values0","values1","runBeforeRender","ownerSupport","runAfterRender","tagClosed$","runBeforeDestroy","deleted","hasLiveElements","childTags","filter","child","oldest","forEach","renderTagOnly","newTagSupport","prevSupport","oldRenderCount","renderCount","parentSupport","lastOwnerSupport","runtimeOwnerSupport","lastState","runBeforeRedraw","beforeWithRender","reSupport","variablePrefix","escapeVariable","escapeSearch","Tag","arrayValue","html","destroyTagMemory","oldTagSupport","destroy","context","insertAfter","newNode","referenceNode","parentNode","insertBefore","nextSibling","isSimpleType","destroyArrayTag","counts","stagger","removed","removeChild","restoreTagMarker","lastSupport","placeholderElm","placeholder","getValueType","type","function","date","tagArray","unknown","cloneValueArray","props","getChildTagsToDestroy","allTags","cTag","TemplaterResult","tagged","madeChildIntoSubject","childSubject","templaterResult","kid","kidsToTagArraySubject","processNewTag","TagSupport","swapInsertBefore","document","createTextNode","specialAttribute","element","names","split","style","classList","remove","hasPropChanges","pastCloneProps","castedProps","castedPastProps","compare","subCastedProps","subCompareProps","matched","entries","compareProps","onDelete","compareOriginal","processTagResult","subjectTag","newSupport","updateBy","processTagResultUpdate","buildBeforeElement","processSubjectComponent","options","label","substring","preClones","renderWithSupport","myClones","fClone","renderSubjectComponent","castProps","stateArray","checkProp","alterProp","newProp","seen","toCall","wrap","callWith","noCycle","run","allMatched","renderTagSupport","callbackPropOwner","assign","getPropWrap","subValue","afterCheckProp","hasSetter","getOwnPropertyDescriptor","pastValue","destroy$","updateExistingTagComponent","renderUp","oldWrapper","newWrapper","isSameTag","added","hasChanged","newTemplater","propsChanged","propsConfig","latestCloned","propsChanged2","kidsChanged","oldCloneKidValues","lastClonedKidValues","newClonedKidValues","hasKidsChanged","hasTagSupportChanged","newPropsArray","priorPropConfig","priorPropsArray","newArray","syncPriorPropFunction","syncFunctionProps","locked","blocked","isLikeTag","oldestTag","oldInsertBefore","buildNewTag","afterTagRender","priorProp","oldOwnerState","useLocks","runTagCallback","bindTo","findTagToCallback","bind","callbackResult","lastResult","block","checkAfterCallbackPromise","last","renderCallbackSupport","afterTagCallback","startRegX","endRegX","isTagVar","search","processAttribute","attrName","scope","howToSet","getContextValueByVarString","processNameValueAttr","processScopedNameValueAttr","attrValue","removeAttribute","processNameOnlyAttr","isSpecialAttr","replace","reverse","join","isSpecial","action","newAttrValue","oneRender","isChildOverride","subjectFunction","bindSubjectCallback","processAttributeSubjectValue","callbackFun","fun","howToSetAttribute","setAttribute","howToSetInputValue","interpolateAttributes","attrNames","getAttributeNames","nodeName","getAttribute","interpolateReplace","processTag","newTagSupportByTemplater","tagFakeTemplater","getFakeTemplater","fake","isTag","setupNewSupport","processTagArray","lastArray","setPlaceholderElm","runtimeInsertBefore","destroyArrayItem","subTag","tagClass","prevArrayValue","destroyItem","valueA","valueB","areLikeValues","previousSupport","itemSubject","setupNewTemplater","template","getTemplate","processAddTagArrayItem","fragment","createDocumentFragment","newTempElm","createElement","appendChild","updateBeforeTemplate","lastFirstChild","parent","textNode","castTextValue","processRegularValue","castedValue","oldClone","textContent","oneRenderToTagSupport","processFirstSubjectValue","v","processFirstRegularValue","updateExistingValue","valueType","displaySubject","hasLastValue","newType","destroySimpleValue","arraySubject","wasArray","isValueTag","checkDestroyPrevious","subjectSup","newestState","prepareUpdateToComponent","isClass","valueSupport","handleStillTag","interpolateTemplate","hasAttribute","variableName","existingSubject","subscribeToTemplate","called","onValue","mutatingCallback","afterElmBuild","elm","textarea","match","dynamic","_elm","_name","scanTextAreaValue","diff","onInitDoubleWrap","oninit","onInitWrap","onInit","target","elementInitCheck","focus","select","interpolateContentTemplates","tagComponents","subChild","isRenderEndTemplate","nextClones","nextTagComponent","tagName","interpolateElement","container","interpolatedTemplates","interpolation","content","nextTagComponents","processChildrenAttributes","interpolateString","expression","startsWith","id","interpolateToTemplates","afterInterpolateElement","temporary","firstChild","nextNextSibling","buildClones","prefixSearch","BaseTagSupport","isApp","appElement","clonePropsBy","kidValue","latest","setTagPlaceholder","update","elementContainer","tempDraw","innerHTML","thisTag","updateContext","_string","updateContextItem","processNewValue","tempTag","updateConfig","updateValues","byParent","firstDestroy","destroySubscriptions","subGlobal","mainPromise","checkRestoreTagMarker","promise","destroyClones","resetTagSupport","async","promises","oldClones","checkCloneRemoval","oldContext","customElm","ondestroy","onDestroyDoubleWrap","onDestroyWrap","onDestroy","elementDestroyCheck","compareClone","version","getAppTagSupport","support","softDestroySupport","destroyUnlikeTags","oldGlobal","moveProviders","placeParent","insertParent","handleProviderChanges","appSupport","tagsWithProvider","getTagsWithProvider","renderExistingTag","oldestSupport","preRenderCount","providersWithChanges","providersChangeCheck","ownerTag","selfPropChange","callbackStateUpdate","maybePromise","finally","innerCallback","a","b","c","d","e","f","callbackMaker","originalGetter","initMemory","setCurrentTagSupport","childrenCurrentSupport","tags","tagCount","innerTagWrap","lastTagSupport","originalFunction","nowState","valuesValue","getTagWrap","tagIndex","route","routeProps","app","routeTag","oneRenderFunction","appElements","tagElement","appElmIndex","appElm","runWrapper","templateElm","hmr"],"sourceRoot":""}