{"version":3,"sources":["jsdelivr-header.js","/npm/wesl@0.7.23/dist/index.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,ACJG,IAAC,EAAM,QAAQ,IAEb,MAAC,GAAQ,EAER,GAAa,EAEnB,eAAe,EAAgB,EAAO,GACrC,MAAM,EAAO,EACb,IAEC,OADA,EAAM,QACO,GACf,CAAE,QACA,EAAM,CACR,CACA,CAMA,SAAS,EAAO,EAAK,KAAQ,GAC5B,GAAmB,iBAAR,EAEV,YADA,EAAe,EAAK,EAAK,KAAQ,GAGlC,MAAQ,IAAK,EAAS,UAAE,GAGzB,SAAyB,EAAQ,GAChC,MAAM,EAAS,EAAO,gBAAgB,CAAC,GAAS,SAC1C,IAAE,GAAQ,EAAO,GACvB,IAAI,EACwE,EAAxE,EAAO,IAAI,KAAK,OAAS,EAAI,MAAQ,EAAO,IAAI,KAAK,OAAS,EAAI,KAAkB,EAAO,KAAK,GAAM,EAAE,WAC3F,EAAO,GAAG,SAC3B,MAAO,CACN,MACA,YAEF,CAbuC,CAAgB,EAAK,GAC3D,EAAe,EAAK,EAAU,KAAM,KAAc,EACnD,CAYA,SAAS,EAAe,EAAO,EAAK,KAAQ,GAC3C,KAAS,GACT,MAAM,KAAE,EAAI,QAAE,EAAO,QAAE,EAAO,SAAE,GAWjC,SAAiB,EAAK,GACrB,IAAI,EACA,EACoB,iBAAb,EAAuB,EAAM,GAClC,EAAK,GAAQ,EACnB,MAAM,EAoBP,SAAmB,GAClB,MAAM,EAAQ,EAAW,IAAI,GAC7B,GAAI,EAAO,OAAO,EAClB,MAAM,EAAS,IAAI,EAAI,SAAS,QAAQ,KAAK,GAAM,EAAE,MAAQ,IAG7D,OAFA,EAAO,QAAQ,GACf,EAAW,IAAI,EAAK,GACb,CACR,CA3BgB,CAAU,GACzB,IAQI,EARA,EAAQ,EACR,EAAM,EAAO,OAAS,EACtB,GAAO,EAAO,KAAM,EAAQ,GAChC,KAAO,EAAQ,EAAI,GAAK,CACvB,MAAM,EAAM,EAAQ,GAAO,EACvB,GAAO,EAAO,GAAM,EAAQ,EAC3B,EAAM,CACb,MAEc,IAAT,GAAmB,GAAQ,EAAO,IAAU,EAAO,EAAO,KAAM,EAAW,EAAO,EAAO,IAC7F,MAAM,EAAS,EAAI,MAAM,EAAO,GAAQ,EAAO,EAAQ,IAAM,EAAI,QACjE,MAAO,CACN,KAA2B,OAArB,EAAO,OAAO,GAAc,EAAO,MAAM,GAAI,GAAK,EACxD,QAAS,EAAM,EAAO,GACtB,WACA,QAAS,EAAQ,EAEnB,CAlC8C,CAAQ,EAAK,GAC1D,EAAM,EAAM,QAAQ,KACpB,EAED,SAAgB,EAAS,GACxB,MAAM,EAAS,IAAI,OAAO,KAAK,IAAI,EAAG,IAChC,EAAY,EAAW,EAAW,EAAU,EAClD,OAAO,EAAS,IAAI,OAAO,KAAK,IAAI,EAAG,GACxC,CANO,CAAO,EAAS,GACvB,CAMA,MAAM,EAA6B,IAAI,IA2CvC,SAAS,EAAgB,EAAW,IAJpC,SAAoB,EAAW,GAC9B,IAAK,EAAW,MAAM,IAAI,MAAM,EACjC,CAGY,CAAW,EAAW,EAClC,CAOA,SAAS,EAAkB,GAC1B,MAAM,IAAI,EAAc,oBAAqB,CAAE,KAAM,GACtD,CACA,IAAI,EAAgB,cAAc,MACjC,KACA,WAAA,CAAY,EAAS,GACpB,MAAM,EAAS,GACf,KAAK,KAAO,GAAS,IACvB,GAKA,SAAS,EAAY,EAAG,EAAG,EAAG,GAC7B,MAAM,EAAO,EAAE,IAAI,IAAsB,IAAI,IAC7C,EAAE,IAAI,EAAG,GACT,EAAK,IAAI,EAAG,EACb,CACA,MAAM,EAAa,cAInB,SAAS,EAAa,EAAM,GAC3B,OAAO,EAAK,WAAW,GAAa,GAAM,KAAK,EAAU,EAAQ,GAAK,GACvE,CAEA,SAAS,EAAQ,EAAG,EAAM,EAAS,GAClC,MAAM,EAAS,GACf,IAAK,IAAI,EAAI,EAAG,EAAI,EAAE,OAAQ,GAAK,EAAQ,EAAO,KAAK,EAAE,MAAM,EAAG,EAAI,IACtE,OAAO,CACR,CAEA,SAAS,EAAQ,EAAG,GACnB,MAAM,EAAyB,IAAI,IACnC,IAAK,MAAM,KAAK,EAAG,CAClB,MAAM,EAAI,EAAI,GACR,EAAQ,EAAO,IAAI,IAAM,GAC/B,EAAM,KAAK,GACX,EAAO,IAAI,EAAG,EAChB,CACC,OAAO,CACR,CAEA,SAAS,EAAU,EAAG,GACrB,MAAM,EAAU,GACV,EAAS,GACf,IAAK,MAAM,KAAK,EAAO,EAAO,GAAI,EAAQ,KAAK,GAC1C,EAAO,KAAK,GACjB,MAAO,CAAC,EAAS,EAClB,CAGA,SAAS,EAAK,EAAO,EAAI,GACxB,MAAM,EAAS,CAAC,GAChB,IAAI,EAAU,EACd,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,IACjC,EAAU,EAAG,EAAM,GAAI,GACvB,EAAO,KAAK,GAEb,OAAO,CACR,CAKA,SAAS,EAAW,EAAG,GACtB,MAAM,EAAW,OAAO,QAAQ,GAAG,KAAI,EAAE,EAAK,KACtC,CAAC,EAAK,KAAS,EAAI,EAAE,GAAS,KAEtC,OAAO,OAAO,YAAY,EAC3B,CAEA,SAAS,EAAK,GACb,OAAO,EAAE,EAAE,OAAS,EACrB,CAKA,SAAS,EAAY,EAAG,GACvB,IAAI,EAAc,KAAK,IAAI,EAAE,OAAQ,EAAE,QACvC,KAAO,EAAc,IAAO,EAAY,EAAE,OAAO,GAAc,EAAE,MAAM,EAAG,KACrE,IACL,GAAI,EAAa,OAAO,EAAE,MAAM,EACjC,CACA,SAAS,EAAY,EAAG,GACvB,OAAO,EAAE,SAAW,EAAE,QAAU,EAAE,OAAM,CAAC,EAAK,IAAU,IAAQ,EAAE,IACnE,CAEA,SAAS,EAAU,EAAK,GACvB,MAAM,EAAM,GACZ,IAAK,MAAM,KAAK,EAAK,CACpB,MAAM,EAAI,EAAG,GACT,GAAG,EAAI,KAAK,EAClB,CACC,OAAO,CACR,CAEA,SAAS,EAAQ,EAAK,GACrB,IAAK,MAAM,KAAK,EAAK,CACpB,MAAM,EAAI,EAAG,GACb,GAAI,EAAG,OAAO,CAChB,CACA,CAGA,SAAS,EAAU,EAAK,GACvB,OAAO,OAAO,YAAY,OAAO,QAAQ,GAAK,KAAI,EAAE,EAAG,KAAO,CAAC,EAAG,EAAG,MACtE,CAIA,SAAS,EAAmB,EAAQ,GACnC,MAAM,EAAa,KAAK,IAAI,EAAK,OAAQ,KAAK,IAAI,EAAG,IACrD,IAAI,EAAkB,EAClB,EAAU,EACd,OAAa,CACZ,MAAM,EAAU,EAAK,QAAQ,KAAM,GACnC,IAAiB,IAAb,GAAkB,GAAc,EAAS,CAE5C,MAAO,CAAC,EADa,EAAa,EAAlB,EAEnB,CACG,EAAkB,EAAU,EAC5B,GAAW,CAEd,CACA,CAKA,SAAS,EAAe,EAAQ,GAC/B,IAAI,EAAkB,EAAO,YAAY,KAAM,EAAK,IACpD,GAAuC,IAArB,EAAyB,EAAI,EAAkB,EACjE,IAAI,EAAgB,EAAO,QAAQ,KAAM,EAAK,KACvB,IAAnB,IAAsB,EAAgB,EAAO,QACjD,MAAM,EAAc,EAAK,GAAK,EAAK,GAC7B,EAAa,KAAK,IAAI,EAAG,GACzB,EAAU,KAAK,IAAI,EAAG,EAAK,GAAK,GACtC,MAAO,CAAC,EAAO,MAAM,EAAiB,GAAgB,IAAI,OAAO,GAAW,IAAI,OAAO,GACxF,CAcA,MAAM,EAAkB,GAKxB,SAAS,EAAU,GAClB,GAAqB,iBAAV,EAAoB,OAAO,EAAe,GACrD,IAAI,EAAS,GACb,IAAK,IAAI,EAAI,EAAG,EAAI,EAAM,OAAQ,GAAK,EAAG,GAAU,EAAe,EAAM,IACzE,OAAO,CACR,CACA,SAAS,EAAe,GACvB,IACI,EADA,EAAS,GAEA,EAAT,EAAM,GAAU,GAAO,EAAI,EACpB,GAAO,EAClB,EAAG,CACF,IAAI,EAAgB,GAAN,EACd,KAAS,EACL,EAAM,IAAG,GAAW,IACxB,GAAU,EAAgB,EAC5B,OAAU,EAAM,GACf,OAAO,CACR,CAtBA,oEAAoE,MAAM,IAAI,SAAQ,CAAC,EAAM,KAE5F,EAAgB,GAAK,CAAI,IAwB1B,MAAM,EAAY,aAAc,WAGhC,SAAS,EAAoB,GAC5B,MAAM,IAAE,EAAG,KAAE,EAAI,WAAE,EAAU,WAAE,EAAU,OAAE,EAAM,MAAE,GAAU,EACvD,EAAe,CACpB,KAAM,EACN,KAAM,EACN,OAAQ,EACR,UAGD,GADA,EAAM,aAAe,GACN,EAAW,MAAM,EAChC,MAWM,EAAY,CACjB,QAAS,EACT,KAAM,KACN,QAAS,CAAC,GACV,eAAgB,CAAC,GAAQ,MACzB,MAAO,GACP,SAjBgB,EAAU,CAC1B,EACA,EACA,KAAK,IAAI,EAAG,EAAa,GACzB,KAAK,IAAI,EAAG,EAAa,KACrB,IAAM,EAAU,CACpB,GACA,EACA,KAAK,IAAI,EAAG,EAAa,GACzB,KAAK,IAAI,EAAG,EAAa,GAAK,KAU/B,IAAI,EAAgB,mBAAmB,KAAK,UAAU,EAAM,QAAU,OACtE,GAAiB,uDAAyD,KAAK,SAAS,mBAAmB,KAAK,UAAU,MAC1H,GAAiB,mBAAqB,EAAU,QAAQ,GACxD,IAAI,EAAW,EACX,oBAAqB,QACxB,EAAW,MAAM,gBACjB,MAAM,gBAAkB,GAEzB,KACC,EAAI,MAAM,EACZ,CAAG,MAAO,GAKR,KAJI,oBAAqB,QAAO,MAAM,gBAAkB,GACxD,EAAM,QAAU,GACL,EAAE,MAAQ,EACrB,EAAE,aAAe,EACX,CACR,CACA,CAEA,SAAS,EAAU,EAAO,GACzB,MAAM,aAAE,EAAY,aAAE,GAAiB,EACjC,EAAc,GAAO,IAAI,KAC/B,IAAI,EACC,MAAM,IAAI,MAAM,GADH,EAAc,EAAc,EAE/C,CAEA,SAAS,EAAc,EAAW,EAAM,IACvC,MAAM,UAAE,EAAS,MAAE,EAAK,IAAE,GAAQ,GAC5B,cAAE,EAAa,IAAE,GAAQ,EACzB,EAAkB,GAAG,cAAgB,IAC3C,EAAO,EAAK,CAAC,EAAO,GAAM,GAC1B,MAAO,EAAY,GAAc,EAAmB,EAAO,GAC3D,EAAoB,CACnB,IAAK,EACL,KAAM,EACN,aACA,aACA,OAAQ,EAAM,EACd,MAAO,IAAI,MAAM,IAEnB,CAcA,SAAS,EAAqB,EAAY,GACzC,MAAM,KAAE,GAAS,EACjB,GAAa,qBAAT,EAEH,OADA,EAA8C,MAA9B,EAAW,SAAS,QAC5B,EAAqB,EAAW,WAAY,GAC9C,GAAa,sBAAT,EAOJ,IAAa,YAAT,EAAoB,CAC9B,MAAM,MAAE,GAAU,EAElB,OADA,EAA0B,SAAV,GAA8B,UAAV,GACnB,SAAV,CACT,CAAQ,GAAa,6BAAT,EAAqC,OAAO,EAAqB,EAAW,WAAY,GAC9F,GAAa,QAAT,EAAgB,OAAO,EAAW,EAAW,MAAM,gBAAiB,EACxE,MAAM,IAAI,MAAM,6BAA6B,KAAK,UAAU,KAAc,CAbtC,CACxC,MAAM,EAAK,EAAW,SAAS,MAC/B,EAAuB,OAAP,GAAsB,OAAP,GAC/B,MAAM,EAAa,EAAqB,EAAW,KAAM,GACzD,GAAW,OAAP,EAAa,OAAO,GAAc,EAAqB,EAAW,MAAO,GACxE,GAAW,OAAP,EAAa,OAAO,GAAc,EAAqB,EAAW,MAAO,GAC7E,EAAkB,EACzB,CAOA,CASA,SAAS,EAAoB,EAAU,GACtC,IAAI,GAAY,EAChB,OAAO,EAAS,SAAS,IACxB,MAAM,EAAa,EAAE,YACf,MAAE,EAAK,cAAE,GAyCjB,SAA4B,EAAY,EAAW,GAClD,OAAO,EAAoB,EAAgB,GAAa,EAAW,EACpE,CA3CmC,CAAmB,EAAY,EAAW,GAE3E,OADA,EAAY,EACL,EAAQ,CAAC,GAAK,EAAE,GAEzB,CAKA,SAAS,EAAoB,EAAe,EAAW,GACtD,IAAK,EAAe,MAAO,CAC1B,OAAO,EACP,cAAe,GAEhB,GAA2B,QAAvB,EAAc,KAAgB,CACjC,MAAM,EAxDR,SAA6B,EAAa,GACzC,OAAO,EAAqB,EAAY,MAAM,WAAY,EAC3D,CAsDgB,CAAoB,EAAe,GACjD,MAAO,CACN,QACA,eAAgB,EAEnB,CAAQ,GAA2B,UAAvB,EAAc,KAAkB,CAC1C,IAAK,EAAW,MAAO,CACtB,OAAO,EACP,eAAe,GAEhB,MAAM,EA9DR,SAA+B,EAAe,GAC7C,OAAO,EAAqB,EAAc,MAAM,WAAY,EAC7D,CA4DgB,CAAsB,EAAe,GACnD,MAAO,CACN,QACA,eAAgB,EAEnB,CAAQ,MAAO,CACb,MAAO,EACP,eAAe,EAEjB,CAWA,SAAS,EAAgB,GACxB,GAAK,EACL,IAAK,MAAM,KAAQ,EAAY,CAC9B,MAAM,EAAO,EAAK,UAAU,KAC5B,GAAa,QAAT,GAA2B,UAAT,GAA6B,UAAT,EAAkB,OAAO,EAAK,SAC1E,CACA,CAMA,SAAS,EAAW,EAAG,GACjB,IACL,EAAgB,EAAE,OAAS,EAAE,MAC7B,EAAgB,EAAE,SAAW,EAAE,QAC/B,GAAiB,EAAE,eACnB,EAAE,SAAW,EAAE,SAAS,OAAO,EAAE,UAClC,CAEA,SAAS,IACR,EAAU,EACV,EAAU,CACX,CACA,IAAI,EAAU,EACV,EAAU,EACd,SAAS,IACR,OAAO,GACR,CAEA,SAAS,EAAW,EAAQ,EAAO,SAClC,MAAO,CACN,GAAI,IACJ,OACA,SACA,SAAU,GAEZ,CAGA,SAAS,EAAc,EAAW,GACjC,GAAI,IAAU,EAAW,OAAO,EAChC,IAAK,MAAM,KAAS,EAAU,SAAU,GAAI,EAAW,IAAU,EAAc,EAAO,GAAQ,OAAO,EACrG,OAAO,CACR,CAGA,SAAS,EAAW,GACnB,MAAM,KAAE,GAAS,EACjB,MAAgB,YAAT,GAA+B,UAAT,CAC9B,CAGA,SAAS,EAAW,GACnB,OAAQ,EAAW,EACpB,CAIK,MAAC,EAAS,usDA4BuC,MAAM,OACtD,EAAsB,8FAItB,EAA2B,8DAG3B,EAAsB,8FAItB,EAAW,2WASb,QACA,4BAEA,0TAQU,MAAM,OAEd,EAAgB,mQAK0B,MAAM,OAGhD,EAAyB,IAAI,IAAI,CACtC,QACA,UACA,YACA,UACA,QACA,WACA,QACA,KACA,YACA,WACA,WACA,OACA,SACA,mBAGD,SAAS,EAAQ,GAChB,OAAO,EAAS,SAAS,EAC1B,CAEA,SAAS,GAAM,GACd,OAAO,EAAO,SAAS,IAAS,EAAQ,EACzC,CAEA,SAAS,GAAa,GACrB,OAAO,EAAc,SAAS,EAC/B,CAKA,SAAS,GAAa,GACrB,MAAM,WAAE,EAAU,UAAE,EAAS,WAAE,GAAe,GACxC,WAAE,GAAa,EAAI,yBAAE,GAA2B,GAAU,EAC1D,EAAc,CACnB,aACA,aACA,cAEK,EAAgB,EAA2B,EAAY,EAAoB,EAAW,GAC5F,IAAK,MAAM,KAAK,EAAe,GAAiB,EAAG,EACpD,CACA,SAAS,GAAiB,EAAG,GAC5B,OAAQ,EAAE,MACT,IAAK,SAAU,OACf,IAAK,OAEJ,YA6FH,SAAkB,EAAG,GACpB,EAAI,WAAW,QAAQ,EAAE,MAAO,EAAE,IACnC,CAhGG,CAAS,EAAG,GAEb,IAAK,OAEJ,YA6FH,SAAkB,EAAG,GACpB,EAAI,WAAW,IAAI,EAAE,KAAM,EAAE,MAAO,EAAE,IACvC,CAhGG,CAAS,EAAG,GAEb,IAAK,YAEJ,YA6JH,SAAuB,EAAG,GACzB,MAAM,KAAE,GAAS,EACjB,EAAI,WAAW,aAAa,EAAM,EAAM,EAAG,EAAK,OACjD,CAjKG,CAAc,EAAG,GAElB,IAAK,MAEJ,YADA,GAAa,EAAG,GAEjB,IAAK,OAEJ,YADA,GAAc,EAAG,GAElB,IAAK,UACL,IAAK,oBACL,IAAK,mBACL,IAAK,kBACL,IAAK,2BACL,IAAK,uBACL,IAAK,8BAEJ,YADA,GAAe,EAAG,GAEnB,IAAK,QACL,IAAK,WACL,IAAK,SACL,IAAK,YACL,IAAK,aACL,IAAK,OACL,IAAK,gBAEJ,YADA,GAAa,EAAG,GAEjB,IAAK,QAEJ,YAkCH,SAAmB,EAAG,GACrB,GAAyB,EAAG,EAC7B,CArCG,CAAU,EAAG,GAEd,IAAK,SAEJ,YAkCH,SAAoB,EAAG,GACtB,MAAM,EAAgB,EAAoB,EAAE,SAAU,EAAI,YAC1D,IAAK,MAAM,KAAS,EACA,SAAf,EAAM,MACwD,KAA7D,EAAM,UAAU,IAAI,MAAM,EAAM,MAAO,EAAM,KAAK,QAEvD,GAAiB,EAAO,EAE1B,CA3CG,CAAW,EAAG,GAEf,IAAK,MACL,IAAK,MACL,IAAK,YACL,IAAK,aAEJ,YAqCH,SAAyB,EAAG,GACrB,EAAE,SAAS,OAAS,GAA4B,cAAvB,EAAE,SAAS,GAAG,MAAuB,GAAe,EAAE,WAAY,GACjG,GAAa,EAAG,EACjB,CAzCG,CAAgB,EAAG,GAEpB,IAAK,WACL,IAAK,QACL,IAAK,SACL,IAAK,QACL,IAAK,OAEJ,YAkCH,SAAsB,EAAG,GACxB,GAAe,GACT,EAAE,SAAS,OAAS,GAA4B,cAAvB,EAAE,SAAS,GAAG,MAAuB,GAAe,EAAE,WAAY,GACjG,GAAyB,EAAG,EAC7B,CAvCG,CAAa,EAAG,GAEjB,IAAK,KAGJ,OAFA,GAAe,QAiDlB,SAAgB,EAAG,GAClB,MAAM,WAAE,EAAU,KAAE,EAAI,OAAE,EAAM,iBAAE,EAAgB,WAAE,EAAU,KAAE,GAAS,GACnE,WAAE,EAAY,WAAY,GAAY,EAC5C,GAAe,EAAY,GAC3B,EAAQ,IAAI,MAAO,EAAK,MAAQ,EAAG,EAAK,OACxC,GAAc,EAAM,GACpB,EAAQ,WAAW,KACnB,MAAM,EAAc,EAAoB,EAAQ,GAChD,EAAY,SAAQ,CAAC,EAAG,KACjB,EAAE,SAAS,OAAS,GAA4B,cAAvB,EAAE,SAAS,GAAG,MAAuB,GAAe,EAAE,WAAY,GACjG,GAAiB,EAAG,GAChB,EAAI,EAAY,OAAS,GAAG,EAAQ,WAAW,KAAK,IAEzD,EAAQ,WAAW,MACf,IACH,EAAQ,WAAW,OACnB,GAAe,EAAkB,GACjC,GAAiB,EAAY,GAC7B,EAAQ,WAAW,MAEpB,GAAa,EAAM,EACpB,CArEG,CAAO,EAAG,GAEX,IAAK,SAGJ,OAFA,GAAe,QAyElB,SAAoB,EAAG,GACtB,MAAM,WAAE,EAAU,KAAE,EAAI,QAAE,EAAO,MAAE,GAAU,GACvC,WAAE,EAAU,WAAE,GAAe,EAC7B,EAAe,EAAoB,EAAS,GAC5C,EAAc,EAAa,OACjC,GAAoB,IAAhB,EAEH,YAuBF,SAAyB,GACxB,MAAM,KAAE,EAAI,QAAE,GAAY,EACpB,EAAU,EAAQ,OAAS,4BAA8B,GAC/D,EAAc,EAAM,WAAW,EAAK,MAAM,gCAAgC,IAC3E,CA5BE,CAAgB,GAGjB,GAAe,EAAY,GAC3B,EAAW,IAAI,UAAW,EAAO,EAAK,OACtC,GAAc,EAAM,GACA,IAAhB,GACH,EAAW,WAAW,OACtB,GAAyB,EAAa,GAAI,GAC1C,EAAW,WAAW,MACtB,EAAW,UAEX,EAAW,WAAW,MACtB,EAAW,QACX,EAAa,SAAS,IACrB,EAAW,WAAW,MACtB,GAAiB,EAAG,GACpB,EAAW,WAAW,KACtB,EAAW,OAAO,IAEnB,EAAW,WAAW,KACtB,EAAW,QAEb,CArGG,CAAW,EAAG,GAEf,IAAK,YAEJ,YADA,GAAc,EAAG,GAElB,IAAK,YAEJ,YAmQH,SAAuB,EAAG,GACzB,MAAM,UAAE,GAAc,GAChB,KAAE,GAAS,EACjB,GAAa,eAAT,EAAuB,CAC1B,MAAM,EAAU,aAAa,GAA0B,EAAU,SAAU,EAAU,SACrF,EAAI,WAAW,IAAI,EAAS,EAAE,MAAO,EAAE,IACzC,MAAQ,GAAa,WAAT,EAAmB,CAC7B,MAAM,EAAO,EAAU,WAAW,KAAK,GAAM,EAAE,OAAM,KAAK,MAC1D,EAAI,WAAW,IAAI,UAAU,KAAS,EAAE,MAAO,EAAE,IACnD,MAAQ,GAAa,aAAT,EAAqB,CAC/B,MAAM,EAAO,EAAU,WAAW,KAAK,GAAM,EAAE,OAAM,KAAK,MAC1D,EAAI,WAAW,IAAI,YAAY,KAAS,EAAE,MAAO,EAAE,IACrD,MAAQ,EAAkB,EAC1B,CAjRG,CAAc,EAAG,GAElB,QAAS,EAAkB,GAE7B,CAuBA,SAAS,GAAe,GACvB,EAAI,WAAW,QACf,EAAI,WAAW,OAChB,CA8BA,SAAS,GAAe,EAAY,GACnC,GAAY,SAAS,IAChB,GAAc,EAAG,IAAM,EAAI,WAAW,IAAI,IAAK,EAAE,MAAO,EAAE,IAAI,GAEpE,CAyCA,SAAS,GAAa,EAAM,GAC3B,MAAM,EAAgB,EAAoB,EAAK,SAAU,EAAI,YAC7D,IAAK,MAAM,KAAK,EAAe,GAAiB,EAAG,EACpD,CAEA,SAAS,GAAyB,EAAM,GACvC,MAAM,EAAgB,EAAoB,EAAK,SAAU,EAAI,YACvD,EAAY,EAAc,WAAW,IAAO,GAAkB,KAC9D,EAAW,EAAc,eAAe,IAAO,GAAkB,KACvE,EAAc,SAAQ,CAAC,EAAM,KAC5B,GAAkB,SAAd,EAAK,KAAiB,CACzB,IAAI,EAAO,EAAK,UAAU,IAAI,MAAM,EAAK,MAAO,EAAK,KACjD,IAAM,IAAW,EAAO,EAAK,aAC7B,IAAM,IAAU,EAAO,EAAK,WAC5B,GAAM,EAAI,WAAW,IAAI,EAAM,EAAK,MAAO,EAAK,IACvD,MAAS,GAAiB,EAAM,EAAI,GAEpC,CACA,SAAS,GAAkB,GAC1B,GAAe,cAAX,EAAE,KAAsB,OAAO,EACnC,MAAM,KAAE,GAAS,EAAE,UACnB,MAAgB,QAAT,GAA2B,UAAT,GAA6B,UAAT,CAC9C,CAEA,SAAS,GAAiB,EAAM,GAC/B,EAAoB,EAAK,SAAU,EAAI,YAAY,SAAS,IAC3D,GAAe,SAAX,EAAE,KAAiB,CACtB,MAAM,UAAE,EAAS,MAAE,EAAK,IAAE,GAAQ,EAClC,GAA+C,KAA3C,EAAU,IAAI,MAAM,EAAO,GAAK,OAAe,MACtD,CACE,GAAiB,EAAG,EAAI,GAE1B,CACA,SAAS,GAAa,EAAG,GACxB,GAAI,EAAE,MAAM,IAAK,EAAI,WAAW,IAAI,EAAE,MAAM,aAAc,EAAE,MAAO,EAAE,SAChE,CACJ,MAAM,EAAc,GAAY,GAAS,EAAE,QAC3C,EAAI,WAAW,IAAI,EAAa,EAAE,MAAO,EAAE,IAC7C,CACA,CACA,SAAS,GAAc,EAAG,GACzB,MAAM,EAAc,GAAY,EAAE,OAClC,EAAI,WAAW,IAAI,EAAa,EAAE,MAAO,EAAE,IAC5C,CACA,SAAS,GAAe,EAAG,GAC1B,MAAM,KAAE,GAAS,EACjB,GAAa,YAAT,EAIJ,GAAa,QAAT,EAIJ,GAAa,SAAT,EAAJ,CAIA,GAAa,sBAAT,EAIH,OAHA,GAAe,EAAE,KAAM,GACvB,EAAI,WAAW,IAAI,IAAI,EAAE,SAAS,SAAU,EAAE,SAAS,KAAK,GAAI,EAAE,SAAS,KAAK,SAChF,GAAe,EAAE,MAAO,GAGzB,GAAa,qBAAT,EAGH,OAFA,EAAI,WAAW,IAAI,EAAE,SAAS,MAAO,EAAE,SAAS,KAAK,GAAI,EAAE,SAAS,KAAK,SACzE,GAAe,EAAE,WAAY,GAG9B,GAAa,6BAAT,EAAJ,CAIA,GAAa,oBAAT,EAMJ,MAAa,yBAAT,GACH,GAAe,EAAE,KAAM,QACvB,GAAe,EAAE,OAAQ,IAGb,gCAAT,GACH,GAAe,EAAE,KAAM,QACD,SAAlB,EAAE,OAAO,MAAiB,EAAI,WAAW,IAAI,EAAE,OAAO,KAAM,EAAE,OAAO,MAAO,EAAE,OAAO,YAG1F,EAAkB,GAdjB,GADA,GAAe,EAAE,SAAU,GACvB,EAAE,aAAc,IAAK,MAAM,KAAQ,EAAE,aAAc,GAAiB,EAAM,GAC9E,IAAK,MAAM,KAAO,EAAE,UAAW,GAAe,EAAK,EAJrD,MAFE,GAAe,EAAE,WAAY,EAb/B,MAFE,GAAa,EAAG,QAJhB,GAAa,EAAG,QAJhB,EAAI,WAAW,IAAI,EAAE,MAAO,EAAE,MAAO,EAAE,IA2CzC,CACA,SAAS,GAAc,EAAG,GACzB,MAAM,KAAE,GAAS,EAAE,UACnB,GAAa,QAAT,GAA2B,UAAT,GAA6B,UAAT,EAAkB,OAAO,EACnE,GAAa,eAAT,EACH,QAAK,EAAuB,IAAI,EAAE,UAAU,QAoB9C,SAA+B,EAAG,GACjC,GAAyB,eAArB,EAAE,UAAU,KAAuB,OACvC,MAAM,OAAE,GAAW,EAAE,UACrB,IAAK,GAA4B,IAAlB,EAAO,OAErB,YADA,EAAI,WAAW,IAAI,IAAM,EAAE,UAAU,KAAM,EAAE,MAAO,EAAE,KAGvD,EAAI,WAAW,IAAI,IAAM,EAAE,UAAU,KAAO,IAAK,EAAE,MAAO,EAAO,GAAG,OACpE,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,OAAQ,IAClC,GAAa,EAAO,GAAI,GACpB,EAAI,EAAO,OAAS,GAAG,EAAI,WAAW,IAAI,IAAK,EAAO,GAAG,IAAK,EAAO,EAAI,GAAG,OAEjF,EAAI,WAAW,IAAI,IAAK,EAAO,EAAO,OAAS,GAAG,IAAK,EAAE,IAC1D,CAhCE,CAAsB,EAAG,IAClB,GAER,GAAa,aAAT,EAEH,OADA,EAAI,WAAW,IAAI,YAAc,EAAE,UAAU,MAAM,KAAO,IAAK,EAAE,MAAO,EAAE,MACnE,EAER,GAAa,gBAAT,EAAwB,CAC3B,MAAM,EAAU,cAAgB,GAA0B,EAAE,UAAU,SAAU,EAAE,UAAU,MAE5F,OADA,EAAI,WAAW,IAAI,EAAS,EAAE,MAAO,EAAE,MAChC,CACT,CACC,GAAa,iBAAT,EAAyB,CAC5B,MAAM,EAAS,EAAE,UAAU,OAAO,KAAK,GAAM,EAAE,OAAM,KAAK,MAE1D,OADA,EAAI,WAAW,IAAI,gBAAgB,KAAW,EAAE,MAAO,EAAE,MAClD,CACT,CACC,EAAkB,EACnB,CAeA,SAAS,GAA0B,EAAU,GAC5C,MAAM,EAAU,EAAK,GAAG,MAAoB,OAAZ,EAAK,GAAc,IAAM,EAAK,GAAG,KAAO,IACxE,MAAO,IAAI,EAAS,SAAS,IAC9B,CACA,SAAS,GAAmB,GAC3B,MAAM,KAAE,GAAS,EACjB,OAAQ,GACP,IAAK,oBAAqB,CACzB,MAAM,EAAO,GAAmB,EAAK,MAC/B,EAAQ,GAAmB,EAAK,OACtC,MAAO,GAAG,KAAQ,EAAK,SAAS,SAAS,GAC5C,CACE,IAAK,mBAAoB,MAAO,GAAG,EAAK,SAAS,QAAQ,GAAmB,EAAK,cACjF,IAAK,MAAO,OAAO,EAAK,MAAM,aAC9B,IAAK,UAAW,OAAO,EAAK,MAC5B,IAAK,2BAA4B,MAAO,IAAI,GAAmB,EAAK,eACpE,IAAK,uBAAwB,MAAO,GAAG,GAAmB,EAAK,SAAS,EAAK,UAC7E,IAAK,8BAA+B,MAAO,GAAG,GAAmB,EAAK,SAAS,EAAK,SACpF,IAAK,kBAAmB,CACvB,MAAM,EAAK,EAAK,SAChB,MAAO,GAAe,QAAZ,EAAG,KAAiB,EAAG,MAAM,aAAe,EAAG,KAAK,eAAe,EAAK,aAAe,QAAU,MAAM,EAAK,UAAU,IAAI,IAAoB,KAAK,QAChK,CACE,IAAK,OAAQ,OAAO,EAAK,KAAK,aAC9B,QAAS,EAAkB,GAE7B,CAeA,SAAS,GAAY,GACpB,OAAI,EAAU,UACb,EAAgB,EAAU,YAAa,8CAA8C,GAAc,MAC5F,EAAU,aAEX,EAAU,aAAe,EAAU,YAC3C,CAEA,SAAS,GAAS,GACjB,IAAI,EAAI,EACR,EAAG,CACF,GAAe,SAAX,EAAE,KAAiB,OAAO,EAC9B,EAAI,EAAE,QACR,OAAU,GACT,MAAM,IAAI,MAAM,yBAAyB,EAAM,eAChD,CAOA,SAAS,GAAmB,GAC3B,MAAO,IAAI,EAAK,SAAS,KAAK,GAAM,EAAE,OAAO,GAAgB,EAAK,eAAe,KAAK,KACvF,CACA,SAAS,GAAgB,GACxB,GAAqB,gBAAjB,EAAQ,KAAwB,CACnC,MAAM,KAAE,EAAI,GAAE,GAAO,EACrB,MAAO,GAAG,IAAO,EAAK,OAAO,IAAO,IACtC,CAAQ,GAAqB,sBAAjB,EAAQ,KAA8B,MAAO,IAAI,EAAQ,SAAS,KAAK,GAAM,GAAmB,KAAI,KAAK,SAC/G,EAAkB,EACxB,CAOA,IAAI,GAAc,MACjB,GAAa,GACb,GAAU,EACV,GACA,IAAW,EACX,IAAa,EACb,GACA,SACA,OACA,WAAA,CAAY,EAAS,EAAG,EAAW,GAAI,EAAgB,GACtD,KAAK,SAAW,EAChB,KAAK,OAAS,EACd,MAAK,EAAO,IAAI,OAAO,GACvB,MAAK,EAAc,IAAI,OAAO,EAChC,CAEC,EAAA,GACC,MAAK,EAAW,KAAK,MACrB,MAAK,EAAU,EACf,MAAK,GAAW,EAChB,MAAK,GAAa,CACpB,CAEC,GAAA,CAAI,GACC,MAAK,EA2BX,SAAyB,GACxB,MAAM,EAAI,EAAE,QAAQ,MACpB,OAAc,IAAP,EAAW,EAAE,OAAS,CAC9B,CA9BqB,CAAgB,GAAK,KAAK,UAAU,KAAK,YACvC,IAAjB,MAAK,IACR,MAAK,EAAW,KAAK,MAAK,GACtB,MAAK,GAAY,MAAK,EAAW,KAAK,MAAK,GAC/C,MAAK,EAAU,KAAK,QAErB,MAAK,EAAW,KAAK,GACrB,MAAK,GAAW,EAAE,MACpB,CAEC,QAAA,CAAS,EAAG,GAAa,GACxB,MAAK,EAAW,KAAK,GACjB,GAAY,KAAK,IACvB,CAEC,UAAI,GACH,OAAO,MAAK,EAAW,KAAK,GAC9B,CAEC,WAAI,GACH,OAAO,MAAK,CACd,CACC,SAAA,GACC,KAAK,KACL,MAAK,GAAa,CACpB,GAUA,SAAS,GAAY,EAAM,EAAS,GACnC,MAAM,KAAE,GAAS,EACX,EAAM,IAAI,GAAY,EAHP,KAIrB,EAAI,IAAI,GAUT,SAAuB,EAAM,GAC5B,MAAM,KAAE,GAAS,EACjB,GAAa,WAAT,GAA8B,WAAT,GAA8B,UAAT,GAA6B,UAAT,GAA6B,kBAAT,EAA0B,OAChH,GAAa,SAAT,EAAiB,EAAI,IAAI,KAAK,EAAK,UAAU,IAAI,MAAM,EAAK,MAAO,EAAK,cACvE,GAAa,QAAT,GAA2B,QAAT,GAA2B,SAAT,GAA4B,UAAT,GAA6B,aAAT,EACnF,GAAkB,EAAK,KAAM,GAC7B,GAAmB,EAAK,WAAY,QAC9B,GAAa,WAAT,EAAmB,EAAI,IAAI,IAAM,EAAK,KAAK,MAAM,mBACvD,GAAa,WAAT,EACR,GAAmB,EAAK,WAAY,GACpC,EAAI,IAAI,IAAI,EAAK,KAAK,SAAS,GAAoB,EAAK,iBAClD,GAAa,SAAT,EAAiB,EAAI,IAAI,IAAM,EAAK,WAC1C,GAAa,cAAT,EAAsB,CAC9B,MAAM,EAAQ,EAAK,gBAAkB,GAAsB,EAAK,iBAAmB,GACnF,EAAI,IAAI,IAAI,EAAK,KAAK,MAAM,gBAAgB,EAAK,OAAO,OAAO,IACjE,MAAQ,GAAa,OAAT,GAsDZ,SAAqB,EAAM,GAC1B,MAAM,KAAE,EAAI,OAAE,EAAM,WAAE,EAAU,WAAE,GAAe,EAC3C,EAAY,EAAO,KAAK,IAC7B,MAAM,aAAE,GAAiB,EAAE,KAAK,KAAK,MACrC,MAAO,GAAG,MAAiB,GAAoB,EAAE,KAAK,UAAU,IAEjE,EAAI,IAAI,IAAI,EAAK,MAAM,gBAAgB,EAAU,KAAK,UACtD,GAAmB,EAAY,GAC3B,GAAY,EAAI,IAAI,OAAS,GAAoB,GACtD,CA/D2B,CAAY,EAAM,QACvC,GAAa,UAAT,EAAkB,CAC1B,MAAM,EAAkC,SAAzB,EAAK,KAAK,MAAM,KAAkB,IAAM,GACvD,EAAI,IAAI,IAAI,IAAS,EAAK,KAAK,MAAM,gBAAgB,GAAoB,EAAK,WAChF,MAAQ,GAAa,cAAT,EAAsB,GAAmB,EAAK,UAAW,QAC/D,GAAa,eAAT,EAAuB,CAC/B,MAAM,EAAW,EAAK,SAAS,KAAK,GAAiB,SAAX,EAAE,KAAkB,IAAI,EAAE,UAAU,IAAI,MAAM,EAAE,MAAO,EAAE,QAAU,GAAY,KAAI,KAAK,KAClI,EAAI,IAAI,IAAM,EAChB,MAAQ,GAAa,SAAT,EAAiB,CAC3B,MAAM,EAA+B,iBAAd,EAAK,KAAoB,EAAK,KAAO,EAAK,KAAK,aAChE,EAAS,EAAK,gBAAgB,IAAI,IAAuB,KAAK,MACpE,EAAI,IAAI,EAAS,IAAI,KAAW,KAAY,IAAI,IAClD,KAAqB,cAAT,EAAsB,EAAI,IAAI,KAAK,EAAK,SACjC,WAAT,GACR,EAAI,IAAI,KAvHF,GAuHuB,EAAK,SAvHD,MAwHjC,GAAmB,EAAK,WAAY,IACjB,QAAT,EAAgB,EAAI,IAAI,IAAM,EAAK,MAAM,cAClC,aAAT,EAAqB,GAAkB,EAAM,GACpC,SAAT,EAAiB,EAAI,IAAI,KAAO,EAAK,MAAM,cAClC,cAAT,EAsDV,SAAsB,EAAM,GAC3B,MAAM,UAAE,EAAS,WAAE,GAAe,GAC5B,KAAE,GAAS,EACjB,GAAa,eAAT,EAAuB,CAC1B,MAAM,SAAE,EAAQ,KAAE,GAAS,EACrB,EAAU,GAA0B,EAAU,GACpD,EAAI,IAAI,cAAc,IACxB,KAAqB,WAAT,GAA8B,aAAT,EAAqB,EAAI,IAAI,IAAI,KAAQ,EAAU,WAAW,KAAK,GAAM,EAAE,OAAM,KAAK,SACjH,EAAkB,GACvB,GAAmB,EAAY,EAChC,CAhEgC,CAAa,EAAM,GAChC,cAAT,GAAiC,eAAT,EAAuB,GAAmB,EAAK,WAAY,GAC1E,YAAT,EAAoB,EAAI,IAAI,YAAY,EAAK,UACpC,sBAAT,EAA8B,EAAI,IAAI,UAAU,EAAK,SAAS,UACrD,qBAAT,EAA6B,EAAI,IAAI,SAAS,EAAK,SAAS,UACnD,oBAAT,EAA4B,EAAI,IAAI,SAC3B,6BAAT,EAAqC,EAAI,IAAI,WACpC,yBAAT,EAAiC,EAAI,IAAI,OAChC,gCAAT,EAAwC,EAAI,IAAI,MACpD,EAAkB,EACxB,CArDC,CAAc,EAAM,GACpB,IAAI,EAAe,GAMnB,MALI,aAAc,IAAM,EAAe,EAAK,SAAS,KAAK,GAAM,GAAY,EAAG,EAAS,MACpF,EAAa,SAChB,EAAI,KACJ,EAAI,SAAS,EAAa,KAAK,OAAO,IAEhC,EAAI,MACZ,CA8CA,SAAS,GAAmB,EAAM,GACjC,MAAM,KAAE,GAAS,EACjB,GAAa,eAAT,EAAuB,CAC1B,MAAM,KAAE,EAAI,OAAE,GAAW,EACnB,EAAY,GAAQ,OAAS,IAAI,EAAO,IAAI,IAA2B,KAAK,SAAW,GAC7F,EAAI,IAAI,KAAK,IAAO,IACtB,KAAqB,aAAT,EAAqB,EAAI,IAAI,aAAa,EAAK,MAAM,SAC9C,gBAAT,EAAwB,EAAI,IAAI,eAAe,GAA0B,EAAK,SAAU,EAAK,SACpF,QAAT,GAA2B,UAAT,EAAkB,EAAI,IAAI,IAAI,KAAQ,GAAmB,EAAK,MAAM,gBAC7E,UAAT,EAAkB,EAAI,IAAI,UACjB,iBAAT,EAAyB,EAAI,IAAI,iBAAiB,EAAK,OAAO,KAAK,GAAM,EAAE,OAAM,KAAK,UAC1F,EAAkB,EACxB,CAEA,SAAS,GAAkB,GAC1B,MAAM,EAAM,IAAI,GAAY,EA1EP,KA4ErB,OADA,GAAmB,EAAM,GAClB,EAAI,MACZ,CACA,SAAS,GAAkB,EAAM,GAChC,MAAM,KAAE,EAAI,QAAE,GAAY,EAC1B,EAAI,IAAI,KAAO,EAAK,MAAM,cACtB,GAAS,EAAI,IAAI,MAAQ,GAAoB,GAClD,CAYA,SAAS,GAAmB,EAAO,GAClC,GAAO,SAAS,IAIjB,IAAuB,EAHrB,EAAI,IAAI,KAIY,gBADC,EAHO,EAAE,WAInB,KAAwB,IAAM,EAAK,KAAO,EAAK,MAJjB,GAE3C,CAeA,SAAS,GAA0B,GAClC,MAAM,aAAc,EACb,EAAK,SAAS,KAAK,GACV,SAAX,EAAE,KAAwB,IAAI,EAAE,UAAU,IAAI,MAAM,EAAE,MAAO,EAAE,QAC5D,GAAY,KACjB,KAAK,KAJ0B,GAAY,EAK/C,CACA,SAAS,GAAsB,GAC9B,MAAiB,iBAAN,EAAuB,EACnB,SAAX,EAAE,KAAwB,GAAoB,GAC3C,GAAY,EACpB,CACA,SAAS,GAAoB,GAC5B,IAAK,EAAM,MAAO,SAClB,MAAM,EAA+B,iBAAd,EAAK,KAAoB,EAAK,KAAO,EAAK,KAAK,aAChE,EAAS,EAAK,gBAAgB,IAAI,IAAuB,KAAK,MACpE,OAAO,EAAS,GAAG,KAAW,KAAY,CAC3C,CACA,SAAS,GAAsB,GAC9B,OAAO,EAAK,SAAS,KAAK,GACV,SAAX,EAAE,KAAwB,EAAE,UAAU,IAAI,MAAM,EAAE,MAAO,EAAE,KAChD,QAAX,EAAE,KAAuB,EAAE,MAAM,aAC9B,IAAI,EAAE,UACX,KAAK,IACT,CAKA,SAAS,GAAc,EAAO,EAAS,EAAG,GAAc,GACvD,MAAM,SAAE,EAAQ,KAAE,EAAI,cAAE,GAAkB,EACpC,EAAM,IAAI,GAAY,GACtB,EAAc,GAAiB,GAAkB,GACnD,GAAa,EAAI,IAAI,EAAc,KAC1B,YAAT,GAAoB,EAAI,IAAI,KAChC,EAAI,IAAI,MACR,MAAM,EAAO,EAAS,OAAS,EAC/B,IAAI,GAAe,EACf,GAAW,EAuBf,OAtBA,EAAS,SAAQ,CAAC,EAAM,KACvB,GAAI,EAAW,GAAO,CACrB,MAAM,EAAa,GAAc,EAAM,EAAS,EAAG,GAC9C,GAAc,EAAI,KACvB,EAAI,SAAS,GACb,GAAe,EACf,GAAW,CACd,KAAS,CACF,GAAc,EAAI,IAAI,MAC1B,GAAe,EACf,MAAM,EAAQ,EACV,EAAa,EAAI,IAkBxB,SAA0B,GACzB,MAAM,KAAE,EAAI,aAAE,GAAiB,EAC/B,MAAO,GAAY,SAAT,EAAkB,IAAM,KAAK,GACxC,CArB4B,CAAiB,IACrC,EAAI,IAAI,GAAc,IACvB,EAAI,GAAM,EAAI,IAAI,IACzB,MAEM,GAAY,EAAI,QAAS,EAAI,IAAI,OAEjC,IAAa,GAAc,EAAI,KACnC,EAAI,IAAI,MAET,EAAI,IAAI,KAAK,EAAM,MACZ,EAAI,MACZ,CAEA,SAAS,GAAkB,GAC1B,OAAO,GAAc,EAAO,GAAG,EAChC,CAMA,SAAS,GAAc,GACtB,IAAK,EAAO,OAAO,KAAK,UAAU,GAClC,MAAM,KAAE,EAAI,aAAE,GAAiB,EACzB,EAAQ,EAAM,GAAK,IAAI,EAAM,KAAO,GAC1C,GAAa,QAAT,EAAgB,MAAO,GAAG,KAAgB,QAAY,GAAc,EAAM,YACzE,CACJ,MAAM,YAAE,GAAgB,EACxB,MAAO,IAAI,IAAe,EAAc,IAAI,KAAiB,MAAM,IACrE,CACA,CAKA,SAAS,GAAc,EAAS,MAC/B,MAAO,CACN,MAAuB,IAAI,IAC3B,SAEF,CAEA,SAAS,GAAkB,GAC1B,MAAM,MAAE,EAAK,OAAE,GAAW,EAC1B,MAAO,YAAY,MAAM,KAAK,EAAM,WAAW,KAAI,EAAE,EAAM,KAAU,GAAG,KAAQ,GAAc,OAAS,KAAK,oBAAoB,EAAS,GAAkB,GAAU,QACtK,CASA,SAAS,GAAiB,EAAM,GAC/B,MAAM,WAAE,GAAe,EACvB,MAAO,IAAI,EAAW,MAAM,MAAO,EAAK,cAAc,KAAK,IAC1D,MAAM,GAAmB,EAAE,MAAM,OAAS,IAAI,OAC9C,OAAI,EAAkB,EAAU,IAAM,EAAkB,EAC5C,CAAC,IACX,KAAK,IACT,CAIA,SAAS,GAAmB,EAAM,GAIjC,MAAO,IAAM,IAAI,EAAU,WAAW,MAAM,MAAO,EAAK,cAAc,KAAK,IAAM,OAHzD,EAGwE,EAFxF,IAAI,GAAM,OAEmF,EAHrG,IAAwB,CAG8E,IAAE,KAAK,GAC9G,CAKA,SAAS,GAAc,EAAI,EAAI,EAAc,GAC5C,OAAO,GAAqB,EAAc,EAC3C,CAKA,SAAS,GAAqB,EAAc,GAC3C,IAAI,EAAU,EACV,EAAY,EAChB,KAAO,EAAY,IAAI,IAAU,EAAU,EAAe,IAC1D,OAAO,CACR,CAWA,SAAS,GAA0B,EAAO,EAAa,GACtD,MAAM,EAAW,EAAiB,GAAkB,EAAO,GAAkB,EACvE,EAAc,EAAS,GAC7B,GAAoB,YAAhB,GAA6B,IAAgB,EAAa,OAAO,EAAS,MAAM,GAAG,KAAK,IAC7F,CAEA,SAAS,GAAqB,EAAY,EAAa,GACtD,MAAM,EAAW,GAAe,MAAM,MACtC,OAAO,GAA0B,EAAW,MAAM,MAAO,EAAa,EACvE,CAMA,SAAS,GAAkB,EAAO,GACjC,MAAM,EAAwB,YAAb,EAAM,GAAmB,CAAC,EAAe,MAAO,EAAM,MAAM,IAAM,EAC7E,EAAY,EAAS,YAAY,SACvC,OAAmB,IAAf,EAAyB,EACtB,IAAI,EAAe,MAAM,IAAK,EAAY,OAAQ,EAAS,MAAM,EAAY,GACrF,CAEA,SAAS,GAAmB,GAC3B,YAAa,IAAT,EAAwB,KACf,KAAT,EAAoB,GACjB,EAAK,SAAS,KAAO,EAAO,EAAO,GAC3C,CASA,SAAS,GAAkB,GAC1B,OAEA,SAAS,EAAiB,EAAoB,EAAoB,EAAe,GAChF,GAAI,EAAc,OAAS,EAAG,CAC7B,MAAO,KAAY,GAAQ,EAC3B,OAAO,EAAiB,IAAI,EAAoB,EAAQ,MAAO,IAAI,EAAoB,EAAQ,MAAO,EAAM,EAC/G,CAAS,GAA0B,sBAAtB,EAAa,KAA8B,OAAO,EAAa,SAAS,SAAS,GACpF,EAAiB,EAAoB,EAAoB,EAAK,SAAU,EAAK,gBAEhF,GAA0B,gBAAtB,EAAa,KAAwB,MAAO,CAAC,CACrD,WAAY,IAAI,EAAoB,EAAa,IAAM,EAAa,MACpE,WAAY,IAAI,EAAoB,EAAa,QAE7C,EAAkB,EACzB,CAdQ,CAAiB,GAAI,GAAI,EAAI,SAAU,EAAI,aAenD,CAIG,IAAC,GAAa,cAAc,MAC9B,KACA,WAAA,CAAY,EAAK,GAChB,MAAM,GACN,KAAK,KAAO,CACd,GAMA,SAAS,GAAU,EAAK,EAAM,EAAW,IACxC,EAAI,MAAM,QAAQ,UAAU,KAAK,CAChC,OACA,SAAU,IAAI,IAEhB,CAEA,SAAS,GAAe,EAAK,EAAO,GACnC,MAAM,EAAO,EAAI,MAAM,QAAQ,UAAU,MACzC,IAAK,EAAM,MAAM,IAAI,MAAM,4BAC3B,OAuBD,SAAuB,EAAK,EAAU,EAAO,GAC5C,MAAM,UAAE,GAAc,EAAI,MAAM,OAC1B,EAAS,EAAS,QAAQ,MAAK,CAAC,EAAG,IAAM,EAAE,MAAQ,EAAE,QACrD,EAAQ,GACd,IAAI,EAAM,EACV,IAAK,MAAM,KAAQ,EACd,EAAM,EAAK,OAAO,EAAM,KAAK,GAAS,EAAW,EAAK,EAAK,QAC/D,EAAM,KAAK,GACX,EAAM,EAAK,IAER,EAAM,GAAK,EAAM,KAAK,GAAS,EAAW,EAAK,IACnD,OAAO,CACR,CAnCQ,CAAc,EAAK,EAAK,SAAU,EAAO,EACjD,CAEA,SAAS,GAAW,EAAM,EAAO,EAAK,GACrC,MAAM,EAAM,EAAI,OAAO,aACvB,MAAO,CACN,OACA,QACA,MACA,SAAU,GAAe,EAAK,EAAO,MAClC,EAEL,CAEA,SAAS,GAAS,EAAW,EAAO,GACnC,MAAO,CACN,KAAM,OACN,QACA,MACA,YAEF,CAkBA,SAAS,GAAY,GACpB,MAAO,EAAO,GAAO,EAAM,KAC3B,MAAO,CACN,KAAM,UACN,MAAO,EAAM,KACb,QACA,MAEF,CAuBA,SAAS,GAAqB,EAAM,EAAU,GAC7C,MAAM,MAAE,GAAU,EAClB,MAAO,CACN,KAAM,oBACN,WACA,OACA,QACA,QACA,IAAK,EAAM,IAEb,CAmBA,SAAS,GAAmB,EAAI,EAAc,EAAM,GACnD,MAAO,CACN,KAAM,kBACN,SAAU,EACV,aAAc,QAAgB,EAC9B,UAAW,EACX,MAAO,EAAG,MACV,MAEF,CAKA,SAAS,GAAO,EAAQ,EAAM,GAC7B,MAAM,EAAQ,EAAO,UAAU,GAC/B,IAAK,EAAO,CACX,MAAM,EAAM,EAAO,aACnB,MAAM,IAAI,GAAW,EAAU,aAAa,YAAe,IAAY,aAAa,KAAS,CAAC,EAAK,GACrG,CACC,OAAO,CACR,CAEA,SAAS,GAAW,EAAQ,GAC3B,MAAM,EAAQ,EAAO,OAGrB,OAFK,GAAwB,SAAf,EAAM,MAAiB,GAAgB,EAAQ,GAC7D,EAAO,YACA,CACR,CAEA,SAAS,GAAiB,EAAK,EAAW,uBACzC,MAAM,EAAO,GAAgB,GAG7B,OAFK,GAAM,GAAgB,EAAI,OAAQ,GACnC,EAAI,QAAQ,qBAAqB,EAAI,QAAQ,GAC1C,CACR,CAEA,SAAS,GAAgB,EAAQ,GAChC,MAAM,EAAa,EACb,EAAQ,EAAW,OACzB,MAAM,IAAI,GAAW,EAAS,EAAQ,EAAM,KAAO,CAAC,EAAW,aAAc,EAAW,cACzF,CAEA,SAAS,GAAe,EAAK,GAC5B,MAAM,EAAQ,GACd,OAAa,CACZ,MAAM,EAAO,EAAU,GACvB,GAAa,OAAT,EAAe,MAEnB,GADA,EAAM,KAAK,IACN,EAAI,OAAO,UAAU,KAAM,KAClC,CACC,OAAO,CACR,CAEA,SAAU,GAAU,EAAK,GACxB,IAAK,IAAI,EAAO,EAAM,GAAM,EAAM,EAAO,EAAM,SAAY,CAC5D,CAEA,SAAS,GAAa,GACrB,MAAO,EAAO,GAAO,EAAM,KAC3B,MAAO,CACN,KAAM,OACN,KAAM,EAAM,KACZ,QACA,MAEF,CAEA,SAAS,GAAoB,EAAK,EAAW,GAC5C,MAAM,EAAY,EAAI,gBAAgB,EAAU,KAAM,IAC/C,EAAO,GAAO,EAAU,KAC/B,MAAO,CACN,KAAM,OACN,MAAO,EACP,UAAW,EAAI,UACf,QACA,MAEF,CAEA,SAAS,GAAiB,EAAK,EAAU,EAAO,GAC/C,MAAM,EAAO,CACZ,KAAM,MACN,MAAO,EACP,UAAW,EAAI,UACf,QACA,OAGD,OADA,EAAS,aAAe,EACjB,CACR,CACA,SAAS,GAAyB,GACjC,MAAM,KAAE,GAAS,EACjB,MAAgB,QAAT,GAA2B,UAAT,GAA6B,UAAT,CAC9C,CAEA,SAAS,GAAwB,GAChC,OAAO,EAAW,MAAM,GAAS,GAAyB,EAAK,YAChE,CAEA,SAAS,GAAiB,EAAM,GAC3B,GAAY,SAAQ,EAAK,WAAa,EAC3C,CAEA,SAAS,GAAkB,EAAe,GACzC,EAAc,MAAM,SAAW,CAChC,CAEA,SAAS,GAAc,EAAW,GACjC,GAAkB,EAAU,KAAM,EACnC,CAoBA,MAAM,GAAmB,CACxB,KAAM,EACN,KAAM,EACN,IAAK,EACL,IAAK,EACL,IAAK,EACL,KAAM,EACN,KAAM,EACN,IAAK,EACL,KAAM,EACN,IAAK,EACL,KAAM,EACN,KAAM,EACN,KAAM,EACN,IAAK,EACL,IAAK,EACL,IAAK,GACL,IAAK,GACL,IAAK,IAMN,SAAS,GAAc,GACtB,OAAO,GAAiB,EAAQ,OAAS,CAC1C,CACA,SAAS,GAAW,GACnB,OAAQ,GACP,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IACL,IAAK,IAcL,QAAS,MAAO,aAbhB,IAAK,KACL,IAAK,KAAM,MAAO,QAClB,IAAK,IACL,IAAK,IACL,IAAK,KACL,IAAK,KACL,IAAK,KACL,IAAK,KAAM,MAAO,aAClB,IAAK,IAAK,MAAO,SACjB,IAAK,IAAK,MAAO,SACjB,IAAK,IAAK,MAAO,QACjB,IAAK,KAAM,MAAO,aAClB,IAAK,KAAM,MAAO,YAGpB,CAEA,SAAS,GAAe,EAAQ,EAAI,GAEnC,MAAM,EAAU,GAAW,GAiB5B,IAAsB,EAdrB,OAGD,SAAqB,EAAI,GACxB,MAAM,EAAU,GAAW,GAC3B,MAAgB,UAAZ,EAA0C,UAAd,EAChB,WAAZ,EAA2C,UAAd,GAAuC,WAAd,EAC1C,WAAZ,EAA2C,UAAd,GAAuC,WAAd,EAC1C,UAAZ,EAA0C,UAAd,GAAuC,UAAd,EACzC,eAAZ,GAAkC,GAAU,IAA4B,cAAd,EAC9C,cAAZ,IAAiC,GAAU,IAA4B,eAAd,CAE9D,CAdM,CAAY,EAAI,IAAY,GAAgB,EAAQ,IAAI,iCAAkC,KAiB9E,WADI,EAfH,IAgBoB,eAAV,GAhBE,IAAc,GAAS,GAAgB,EAAQ,IAAI,wBAC1E,CACR,CAgBA,SAAS,GAAU,GAClB,MAAa,WAAN,GAAwB,WAAN,GAAwB,UAAN,CAC5C,CAKA,MAAM,GAAe,IAAI,IAAI,CAC5B,KACA,SACA,UACA,QACA,SAEK,GAAqB,IAAI,IAAI,CAAC,UAAW,UAE/C,SAAS,GAAgB,GACxB,MAAM,EAAQ,EAAO,OACrB,IAAK,IAAU,GAAc,GAAO,GAAO,OAAO,KAClD,MAAM,EAAQ,EAAM,KAAK,GACzB,EAAO,YACP,MAAM,EAAQ,CAAC,EAAM,MACrB,KAAO,EAAO,UAAU,OAAO,CAC9B,MAAM,EAAO,EAAO,OACf,GAAS,GAAc,GAAM,IAAQ,GAAgB,EAAQ,kCAClE,EAAO,YACP,EAAM,KAAK,EAAK,KAClB,CACC,MAAO,CACN,QACA,QACA,IAAK,EAAO,aAEd,CAmBA,SAAS,GAAc,EAAO,GAC7B,MAAmB,SAAf,EAAM,MACS,YAAf,EAAM,QACN,GAAa,IAAI,EAAM,OAAc,GAAW,GAAmB,IAAI,EAAM,MAElF,CASA,SAAS,GAAmB,GAC3B,MAAM,EAAO,GAAgB,EAAI,QACjC,IAAK,EAAM,OAAO,KAClB,MAAM,MAAE,EAAK,MAAE,EAAO,IAAK,GAAY,EACjC,EAAW,EAAI,eAAe,EAAM,KAAK,OAC/C,GAAU,EAAK,QACf,MAAM,EAAe,GAAiB,EAAK,EAAU,EAAO,GAG5D,OAFA,EAAI,UAAU,GACd,EAAI,QAAQ,GACL,GAAW,OAAQ,EAAO,EAAK,CACrC,KAAM,EACN,eAAgB,EAAI,OAAO,yBAA2B,GAAoB,QAAO,GAEnF,CAEA,SAAS,GAAoB,GAC5B,MAAM,OAAE,GAAW,EACnB,GAAI,GAAmB,GAAS,MAAO,GACvC,MAAM,EAAS,CAAC,GAAmB,IACnC,KAAO,EAAO,UAAU,MAAM,EAAO,KAAK,GAAmB,IAE7D,OADK,GAAmB,IAAS,GAAgB,EAAQ,gDAClD,CACR,CAEA,SAAS,GAAmB,GAC3B,QAAK,EAAO,QAAQ,KAAK,WAAW,OAC/B,EAAO,wBAAwB,GAAgB,EAAQ,8CACrD,EACR,CAEA,SAAS,GAAmB,GAC3B,MAAM,EAAO,GAAgB,EAAK,CAAE,YAAY,IAChD,GAAI,EAAM,OAAO,EACjB,GAAgB,EAAI,OAAQ,6CAC7B,CAQA,SAAS,GAAgB,EAAK,EAAS,GACtC,GAAqB,QAAjB,EAAQ,MAAmC,SAAjB,EAAQ,KAAiB,OAAO,KAC9D,MAAM,OAAE,GAAW,EACb,EAAgC,SAAjB,EAAQ,KAAkB,EAAQ,gBAAkB,KAgB1E,SAA+B,GAC9B,MAAM,OAAE,GAAW,EACb,EAAM,EAAO,aACnB,IAAK,EAAO,yBAA0B,OAAO,KAC7C,MAAM,EAAS,GAAoB,GACnC,GAA4B,MAAxB,EAAO,QAAQ,KAElB,OADA,EAAO,MAAM,GACN,KAER,OAAO,CACR,CA1BiF,CAAsB,GACtG,IAAK,EAAO,UAAU,KAAM,OAAO,KACnC,MAAM,EAAO,GACb,OAAa,CACZ,MAAM,EAAW,GAAgB,GACjC,GAAiB,OAAb,EAAmB,OAAO,GAAmB,EAAS,EAAc,EAAM,GAC9E,MAAM,EAAM,EAAU,GAGtB,GAFK,GAAK,GAAgB,EAAQ,uBAClC,EAAK,KAAK,GACN,EAAO,UAAU,KAAM,SAC3B,MAAM,EAAM,GAAgB,GAC5B,GAAY,OAAR,EAAc,OAAO,GAAmB,EAAS,EAAc,EAAM,GACzE,GAAgB,EAAQ,4CAC1B,CACA,CAcA,SAAS,GAAgB,GACxB,MAAM,EAAQ,EAAO,UAAU,KAC/B,OAAO,EAAQ,EAAM,KAAK,GAAK,IAChC,CAWA,SAAS,GAAgB,EAAK,GAC7B,MAAM,aAAE,EAAY,WAAE,IAAwB,IAAT,EAAgB,CACpD,cAAc,EACd,YAAY,GACT,GAAQ,GACN,IAAU,QAAsB,EAChC,EAAY,GAAqB,EAAK,GAC5C,OAAK,EACE,GAAgB,EAAK,CAC3B,KAAM,EACN,KAAM,EACN,MAAO,QACP,UACA,eACE,KAPoB,IAQxB,CAMA,SAAS,GAAqB,EAAK,GAClC,MAAM,OAAE,GAAW,EACb,EAAQ,EAAO,OACrB,IAAK,EAAO,OAAO,KACnB,GAAI,QAAQ,SAAS,EAAM,MAAO,CACjC,EAAO,YACP,MAAM,EAlbR,SAA2B,GAC1B,MAAO,CACN,MAAO,EAAM,KACb,KAAM,EAAM,KAEd,CA6amB,CAAkB,GAC7B,EAAU,GAAqB,EAAK,GAE1C,OADK,GAAS,GAAgB,EAAQ,4CAxaxC,SAA6B,EAAU,GACtC,MAAO,GAAS,EAAS,KACzB,MAAO,CACN,KAAM,mBACN,WACA,WAAY,EACZ,QACA,IAAK,EAAK,IAEZ,CAgaS,CAAoB,EAAU,EACvC,CACC,OA6CD,SAA0B,EAAK,GAC9B,MAAM,EAYP,SAAwB,EAAK,GAC5B,MAAM,OAAE,GAAW,EACb,EAAO,EAAO,UAAU,KAC9B,IAAK,EAAM,OAAO,KAClB,MAAM,EAAa,GAAgB,EAAK,GACnC,GAAY,GAAgB,EAAQ,iCACzC,MAAM,EAAQ,GAAO,EAAQ,IAAK,cAClC,MAAO,CACN,KAAM,2BACN,aACA,MAAO,EAAK,KAAK,GACjB,IAAK,EAAM,KAAK,GAElB,CAzBc,CAAe,EAAK,IA2BlC,SAA4B,GAC3B,MAAM,EAAM,EAAO,UAAU,UAC7B,OAAI,EAAY,GAAY,GA4B7B,SAAsB,GACrB,MAAM,EAAY,EAAO,UAAU,UAAW,SAAW,EAAO,UAAU,UAAW,SACrF,OAAK,EACE,GAAY,GADI,IAExB,CA/BQ,CAAa,EACrB,CA/BmD,CAAmB,EAAI,SAoC1E,SAAsC,EAAK,GAC1C,MAAM,EAtOP,SAAoB,EAAK,GACxB,MAAM,EAAO,GAAgB,EAAI,QACjC,IAAK,EAAM,OAAO,KAClB,MAAM,MAAE,EAAK,MAAE,EAAK,IAAE,GAAQ,EACxB,EAAQ,EAAI,eAAe,EAAM,KAAK,OACxC,IAAc,EAAM,cAAe,GACvC,MAAM,EAAe,GAAiB,EAAK,EAAO,EAAO,GAKzD,OAJK,IACJ,EAAI,UAAU,GACd,EAAI,QAAQ,IAEN,CACR,CA0NkB,CAAW,EAAK,GACjC,IAAK,EAAU,OAAO,KACtB,IAAK,EAAI,OAAO,yBAA0B,OAAO,EACjD,MAAM,EAAiB,GAAoB,GAC3C,MAAO,CACN,KAAM,OACN,KAAM,EAAS,MACf,iBACA,MAAO,EAAS,MAChB,IAAK,EAAI,OAAO,aAChB,SAAU,GAEZ,CAjDqF,CAA6B,EAAK,GACtH,OAAK,EACD,EAAqB,EAClB,GAAuB,EAAK,GAFjB,IAGnB,CAlDQ,CAAiB,EAAK,EAC9B,CAUA,SAAS,GAAgB,EAAK,GAC7B,MAAM,OAAE,GAAW,GACX,KAAM,EAAa,KAAE,EAAM,MAAO,GAAc,GAClD,QAAE,EAAO,WAAE,GAAe,EAChC,IAAI,EAAU,EACV,EAAe,EACnB,OAAa,CACZ,MAAM,EAAU,EAAO,OACvB,IAAK,GAAoB,EAAS,GAAa,MAC/C,MAAM,EAAa,GAAc,GACjC,GAAI,EAAa,EAAe,MAChC,EAAO,YACP,EAAe,GAAe,EAAQ,EAAQ,KAAM,GACpD,IAAI,EAAQ,GAAqB,EAAK,GACjC,GAAO,GAAgB,EAAQ,6CACpC,MAAM,EAAY,EAAO,OACzB,GAAI,GAAoB,EAAW,GAAa,CAC/C,MAAM,EAAW,GAAc,GAC3B,EAAW,IAAY,EAAQ,GAAgB,EAAK,CACvD,KAAM,EACN,KAAM,EACN,MAAO,QACP,UACA,eACE,KACN,CACE,EAAU,GAAqB,EArdzB,CACN,OAF0B,EAsdiC,GApd9C,KACb,KAAM,EAAM,MAmdyD,EACvE,CAvdA,IAA4B,EAwd3B,MAAO,CACN,KAAM,EACN,MAAO,EAET,CASA,SAAS,GAAoB,EAAO,GACnC,QAnSD,SAA0B,GACzB,QAAK,GACE,EAAM,QAAQ,EACtB,CAgSM,CAAiB,MAClB,IAAc,EAAM,KAAK,WAAW,KAEzC,CAyCA,SAAS,GAAuB,EAAK,GACpC,MAAM,EAUP,SAAwB,EAAK,GAC5B,OAGD,SAA2B,EAAK,GAC/B,OAAK,EAAI,OAAO,UAAU,KA9f3B,SAAuC,EAAM,GAC5C,MAAO,CACN,KAAM,8BACN,OACA,SACA,MAAO,EAAK,MACZ,IAAK,EAAO,IAEd,CAufQ,CAA8B,EAAM,GAAa,GAAW,EAAI,OAAQ,mCADxC,IAExC,CANQ,CAAkB,EAAK,IAQ/B,SAA0B,EAAK,GAC9B,MAAM,OAAE,GAAW,EACnB,OAAK,EAAO,UAAU,KA7gBvB,SAAiC,EAAM,EAAQ,GAC9C,MAAO,CACN,KAAM,uBACN,OACA,SACA,MAAO,EAAK,MACZ,MAEF,CAsgBQ,CAAwB,EAAM,GAAiB,EAAK,sCAAuC,GAAO,EAAQ,IAAK,eAAe,KAAK,IADvG,IAEpC,CAZwC,CAAiB,EAAK,IAAS,GAAgB,EAAK,EAAM,GAClG,CAZc,CAAe,EAAK,GACjC,OAAI,EAAa,GAAuB,EAAK,GACtC,CACR,CAyBA,SAAS,GAAmB,GAC3B,MAAO,IAAI,GAAU,EAAK,IAC3B,CAuBA,SAAS,GAAe,GACvB,MAAM,OAAE,GAAW,EACb,EAAW,EAAO,aACxB,IAAK,EAAO,UAAU,KAAM,OAAO,KACnC,EAAO,MAAM,GACb,MAAM,EAAW,GAAqB,GACtC,GAAI,EAAU,OAAO,EACrB,MAAM,EAiDP,SAAgC,GAC/B,MAAM,OAAE,GAAW,EACb,EAAW,EAAO,aAClB,EAAU,EAAO,UAAU,KACjC,IAAK,EAAS,OAAO,KACrB,MAAM,EAAW,EAAQ,KAAK,GACxB,EAAY,EAAO,OACzB,IAAK,GAAgC,SAAnB,EAAU,MAAsC,YAAnB,EAAU,KAExD,OADA,EAAO,MAAM,GACN,KAER,EAAO,YACP,MAAM,EAAO,EAAU,KACvB,GAAa,YAAT,EAAoB,OAiCzB,SAA+B,EAAK,GACnC,MAAM,OAAE,GAAW,EACnB,GAAO,EAAQ,IAAK,YACpB,MAAM,EAAY,GAAW,EAAQ,mCAErC,OADA,GAAO,EAAQ,IAAK,sBACb,GAAc,CACpB,KAAM,WACN,MAAO,GAAa,IAClB,EAAU,EAAO,aACrB,CA1CgC,CAAsB,EAAK,GAC1D,GAAa,gBAAT,EAAwB,OA0C7B,SAAmC,EAAK,GACvC,MAAM,OAAE,GAAW,EACnB,GAAO,EAAQ,IAAK,gBACpB,MAAM,EAAS,GAAe,EAAK,IAEnC,OADA,GAAO,EAAQ,IAAK,2BACb,GAAc,CACpB,KAAM,eACN,UACE,EAAU,EAAO,aACrB,CAnDoC,CAA0B,EAAK,GAClE,GAAa,eAAT,EAAuB,OAuD5B,SAAkC,EAAK,GACtC,MAAM,OAAE,GAAW,EACnB,GAAO,EAAQ,IAAK,eACpB,MAAM,EAAW,GAAa,GAAW,EAAQ,qCACjD,GAAO,EAAQ,IAAK,wBACpB,MAAM,EAAY,GAAa,GAAW,EAAQ,iCAClD,IAAI,EACuB,EAAvB,EAAO,UAAU,KAAa,CAAC,EAAW,GAAa,GAAW,EAAQ,mCAClE,CAAC,EAAW,MAExB,OADA,GAAO,EAAQ,IAAK,0BACb,GAAc,CACpB,KAAM,cACN,WACA,QACE,EAAU,EAAO,aACrB,CAtEmC,CAAyB,EAAK,GAChE,IAAI,EACA,EAAO,UAAU,OACpB,EAAI,iBAAmB,EACvB,EAoEF,SAA8B,GAC7B,OAAO,GAAe,EAAK,GAC5B,CAtEW,CAAqB,GAC9B,EAAI,sBAAmB,EACvB,GAAO,EAAQ,IAAK,yBAErB,GAAa,aAAT,QAAkC,IAAX,EAAmB,MAAM,IAAI,GAAW,uCAAwC,CAAC,EAAU,EAAO,eAC7H,OAAO,GAAc,CACpB,KAAM,aACN,OACA,UACE,EAAU,EAAO,aACrB,CA9EiB,CAAuB,GACvC,OAAI,GACG,IACR,CAEA,SAAS,GAA0B,EAAK,EAAS,GAChD,MAAM,OAAE,GAAW,EACb,EAAW,EAAO,aACxB,IAAK,EAAO,cAAc,IAAK,GAAU,OAAO,KAChD,GAAO,EAAQ,IAAK,IAAI,KACxB,MAAM,EAAO,GAAgB,GAAK,GAClC,OAAK,GACL,EAAO,UAAU,KACjB,GAAO,EAAQ,IAAK,IAAI,gBACjB,EAkEA,CACN,KAAM,4BACN,YAHuC,EAjEQ,CAC/C,MAAO,EACP,KAAM,CAAC,EAAU,EAAO,gBAkEP,MACjB,KAAM,EAAK,QAxEM,KAoEnB,IAAyC,CA7DzC,CACA,SAAS,GAAgB,GACxB,MAAO,CACN,KAAM,MACN,QAEF,CAIA,SAAS,GAAkB,GAC1B,MAAO,CACN,KAAM,QACN,QAEF,CAEA,SAAS,GAAqB,GAC7B,MAAM,OAAE,GAAW,EACb,EAAS,EAAO,OACtB,GAAqB,MAAjB,GAAQ,KAAc,OAAO,KACjC,MAAM,EAAW,EAAO,KAAK,GACvB,EApEP,SAA0B,GACzB,OAAO,GAA0B,EAAK,KAAM,GAC7C,CAkEgB,CAAiB,GAChC,GAAI,EAAQ,OAAO,GAAc,EAAQ,EAAU,EAAO,cAC1D,MAAM,EA7DP,SAA4B,GAC3B,OAAO,GAA0B,EAAK,OAAQ,GAC/C,CA2DkB,CAAmB,GACpC,GAAI,EAAU,OAAO,GAAc,EAAU,EAAU,EAAO,cAC9D,MAAM,EApEP,SAA4B,GAC3B,OAAK,EAAI,OAAO,cAAc,IAAK,QAiD5B,CAAE,KAAM,SAjDoC,IAEpD,CAiEkB,CAAmB,GACpC,OAAI,EAAiB,GAAc,EAAU,EAAU,EAAO,cACvD,IACR,CAuCA,SAAS,GAAc,EAAW,EAAO,GACxC,MAAO,CACN,KAAM,YACN,YACA,QACA,MACA,SAAU,GAEZ,CAqBA,SAAS,GAAc,GACtB,OAAO,GAAa,GAAW,EAAI,OAAQ,uBAC5C,CAsBA,SAAS,GAAe,GACvB,MAAM,OAAE,GAAW,EACb,EAAQ,EAAO,aACrB,GAAU,EAAK,cACf,GAAgB,GAChB,MAAM,EAAM,EAAO,aACnB,MAAO,CACN,KAAM,aACN,QACA,MACA,SAAU,GAAe,EAAK,EAAO,GAEvC,CAKA,SAAS,GAAe,GACvB,MAAM,OAAE,GAAW,EACb,EAAW,EAAO,aAClB,EAAa,GAAmB,GAChC,EAAQ,EAAW,OAAS,EAAI,OAAa,EAC7C,EAAS,GAAwB,EAAK,SAAU,IAAU,GAAwB,EAAK,WAAY,IAuB1G,SAAkC,EAAK,GACtC,MAAM,OAAE,GAAW,EACb,EAAQ,EAAO,UAAU,cAC/B,IAAK,EAAO,OAAO,KACnB,GAAO,EAAQ,IAAK,cACpB,MAAM,EAAW,GAAa,GAAW,EAAQ,oCACjD,GAAO,EAAQ,IAAK,uBACpB,MAAM,EAAW,GAAa,GAAW,EAAQ,qCACjD,IAAI,EAAU,KACV,EAAO,UAAU,OAAM,EAAU,GAAa,GAAW,EAAQ,qCAIrE,OAHA,EAAO,UAAU,KACjB,GAAO,EAAQ,IAAK,mBACpB,GAAO,EAAQ,IAAK,wBACb,GAAkB,CACxB,KAAM,aACN,WACA,KAAM,CAAC,EAAU,IACf,EAAO,EAAQ,EACnB,CAzCoH,CAAyB,EAAK,GAEjJ,OADK,GAAQ,EAAO,MAAM,GACnB,CACR,CAEA,SAAS,GAAwB,EAAK,EAAS,GAC9C,MAAM,OAAE,GAAW,EACb,EAAQ,EAAO,UAAU,GAC/B,IAAK,EAAO,OAAO,KACnB,MAAM,EAAa,GAAe,EAAK,IAEvC,OADA,GAAO,EAAQ,IAAK,GAAG,eAChB,GAAkB,CACxB,KAAM,EACN,cACE,EAAO,EAAQ,EACnB,CACA,SAAS,GAAmB,GAC3B,OAAO,GAAa,GAAW,EAAI,OAAQ,oCAC5C,CAwBA,SAAS,GAAkB,EAAW,EAAO,EAAQ,GACpD,MAAM,EAAO,CACZ,KAAM,YACN,YACA,MAAO,IAAa,IAAI,OAAS,EAAM,KAAK,GAC5C,IAAK,EAAO,cAGb,OADA,GAAiB,EAAM,GAChB,CACR,CAQA,SAAS,GAAiB,EAAK,GAC9B,MAAM,EAAW,GAAe,EAAK,KAAM,GAC3C,GAAiB,OAAb,EAAmB,OAAO,KAC9B,GAAiB,EAAK,4CACtB,MAAM,EAAO,GAAe,EAAK,mCAGjC,OAFA,EAAI,QAAQ,GAgBb,SAAwB,GACvB,MAAM,OAAE,GAAW,EACnB,KAAO,EAAO,UAAU,SAAS,CAChC,GAAI,EAAO,UAAU,MAAO,CAC3B,GAAiB,EAAK,uCACtB,MAAM,EAAO,GAAe,EAAK,8BACjC,EAAI,QAAQ,GACZ,QACH,CACE,MAAM,EAAO,GAAe,EAAK,2BACjC,EAAI,QAAQ,GACZ,KACF,CACA,CA5BC,CAAe,GACR,GAAqB,EAAU,EAAK,EAC5C,CAEA,SAAS,GAAqB,EAAK,GAClC,MAAM,EAAW,GAAe,EAAK,SAAU,GAC/C,OAAiB,OAAb,EAA0B,MAC9B,GAAiB,EAAK,sCA4BvB,SAA6B,GAC5B,MAAM,OAAE,GAAW,EACnB,GAAmB,GACnB,GAAO,EAAQ,IAAK,qBACpB,MAAQ,EAAO,UAAU,MAAM,CAC9B,MAAM,EAAc,EAAO,aACrB,EAAc,GAAmB,GACvC,GAAU,EAAK,gBAAiB,EAAY,OAAS,OAAc,GAC/D,EAAO,UAAU,SACpB,GAAmB,GACnB,GAAc,EAAK,kCACT,EAAO,UAAU,WAAY,GAAc,EAAK,gCACtD,GAAgB,EAAQ,gDAC7B,MAAM,EAAa,GAAW,gBAAiB,EAAa,EAAK,IACjE,GAAiB,EAAY,EAAY,OAAS,OAAc,GAChE,EAAI,QAAQ,EACd,CACA,CA5CC,CAAoB,GACb,GAAqB,EAAU,EAAK,GAC5C,CA4CA,SAAS,GAAmB,GAC3B,MAAM,OAAE,GAAW,EAEnB,IADA,GAAiB,EAAK,oCACf,EAAO,UAAU,MAAM,GAAiB,EAAK,+CACrD,CAKA,SAAS,GAAc,EAAK,GAC3B,EAAI,OAAO,UAAU,KACrB,MAAM,EAAY,GAAmB,GAC/B,EAAO,GAAuB,EAAK,EAAU,OAAS,EAAI,OAAY,GACvE,GAAM,GAAgB,EAAI,OAAQ,GACvC,EAAI,QAAQ,EACb,CAKA,SAAS,GAAe,EAAK,GAC5B,OAAO,GAAe,EAAK,SAAS,EA2DrC,SAAuB,GACtB,IAAI,EAAQ,EAAI,eAChB,KAAsB,YAAf,EAAM,MAAsB,EAAM,QAAQ,EAAQ,EAAM,OAC/D,OAAwB,OAAjB,EAAM,MACd,CA/D2C,CAAc,GAAM,EAC/D,CAMA,SAAS,GAAe,EAAK,GAAW,GACvC,MAAM,EAAY,EAAI,OAAO,UAAU,QACvC,IAAK,EAAW,OAAO,KACvB,MAAM,EAAQ,EAAU,KAAK,GAC7B,GAAU,EAAK,YACf,MAAM,EAAO,GAAoB,EAAK,EAAW,GACjD,EAAI,QAAQ,GACZ,EAAI,UAAU,EAAK,OACnB,MAAM,QAAE,EAAO,UAAE,GAkDlB,SAA2B,GAC1B,IAAK,EAAI,OAAO,UAAU,KAAM,MAAO,GACvC,EAAI,YACJ,MAAM,EAAU,GAAmB,GAC9B,GAAS,GAAgB,EAAI,OAAQ,2BAC1C,EAAI,QAAQ,GACZ,MAAM,EAAY,EAAI,eAEtB,OADA,EAAI,WACG,CACN,UACA,YAEF,CA9DgC,CAAkB,GAC3C,EAAM,EAAI,OAAO,aACvB,MAAO,CACN,KAAM,WACN,OACA,UACA,YACA,QACA,MACA,SAAU,GAAe,EAAK,EAAO,GAEvC,CAEA,SAAS,GAAe,EAAK,EAAS,EAAc,EAAU,GAC7D,MAAM,OAAE,GAAW,EACb,EAAQ,EAAO,UAAU,GAC/B,IAAK,EAAO,OAAO,KACnB,MAAM,EAAW,GAAuB,EAAY,EAAM,KAAK,IAC/D,EAAI,UAAU,WACd,GAAU,EAAK,EAAS,GACxB,MAAM,EAAY,GAAe,EAAK,GACjC,GAAW,GAAgB,EAAQ,8BAA8B,MACtE,EAAI,QAAQ,GACR,GACH,GAAO,EAAQ,IAAK,GAAG,gBACvB,GAAiB,IACP,EAAO,UAAU,MAAM,GAAiB,GACnD,GAAO,EAAQ,IAAK,GAAG,iBACvB,MAAM,EAAS,EAAO,aAChB,EAAW,GAAe,EAAK,EAAU,GAC/C,EAAU,KAAK,MAAM,eAAiB,EAAI,eAC1C,EAAI,WACJ,MAAM,EAAO,CACZ,KAAM,EACN,KAAM,EACN,MAAO,EACP,IAAK,EACL,YAID,OAFA,GAAiB,EAAM,GACvB,GAAc,EAAW,GAClB,CACR,CA2EA,SAAS,GAAiB,EAAK,GAC9B,MAAM,EAAc,EAAI,OAAO,UAAU,gBACzC,IAAK,EAAa,OAAO,KACzB,MAAM,EAAW,GAAuB,EAAY,EAAY,KAAK,IACrE,GAAU,EAAK,SAAU,GACzB,GAAiB,GACjB,GAAO,EAAI,OAAQ,IAAK,2BACxB,MAAM,EAAO,GAAW,SAAU,EAAU,EAAK,IAEjD,OADA,GAAiB,EAAM,GAChB,CACR,CAEA,SAAS,GAAiB,GACzB,MAAM,OAAE,GAAW,EACnB,GAAK,EAAO,yBACZ,OAAa,CACZ,MAAM,EAAO,EAAO,OAEpB,GADK,GAAM,GAAgB,EAAQ,wCAC/B,EAAK,KAAK,WAAW,KAExB,YADA,EAAO,uBAGR,EAAO,WACT,CACA,CAQA,SAAS,GAAkB,EAAK,GAC/B,OAAO,GAAc,EAAK,OAAO,GAAM,EAAO,EAC/C,CAEA,SAAS,GAAa,EAAK,GAC1B,OAAO,GAAc,EAAK,OAAO,GAAO,EAAM,EAC/C,CAEA,SAAS,GAAc,EAAK,EAAS,EAAa,EAAc,GAC/D,MAAM,OAAE,GAAW,EACb,EAAQ,EAAO,UAAU,GAC/B,IAAK,EAAO,OAAO,KACnB,MAAM,EAAW,GAAuB,EAAY,EAAM,KAAK,IAC/D,GAAU,EAAK,EAAS,GACpB,GAAa,GAAiB,GAClC,MAAM,EAAY,GAAe,GAAK,GACjC,GAAW,GAAgB,EAAQ,8BAA8B,MACtE,EAAI,QAAQ,GACR,GACH,GAAO,EAAQ,IAAK,GAAG,iBAAuB,8BAC9C,GAAiB,IACP,EAAO,UAAU,MAAM,GAAiB,GACnD,GAAO,EAAQ,IAAK,GAAG,iBACvB,MAAM,EAAO,GAAW,EAAS,EAAU,EAAK,CAAE,KAAM,IAGxD,OAFA,GAAiB,EAAM,GACvB,GAAc,EAAW,GAClB,CACR,CAIA,MAAM,GAAgB,IAAI,IAAI,CAC7B,IACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,KACA,MACA,QASD,SAAS,GAAqB,EAAK,GAClC,MAAM,OAAE,GAAW,EACb,EAAW,GAAuB,EAAY,EAAO,cAC3D,OAGD,SAAyB,EAAK,EAAU,GACvC,MAAM,OAAE,GAAW,EACnB,IAAK,EAAO,UAAU,UAAW,OAAO,KACxC,GAAU,EAAK,YAAa,GAC5B,MAAM,EAAO,GAAgB,GACzB,GAAQ,EAAI,QAAQ,qBAAqB,EAAI,QAAQ,GAEzD,OADA,GAAO,EAAQ,IAAK,oBACb,GAAqB,EAAU,EAAK,EAC5C,CAXQ,CAAgB,EAAK,EAAU,IAgBvC,SAAwB,EAAK,EAAU,GACtC,MAAM,OAAE,GAAW,EACnB,IAAK,EAAO,UAAU,SAAU,OAAO,KACvC,GAAU,EAAK,YAAa,GACxB,EAAO,UAAU,OAAO,GAAiB,EAAK,uCAElD,OADA,GAAO,EAAQ,IAAK,mBACb,GAAqB,EAAU,EAAK,EAC5C,CAvBsD,CAAe,EAAK,EAAU,IAAe,GAAiB,EAAK,EAAU,EAAY,aAAe,GAAiB,EAAK,EAAU,EAAY,YAiC1M,SAAwB,EAAQ,GAC/B,OAAK,EAAO,UAAU,KACf,CACN,KAAM,YACN,QACA,IAAK,EAAO,aACZ,SAAU,IALwB,IAOpC,CAzCwN,CAAe,EAAQ,IA2C/O,SAA8B,EAAK,EAAU,GAC5C,MAAM,OAAE,GAAW,EACnB,IAAK,EAAO,UAAU,KAAM,OAAO,KAC9B,GAAwB,IAAS,GAAgB,EAAQ,0CAI9D,OAHA,GAAU,EAAK,YAAa,GAC5B,GAAiB,EAAK,iDACtB,GAAO,EAAQ,IAAK,cACb,GAAqB,EAAU,EAAK,EAC5C,CAnD4P,CAAqB,EAAK,EAAU,IAwDhS,SAA6B,EAAK,EAAU,GAC3C,MAAM,OAAE,GAAW,EACnB,GAAU,EAAK,YAAa,GAC5B,MAAM,EAAO,GAAgB,GAC7B,IAAK,EAGJ,OAFA,GAAe,EAAK,EAAU,GAC9B,EAAO,MAAM,GACN,KAEJ,EAAI,QAAQ,qBAAqB,EAAI,QAAQ,GAC5C,GAAoB,IAAS,GAAmB,GAErD,OADA,GAAO,EAAQ,IAAK,cACb,GAAqB,EAAU,EAAK,EAC5C,CArE+S,CAAoB,EAAK,EAAU,EAClV,CAwBA,SAAS,GAAiB,EAAK,EAAU,EAAY,GACpD,MAAM,OAAE,GAAW,EACnB,OAAK,EAAO,UAAU,IACtB,GAAU,EAAK,YAAa,GAC5B,GAAO,EAAQ,IAAK,GAAG,eAChB,GAAqB,EAAU,EAAK,IAHJ,IAIxC,CAwCA,SAAS,GAAwB,GAChC,QAAS,EAAO,QAAO,EAAG,UAAW,GAAc,IAAI,IACxD,CAEA,SAAS,GAAmB,GAC3B,QAAK,GAAwB,EAAI,UACjC,GAAiB,EAAK,kDACf,EACR,CAEA,SAAS,GAAoB,GAC5B,QAAS,EAAO,QAAO,EAAG,UAAoB,OAAT,GAA0B,OAAT,GACvD,CAQA,SAAS,GAAkB,EAAK,GAC/B,MAAM,OAAE,GAAW,EACb,EAAW,GAAe,EAAK,MAAO,GAC5C,GAAiB,OAAb,EAAmB,OAAO,KAC9B,EAAI,YACJ,GAAO,EAAQ,IAAK,SAwCrB,SAAsB,GACrB,MAAM,OAAE,GAAW,EACb,EAAU,GAAkB,GAClC,GAAI,EAAS,EAAI,QAAQ,OACpB,CACJ,MAAM,EAAO,GAAgB,GACzB,GAAQ,EAAI,QAAQ,qBAAqB,EAAI,QAAQ,GACzD,GAAO,EAAQ,IAAK,gBACtB,CACA,CAhDC,CAAa,GACb,MAAM,EAAO,GAAgB,GACzB,GAAQ,EAAI,QAAQ,qBAAqB,EAAI,QAAQ,GACzD,GAAO,EAAQ,IAAK,sBAgDrB,SAAwB,GACvB,MAAM,EAAO,GAAgB,GACzB,GAAQ,EAAI,QAAQ,qBAAqB,EAAI,QAAQ,GACzD,GAAoB,EAAI,SAAW,GAAmB,EACvD,CAnDC,CAAe,GACf,GAAO,EAAQ,IAAK,mBACpB,MAAM,EAAO,GAAe,EAAK,sCAGjC,OAFA,EAAI,QAAQ,GACZ,EAAI,WACG,GAAqB,EAAU,EAAK,EAC5C,CAEA,SAAS,GAAoB,EAAK,GACjC,MAAM,EAAW,GAAe,EAAK,QAAS,GAC9C,GAAiB,OAAb,EAAmB,OAAO,KAC9B,GAAiB,EAAK,+CACtB,MAAM,EAAO,GAAe,EAAK,sCAEjC,OADA,EAAI,QAAQ,GACL,GAAqB,EAAU,EAAK,EAC5C,CAEA,SAAS,GAAmB,EAAK,GAChC,MAAM,EAAW,GAAe,EAAK,OAAQ,GAC7C,GAAiB,OAAb,EAAmB,OAAO,KAC9B,MAAM,EAAO,GAAe,EAAK,6BAA6B,GAE9D,OADA,EAAI,QAAQ,GACL,GAAqB,EAAU,EAAK,EAC5C,CAEA,SAAS,GAAyB,EAAK,GACtC,MAAM,EAAW,GAAe,EAAK,aAAc,EAAY,cAC/D,GAAiB,OAAb,EAAmB,OAAO,KAC9B,MAAM,EAAO,GAAe,EAAK,mCAEjC,OADA,EAAI,QAAQ,GACL,GAAqB,EAAU,EAAK,EAAY,aACxD,CAgCA,SAAS,GAAuB,EAAK,EAAY,GAChD,MAAM,EAAQ,EAAI,OAAO,UAAU,KACnC,IAAK,EAAO,OAAO,KACnB,MAAM,EAAW,GAAuB,EAAY,EAAM,KAAK,IAC/D,GAAU,EAAK,YAAa,GAC5B,MAAM,EAAY,GAAS,SA8B5B,SAA4B,GAC3B,QAAS,GAAc,GAAwB,EAChD,CAhCuC,CAAmB,GAIzD,OAHK,GAAW,EAAI,YAiCrB,SAA8B,EAAK,GAClC,MAAM,OAAE,GAAW,EACnB,MACK,EAAO,UAAU,MADT,CAEZ,MAAM,EAAO,GAAe,GAG5B,GAFK,GAAM,GAAgB,EAAQ,6BACnC,EAAI,QAAQ,GACR,GAA0B,eAAd,EAAK,KAAuB,CAC3C,GAAO,EAAQ,IAAK,oBACpB,KACH,CACA,CACA,CA5CC,CAAqB,EAAK,GAAS,UAC9B,GAAW,EAAI,WACb,GAAqB,EAAU,EAAK,EAC5C,CAEA,SAAS,GAAe,EAAK,EAAU,GACtC,MAAM,EAAQ,GAAmB,GAC3B,EAAQ,GAAuB,EAAK,EAAM,OAAS,EAAI,OAAQ,EAAQ,EAAW,CAAE,iBAAa,GAEvG,OADK,GAAO,GAAgB,EAAI,OAAQ,GACjC,CACR,CAEA,SAAS,GAAuB,EAAY,GAC3C,OAAO,IAAa,IAAI,OAAS,CAClC,CAEA,SAAS,GAAe,EAAK,EAAS,EAAY,EAAO,aACxD,MAAM,EAAa,EAAI,OAAO,aAC9B,IAAK,EAAI,OAAO,UAAU,GAAU,OAAO,KAC3C,MAAM,EAAW,GAAuB,EAAY,GAEpD,OADA,GAAU,EAAK,EAAM,GACd,CACR,CACA,SAAS,GAAqB,EAAO,EAAK,EAAY,EAAO,aAC5D,MAAM,EAAO,GAAW,EAAM,EAAO,EAAK,IAE1C,OADA,GAAiB,EAAM,GAChB,CACR,CA0BA,SAAS,GAAe,GACvB,MAAM,OAAE,GAAW,EACb,EAAW,EAAO,aAClB,EAAa,GAAmB,GAChC,EAAQ,EAAO,OACrB,IAAK,GAAwB,MAAf,EAAM,KAEnB,OADA,EAAO,MAAM,GACN,KAER,MAAM,EAAiB,EAAW,OAAS,GAAK,GAAwB,GACpE,GAAgB,EAAI,UAAU,WAClC,MAAM,EAAe,EAAW,OAAS,EAAI,OAAa,EACpD,EAAO,EAAQ,CACpB,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,KACG,GAAM,EAAE,EAAK,KACjB,OAAK,GAIN,SAA+B,EAAK,EAAgB,GACnD,GAAI,EAAgB,CACE,EAAI,WACZ,cAGf,SAAiC,GAChC,OAAO,EAAW,MAAM,GAAM,GAAyB,EAAE,cAAa,SACvE,CAL+B,CAAwB,EACvD,CACA,CARC,CAAsB,EAAK,EAAgB,GACpC,GAFW,IAGnB,CAiFA,SAAS,GAAgB,EAAY,EAAM,EAAQ,EAAY,GAC9D,MAAM,EAAO,EAAa,CACzB,KACG,EACH,EACA,GACG,CACH,KACG,EACH,GAED,OAAO,GAAY,OAAS,IAAI,KAAe,GAAQ,CACxD,CAEA,SAAS,GAAa,GACrB,MAAM,EAAa,GAAmB,GACtC,GAAgC,SAA5B,EAAI,OAAO,QAAQ,KAAiB,OAAO,KAC/C,GAAU,EAAK,QAAS,EAAW,OAAS,OAAa,GACzD,MAAM,EAAO,GAAe,GAAK,GACjC,IAAK,EAAM,MAAM,IAAI,MAAM,wDAC3B,EAAI,QAAQ,GACZ,MAAM,EAAO,GAAW,QAAS,GAAuB,EAAY,EAAK,OAAQ,EAAK,CAAE,SAGxF,OAFA,GAAc,EAAM,GACpB,GAAiB,EAAM,EAAW,OAAS,EAAI,OAAa,GACrD,CACR,CASA,SAAS,GAAqB,GAC7B,MAAM,OAAE,GAAW,EACb,EAAW,GAAqB,GAChC,EAeP,SAAkC,GACjC,MAAM,EAAc,EAAO,UAAU,UACrC,IAAK,EAAa,OAAO,KACzB,MAAM,EAUP,SAA6B,GAC5B,GAAI,EAAO,cAAc,UAAW,MAAO,MAAO,CAAC,GAAY,YAC/D,MAAM,EAAW,GACjB,KAAO,EAAO,cAAc,QAAS,OAAO,EAAS,KAAK,GAAY,UACtE,OAAO,EAAS,OAAS,EAAI,EAAW,IACzC,CAfkB,CAAoB,IAAW,GAC1C,EAAS,GAAsB,IAAW,GAAsB,GACjE,GAAQ,GAAgB,EAAQ,sCAChC,EAAO,UAAU,MAAM,GAAgB,EAAQ,gCACpD,MAAO,CACN,UAA2B,qBAAhB,EAAO,KAA8B,GAAgB,EAAU,GAAU,GAAc,EAAU,GAC5G,UAAW,EAAY,KAAK,GAE9B,CA1BqB,CAAyB,GAC7C,IAAK,EAEJ,OADI,GAAU,EAAO,MAAM,EAAS,OAC7B,KAER,MAAQ,UAAW,EAAO,UAAE,GAAc,EAC1C,MAAO,CACN,KAAM,SACN,UACA,MAAO,GAAU,OAAS,EAC1B,IAAK,EAAO,aACZ,WAAY,EAAW,CAAC,QAAY,EAEtC,CAsBA,SAAS,GAAsB,GAC9B,IAAK,EAAO,UAAU,KAAM,OAAO,KACnC,MAAM,EAAM,2CACN,EAAQ,GAAsB,GAC/B,GAAO,GAAgB,EAAQ,GACpC,MAAM,EAAa,CAAC,GACpB,KAAO,EAAO,UAAU,MACK,MAAxB,EAAO,QAAQ,MADU,CAE7B,MAAM,EAAO,GAAsB,GAC9B,GAAM,GAAgB,EAAQ,EAAM,cACzC,EAAW,KAAK,EAClB,CAEC,OADK,EAAO,UAAU,MAAM,GAAgB,EAAQ,yCA8C7C,CACN,KAAM,oBACN,SA/CqB,EACvB,CAKA,SAAS,GAAsB,GAC9B,MAAM,EA4CP,SAA0B,GACzB,MAAM,EAAQ,EAAO,OACrB,IAAK,EAAO,OAAO,KACnB,MAAM,KAAE,EAAI,KAAE,GAAS,EACvB,MAAa,SAAT,GAA4B,YAAT,GACnB,GAAa,IAAI,GAD6B,MAElD,EAAO,YACA,EACR,CApDc,CAAiB,GAC9B,IAAK,EAAM,OAAO,KAClB,GAAI,EAAO,UAAU,MAAO,CAC3B,MAAM,EAAU,GAAY,GACtB,EAAa,GAAsB,GACzC,GAAI,EAAY,OAAO,GAAc,CAAC,GAAU,GAChD,MAAM,EAAa,GAAsB,GACzC,GAAI,EAAY,OAAO,GAAgB,CAAC,GAAU,GAClD,GAAgB,EAAQ,uCAC1B,CACC,GAAI,EAAO,UAAU,MAAO,CAC3B,MAAM,EAAQ,EAAO,UAAU,QAE/B,OADK,GAAO,GAAgB,EAAQ,gCAC7B,GAAc,GAAI,GAAe,EAAM,EAAM,MACtD,CACC,OAAO,GAAc,GAAI,GAAe,GACzC,CAEA,SAAS,GAAgB,EAAU,GAClC,MAAO,IACH,EACH,SAAU,EAAS,OAAO,EAAU,UAEtC,CACA,SAAS,GAAc,EAAU,GAChC,MAAO,CACN,KAAM,mBACN,WACA,eAEF,CACA,SAAS,GAAY,GACpB,MAAO,CACN,KAAM,iBACN,OAEF,CAiBA,SAAS,GAAe,EAAM,GAC7B,MAAO,CACN,KAAM,cACN,OACA,KAEF,CAsCA,SAAS,GAAkB,GAC1B,MAAM,OAAE,GAAW,EACb,EAAa,EAAO,aACpB,EAAa,GAAmB,GAChC,EAAY,EAAO,UAAU,QACnC,IAAK,EAEJ,OADA,EAAO,MAAM,GACN,KAER,MAAM,EAAQ,GAAuB,EAAY,EAAU,KAAK,IAChE,GAAU,EAAK,SAAU,EAAW,OAAS,OAAa,GAC1D,MAAM,EAAO,GAAa,GAC1B,EAAI,QAAQ,GACZ,GAAO,EAAQ,IAAK,sBACpB,MAAM,EAAU,GAAmB,GAC9B,GAAS,GAAgB,EAAQ,2BACtC,EAAI,QAAQ,GACZ,MAAM,EAAO,GAAW,SAAU,EAAO,EAAK,CAC7C,OACA,YAGD,OADA,GAAiB,EAAM,EAAW,OAAS,OAAa,GACjD,CACR,CAIA,MAAM,GAAc,CACnB,GA9vBD,SAA2B,EAAK,GAC/B,OAAO,GAAe,EAAK,YAAY,GAAO,EAAM,EACrD,EAgFA,SAA4B,EAAK,GAChC,MAAM,OAAE,GAAW,EACb,EAAW,EAAO,UAAU,OAClC,IAAK,EAAU,OAAO,KACtB,MAAM,EAAW,GAAuB,EAAY,EAAS,KAAK,IAClE,EAAI,UAAU,WACd,GAAU,EAAK,OAAQ,GACvB,GAAiB,GACjB,MAAM,EAAY,GAAe,GAC5B,GAAW,GAAgB,EAAQ,mCACxC,EAAI,QAAQ,GACR,EAAO,UAAU,MAAM,GAAiB,GAC5C,GAAO,EAAQ,IAAK,mBACpB,EAAU,KAAK,MAAM,eAAiB,EAAI,eAC1C,EAAI,WACJ,MAAM,EAAU,GAAW,OAAQ,EAAU,EAAK,CAAE,KAAM,IAG1D,OAFA,GAAiB,EAAS,GAC1B,GAAc,EAAW,GAClB,CACR,EAEA,SAAwB,EAAK,GAC5B,MAAM,OAAE,GAAW,EACb,EAAa,EAAO,UAAU,SACpC,IAAK,EAAY,OAAO,KACxB,MAAM,EAAW,GAAuB,EAAY,EAAW,KAAK,IACpE,GAAU,EAAK,QAAS,GACxB,MAAM,EAAgB,GAAoB,EAAK,GAAW,EAAQ,sCAAsC,GACxG,EAAI,QAAQ,GACZ,EAAI,UAAU,EAAc,OAC5B,GAAO,EAAQ,IAAK,cACpB,EAAI,YACJ,MAAM,EAAU,GAAmB,GAC9B,GAAS,GAAgB,EAAQ,gDACtC,EAAI,QAAQ,GACZ,EAAc,MAAM,eAAiB,EAAI,eACzC,EAAI,WACJ,GAAO,EAAQ,IAAK,qBACpB,MAAM,EAAY,GAAW,QAAS,EAAU,EAAK,CACpD,KAAM,EACN,YAID,OAFA,GAAiB,EAAW,GAC5B,GAAkB,EAAe,GAC1B,CACR,EAqkBA,SAAyB,EAAK,GAC7B,MAAM,OAAE,GAAW,EACb,EAAc,EAAO,UAAU,UACrC,IAAK,EAAa,OAAO,KACzB,MAAM,EAAQ,GAAuB,EAAY,EAAY,KAAK,IAC5D,EAAY,GAAoB,EAAK,GAAW,EAAQ,uCAAuC,GACrG,EAAI,UAAU,EAAU,OACxB,GAAU,EAAK,SAAU,GACzB,EAAI,QAAQ,GACZ,GAAO,EAAQ,IAAK,eACpB,EAAI,YACJ,MAAM,EAaP,SAA4B,GAC3B,MAAM,EAAU,GAAe,EAAK,IACpC,IAAK,MAAM,KAAU,EAAS,EAAI,QAAQ,GAC1C,OAAO,CACR,CAjBiB,CAAmB,GACnC,EAAU,MAAM,eAAiB,EAAI,eACrC,EAAI,WACJ,GAAO,EAAQ,IAAK,iBACpB,MAAM,EAAO,GAAW,SAAU,EAAO,EAAK,CAC7C,KAAM,EACN,YAID,OAFA,GAAiB,EAAM,GACvB,GAAkB,EAAW,GACtB,CACR,EApPA,SAAqB,EAAK,GACzB,MAAM,OAAE,GAAW,EACb,EAAU,EAAO,UAAU,MACjC,IAAK,EAAS,OAAO,KACrB,MAAM,EAAW,GAAuB,EAAY,EAAQ,KAAK,IAC3D,EAAgB,GAAoB,EAAK,GAAW,EAAQ,mCAAmC,GACrG,EAAI,UAAU,EAAc,OAC5B,EAAI,YACJ,MAAM,EAAiB,EAAI,eAC3B,EAAI,YACJ,MAAM,EA0BP,SAAuB,GACtB,MAAM,OAAE,GAAW,EACb,EAAS,GACf,GAAO,EAAQ,IAAK,iBACpB,MAAQ,EAAO,UAAU,MAAM,CAC9B,MAAM,EAAQ,GAAa,GAG3B,GAFK,GAAO,GAAgB,EAAQ,sCACpC,EAAO,KAAK,IACR,EAAO,UAAU,KAArB,CACA,GAAO,EAAQ,IAAK,sBACpB,KAF2B,CAG7B,CACC,OAAO,CACR,CAvCgB,CAAc,GACvB,EAAY,EAAI,eACtB,EAAI,MAAM,QAAQ,MAAQ,EAC1B,MAAM,WAAE,EAAU,iBAAE,GAsCrB,SAAuB,GACtB,MAAM,OAAE,GAAW,EACnB,IAAK,EAAO,UAAU,MAAO,MAAO,GACpC,MAAM,EAAQ,GAAmB,GAC3B,EAAa,GAAmB,GACjC,GAAY,GAAgB,EAAQ,4BACzC,MAAO,CACN,aACA,iBAAkB,EAAM,OAAS,EAAI,OAAQ,EAE/C,CAhD0C,CAAc,GACvD,EAAI,MAAM,QAAQ,MAAQ,EAC1B,MAAM,EAjIP,SAA2B,GAC1B,OAAO,GAAuB,OAAK,EAAQ,CAAE,SAAS,GACvD,CA+Hc,CAAkB,GAC1B,GAAM,GAAgB,EAAQ,0BACnC,EAAI,WACJ,EAAc,MAAM,eAAiB,EAAI,eACzC,EAAI,WACJ,MAAM,EAAS,CACd,KAAM,KACN,KAAM,EACN,SACA,OACA,aACA,mBACA,MAAO,EACP,IAAK,EAAO,aACZ,SAAU,GAAgB,EAAY,EAAe,EAAQ,EAAY,IAI1E,OAFA,GAAiB,EAAQ,GACzB,GAAkB,EAAe,GAC1B,CACR,EA4PC,IAGD,SAAS,GAAY,GAGpB,KAGD,SAAsB,GACrB,MAAM,EA3MP,SAA0B,GACzB,MAAO,IAAI,GAAU,EAAK,IAC3B,CAyMqB,CAAiB,GACrC,IAAK,MAAM,KAAc,EACxB,EAAI,QAAQ,GACZ,EAAI,MAAM,OAAO,QAAQ,KAAK,EAAW,QAE3C,CAXC,CAAa,GAad,SAAyB,GACxB,MAAM,EAAa,GAAU,EAAK,IAClC,IAAK,MAAM,KAAQ,EAAY,EAAI,QAAQ,EAC5C,CAfC,CAAgB,GACT,GAAqB,KAC7B,CAeA,SAAS,GAAqB,GAC7B,MAAM,OAAE,GAAW,EACnB,GAAI,EAAO,UAAU,KAAM,OAAO,EAClC,MAAM,EAAQ,GAAmB,GAC3B,EAAiB,GAAwB,GAC3C,GAAgB,EAAI,UAAU,WAClC,MAAM,EAOP,SAAmB,EAAK,GACvB,MAAM,EAAe,EAAM,OAAS,OAAQ,EACtC,EAAO,EAAQ,IAAc,GAAM,EAAE,EAAK,KAChD,GAAI,EAEH,OAUF,SAAoB,EAAK,EAAM,GAC1B,EAAM,QAAU,EAAK,MAAQ,EAAM,GAAG,QAAO,EAAK,MAAQ,EAAM,GAAG,OAEvE,GADA,EAAI,QAAQ,GACM,WAAd,EAAK,KAAmB,CAC3B,MAAM,OAAE,GAAW,EAAI,MACvB,EAAO,gBAAkB,GACzB,EAAO,cAAc,KAAK,EAC5B,CACA,CAnBE,CAAW,EAAK,EAAM,IACf,EAER,OAAO,CACR,CAfgB,CAAU,EAAK,GAE9B,OADI,GAAkB,GAgBvB,SAA6B,EAAK,GACjC,MAAM,EAAe,EAAI,WACzB,EAAa,cAAgB,EAAQ,GAAO,EAAG,gBAAgB,MAa7C,SADa,EAZuD,GAa7E,MAA6B,UAAX,EAAE,MAA+B,UAAX,EAAE,KAbgD,OAAY,EAYhH,IAAgC,CAZsF,GACtH,CAnB+B,CAAoB,EAAK,KACnD,IACA,EAAM,QAAQ,GAAgB,EAAQ,0CACnC,EACR,CAiCA,IAAI,GAAiB,MACpB,IACA,UACA,OACA,MACA,QACA,WAAA,CAAY,EAAQ,EAAO,GAC1B,KAAK,OAAS,EACd,KAAK,MAAQ,EACb,KAAK,UAAY,EAAM,OAAO,UAC9B,KAAK,IAAM,KAAK,UAAU,IAC1B,KAAK,QAAU,GAAW,EAC5B,CACC,QAAA,GACC,OAAO,KAAK,OAAO,YACrB,CACC,YAAA,GACC,OAAO,KAAK,MAAM,QAAQ,KAC5B,CACC,OAAA,CAAQ,GACP,MAAM,UAAE,GAAc,KAAK,MAAM,QAC7B,EAAU,OAAS,GAAG,EAAU,EAAU,OAAS,GAAG,SAAS,KAAK,EAC1E,CACC,SAAA,CAAU,EAAO,SAChB,MAAM,MAAE,GAAU,KAAK,MAAM,QACvB,EAAW,EAAW,EAAO,GACnC,EAAM,SAAS,KAAK,GACpB,KAAK,MAAM,QAAQ,MAAQ,CAC7B,CACC,QAAA,GACC,MAAM,EAAc,KAAK,MAAM,QACzB,EAAiB,EAAY,MAEnC,OADI,EAAe,SAAQ,EAAY,MAAQ,EAAe,QACvD,CACT,CACC,aAAA,GACC,IAAI,EAAQ,KAAK,eACjB,KAAsB,YAAf,EAAM,MAAsB,EAAM,QAAQ,EAAQ,EAAM,OAC/D,OAAwB,OAAjB,EAAM,MACf,CAEC,iBACA,cAAA,CAAe,GACd,MAAM,EAAM,CACX,KAAM,MACN,aAAc,EACd,IAAK,KAAK,MAAM,OAChB,GAAI,IACJ,aAAc,MAGf,OADI,KAAK,mBAAkB,EAAI,UAAY,KAAK,kBACzC,CACT,CACC,eAAA,CAAgB,EAAM,GAAW,GAChC,MAAO,CACN,KAAM,OACN,aAAc,EACd,gBAAiB,KAAK,MAAM,QAAQ,MACpC,WACA,GAAI,IACJ,UAAW,KAAK,UAChB,SAAU,KAEb,CACC,SAAA,CAAU,GACT,KAAK,MAAM,QAAQ,MAAM,SAAS,KAAK,EACzC,GAMA,MAAM,GAAW,wLAEiD,MAAM,OAElE,GAAgB,8pCAYkF,MAAM,OAI9G,IAAI,GAAgB,MACnB,MAAQ,IAAI,GAAM,GAClB,MACA,WAAA,CAAY,GACX,KAAK,MAAQ,CACf,CACC,UAAA,GACC,OAAO,KAAK,MAAM,YACpB,CACC,KAAA,CAAM,GACL,KAAK,MAAM,MAAM,EACnB,CACC,SAAA,GACC,MAAM,EAAW,KAAK,aAChB,EAAc,KAAK,MAAM,IAAI,GACnC,QAAoB,IAAhB,EAEH,OADA,KAAK,MAAM,EAAY,YAChB,EAAY,MACb,CACN,MAAM,EAAQ,KAAK,MAAM,YACnB,EAAa,KAAK,aAKxB,OAJA,KAAK,MAAM,IAAI,EAAU,CACxB,QACA,eAEM,CACV,CACA,CACC,OAAI,GACH,OAAO,KAAK,MAAM,GACpB,GAGI,GAAQ,cAAc,IACzB,IACA,WAAA,CAAY,GACX,QACA,KAAK,IAAM,CACb,CACC,GAAA,CAAI,EAAG,GACN,GAAI,KAAK,KAAO,KAAK,IAAK,CACzB,MAAM,EAAQ,KAAK,OAAO,OAAO,MAC7B,GAAO,KAAK,OAAO,EAC1B,CACE,OAAO,MAAM,IAAI,EAAG,EACtB,GAKA,SAAS,GAAc,GACtB,MAAO,EAAM,GAAK,EAClB,GAAiB,iBAAN,EAAgB,CAC1B,MAAM,EAAS,IAAI,GAAY,MAE/B,OADA,GAAmB,EAAM,IAAI,OAAO,IAC7B,CACT,CAEE,OADA,GAAmB,EAAM,GAClB,IAAI,EAAE,SAEf,CACA,SAAS,GAAmB,EAAM,GACjC,GAAI,IAAI,OAAO,IAAM,EAAI,QAAQ,KAAK,IAAI,OAAS,EAAG,MAAM,IAAI,MAAM,kDAAkD,OAAU,EAAI,gCACvI,CACA,MAAM,GAAgB,uBACtB,SAAS,GAAY,GACpB,OAAO,EAAE,QAAQ,GAAe,OACjC,CAMA,SAAS,GAAW,GACnB,MAAM,EAAU,EAAK,MAAM,OAAO,MAAK,CAAC,EAAG,IAAM,EAAE,OAAS,EAAE,SAAQ,QAAQ,GAAM,IAAG,IAAI,IAC3F,OAAO,IAAI,OAAO,EAAQ,KAAK,KAChC,CAKA,IAAI,GAAiB,MACpB,SAAW,EACX,KACA,SACA,WAAA,CAAY,EAAM,GACjB,KAAK,KAAO,EACZ,KAAK,SAAW,CAClB,CACC,UAAA,GACC,OAAO,KAAK,QACd,CACC,KAAA,CAAM,GACL,KAAK,SAAW,CAClB,CACC,SAAA,GACC,MAAM,EAAS,KAAK,SAAS,OAAO,KAAK,KAAM,KAAK,UACpD,OAAe,OAAX,EAAwB,MAC5B,KAAK,SAAW,EAAO,KAAK,GACrB,EACT,CACC,OAAI,GACH,OAAO,KAAK,IACd,GAyCA,MAGM,GAAoB,IAAI,IAAI,GAAS,OAAO,KAC5C,GAAc,IAtCA,MACnB,OACA,IACA,WAAA,CAAY,GACX,KAAK,OAAS,OAAO,KAAK,GAC1B,MAAM,EAAW,OAAO,QAAQ,GAAU,IAAI,IAAe,KAAK,KAClE,KAAK,IAAM,IAAI,OAAO,EAAU,MAClC,CACC,MAAA,CAAO,EAAM,GACZ,KAAK,IAAI,UAAY,EACrB,MAAM,EAWR,SAAsB,GACrB,QAAgB,IAAZ,EAAoB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAQ,OAAQ,IAAK,CAChE,MAAM,EAAO,EAAQ,GACrB,QAAa,IAAT,EAAiB,MAAO,CAC3B,OACA,SAAU,EAAI,EAEjB,CACA,CAnBuB,CAAa,KAAK,IAAI,KAAK,IAAO,SACvD,GAAI,EAAc,CACjB,MAAM,KAAE,EAAI,SAAE,GAAa,EAC3B,MAAO,CACN,KAAM,KAAK,OAAO,GAClB,OACA,KAAM,EAAK,MAAM,EAAK,GAAI,EAAK,IAEnC,CAAS,OAAO,IAChB,GAmBsC,CACrC,KAHa,mEAIb,OAAQ,IAAI,OAAO,gCAAgC,OAAS,+CAA+C,OAAS,+CAA+C,OAAS,kCAAkC,OAAS,gEAAgE,OAAS,gEAAgE,OAAS,6CAA6C,OAAS,8BAA8B,OAAS,mCAAmC,QACze,YAPmB,0DAQnB,aAAc,YACd,OAAQ,GARS,kIASjB,QAAS,QAGP,IAAC,GAAa,MAChB,OAEA,WAAa,2CACb,oBAAsB,aACtB,IACA,WAAA,CAAY,GACX,KAAK,IAAM,EACX,KAAK,OAAS,IAAI,GAAc,IAAI,GAAe,EAAK,IAC1D,CACC,UAAA,GACC,OAAO,KAAK,OAAO,YACrB,CACC,KAAA,CAAM,GACL,KAAK,OAAO,MAAM,EACpB,CACC,SAAA,GACC,OAAa,CACZ,MAAM,EAAQ,KAAK,OAAO,YAC1B,GAAc,OAAV,EAAgB,OAAO,KAC3B,MAAM,EAAO,EAAM,KACnB,GAAa,gBAAT,EAAJ,CACK,GAAa,iBAAT,EAEJ,IAAa,SAAT,EAAiB,CACzB,MAAM,EAAc,EAEpB,OADI,GAAkB,IAAI,EAAM,QAAO,EAAY,KAAO,WACnD,CACX,CAAU,GAAa,YAAT,EAAoB,MAAM,IAAI,GAAW,iBAAmB,EAAM,KAAM,EAAM,MACpF,OAAO,CAAK,CAPoC,OAAf,EAAM,KAAe,KAAK,OAAO,MAAM,KAAK,UAAU,EAAM,KAAK,KAClG,KAAK,OAAO,MAAM,KAAK,iBAAiB,EAAM,KAAK,IAMvC,CACpB,CACA,CAEC,IAAA,GACC,MAAM,EAAM,KAAK,aACX,EAAQ,KAAK,YAEnB,OADA,KAAK,MAAM,GACJ,CACT,CAEC,SAAA,CAAU,GACT,MAAM,EAAQ,KAAK,OACnB,OAAI,GAAO,OAAS,GACnB,KAAK,YACE,GAED,IACT,CAEC,SAAA,CAAU,EAAM,GACf,MAAM,EAAQ,KAAK,OACnB,OAAI,GAAO,OAAS,GAAU,GAAQ,EAAM,OAAS,EAI9C,MAHN,KAAK,YACE,EAGV,CAEC,MAAA,CAAO,GACN,MAAM,EAAQ,KAAK,OACnB,OAAI,GAAS,EAAU,IACtB,KAAK,YACE,GAED,IACT,CAEC,aAAA,IAAiB,GAChB,MAAM,EAAW,KAAK,aAChB,EAAS,GACf,IAAK,MAAM,KAAQ,EAAO,CACzB,MAAM,EAAQ,KAAK,UAAU,GAC7B,IAAK,EAEJ,OADA,KAAK,MAAM,GACJ,KAER,EAAO,KAAK,EACf,CACE,OAAO,CACT,CACC,SAAA,CAAU,GAET,OADA,KAAK,WAAW,UAAY,EACW,OAAnC,KAAK,WAAW,KAAK,KAAK,KAAsB,KAAK,IAAI,OACjD,KAAK,WAAW,SAC9B,CACC,gBAAA,CAAiB,GAChB,IAAI,EAAW,EACf,OAAa,CACZ,KAAK,oBAAoB,UAAY,EACrC,MAAM,EAAS,KAAK,oBAAoB,KAAK,KAAK,KAClD,GAAe,OAAX,EAAiB,MAAM,IAAI,GAAW,0BAA2B,CAAC,EAAU,IAC3E,GAAkB,OAAd,EAAO,GAAa,OAAO,KAAK,oBAAoB,UACxD,GAAkB,OAAd,EAAO,GACX,MAAM,IAAI,MAAM,8CADQ,EAAW,KAAK,iBAAiB,KAAK,oBAAoB,UAE1F,CACA,CAMC,sBAAA,GACC,MAAM,EAAgB,KAAK,OAAO,aAC5B,EAAQ,KAAK,YAEnB,OADA,KAAK,OAAO,MAAM,GACJ,OAAV,GACe,WAAf,EAAM,KADiB,KAER,MAAf,EAAM,KAAkB,KAAK,gBAAgB,EAAM,KAAK,KAC3D,KAAK,OAAO,MAAM,EAAM,KAAK,IACtB,IAEP,KAAK,OAAO,MAAM,GACX,MAEI,IACd,CACC,oBAAA,GACC,MAAM,EAAgB,KAAK,OAAO,aAC5B,EAAQ,KAAK,YAEnB,GADA,KAAK,OAAO,MAAM,GACJ,OAAV,EAAgB,OAAO,KAC3B,GAAmB,WAAf,EAAM,MAAuC,MAAlB,EAAM,KAAK,GAAY,CACrD,MAAM,EAAgB,EAAM,KAAK,GAEjC,OADA,KAAK,OAAO,MAAM,EAAgB,GAC3B,CACN,KAAM,SACN,KAAM,CAAC,EAAe,EAAgB,GACtC,KAAM,IAEV,CAAS,OAAO,IAChB,CACC,eAAA,CAAgB,GACf,KAAK,OAAO,MAAM,GAClB,IAAI,EAAiB,EACrB,OAAa,CACZ,MAAM,EAAY,KAAK,OAAO,YAC9B,GAAkB,OAAd,EAAoB,OAAO,EAC/B,GAAuB,WAAnB,EAAU,KACd,GAAuB,MAAnB,EAAU,KAAc,GAAkB,OACzC,GAA0B,MAAtB,EAAU,KAAK,GAAY,CACnC,GAAuB,MAAnB,EAAU,MAAmC,OAAnB,EAAU,KAAe,GAAkB,MACpE,IAAuB,QAAnB,EAAU,MAAqC,OAAnB,EAAU,KAC1C,MAAM,IAAI,MAAM,+FADyC,GAAkB,CACmC,CACnH,GAAI,GAAkB,EAAG,OAAO,CACpC,MAAU,GAAuB,MAAnB,EAAU,KAAc,KAAK,eAAe,UAClD,GAAuB,MAAnB,EAAU,KAAc,KAAK,eAAe,UAChD,GAAuB,OAAnB,EAAU,MAAoC,OAAnB,EAAU,MAAoC,MAAnB,EAAU,MAAmC,MAAnB,EAAU,MAAmC,MAAnB,EAAU,MAAmC,OAAnB,EAAU,MAAoC,OAAnB,EAAU,KAAe,OAAO,CAC3M,CACA,CAKC,cAAA,CAAe,GACd,OAAa,CACZ,MAAM,EAAY,KAAK,OAAO,YAC9B,GAAkB,OAAd,EAAoB,CACvB,MAAM,EAAQ,KAAK,OAAO,aAC1B,MAAM,IAAI,GAAW,oBAAqB,CAAC,EAAO,GACtD,CACG,GAAuB,WAAnB,EAAU,KACd,GAAuB,MAAnB,EAAU,KAAc,KAAK,eAAe,UAC3C,GAAuB,MAAnB,EAAU,KAAc,KAAK,eAAe,UAChD,GAAI,EAAU,OAAS,EAAgB,MAC/C,CACA,GAMA,SAAS,GAAU,EAAW,GAC7B,MAAM,IAAE,EAAG,MAAE,GAmBd,SAA0B,EAAW,GACpC,MAAM,EAAS,IAAI,GAAW,EAAU,KAClC,EAAY,EAAW,MACvB,EAAa,CAClB,KAAM,SACN,SAAU,GACV,MAAO,EACP,IAAK,EAAU,IAAI,QAEd,EAAQ,CACb,QAAS,CACR,MAAO,EACP,UAAW,IAEZ,OAAQ,CACP,YACA,aACA,YACA,QAAS,KAGX,MAAO,CACN,IAAK,IAAI,GAAe,EAAQ,EAAO,GACvC,QAEF,CA5CwB,CAAiB,EAAW,GACnD,IACC,GAAU,EAAK,UACf,GAAY,GACZ,MAAM,EAAa,EAAM,OAAO,WAEhC,OADA,EAAW,SAAW,GAAe,EAAK,EAAG,EAAW,KACjD,EAAM,MACf,CAAG,MAAO,GACR,GAAI,aAAa,GAAY,MAAM,IAAI,GAAe,CACrD,MAAO,EACP,IAAK,IAEN,MAAM,IAAI,GAAe,CACxB,MAAO,IAAI,GAAW,aAAa,MAAQ,EAAE,QAAU,OAAO,GAAI,CAAC,EAAG,IACtE,IAAK,GAER,CACA,CAgCG,IAAC,GAAiB,cAAc,MAClC,KACA,IACA,WAAA,CAAY,GACX,MAAM,EAAS,EAAK,IAAI,KACjB,EAAS,GAAW,EAAmB,EAAK,MAAM,KAAK,GAAI,GAClE,IAAI,EAAU,GAAG,EAAK,IAAI,iBAAiB,KAAW,IACtD,GAAW,WAAW,EAAK,MAAM,YACjC,GAAW,EAAe,EAAQ,EAAK,MAAM,MAAM,KAAK,MACxD,MAAM,EAAS,CAAE,MAAO,EAAK,QAC7B,KAAK,KAAO,EAAK,MAAM,KACvB,KAAK,IAAM,EAAK,GAClB,GAGA,SAAS,GAAe,EAAW,GAClC,OAAO,GAAU,EAAW,EAC7B,CAEA,SAAS,GAAY,EAAK,GACzB,GAAI,EAAI,eAAiB,EAAY,OAAO,EAAI,aAChD,MAAM,EAAc,EAAI,WAAW,SAAS,QAAQ,GAAuB,WAAd,EAAK,OAC5D,GAAQ,EAAa,EAAoB,EAAa,GAAc,GAAa,KAAK,GAAS,EAAK,UAAS,QAAQ,IAE3H,OADK,IAAY,EAAI,aAAe,GAC7B,CACR,CAKA,SAAS,GAAW,GACnB,MAAM,QAAE,EAAO,SAAE,EAAQ,SAAE,EAAQ,kBAAE,GAAsB,GACrD,WAAE,EAAa,GAAE,QAAE,EAAU,IAAkB,GAC/C,cAAE,GAAkB,EACpB,EAAc,EAAQ,UAAU,WAAW,MAAM,MAAM,GACvD,EAAY,EAAgB,GAAiB,EAAQ,WAAa,GAAmB,EAAQ,UAAW,IACxG,YAAE,EAAW,WAAE,GA6BtB,SAAuB,GACtB,IAAK,MAAM,KAAK,EAAgB,EAAE,YAAc,EAAE,aAClD,MAAM,EAAa,IAAI,IAAI,GAC3B,MAAO,CACN,YAAa,IAAI,IAAI,EAAe,KAAK,GAAM,EAAE,gBACjD,aAEF,CApCqC,CAAc,GAC5C,EAAc,CACnB,WACA,aACA,aACA,WACA,UACA,cACA,YAA6B,IAAI,IACjC,cACA,iBAAkC,IAAI,IACtC,QAAS,EAAoB,QAAK,EAClC,iBAEK,EAAY,CACjB,MAAO,IAAI,IAAI,EAAU,KAAK,GAAM,CAAC,EAAE,aAAc,MACrD,OAAQ,MAKT,MAAO,CACN,MAAO,IAJc,EAAU,SAAS,GAAS,GAAsB,EAAM,QAC7D,GAAoB,EAAQ,UAAW,EAAa,IAIpE,cACA,cAJqB,IAAI,EAAY,iBAAiB,UAKtD,QAAS,EAAY,QAEvB,CAWA,SAAS,GAAY,GACpB,GAAkB,SAAd,EAAK,MAAiD,YAA9B,EAAK,gBAAgB,KACjD,MAAkB,SAAd,EAAK,KAAwB,EAAgB,EAAK,UAAU,YAC9C,YAAd,EAAK,MAAoC,UAAd,EAAK,KAAyB,EAAK,mBAAlE,CACD,CAEA,SAAU,GAAW,EAAO,GAC3B,IAAI,GAAY,EAChB,IAAK,MAAM,KAAQ,EAAM,SAAU,CAClC,MAAM,EAAO,EAAoB,GAAY,GAAO,EAAW,GAC/D,EAAY,EAAK,cACb,EAAK,cAAa,EACxB,CACA,CAEA,SAAS,GAAmB,EAAW,GACtC,OAAO,GAAa,GAAW,EAAW,GAC3C,CAEA,SAAS,GAAiB,GACzB,OAAO,GAAa,EAAU,SAC/B,CAEA,SAAS,GAAW,EAAO,EAAM,GAChC,OAoJD,SAA2B,EAAW,GACrC,MAAM,EAAW,EAEjB,OADA,EAAS,kBAAoB,GAAmB,EAAW,GACpD,EAAS,eACjB,CAxJQ,CAAkB,EAAO,GAAY,MAAM,GAAM,EAAE,eAAiB,GAC5E,CAMA,SAAS,GAAoB,EAAO,EAAa,GAChD,MAAM,gBAAE,EAAe,YAAE,GAAgB,EACzC,GAAI,EAAY,IAAI,GAAQ,MAAO,GACnC,EAAY,IAAI,GAChB,MAAM,WAAE,EAAU,gBAAE,GAQrB,SAAsB,EAAO,EAAa,GACzC,MAAM,EAAa,GACb,EAAkB,GAClB,EAAQ,EAAY,cAAgB,EAAM,SAAW,GAAW,EAAO,EAAY,YACzF,IAAK,MAAM,KAAS,EAAO,GAAmB,SAAf,EAAM,KAAiB,EAAU,MAAM,IAAI,EAAM,aAAc,QACzF,GAAmB,QAAf,EAAM,KAAgB,CAC9B,MAAM,EAAU,GAAU,EAAO,EAAW,GACxC,GAAS,EAAW,KAAK,EAC/B,KAAQ,CACN,MAAM,EAAyB,UAAf,EAAM,KAAmB,GAAc,GAAa,EACpE,EAAgB,QAAQ,GAAoB,EAAO,EAAa,GAClE,CACC,MAAO,CACN,aACA,kBAEF,CAxByC,CAAa,EAAO,EAAa,GACzE,MAAO,CACN,EACA,EACA,EAAkB,GAAK,GAAY,EAAY,IAC9C,MACH,CAoBA,SAAS,GAAsB,EAAM,GACpC,MAAM,eAAE,GAAmB,EAC3B,IAAK,EAAgB,MAAO,GAC5B,MAAM,EAkHP,SAAuB,EAAM,GAC5B,EAAgB,EAAK,SAAU,GAAc,IAC7C,IAAI,EAAQ,EAAK,gBACjB,KAAO,EAAM,QAAQ,EAAQ,EAAM,OACnC,EAA+B,UAAf,EAAM,MACtB,MAAM,EAAO,EACb,IAAK,EAAK,YAAa,CACtB,MAAM,EAAY,GAAmB,EAAO,GAC5C,EAAK,YAAc,CAAE,MAAO,IAAI,IAAI,EAAU,KAAK,GAAM,CAAC,EAAE,aAAc,MAC5E,CACC,OAAO,EAAK,WACb,CA7HmB,CAAc,EAAM,EAAI,YAC1C,OAAK,EACE,GAAoB,EAAgB,EAAK,GAAc,IADvC,EAExB,CAMA,SAAS,GAAU,EAAO,EAAW,GACpC,GAAI,EAAM,UAAY,EAAM,IAAK,OACjC,GAAI,EAAM,aAAc,OACxB,GAAI,EAAM,YAAc,EAAuB,IAAI,EAAM,WAAY,OACrE,MAAM,EAAY,GAAiB,EAAO,IAwC3C,SAA6B,EAAU,GACtC,MAAM,WAAE,EAAU,QAAE,EAAO,cAAE,GAAkB,EACzC,EAAQ,OAAgB,EAAS,EACjC,EAAW,GAAY,EAAS,IAAK,GACrC,EAAa,EAAS,aAAa,MAAM,MACzC,EAqBP,SAAwB,EAAY,GACnC,MAAM,EAAO,EAAQ,MAAM,GAAM,EAAE,WAAW,IAAI,KAAO,EAAW,KACpE,GAAI,EAAM,MAAO,IAAI,EAAK,cAAe,EAAW,MAAM,GAC3D,CAxBmB,CAAe,EAAY,IAkF9C,SAAwB,GACvB,GAAI,EAAW,OAAS,EAAG,OAAO,CACnC,CApF2D,CAAe,GACzE,IAAK,EAEJ,YADI,IAAY,GAAQ,EAAS,eAAe,GAAY,EAAS,EAAY,IAGlF,MAAM,EAqBP,SAAoB,EAAW,EAAW,GACzC,MAAM,EAAa,GAAkB,EAAW,EAAU,WAAW,MAAM,OAAO,MAAM,GAAI,GAAG,KAAK,MAC9F,EAAY,EAAI,SAAS,cAAc,IAS9C,SAAuB,EAAY,GAClC,MAAM,EAAQ,EAAI,WAAW,GAC7B,IAAK,EAAO,OACZ,GAAI,EAAM,IAAK,OAAO,EAAM,IAC5B,MAAM,EAAM,EAAM,GAAG,EAAI,YAMzB,OALA,EAAM,IAAM,GAAe,CAC1B,WAAY,EAAI,YAAc,KAAO,EACrC,cAAe,EACf,QAEM,EAAM,GACd,CApB6D,CAAc,EAAU,GAAI,GACxF,IAAK,EAAW,OAChB,MAAM,EAAO,GAAW,EAAU,UAAW,EAAK,GAAY,EAAI,YAClE,GAAI,EAAM,MAAO,CAChB,OACA,YAEF,CA9BgB,CAAW,EAAW,EAAS,IAAI,UAAW,GACxD,IAAY,EAAS,GAAY,EAAS,EAAW,GACrD,EAAU,EAAU,yBAAyB,EAAU,KAAK,WACjE,OAAO,CACR,CAtDyD,CAAoB,EAAO,GACnF,GAAI,EAEH,OADA,EAAM,SAAW,EAAU,KAc7B,SAAuB,EAAU,EAAW,GAC3C,MAAM,KAAE,EAAI,UAAE,GAAc,GACtB,WAAE,EAAU,YAAE,EAAW,QAAE,EAAO,iBAAE,GAAqB,EAC/D,GAAI,EAAW,IAAI,GAAO,OAC1B,EAAW,IAAI,GAGf,GA2FD,SAAwB,EAAc,EAAM,EAAa,EAAW,GACnE,GAAI,EAAK,YAAa,OACtB,MAAM,EAAM,EAAa,YAAY,MAC/B,GAAgB,IAAT,EAAa,EAAe,EAAa,MAAM,EAAM,GAC5D,EAAc,EAAK,SAAW,EAAQ,EAAM,EAAW,EAAM,GAAe,EAAK,aACvF,EAAK,YAAc,EACnB,EAAY,IAAI,EACjB,CAnGC,CADa,EAAS,aACD,EAAM,EAAa,EAAK,UAAW,IACnD,EAAK,SAAU,OACpB,IAAK,MAAM,KAAQ,EAAU,eAAiB,GAAI,EAAiB,IAAI,EAAM,CAC5E,UAAW,EAAK,UAChB,SAED,OAAO,CACR,CA1BS,CAAc,EAAO,EAAW,GAEpC,GAAQ,EAAM,cACjB,EAAM,KAAM,EAGR,EAAY,SAAS,EAAU,EAAO,0BAA0B,EAAM,gBAC5E,CAEA,SAAS,GAAY,EAAY,GAChC,OAAO,EAAW,SAAS,GAAS,GAAsB,EAAM,IACjE,CAiBA,SAAS,GAAiB,EAAO,GAChC,MAAM,EAAQ,EAAU,MAAM,IAAI,EAAM,cACxC,OAAI,EAAc,CACjB,KAAM,EACN,UAAW,EAAM,KAEd,EAAU,OAAe,GAAiB,EAAO,EAAU,aAA/D,CACD,CAkBA,SAAS,GAAY,EAAS,EAAM,GACnC,MAAM,UAAE,EAAS,MAAE,EAAK,IAAE,GAAQ,EAAS,aAC3C,EAAQ,KAAK,CACZ,OACA,YACA,QACA,OAEF,CA2DA,SAAS,GAAQ,GAChB,OAAO,EAAQ,IAAS,GAAM,IAAS,GAAa,EACrD,CAMA,SAAS,GAAa,GACrB,MAAO,IAAI,GAAO,SAAS,IAC1B,MAAM,KAAE,GAAS,EACjB,MAAa,SAAT,EAAwB,CAAC,GAChB,YAAT,EAA2B,GAAa,EAAK,UAC1C,EAAE,GAEX,CAMA,SAAS,GAAU,GAClB,MAAM,EAAS,EAAK,MAAM,KAAK,QAAQ,GAAY,MAAN,IACvC,EAAQ,GAKd,OAJA,EAAO,SAAS,IACL,KAAN,IAAoB,OAAN,GAAc,EAAM,QAAsC,OAA5B,EAAM,EAAM,OAAS,GAAa,EAAM,MACnF,EAAM,KAAK,GAAE,IAEZ,EAAM,KAAK,IACnB,CAGA,SAAS,GAAS,GACjB,MAAM,EAAY,EAAK,YAAY,KAC7B,GAA2B,IAAf,EAAmB,EAAI,EAAY,EAC/C,EAAS,EAAK,QAAQ,IAAK,GAC3B,GAA0B,IAAZ,EAAgB,EAAK,OAAS,EAClD,OAAO,EAAK,MAAM,EAAG,EACtB,CAIA,MAAM,GAAW,kBAEd,IAAC,GAAiB,MACpB,SAA2B,IAAI,IAC/B,QACA,YACA,cACA,WAAA,CAAY,EAAS,EAAU,IAC9B,MAAM,YAAE,EAAc,UAAS,cAAE,GAAkB,EACnD,KAAK,QAAU,EACf,KAAK,YAAc,EACnB,KAAK,cAAgB,GAAmB,EAC1C,CACC,aAAA,CAAc,GACb,MAAM,EAAS,KAAK,SAAS,IAAI,GACjC,GAAI,EAAQ,OAAO,EACnB,MAAM,EAAS,KAAK,WAAW,GAC/B,QAAe,IAAX,EAAmB,OACvB,MAAM,EAAM,GAAe,CAC1B,aACA,cAAe,KAAK,sBAAsB,GAC1C,IAAK,IAGN,OADA,KAAK,SAAS,IAAI,EAAY,GACvB,CACT,CACC,UAAA,CAAW,GACV,QAAiC,IAA7B,KAAK,QAAQ,GAAwB,OAAO,KAAK,QAAQ,GAC7D,MAAM,EAAW,KAAK,iBAAiB,GACvC,YAAiB,IAAb,EACG,GAAe,KAAK,QAAS,QADpC,CAEF,CAEC,gBAAA,CAAiB,GAChB,OAAO,GAAqB,EAAY,KAAK,YAC/C,CACC,qBAAA,CAAsB,GACrB,MAAM,EAAW,KAAK,iBAAiB,IAAe,EACtD,OAAO,KAAK,cAAgB,EAAW,OACzC,CAEC,UAAA,GACC,IAAK,MAAM,KAAY,OAAO,KAAK,KAAK,SAAU,CACjD,MAAM,EAAsC,YAArB,KAAK,YACtB,EAAa,GAAiB,EAAU,KAAK,YAAa,GAChE,KAAK,cAAc,EACtB,CACE,OAAO,KAAK,SAAS,SACvB,GAGI,GAAoB,MACvB,UACA,WAAA,CAAY,GACX,KAAK,UAAY,CACnB,CACC,aAAA,CAAc,GACb,IAAK,MAAM,KAAY,KAAK,UAAW,CACtC,MAAM,EAAM,EAAS,cAAc,GACnC,GAAI,EAAK,OAAO,CACnB,CACA,GAGI,GAAiB,MACpB,SAA2B,IAAI,IAC/B,QACA,YACA,cACA,WAAA,CAAY,EAAQ,GACnB,KAAK,QAAU,EAAO,QACtB,KAAK,YAAc,EAAO,KAC1B,KAAK,cAAgB,GAAmB,EAC1C,CACC,aAAA,CAAc,GACb,MAAM,EAAY,KAAK,YAAc,KACrC,GAAI,IAAe,KAAK,cAAgB,EAAW,WAAW,GAAY,OAC1E,MAAM,EAAS,KAAK,SAAS,IAAI,GACjC,GAAI,EAAQ,OAAO,EACnB,MAAM,EAAS,KAAK,WAAW,GAC/B,IAAK,EAAQ,OACb,MAAM,EAAM,GAAe,CAC1B,aACA,cAAe,KAAK,sBAAsB,GAC1C,IAAK,IAGN,OADA,KAAK,SAAS,IAAI,EAAY,GACvB,CACT,CACC,UAAA,CAAW,GACV,MAAM,EAAW,KAAK,iBAAiB,GACvC,GAAI,IAAe,KAAK,YAAa,CACpC,MAAM,EAAS,GAAe,KAAK,QAAS,MAAO,CAAC,OAAQ,SAC5D,GAAI,EAAQ,OAAO,CACtB,CACE,OAAO,GAAe,KAAK,QAAS,EACtC,CACC,gBAAA,CAAiB,GAChB,OAAO,GAAqB,EAAY,KAAK,cAAgB,CAC/D,CACC,qBAAA,CAAsB,GACrB,MAAM,EAAW,KAAK,iBAAiB,GACvC,OAAO,KAAK,cAAgB,KAAK,YAAc,IAAM,EAAW,OAClE,GAGA,SAAS,GAAiB,EAAU,EAAa,GAChD,GAAI,EAAS,SAAS,MAAO,OAAO,EACpC,GAAI,GAAkB,GAAS,KAAK,GAAW,OAAO,EAEtD,OAAO,EAAc,KADA,GAAS,GAAU,IAAW,WAAW,IAAK,KAEpE,CAEA,SAAS,GAAe,EAAS,EAAU,EAAa,CAAC,OAAQ,SAChE,IAAK,MAAM,IAAU,CAAC,GAAI,MAAO,CAChC,MAAM,EAAO,EAAS,EACtB,QAAsB,IAAlB,EAAQ,GAAkB,OAAO,EAAQ,GAC7C,IAAK,MAAM,KAAO,EAAY,CAC7B,MAAM,EAAU,GAAG,KAAQ,IAC3B,QAAyB,IAArB,EAAQ,GAAqB,OAAO,EAAQ,EACnD,CACA,CACA,CAcA,SAAS,GAAkB,GAC1B,OAAO,GAAgB,GAAU,KAAK,GAAQ,EAAI,MACnD,CAEA,SAAS,GAAgB,GACxB,MAAM,EAAc,CACnB,WACA,WAAY,GACZ,WAA4B,IAAI,IAChC,YAA6B,IAAI,IACjC,YAA6B,IAAI,IACjC,iBAAkC,IAAI,IACtC,QAAS,GACT,YAAa,UACb,QAAS,GACT,iBAAiB,EACjB,eAAe,GAEhB,IAAK,MAAM,CAAG,KAAQ,EAAS,aAAc,CAC5C,MAAM,EAAY,GAAiB,EAAI,WACjC,EAAY,CACjB,MAAO,IAAI,IAAI,EAAU,KAAK,GAAM,CAAC,EAAE,aAAc,MACrD,OAAQ,MAET,IAAK,MAAM,KAAK,EAAU,GAAY,GAAS,EAAK,iBAAiB,GAAoB,EAAG,EAAa,GAAc,IACvH,GAAoB,EAAI,UAAW,EAAa,EAClD,CACC,OAAO,EAAY,OACpB,CAEG,IAAC,GAAmB,MACtB,QAA0B,IAAI,IAC9B,GACA,WAAA,CAAY,GACX,MAAK,EAAS,CAChB,CACC,aAAA,CAAc,GACb,MAAM,EAAM,MAAK,EAAO,cAAc,GAEtC,OADI,GAAK,KAAK,QAAQ,IAAI,GACnB,CACT,GAQA,SAAS,GAAgB,EAAS,EAAU,EAAgB,EAAc,WACzE,MAAM,EAAW,IAAI,GAAiB,GAChC,EAAU,EAAS,cAAc,GACvC,IAAK,EAAS,MAAM,IAAI,MAAM,2BAA2B,MACzD,MAAM,EAAS,GAAW,CACzB,UACA,SAAU,EACV,mBAAmB,EACnB,eAAe,IAEV,EAAc,IAAI,IAAI,OAAO,KAAK,GAAS,KAAK,GAAQ,CAAC,GAAiB,EAAK,GAAa,GAAQ,MACpG,EAAY,IAAI,EAAS,SAAS,KAAK,GAAM,EAAY,IAAI,KAAI,QAAQ,QAAgB,IAAR,IAAgB,KAAK,GAAQ,CAAC,EAAK,EAAQ,MAC5H,GAAW,EAAO,SAAW,IAAI,KAAK,GAAQ,EAAI,OACxD,MAAO,CACN,QAAS,OAAO,YAAY,GAC5B,UAEF,CAiCA,SAAS,GAAoB,GAC5B,OAAO,EAAQ,QAAQ,KAAM,IAAI,WAAW,IAAK,MAAM,WAAW,IAAK,IACxE,CAWA,SAAU,GAAkB,GAC3B,MAAO,EAAK,GAab,SAAiB,EAAK,GACrB,MAAM,EAAQ,EAAI,QAAQ,GAC1B,OAAe,IAAX,EAAqB,CAAC,EAAK,IACxB,CAAC,EAAI,MAAM,EAAG,GAAQ,EAAI,MAAM,GACxC,CAjBoB,CAAQ,EAAe,KAC1C,IAAI,EAAU,EACV,EAAc,GAClB,GAAI,EAAI,SAAS,MAAO,CACvB,MAAO,KAAU,GAAQ,EAAI,MAAM,MACnC,EAAU,EAAK,KAAK,MACpB,EAAc,IAAI,IACpB,MACO,GAAG,IAAc,IAAU,SAC3B,GAAG,IAAc,EAAQ,WAAW,IAAK,OAAO,GACvD,CAiBG,IAAC,GAAa,MAChB,UACA,WAAA,CAAY,GACX,KAAK,UAAY,CACnB,CAUC,kBAAA,CAAmB,EAAQ,GAC1B,KAAM,gBAAiB,GAAS,OAAO,EAAO,mBAAmB,IAC7D,EACH,KAAM,KAAK,OAEZ,EAAO,eAAe,cACtB,MAAM,EAAS,EAAO,mBAAmB,IACrC,EACH,KAAM,KAAK,OAEZ,EAAO,gBACP,MAAM,QAAE,EAAO,QAAE,GAAY,QAAQ,gBAerC,OAdA,EAAO,YAAY,aAAc,GACjC,EAAO,qBAAqB,MAAM,IACjC,GAAwC,IAApC,EAAgB,SAAS,OAE5B,YADA,EAAQ,MAGT,MAAM,EAAwB,KAAK,sBAAsB,GACnD,EAiDT,SAAuC,EAAiB,GACvD,GAAwC,IAApC,EAAgB,SAAS,OAAc,OAAO,KAClD,IAAI,EAAS,8CAA8C,EAAa,OAAS,kBACjF,MAAM,EAAa,EAAgB,SAAS,QAAQ,GAAiB,UAAX,EAAE,OAAkB,OAC1E,EAAa,IAAG,GAAU,GAAG,sDACjC,IAAK,MAAM,KAAW,EAAgB,SAAU,CAC/C,MAAM,QAAE,EAAO,QAAE,GAAY,EAC7B,GAAU,GAAG,EAAQ,OAAO,OAAO,KAAW,IAC9C,GAAU,IAAI,EAAQ,SAAS,EAAQ,YACvC,MAAM,EAAS,EAAQ,OAAO,KAC1B,IAAQ,GAAU,EAAe,EAAQ,CAAC,EAAQ,OAAQ,EAAQ,OAAS,EAAQ,SAAS,KAAK,MACvG,CACC,OAAO,CACR,CA9DwB,CAA8B,EAAuB,GAC1E,EAAiC,OAAjB,GAChB,MAAM,EAAQ,IAAI,mBAAmB,GACrC,EAAM,MAAwB,IAAI,MAAM,6BACxC,EAAM,gBAAkB,EACxB,EAAQ,EAAM,IAER,CACT,CAKC,QAAI,GACH,OAAO,KAAK,UAAU,KAAK,IAC7B,CAGC,qBAAA,CAAsB,GACrB,MAAO,CACN,QAAS,EAAgB,QACzB,SAAU,EAAgB,SAAS,KAAK,GAAM,KAAK,yBAAyB,KAE/E,CACC,wBAAA,CAAyB,GACxB,MAAM,EAAS,KAAK,UACd,EAAc,EAAO,UAAU,EAAQ,QACvC,GAAU,EAAQ,OAAS,EAAI,EAAO,UAAU,EAAQ,OAAS,EAAQ,QAAU,GAAa,SAAW,EAAY,UACtH,EAAS,GAAW,EAAmB,EAAY,SAAU,EAAY,IAAI,MACpF,MAAO,CACN,QAAS,EAAQ,QACjB,KAAM,EAAQ,KACd,QAAS,EAAQ,QACjB,OAAQ,EAAY,SACpB,SACA,UACA,UACA,OAAQ,CACP,IAAK,EAAY,IAAI,MAAQ,GAC7B,KAAM,EAAY,IAAI,MAG1B,GAyBG,IAAC,GAAS,MAAM,EAClB,QACA,KACA,WAAA,CAAY,EAAM,EAAU,IAC3B,KAAK,KAAO,EACZ,KAAK,QAAU,CACjB,CAEC,UAAA,CAAW,GACV,KAAK,QAAQ,QAAQ,EACvB,CAEC,YAAA,IAAgB,GACf,OAAO,EAAU,KAAK,GAAM,KAAK,UAAU,IAC7C,CAEC,OAAA,GACC,IAAK,KAAK,QAAQ,OAAQ,OAC1B,IAAI,EAAO,KAAK,QAAQ,GACxB,MAAM,EAAa,CAAC,GACpB,IAAK,IAAI,EAAI,EAAG,EAAI,KAAK,QAAQ,OAAQ,IAAK,CAC7C,MAAM,EAAI,KAAK,QAAQ,GACnB,EAAE,IAAI,OAAS,EAAK,IAAI,MAAQ,EAAE,IAAI,OAAS,EAAK,IAAI,MAAQ,EAAK,UAAY,EAAE,WAAa,EAAK,SAAW,EAAE,UAAY,EAAK,OAAS,EAAK,UAAa,EAAK,QAAU,EAAK,WACrL,EAAK,QAAU,EAAE,QACjB,EAAK,OAAS,EAAE,SAEhB,EAAW,KAAK,GAChB,EAAO,EAEX,CACE,KAAK,QAAU,CACjB,CAEC,IAAA,GACC,KAAK,QAAQ,MAAK,CAAC,EAAG,IAAM,EAAE,UAAY,EAAE,WAC9C,CAKC,KAAA,CAAM,GACL,GAAI,IAAU,KAAM,OAAO,KAC3B,MAAM,EAAgB,EAAM,QAAQ,QAAQ,GAAM,EAAE,IAAI,OAAS,KAAK,KAAK,MAAQ,EAAE,IAAI,OAAS,KAAK,KAAK,OAC5G,GAA6B,IAAzB,EAAc,OAEjB,OADA,QAAQ,IAAI,8CACL,EAEA,EAiCD,MAAK,CAAC,EAAG,IAAM,EAAE,SAAW,EAAE,WAhCrC,MAAM,EAAa,EAAc,KAAK,IACrC,MAAM,IAAE,EAAK,SAAU,GAAa,KAAK,UAAU,EAAE,WAC7C,IAAK,EAAQ,SAAU,GAAW,KAAK,UAAU,EAAE,QAC3D,GAAI,IAAW,EAAK,MAAM,IAAI,MAAM,sBACpC,MAAO,CACN,MACA,WACA,SACA,UAAW,EAAE,UACb,QAAS,EAAE,QACX,IAEI,EAAe,EAAM,QAAQ,QAAQ,GAAM,EAAE,IAAI,OAAS,KAAK,KAAK,MAAQ,EAAE,IAAI,OAAS,KAAK,KAAK,OACrG,EAAS,IAAI,EAAO,EAAM,KAAM,IAAI,KAAiB,IAE3D,OADA,EAAO,OACA,CACT,CAEC,SAAA,CAAU,GACT,MAAM,EAAQ,KAAK,QAAQ,MAAM,GAAM,EAAE,WAAa,GAAW,EAAE,SAAW,IAC9E,OAAK,EAIE,CACN,IAAK,EAAM,IACX,SAAU,EAAM,SAAW,EAAU,EAAM,WANzB,CAClB,IAAK,KAAK,KACV,SAAU,EAMb,GAOG,IAAC,GAAgB,MACnB,GAAa,GACb,GAAc,EACd,GAAW,GACX,OACA,WAAA,CAAY,GACX,KAAK,OAAS,CAChB,CAEC,GAAA,CAAI,EAAU,EAAU,GACvB,MAAM,EAAY,MAAK,EACvB,MAAK,GAAe,EAAS,OAC7B,MAAM,EAAU,MAAK,EACrB,MAAK,EAAW,KAAK,GACrB,MAAK,EAAS,KAAK,CAClB,IAAK,KAAK,OACV,WACA,SACA,YACA,WAEH,CAMC,UAAA,CAAW,GACV,MAAM,EAAU,MAAK,EAAS,IAAI,IAAI,SAAW,EACjD,KAAK,IAAI,EAAU,EAAS,EAAU,EAAS,OACjD,CACC,YAAA,CAAa,EAAU,EAAiB,EAAU,GACjD,MAAM,EAAY,MAAK,EACvB,MAAK,GAAe,EAAS,OAC7B,MAAM,EAAU,MAAK,EACrB,MAAK,EAAW,KAAK,GACrB,MAAK,EAAS,KAAK,CAClB,IAAK,CAAE,KAAM,GACb,WACA,SACA,YACA,WAEH,CAEC,KAAA,GACC,MAAM,SAAE,EAAQ,OAAE,GAAW,MAAK,EAAS,IAAI,IAAM,CACpD,SAAU,EACV,OAAQ,GAET,KAAK,IAAI,KAAM,EAAU,EAC3B,CAEC,OAAA,CAAQ,EAAU,GACjB,MAAM,EAAW,KAAK,OAAO,KAAK,MAAM,EAAU,GAClD,KAAK,IAAI,EAAU,EAAU,EAC/B,CAEC,YAAO,CAAM,GACZ,MAAM,EAAM,IAAI,GAAO,CAAE,KAAM,EAAS,KAAK,GAAM,GAAE,EAAW,KAAK,MAAK,KAAK,KAAO,EAAS,SAAS,GAAM,GAAE,KAEhH,OADA,EAAI,UACG,CACT,GAcA,eAAe,GAAK,GACnB,OAAO,IAAI,GAAW,GAAU,GACjC,CAEA,SAAS,GAAU,GAClB,MAAM,QAAE,EAAO,KAAE,EAAO,GAAE,YAAE,EAAW,cAAE,GAAkB,GACrD,SAAE,GAAa,EACf,EAAY,GAClB,GAAI,EAAU,EAAU,KAAK,OACxB,KAAI,EAIJ,MAAM,IAAI,MAAM,+CAJH,EAAU,KAAK,IAAI,GAAe,EAAS,CAC5D,cACA,kBAEkE,CACnE,GAAI,EAAK,OAAS,EAAG,CACpB,MAAM,EASR,SAAgC,EAAM,GACrC,OAOD,SAA4B,GAC3B,MAAM,EAAS,GACT,EAAuB,IAAI,IACjC,SAAS,EAAM,GACV,EAAK,IAAI,KACb,EAAK,IAAI,GACT,EAAO,KAAK,GACZ,EAAO,cAAc,QAAQ,GAC/B,CAEC,OADA,EAAK,QAAQ,GACN,CACR,CAlBQ,CAAmB,GAAM,KAAK,GAAQ,IAAI,GAAe,EAAK,IACtE,CAXuB,CAAuB,EAAM,GAClD,EAAU,QAAQ,EACpB,CACC,MAAM,EAAqC,IAArB,EAAU,OAAe,EAAU,GAAK,IAAI,GAAkB,GACpF,OAAO,GAAa,IAChB,EACH,SAAU,GAEZ,CA4BA,SAAS,GAAa,GACrB,MAAM,eAAE,EAAc,SAAE,EAAQ,cAAE,GAAkB,GAAiB,GACrE,OAAO,GAAc,MA0DtB,SAAkB,EAAgB,EAAW,EAAU,EAAe,EAAa,IAClF,MAAM,EAAmB,EAAc,KAAK,GAkB7C,SAAuB,EAAG,GACzB,MAAM,KAAE,EAAI,UAAE,GAAc,GACpB,IAAK,EAAM,cAAe,GAAS,EACrC,EAAU,IAAI,GAAc,CACjC,OACA,SAQD,OANA,GAAa,CACZ,WAAY,EACZ,UAAW,CAAC,GACZ,eAED,EAAQ,QACD,CACR,CAhCmD,CAAc,EAAG,KAC7D,EAAc,IAAI,GAAc,CACrC,KAAM,EAAU,IAChB,KAAM,EAAU,gBAEjB,GAAa,CACZ,WAAY,EACZ,UAAW,CAAC,GACZ,aACA,YAAY,IAEb,MAAM,EAAe,EAAS,KAAK,GAuBpC,SAAkB,EAAM,GACvB,MAAQ,IAAK,EAAM,cAAe,GAAS,EAAK,UAC1C,EAAU,IAAI,GAAc,CACjC,OACA,SAQD,OANA,GAAa,CACZ,WAAY,EACZ,UAAW,CAAC,EAAK,UACjB,aACA,0BAA0B,IAEpB,CACR,CApC6C,CAAS,EAAM,KAC3D,MAAO,IACH,EACH,KACG,EAEL,CA5E4B,CAAS,EAAe,WAAY,EAAe,UAAW,EAAU,EAAe,EAAO,YAC1H,CAEA,SAAS,GAAiB,GACzB,MAAM,SAAE,EAAQ,QAAE,EAAO,UAAE,EAAS,OAAE,GAAW,GAC3C,eAAE,EAAiB,OAAM,WAAE,EAAa,IAAO,EAC/C,EAsBP,SAAuB,EAAU,EAAY,GAC5C,MAAM,EAAU,EAAS,cAAc,GACvC,IAAK,EAEJ,MADW,QAAQ,IAAI,0BAA0B,WAAoB,MAC/D,IAAI,MAAM,0BAA0B,KAE3C,OAAO,CACR,CA7BiB,CAAc,EAAU,GAAoB,GAAiB,IACvE,YAAE,EAAa,MAAO,EAAQ,cAAE,GAAkB,GAAW,CAClE,UACA,WACA,aACA,SAAU,GAAiB,EAAO,YAAa,GAC/C,YAED,MAAO,CACN,eAAgB,GAAsB,EAAS,EAAa,GAC5D,WACA,gBAEF,CAGA,SAAS,GAAoB,GAC5B,OAAI,EAAK,SAAS,MAAc,EAC5B,EAAK,SAAS,MAAQ,EAAK,SAAS,UAAY,EAAK,SAAS,SAAiB,YAAc,EAAK,QAAQ,iBAAkB,IAAI,QAAQ,QAAS,IAAI,WAAW,IAAK,MAClK,YAAc,CACtB,CAWA,SAAS,GAAiB,EAAa,GACtC,IAAI,EAAO,EACX,GAAI,EAAW,CACd,MAAM,EAAe,IAAM,OAAO,QAAQ,GAAW,KAAI,EAAE,EAAM,KAAW,SAAS,OAAU,OAAU,KAAK,MAC9G,EAAO,IACH,EACH,UAAW,EAEd,CACC,OAAO,GAAQ,EAAU,GAAO,IAAE,CAAQ,QAC3C,CACA,SAAS,GAAsB,EAAY,EAAa,GACvD,MAAM,WAAE,EAAU,UAAE,GAAc,EAC5B,EAAW,CAChB,aACA,YACA,cACA,aAAc,IAEf,OAAO,EAAU,GAAQ,SAAW,IAAK,GAAW,EAAO,YAAW,QAAO,CAAC,EAAK,IAAc,EAAU,IAAM,EAClH,CAqDA,SAAS,GAAS,EAAM,GACvB,EAAQ,GACJ,EAAK,UAAU,EAAK,SAAS,SAAS,IACzC,GAAS,EAAO,EAAQ,GAE1B,CAIA,SAAS,GAAoB,GAC5B,MAAM,KAAE,GAAS,EAAE,UACnB,GAAa,eAAT,EAAuB,CAC1B,MAAM,OAAE,GAAW,EAAE,UACrB,YAAe,IAAX,GAAuC,IAAlB,EAAO,OAAqB,IAAM,EAAE,UAAU,KAC3D,IAAI,EAAE,UAAU,QAAQ,EAAO,KAAK,GAAU,GAAiB,KAAQ,KAAK,QAC1F,CAAQ,MAAa,aAAT,EAA4B,YAAc,EAAE,UAAU,MAAM,KAAO,IAC5D,gBAAT,EAA+B,cAAgB,GAA0B,EAAE,UAAU,SAAU,EAAE,UAAU,MAClG,QAAT,EAAuB,OAAO,GAAmB,EAAE,UAAU,MAAM,eAC1D,UAAT,EAAyB,SAAS,GAAmB,EAAE,UAAU,MAAM,eAC9D,UAAT,EAAyB,QAChB,iBAAT,EAAgC,gBAAgB,EAAE,UAAU,OAAO,KAAK,GAAM,EAAE,OAAM,KAAK,cAC/F,EAAkB,EACxB,CACA,SAAS,GAAiB,GACzB,MAAO,IAAI,EAAO,IAAI,IAAmB,KAAK,QAC/C,CACA,SAAS,GAAkB,GAC1B,YAAc,IAAV,EAAyB,IACV,SAAf,EAAM,KAGX,SAAyB,GACxB,IAAK,EAAG,MAAO,IACf,MAAM,KAAE,EAAI,eAAE,GAAmB,EAC3B,EAAS,EAAiB,GAAiB,GAAkB,GACnE,MAAO,GAAG,GAAY,KAAQ,GAC/B,CARmC,CAAgB,GAC3C,GAAmB,EAC3B,CAOA,SAAS,GAAY,GACpB,GAAmB,iBAAR,EAAkB,OAAO,EACpC,GAAI,EAAI,IAAK,OAAO,EAAI,aACxB,MAAM,EAAO,GAAS,GACtB,OAAO,EAAK,aAAe,EAAK,YACjC,CACA,SAAS,GAAiB,GACzB,GAAkB,8BAAd,EAAK,KAAsC,MAAM,IAAI,MAAM,iBAC1D,MAAkB,eAAd,EAAK,MAAuC,UAAd,EAAK,KAAyB,EAAK,SAAS,KAAK,IACvF,MAAM,KAAE,GAAS,EACjB,MAAa,SAAT,EAAwB,EAAE,UAAU,IAAI,MAAM,EAAE,MAAO,EAAE,KAC3C,QAAT,EAAuB,GAAY,EAAE,OAClC,IAAI,EAAE,OAAO,IACvB,KAAK,KACe,SAAd,EAAK,KAAwB,EAAK,UACtC,EAAkB,EACxB,CAIA,MAAM,GAAiB,GAAW,GAMlC,SAAS,KACR,MAAO,CAAE,UAAW,GACrB,CA4BA,SAAS,GAAoB,GAC5B,MAAM,EAAY,gBAAgB,IAC5B,WAAE,EAAU,YAAE,EAAW,aAAE,GAAiB,EAC5C,EAAiB,GAAmB,GAC1C,GAAe,EAAY,GAC3B,MAAM,EAAU,EAAe,SAAS,GAAM,GAAuB,EAAG,KAClE,EAAc,GAAyB,GAC7C,EAAY,SAAQ,EAAG,YAAW,aACjC,GAA0B,EAAW,EAAO,IAE7C,EAAY,SAAQ,EAAG,oBACtB,EAAc,SAAS,IACtB,EAAE,SAAW,EAAE,GACd,IAEH,MAAM,EA4BP,SAA8B,GAC7B,OAAO,EAAW,SAAS,QAAQ,GAAuB,WAAd,EAAK,OAAsB,EAAK,eAC7E,CA9BkB,CAAqB,GAGtC,OAFA,EAAW,SAAW,IAAI,KAAY,GACtC,EAAa,eAAiB,EACvB,IACH,EACH,aAEF,CACA,SAAS,GAAe,EAAY,GACnC,MAAM,EAMP,SAAmC,EAAK,GACvC,IAAK,MAAM,KAAM,EAAK,CACrB,MAAM,OAAE,GAAW,EACnB,IAAK,MAAM,KAAK,EAAQ,CACvB,MAAM,IAAmB,EAAE,MAAM,SAAS,OAAO,WAAW,SACtD,EAAS,EAAe,MAAM,GAAM,IAAM,IAChD,GAAI,EAAQ,MAAO,CAClB,KACA,SAEJ,CACA,CACA,CAlBiB,CAA0B,EAAW,SAAS,QAAQ,GAAiB,OAAX,EAAE,OAAgB,GAC9F,GAAI,EAAS,CACZ,MAAM,GAAE,EAAE,OAAE,GAAW,EACvB,EAAO,QAAU,CACnB,CACA,CAqBA,SAAS,GAAmB,GAC3B,MAAM,EAAiB,EAAW,SAAS,QAAQ,GAAuB,WAAd,EAAK,OAAmB,OAAO,IAI3F,OAHA,EAAe,SAAS,IACvB,EAAO,eAAgB,CAAI,IAErB,CACR,CAEA,SAAS,GAAgB,GACxB,OAAO,EAAO,QAAQ,MAAK,EAAG,gBAE/B,SAA0B,GACzB,QAAK,GACE,EAAW,MAAK,EAAG,eAAmC,eAAnB,EAAU,OAA6C,YAAnB,EAAU,MAAyC,UAAnB,EAAU,OACzH,CALgD,CAAiB,IACjE,CAMA,SAAS,GAAuB,EAAG,GAClC,OAAO,EAAE,QAAQ,KAAK,IACrB,MAAM,QAAE,EAAS,KAAM,GAAe,GAC9B,KAAM,GAAa,EACrB,EAAiB,GAAS,eAC1B,EAAU,GAAqB,EAAW,KAAM,GACtD,EAAO,eAAiB,EACxB,EAAY,IAAI,GAChB,MAAM,EAAa,EAAO,YAAY,IAAI,IAAqB,KAAK,MAAQ,GACtE,EASR,SAAwB,EAAU,GACjC,GAA8B,QAA1B,EAAS,aAAwB,CACpC,MAAM,EAAa,GAAkB,GAC/B,EAAY,CAAC,EAAW,IAE9B,OADI,EAAW,IAAI,EAAU,KAAK,EAAW,IACtC,CACN,QAAS,GAAiB,GAC1B,QAAS,GAAkB,IAAa,IAE3C,CACA,CAnBmB,CAAe,EAAU,IAoB5C,SAA4B,EAAU,GACrC,GAAwB,iBAAb,EAAuB,MAAO,CACxC,SAAU,EAAS,IAAM,EAAS,aAAe,OAAS,EAAiB,GAAiB,GAAkB,IAC9G,QAAS,GAEX,CAzB+D,CAAmB,EAAU,IA0B5F,SAAmC,EAAU,GAC5C,GAAI,GAAe,KAAK,EAAS,cAAe,MAAO,CACtD,QAAS,GAAY,EAAiB,GAAiB,GAAkB,IACzE,QAAS,GAEX,CA/B+G,CAA0B,EAAU,GACjJ,IAAK,EAEJ,OADA,QAAQ,IAAI,qCAAsC,GAC3C,GAAa,EAAY,EAAS,GAAI,MAE9C,MAAQ,QAAS,EAAW,QAAE,GAAY,EAC1C,OAAO,GAAa,EAAY,EAAS,EAAa,EAAQ,GAEhE,CAwBA,SAAS,GAAa,EAAY,EAAS,EAAiB,GAC3D,MAAO,CACN,KAAM,YACN,KAAM,GAAG,QAAiB,KAAmB,OAAa,OAE5D,CAEA,SAAS,GAAyB,GACjC,MAAM,EAAU,GAIhB,OAHA,GAAS,GAAa,IACH,cAAd,EAAK,MAAsB,EAAQ,KAAK,EAAK,IAE3C,EAAU,EAAS,GAC3B,CAEA,SAAS,GAAsB,GAC9B,MAAM,EAOP,SAAuB,GACtB,MAAM,EAAW,GAAS,GAAO,SACjC,GAAI,GAA8B,UAAlB,EAAS,KAAkB,CAC1C,MAAM,EAAO,EAAS,KAAK,SAAS,KACpC,GAAoB,iBAAT,EAAmB,CAC7B,GAAI,GAAM,IAAK,OACf,MAAM,EAAa,GAAS,GAAM,SAClC,MAAyB,WAArB,GAAY,KAA0B,CACzC,OAAQ,EACR,cAAe,CAAC,SAEjB,CACH,CACA,CACA,CArBe,CAAc,EAAU,KAAK,OAC3C,GAAI,GAAO,OAAO,cAAe,MAAO,CACvC,eACG,EAEL,CAmBA,SAAS,GAA0B,EAAW,GAC7C,MAAM,EAAU,EAAU,OAAO,KAC3B,EAAe,EAAO,QAAQ,MAAM,GAAM,EAAE,KAAK,OAAS,IAChE,IAAK,IAAiB,EAAa,eAElC,OADW,QAAQ,IAAI,8BAA8B,KAC9C,CACN,KAAM,YACN,KAAM,GAGR,MAAM,gBAAE,GAAoB,EACtB,EAAY,EAAkB,GAAiB,GAAmB,GAClE,EAAY,CACjB,KAAM,YACN,KAAM,EAAa,eAAiB,GAGrC,OADA,EAAU,SAAW,CAAC,GACf,CACR,CAYA,eAAe,GAAkB,EAAS,GACzC,IAAK,EAAS,MAAM,IAAI,MAAM,kBAC9B,OAAO,EAAQ,cAAc,GAAY,KAAK,GAC/C,CASA,SAAS,GAAe,GACvB,MAAM,EAAkB,GAyBA,IAAE,EAiB1B,OAzCA,EAAO,YAAc,CAAC,EAAM,KAC3B,MAAM,EAAa,EAAgB,UAAU,GAAM,EAAE,SAAW,SAC7C,IAAf,EAAuB,EAAW,OAAO,KAAK,GAC7C,EAAM,MAAM,IACN,OAAN,GAGN,SAAuB,GACtB,EAAO,iBAAiB,mBAAoB,IAC3C,IAAK,EAAG,iBAAkB,GAAI,oBAAqB,EAAG,MAAO,CAC5D,MAAM,EAAQ,EAAG,MACjB,GAAI,EAAM,gBAAiB,IAAK,MAAM,KAAW,EAAM,gBAAgB,SAAU,EAAoB,CACpG,IAAK,EAAQ,OAAO,IACpB,KAAM,EAAQ,OAAO,MAAQ,KAC7B,WAAY,EAAQ,QACpB,WAAY,EAAQ,QACpB,OAAQ,EAAQ,OAChB,MAAuB,IAAI,MAAM,EAAQ,KAAO,KAAO,EAAQ,gBAE3D,QAAQ,MAAM,EAAG,MAAM,QAChC,MAAU,QAAQ,MAAM,EAAG,MAAM,QAAQ,GACpC,CAAE,MAAM,IACX,EAAO,cAAc,IAAI,wBAAwB,kBAAmB,CAAE,MAAO,IAC/E,CAnBmB,CAAc,EAAE,GAC/B,EAmBH,EAAO,gBAAmB,EAQvB,EAAO,eAPF,SAAS,GAKf,OAJA,EAAgB,KAAK,CACpB,SACA,OAAQ,KAEF,EAAO,KAAK,KAAM,EAC5B,GAEC,EAAO,cAAgB,CAAE,GACjB,WACN,MAAM,EAAa,EAAgB,MACnC,QAAmB,IAAf,EAAuB,MAAM,IAAI,aAAa,kDAAmD,kBAErG,OADA,EAAW,OAAO,KAAK,EAAO,KAAK,OAC5B,QAAQ,IAAI,EAAW,QAAQ,MAAM,GAAW,EAAO,MAAM,GAAY,OAAN,KAAe,MAC5F,EANwB,CAOpB,EAAO,eACH,CACR,CA5QqB,GAAW,GACb,GAAW,U","file":"/npm/wesl@0.7.23/dist/index.js/+esm","sourceRoot":"","sourcesContent":["/**\n * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.39.0.\n * Original file: /npm/wesl@0.7.23/dist/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","//#region src/Logging.ts\n/** base logger (can be overridden to a capturing logger for tests) */\nlet log = console.log;\n/** enable debug assertions and verbose error messages (set false via bundler for smaller builds) */\nconst debug = true;\n/** enable user-facing validation like operator binding rules (set false via bundler for smaller builds) */\nconst validation = true;\n/** use temporary logger for async tests */\nasync function withLoggerAsync(logFn, fn) {\n\tconst orig = log;\n\ttry {\n\t\tlog = logFn;\n\t\treturn await fn();\n\t} finally {\n\t\tlog = orig;\n\t}\n}\n/**\n* Log a message along with the source line and a caret indicating the error position.\n* @param pos is the position in the source string, or if src is a SrcMap,\n*   then pos is the position in the dest (e.g. preprocessed) text\n*/\nfunction srcLog(src, pos, ...msgs) {\n\tif (typeof src === \"string\") {\n\t\tlogInternalSrc(log, src, pos, ...msgs);\n\t\treturn;\n\t}\n\tconst { src: mappedSrc, positions } = mapSrcPositions(src, pos);\n\tlogInternalSrc(log, mappedSrc.text, positions, ...msgs);\n}\nfunction mapSrcPositions(srcMap, destPos) {\n\tconst srcPos = srcMap.mapPositions(...[destPos].flat());\n\tconst { src } = srcPos[0];\n\tlet positions;\n\tif (srcPos[1]?.src?.path === src.path && srcPos[1]?.src?.text === src.text) positions = srcPos.map((p) => p.position);\n\telse positions = srcPos[0].position;\n\treturn {\n\t\tsrc,\n\t\tpositions\n\t};\n}\nfunction logInternalSrc(logFn, src, pos, ...msgs) {\n\tlogFn(...msgs);\n\tconst { line, lineNum, linePos, linePos2 } = srcLine(src, pos);\n\tlogFn(line, `  Ln ${lineNum}`);\n\tlogFn(carets(linePos, linePos2));\n}\nfunction carets(linePos, linePos2) {\n\tconst indent = \" \".repeat(Math.max(0, linePos));\n\tconst numCarets = linePos2 ? linePos2 - linePos : 1;\n\treturn indent + \"^\".repeat(Math.max(1, numCarets));\n}\nconst startCache = /* @__PURE__ */ new Map();\n/** return the line in the src containing a given character position */\nfunction srcLine(src, position) {\n\tlet pos;\n\tlet pos2;\n\tif (typeof position === \"number\") pos = position;\n\telse [pos, pos2] = position;\n\tconst starts = getStarts(src);\n\tlet start = 0;\n\tlet end = starts.length - 1;\n\tif (pos >= starts[end]) start = end;\n\twhile (start + 1 < end) {\n\t\tconst mid = start + end >> 1;\n\t\tif (pos >= starts[mid]) start = mid;\n\t\telse end = mid;\n\t}\n\tlet linePos2;\n\tif (pos2 !== void 0 && pos2 >= starts[start] && pos2 < starts[end]) linePos2 = pos2 - starts[start];\n\tconst lineNl = src.slice(starts[start], starts[start + 1] || src.length);\n\treturn {\n\t\tline: lineNl.slice(-1) === \"\\n\" ? lineNl.slice(0, -1) : lineNl,\n\t\tlinePos: pos - starts[start],\n\t\tlinePos2,\n\t\tlineNum: start + 1\n\t};\n}\n/** return an array of the character positions of the start of each line in the src (cached) */\nfunction getStarts(src) {\n\tconst found = startCache.get(src);\n\tif (found) return found;\n\tconst starts = [...src.matchAll(/\\n/g)].map((m) => m.index + 1);\n\tstarts.unshift(0);\n\tstartCache.set(src, starts);\n\treturn starts;\n}\n\n//#endregion\n//#region src/Assertions.ts\n/** checks whether a condition is true, otherwise throws */\nfunction assertThat(condition, msg) {\n\tif (!condition) throw new Error(msg);\n}\n/** when debug is enabled, checks whether a condition is true, otherwise throws */\nfunction assertThatDebug(condition, msg) {\n\tif (debug) assertThat(condition, msg);\n}\n/**\n* Useful to validate that all cases are handled,\n* TypeScript should complain if this statement could possibly be executed.\n*\n* If this is somehow executed at runtime, throw an exception.\n*/\nfunction assertUnreachable(value) {\n\tthrow new ErrorWithData(\"Unreachable value\", { data: value });\n}\nvar ErrorWithData = class extends Error {\n\tdata;\n\tconstructor(message, options) {\n\t\tsuper(message, options);\n\t\tthis.data = options?.data;\n\t}\n};\n\n//#endregion\n//#region src/Util.ts\nfunction multiKeySet(m, a, b, v) {\n\tconst bMap = m.get(a) || /* @__PURE__ */ new Map();\n\tm.set(a, bMap);\n\tbMap.set(b, v);\n}\nconst tokenRegex = /\\b(\\w+)\\b/gi;\n/** replace strings in a text according to a relacement map\n* replaced strings must be 'tokens', surrounded by spaces or punctuation\n*/\nfunction replaceWords(text, replace) {\n\treturn text.replaceAll(tokenRegex, (s) => s in replace ? replace[s] : s);\n}\n/** return an array partitioned into possibly overlapping groups */\nfunction grouped(a, size, stride = size) {\n\tconst groups = [];\n\tfor (let i = 0; i < a.length; i += stride) groups.push(a.slice(i, i + size));\n\treturn groups;\n}\n/** group an array into subarrays by a key function */\nfunction groupBy(a, key) {\n\tconst groups = /* @__PURE__ */ new Map();\n\tfor (const t of a) {\n\t\tconst k = key(t);\n\t\tconst group = groups.get(k) || [];\n\t\tgroup.push(t);\n\t\tgroups.set(k, group);\n\t}\n\treturn groups;\n}\n/** partition an array into two parts by a discriminator function */\nfunction partition(a, partFn) {\n\tconst yesPart = [];\n\tconst noPart = [];\n\tfor (const t of a) if (partFn(t)) yesPart.push(t);\n\telse noPart.push(t);\n\treturn [yesPart, noPart];\n}\n/** run an carrying function over every element in an array,\n* i.e. an inclusive prefix scan */\nfunction scan(array, fn, zero) {\n\tconst result = [zero];\n\tlet current = zero;\n\tfor (let i = 0; i < array.length; i++) {\n\t\tcurrent = fn(array[i], current);\n\t\tresult.push(current);\n\t}\n\treturn result;\n}\n/** return a new record by replacing values in 'a' with 'b' as a map.\n* values in 'a' that are not in 'b' are unchanged.\n* e.g. {a: \"b\", x: 9}, {b: 1} yields {a: 1, x: 9}\n*/\nfunction mapForward(a, b) {\n\tconst combined = Object.entries(a).map(([key, value]) => {\n\t\treturn [key, value in b ? b[value] : value];\n\t});\n\treturn Object.fromEntries(combined);\n}\n/** return the last element of an array or undefined */\nfunction last(a) {\n\treturn a[a.length - 1];\n}\n/**\n* Overlap two arrays, returning the tail of b if a is a prefix of b.\n* Otherwise, return undefined.\n*/\nfunction overlapTail(a, b) {\n\tlet overlapSize = Math.min(a.length, b.length);\n\twhile (overlapSize > 0) if (arrayEquals(a.slice(-overlapSize), b.slice(0, overlapSize))) break;\n\telse overlapSize--;\n\tif (overlapSize) return b.slice(overlapSize);\n}\nfunction arrayEquals(a, b) {\n\treturn a.length === b.length && a.every((val, index) => val === b[index]);\n}\n/** filter an array, returning the truthy results of the filter function */\nfunction filterMap(arr, fn) {\n\tconst out = [];\n\tfor (const t of arr) {\n\t\tconst u = fn(t);\n\t\tif (u) out.push(u);\n\t}\n\treturn out;\n}\n/** filters an array, returns the first truthy result of the filter function */\nfunction findMap(arr, fn) {\n\tfor (const t of arr) {\n\t\tconst u = fn(t);\n\t\tif (u) return u;\n\t}\n}\n/** Run a function over the values in a Record\n* @return a new Record with mapped values.  */\nfunction mapValues(obj, fn) {\n\treturn Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)]));\n}\n/**\n* Maps an character position in a string to a 1-indexed line number, and 1-indexed column.\n*/\nfunction offsetToLineNumber(offset, text) {\n\tconst safeOffset = Math.min(text.length, Math.max(0, offset));\n\tlet lineStartOffset = 0;\n\tlet lineNum = 1;\n\twhile (true) {\n\t\tconst lineEnd = text.indexOf(\"\\n\", lineStartOffset);\n\t\tif (lineEnd === -1 || safeOffset <= lineEnd) {\n\t\t\tconst linePos = 1 + (safeOffset - lineStartOffset);\n\t\t\treturn [lineNum, linePos];\n\t\t} else {\n\t\t\tlineStartOffset = lineEnd + 1;\n\t\t\tlineNum += 1;\n\t\t}\n\t}\n}\n/** Highlights an error.\n*\n* Returns a string with the line, and a string with the ^^^^ carets\n*/\nfunction errorHighlight(source, span) {\n\tlet lineStartOffset = source.lastIndexOf(\"\\n\", span[0]);\n\tlineStartOffset = lineStartOffset === -1 ? 0 : lineStartOffset + 1;\n\tlet lineEndOffset = source.indexOf(\"\\n\", span[0]);\n\tif (lineEndOffset === -1) lineEndOffset = source.length;\n\tconst errorLength = span[1] - span[0];\n\tconst caretCount = Math.max(1, errorLength);\n\tconst linePos = Math.max(0, span[0] - lineStartOffset);\n\treturn [source.slice(lineStartOffset, lineEndOffset), \" \".repeat(linePos) + \"^\".repeat(caretCount)];\n}\n\n//#endregion\n//#region src/vlq/vlq.ts\n/*!\nCopyright (c) 2017-2021 [these people](https://github.com/Rich-Harris/vlq/graphs/contributors)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n*/\nconst char_to_integer = {};\nconst integer_to_char = {};\n\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\".split(\"\").forEach((char, i) => {\n\tchar_to_integer[char] = i;\n\tinteger_to_char[i] = char;\n});\nfunction encodeVlq(value) {\n\tif (typeof value === \"number\") return encode_integer(value);\n\tlet result = \"\";\n\tfor (let i = 0; i < value.length; i += 1) result += encode_integer(value[i]);\n\treturn result;\n}\nfunction encode_integer(num) {\n\tlet result = \"\";\n\tlet enc;\n\tif (num < 0) enc = -num << 1 | 1;\n\telse enc = num << 1;\n\tdo {\n\t\tlet clamped = enc & 31;\n\t\tenc >>>= 5;\n\t\tif (enc > 0) clamped |= 32;\n\t\tresult += integer_to_char[clamped];\n\t} while (enc > 0);\n\treturn result;\n}\n\n//#endregion\n//#region src/ClickableError.ts\nconst isBrowser = \"document\" in globalThis;\n/** Throw an error with an embedded source map so that browser users can\n*  click on the error in the browser debug console and see the wesl source code.  */\nfunction throwClickableError(params) {\n\tconst { url, text, lineNumber, lineColumn, length, error } = params;\n\tconst weslLocation = {\n\t\tfile: url,\n\t\tline: lineNumber,\n\t\tcolumn: lineColumn,\n\t\tlength\n\t};\n\terror.weslLocation = weslLocation;\n\tif (!debug || !isBrowser) throw error;\n\tconst mappings = encodeVlq([\n\t\t0,\n\t\t0,\n\t\tMath.max(0, lineNumber - 1),\n\t\tMath.max(0, lineColumn - 1)\n\t]) + \",\" + encodeVlq([\n\t\t18,\n\t\t0,\n\t\tMath.max(0, lineNumber - 1),\n\t\tMath.max(0, lineColumn - 1) + length\n\t]);\n\tconst sourceMap = {\n\t\tversion: 3,\n\t\tfile: null,\n\t\tsources: [url],\n\t\tsourcesContent: [text ?? null],\n\t\tnames: [],\n\t\tmappings\n\t};\n\tlet generatedCode = `throw new Error(${JSON.stringify(error.message + \"\")})`;\n\tgeneratedCode += \"\\n//# sourceMappingURL=data:application/json;base64,\" + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap))));\n\tgeneratedCode += \"\\n//# sourceURL=\" + sourceMap.sources[0];\n\tlet oldLimit = 0;\n\tif (\"stackTraceLimit\" in Error) {\n\t\toldLimit = Error.stackTraceLimit;\n\t\tError.stackTraceLimit = 1;\n\t}\n\ttry {\n\t\t(0, eval)(generatedCode);\n\t} catch (e) {\n\t\tif (\"stackTraceLimit\" in Error) Error.stackTraceLimit = oldLimit;\n\t\terror.message = \"\";\n\t\tif (debug) e.cause = error;\n\t\te.weslLocation = weslLocation;\n\t\tthrow e;\n\t}\n}\n/** Warn the user about an identifier and throw a clickable exception */\nfunction failIdent(ident, msg) {\n\tconst { refIdentElem, originalName } = ident;\n\tconst baseMessage = msg ?? `'${originalName}'`;\n\tif (refIdentElem) failIdentElem(refIdentElem, baseMessage);\n\telse throw new Error(baseMessage);\n}\n/** Warn the user about an identifier and throw a clickable exception */\nfunction failIdentElem(identElem, msg = \"\") {\n\tconst { srcModule, start, end } = identElem;\n\tconst { debugFilePath, src } = srcModule;\n\tconst detailedMessage = `${msg} in file: ${debugFilePath}`;\n\tsrcLog(src, [start, end], detailedMessage);\n\tconst [lineNumber, lineColumn] = offsetToLineNumber(start, src);\n\tthrowClickableError({\n\t\turl: debugFilePath,\n\t\ttext: src,\n\t\tlineNumber,\n\t\tlineColumn,\n\t\tlength: end - start,\n\t\terror: new Error(detailedMessage)\n\t});\n}\n\n//#endregion\n//#region src/Conditions.ts\n/** @return true if the @if attribute is valid with current Conditions */\nfunction evaluateIfAttribute(ifAttribute, conditions) {\n\treturn evaluateIfExpression(ifAttribute.param.expression, conditions);\n}\n/** @return true if the @elif attribute is valid with current Conditions */\nfunction evaluateElifAttribute(elifAttribute, conditions) {\n\treturn evaluateIfExpression(elifAttribute.param.expression, conditions);\n}\n/** Evaluate an @if expression based on current runtime Conditions\n* @return true if the expression is true */\nfunction evaluateIfExpression(expression, conditions) {\n\tconst { kind } = expression;\n\tif (kind === \"unary-expression\") {\n\t\tassertThatDebug(expression.operator.value === \"!\");\n\t\treturn !evaluateIfExpression(expression.expression, conditions);\n\t} else if (kind === \"binary-expression\") {\n\t\tconst op = expression.operator.value;\n\t\tassertThatDebug(op === \"||\" || op === \"&&\");\n\t\tconst leftResult = evaluateIfExpression(expression.left, conditions);\n\t\tif (op === \"||\") return leftResult || evaluateIfExpression(expression.right, conditions);\n\t\telse if (op === \"&&\") return leftResult && evaluateIfExpression(expression.right, conditions);\n\t\telse assertUnreachable(op);\n\t} else if (kind === \"literal\") {\n\t\tconst { value } = expression;\n\t\tassertThatDebug(value === \"true\" || value === \"false\");\n\t\treturn value === \"true\";\n\t} else if (kind === \"parenthesized-expression\") return evaluateIfExpression(expression.expression, conditions);\n\telse if (kind === \"ref\") return conditions[expression.ident.originalName] ?? false;\n\telse throw new Error(`unexpected @if expression ${JSON.stringify(expression)}`);\n}\n/**\n* Filter elements based on @if/@else conditional logic.\n* This function processes elements sequentially to handle @if/@else chains correctly.\n*\n* @param elements Array of elements at the same scope level\n* @param conditions Current conditional compilation settings\n* @return Array of valid elements after applying @if/@else logic\n*/\nfunction filterValidElements(elements, conditions) {\n\tlet elseValid = false;\n\treturn elements.flatMap((e) => {\n\t\tconst attributes = e.attributes;\n\t\tconst { valid, nextElseState } = validateAttributes(attributes, elseValid, conditions);\n\t\telseValid = nextElseState;\n\t\treturn valid ? [e] : [];\n\t});\n}\n/**\n* Core logic for validating conditional attributes and managing @if/@elif/@else state.\n* @return valid: whether to process this element, nextElseState: state for next sibling\n*/\nfunction validateConditional(condAttribute, elseValid, conditions) {\n\tif (!condAttribute) return {\n\t\tvalid: true,\n\t\tnextElseState: elseValid\n\t};\n\tif (condAttribute.kind === \"@if\") {\n\t\tconst valid = evaluateIfAttribute(condAttribute, conditions);\n\t\treturn {\n\t\t\tvalid,\n\t\t\tnextElseState: !valid\n\t\t};\n\t} else if (condAttribute.kind === \"@elif\") {\n\t\tif (!elseValid) return {\n\t\t\tvalid: false,\n\t\t\tnextElseState: false\n\t\t};\n\t\tconst valid = evaluateElifAttribute(condAttribute, conditions);\n\t\treturn {\n\t\t\tvalid,\n\t\t\tnextElseState: !valid\n\t\t};\n\t} else return {\n\t\tvalid: elseValid,\n\t\tnextElseState: false\n\t};\n}\n/**\n* Validate element based on attributes (or lack thereof).\n* @return valid if the element is valid under current Conditions and the next elseValid state\n* i.e. `@if(MOBILE) const x = 1;` is valid if MOBILE is true\n* Note that only elements marked with an @if or @else attribute can be invalid\n*/\nfunction validateAttributes(attributes, elseValid, conditions) {\n\treturn validateConditional(findConditional(attributes), elseValid, conditions);\n}\n/** Extract @if, @elif, or @else attribute from an array of attributes */\nfunction findConditional(attributes) {\n\tif (!attributes) return;\n\tfor (const attr of attributes) {\n\t\tconst kind = attr.attribute.kind;\n\t\tif (kind === \"@if\" || kind === \"@elif\" || kind === \"@else\") return attr.attribute;\n\t}\n}\n\n//#endregion\n//#region src/Scope.ts\n/** Combine two scope siblings.\n* The first scope is mutated to append the contents of the second.  */\nfunction mergeScope(a, b) {\n\tif (!b) return;\n\tassertThatDebug(a.kind === b.kind);\n\tassertThatDebug(a.parent === b.parent);\n\tassertThatDebug(!b.condAttribute);\n\ta.contents = a.contents.concat(b.contents);\n}\n/** reset scope and ident debugging ids */\nfunction resetScopeIds() {\n\tscopeId = 0;\n\tidentId = 0;\n}\nlet scopeId = 0;\nlet identId = 0;\nfunction nextIdentId() {\n\treturn identId++;\n}\n/** make a new Scope object */\nfunction emptyScope(parent, kind = \"scope\") {\n\treturn {\n\t\tid: scopeId++,\n\t\tkind,\n\t\tparent,\n\t\tcontents: []\n\t};\n}\n/** For debugging,\n* @return true if a scope is in the rootScope tree somewhere */\nfunction containsScope(rootScope, scope) {\n\tif (scope === rootScope) return true;\n\tfor (const child of rootScope.contents) if (childScope(child) && containsScope(child, scope)) return true;\n\treturn false;\n}\n/** @returns true if the provided element of a Scope\n*    is itself a Scope (and not an Ident) */\nfunction childScope(child) {\n\tconst { kind } = child;\n\treturn kind === \"partial\" || kind === \"scope\";\n}\n/** @returns true if the provided element of a Scope\n*    is an Ident (and not a child Scope) */\nfunction childIdent(child) {\n\treturn !childScope(child);\n}\n\n//#endregion\n//#region src/StandardTypes.ts\nconst stdFns = `bitcast all any select arrayLength \n  abs acos acosh asin asinh atan atanh atan2 ceil clamp cos cosh \n  countLeadingZeros countOneBits countTrailingZeros cross \n  degrees determinant distance dot dot4U8Packed dot4I8Packed \n  exp exp2 extractBits faceForward firstLeadingBit firstTrailingBit \n  floor fma fract frexp insertBits inverseSqrt ldexp length log log2\n  max min mix modf normalize pow quantizeToF16 radians reflect refract\n  reverseBits round saturate sign sin sinh smoothstep sqrt step tan tanh\n  transpose trunc\n  dpdx dpdxCoarse dpdxFine dpdy dpdyCoarse dpdyFine fwidth \n  fwidthCoarse fwidthFine\n  textureDimensions textureGather textureGatherCompare textureLoad\n  textureNumLayers textureNumLevels textureNumSamples\n  textureSample textureSampleBias textureSampleCompare textureSampleCompareLevel\n  textureSampleGrad textureSampleLevel textureSampleBaseClampToEdge\n  textureStore\n  atomicLoad atomicStore atomicAdd atomicSub atomicMax atomicMin\n  atomicAnd atomicOr atomicXor atomicExchange atomicCompareExchangeWeak\n  pack4x8snorm pack4x8unorm pack4xI8 pack4xU8 pack4xI8Clamp pack4xU8Clamp\n  pack2x16snorm pack2x16unorm pack2x16float\n  unpack4x8snorm unpack4x8unorm unpack4xI8 unpack4xU8 \n  unpack2x16snorm unpack2x16unorm unpack2x16float\n  storageBarrier textureBarrier workgroupBarrier workgroupUniformLoad\n  subgroupAdd subgroupAll subgroupAnd subgroupAny subgroupBallot \n  subgroupBroadcast subgroupBroadcastFirst subgroupElect \n  subgroupExclusiveAdd subgroupExclusiveMul subgroupInclusiveAdd \n  subgroupInclusiveMul subgroupMax subgroupMin subgroupMul subgroupOr \n  subgroupShuffle subgroupShuffleUp subgroupShuffleXor subgroupXor\n  quadBroadcast quadSwapDiagonal quadSwapX quadSwapY`.split(/\\s+/);\nconst sampledTextureTypes = `\n  texture_1d texture_2d texture_2d_array texture_3d \n  texture_cube texture_cube_array\n`;\nconst multisampledTextureTypes = `\n  texture_multisampled_2d texture_depth_multisampled_2d\n`;\nconst textureStorageTypes = `\n  texture_storage_1d texture_storage_2d texture_storage_2d_array \n  texture_storage_3d\n`;\nconst stdTypes = `array atomic bool f16 f32 i32 \n  mat2x2 mat2x3 mat2x4 mat3x2 mat3x3 mat3x4 mat4x2 mat4x3 mat4x4\n  mat2x2f mat2x3f mat2x4f mat3x2f mat3x3f mat3x4f\n  mat4x2f mat4x3f mat4x4f\n  mat2x2h mat2x3h mat2x4h mat3x2h mat3x3h mat3x4h\n  mat4x2h mat4x3h mat4x4h\n  u32 vec2 vec3 vec4 ptr\n  vec2i vec3i vec4i vec2u vec3u vec4u\n  vec2f vec3f vec4f vec2h vec3h vec4h\n  ${sampledTextureTypes}\n  ${multisampledTextureTypes}\n  texture_external\n  ${textureStorageTypes}\n  texture_depth_2d texture_depth_2d_array texture_depth_cube\n  texture_depth_cube_array\n  sampler sampler_comparison\n  rgba8unorm rgba8snorm rgba8uint rgba8sint\n  rgba16uint rgba16sint rgba16float \n  r32uint r32sint r32float rg32uint rg32sint rg32float\n  rgba32uint rgba32sint rgba32float\n  bgra8unorm`.split(/\\s+/);\n/** https://www.w3.org/TR/WGSL/#predeclared-enumerants  */\nconst stdEnumerants = `read write read_write \n  function private workgroup uniform storage\n  rgba8unorm rgba8snorm rgba8uint rgba8sint \n  rgba16uint rgba16sint rgba16float \n  r32uint r32sint r32float rg32uint rg32sint rg32float\n  rgba32uint rgba32sint rgba32float bgra8unorm`.split(/\\s+/);\n/** WGSL standard attributes whose params need binding (e.g., @workgroup_size).\n* See: https://www.w3.org/TR/WGSL/#attributes */\nconst wgslStandardAttributes = new Set([\n\t\"align\",\n\t\"binding\",\n\t\"blend_src\",\n\t\"compute\",\n\t\"const\",\n\t\"fragment\",\n\t\"group\",\n\t\"id\",\n\t\"invariant\",\n\t\"location\",\n\t\"must_use\",\n\t\"size\",\n\t\"vertex\",\n\t\"workgroup_size\"\n]);\n/** return true if the name is for a built in type (not a user struct) */\nfunction stdType(name) {\n\treturn stdTypes.includes(name);\n}\n/** return true if the name is for a built in fn (not a user function) */\nfunction stdFn(name) {\n\treturn stdFns.includes(name) || stdType(name);\n}\n/** return true if the name is for a built in enumerant */\nfunction stdEnumerant(name) {\n\treturn stdEnumerants.includes(name);\n}\n\n//#endregion\n//#region src/LowerAndEmit.ts\n/** Traverse the AST, starting from root elements, emitting WGSL for each. */\nfunction lowerAndEmit(params) {\n\tconst { srcBuilder, rootElems, conditions } = params;\n\tconst { extracting = true, skipConditionalFiltering = false } = params;\n\tconst emitContext = {\n\t\tconditions,\n\t\tsrcBuilder,\n\t\textracting\n\t};\n\tconst validElements = skipConditionalFiltering ? rootElems : filterValidElements(rootElems, conditions);\n\tfor (const e of validElements) lowerAndEmitElem(e, emitContext);\n}\nfunction lowerAndEmitElem(e, ctx) {\n\tswitch (e.kind) {\n\t\tcase \"import\": return;\n\t\tcase \"text\":\n\t\t\temitText(e, ctx);\n\t\t\treturn;\n\t\tcase \"name\":\n\t\t\temitName(e, ctx);\n\t\t\treturn;\n\t\tcase \"synthetic\":\n\t\t\temitSynthetic(e, ctx);\n\t\t\treturn;\n\t\tcase \"ref\":\n\t\t\temitRefIdent(e, ctx);\n\t\t\treturn;\n\t\tcase \"decl\":\n\t\t\temitDeclIdent(e, ctx);\n\t\t\treturn;\n\t\tcase \"literal\":\n\t\tcase \"binary-expression\":\n\t\tcase \"unary-expression\":\n\t\tcase \"call-expression\":\n\t\tcase \"parenthesized-expression\":\n\t\tcase \"component-expression\":\n\t\tcase \"component-member-expression\":\n\t\t\temitExpression(e, ctx);\n\t\t\treturn;\n\t\tcase \"param\":\n\t\tcase \"typeDecl\":\n\t\tcase \"member\":\n\t\tcase \"memberRef\":\n\t\tcase \"expression\":\n\t\tcase \"type\":\n\t\tcase \"switch-clause\":\n\t\t\temitContents(e, ctx);\n\t\t\treturn;\n\t\tcase \"stuff\":\n\t\t\temitStuff(e, ctx);\n\t\t\treturn;\n\t\tcase \"module\":\n\t\t\temitModule(e, ctx);\n\t\t\treturn;\n\t\tcase \"var\":\n\t\tcase \"let\":\n\t\tcase \"statement\":\n\t\tcase \"continuing\":\n\t\t\temitStatement$1(e, ctx);\n\t\t\treturn;\n\t\tcase \"override\":\n\t\tcase \"const\":\n\t\tcase \"assert\":\n\t\tcase \"alias\":\n\t\tcase \"gvar\":\n\t\t\temitRootDecl(e, ctx);\n\t\t\treturn;\n\t\tcase \"fn\":\n\t\t\temitRootElemNl(ctx);\n\t\t\temitFn(e, ctx);\n\t\t\treturn;\n\t\tcase \"struct\":\n\t\t\temitRootElemNl(ctx);\n\t\t\temitStruct(e, ctx);\n\t\t\treturn;\n\t\tcase \"attribute\":\n\t\t\temitAttribute(e, ctx);\n\t\t\treturn;\n\t\tcase \"directive\":\n\t\t\temitDirective(e, ctx);\n\t\t\treturn;\n\t\tdefault: assertUnreachable(e);\n\t}\n}\nfunction emitStuff(e, ctx) {\n\temitContentsWithTrimming(e, ctx);\n}\nfunction emitModule(e, ctx) {\n\tconst validElements = filterValidElements(e.contents, ctx.conditions);\n\tfor (const child of validElements) {\n\t\tif (child.kind === \"text\") {\n\t\t\tif (child.srcModule.src.slice(child.start, child.end).trim() === \"\") continue;\n\t\t}\n\t\tlowerAndEmitElem(child, ctx);\n\t}\n}\nfunction emitStatement$1(e, ctx) {\n\tif (!(e.contents.length > 0 && e.contents[0].kind === \"attribute\")) emitAttributes(e.attributes, ctx);\n\temitContents(e, ctx);\n}\nfunction emitRootDecl(e, ctx) {\n\temitRootElemNl(ctx);\n\tif (!(e.contents.length > 0 && e.contents[0].kind === \"attribute\")) emitAttributes(e.attributes, ctx);\n\temitContentsWithTrimming(e, ctx);\n}\n/** Emit newlines between root elements. */\nfunction emitRootElemNl(ctx) {\n\tctx.srcBuilder.addNl();\n\tctx.srcBuilder.addNl();\n}\nfunction emitText(e, ctx) {\n\tctx.srcBuilder.addCopy(e.start, e.end);\n}\nfunction emitName(e, ctx) {\n\tctx.srcBuilder.add(e.name, e.start, e.end);\n}\n/** Emit function explicitly to control commas between conditional parameters. */\nfunction emitFn(e, ctx) {\n\tconst { attributes, name, params, returnAttributes, returnType, body } = e;\n\tconst { conditions, srcBuilder: builder } = ctx;\n\temitAttributes(attributes, ctx);\n\tbuilder.add(\"fn \", name.start - 3, name.start);\n\temitDeclIdent(name, ctx);\n\tbuilder.appendNext(\"(\");\n\tconst validParams = filterValidElements(params, conditions);\n\tvalidParams.forEach((p, i) => {\n\t\tif (!(p.contents.length > 0 && p.contents[0].kind === \"attribute\")) emitAttributes(p.attributes, ctx);\n\t\temitContentsNoWs(p, ctx);\n\t\tif (i < validParams.length - 1) builder.appendNext(\", \");\n\t});\n\tbuilder.appendNext(\") \");\n\tif (returnType) {\n\t\tbuilder.appendNext(\"-> \");\n\t\temitAttributes(returnAttributes, ctx);\n\t\temitContentsNoWs(returnType, ctx);\n\t\tbuilder.appendNext(\" \");\n\t}\n\temitContents(body, ctx);\n}\nfunction emitAttributes(attributes, ctx) {\n\tattributes?.forEach((a) => {\n\t\tif (emitAttribute(a, ctx)) ctx.srcBuilder.add(\" \", a.start, a.end);\n\t});\n}\n/** Emit structs explicitly to control commas between conditional members. */\nfunction emitStruct(e, ctx) {\n\tconst { attributes, name, members, start } = e;\n\tconst { srcBuilder, conditions } = ctx;\n\tconst validMembers = filterValidElements(members, conditions);\n\tconst validLength = validMembers.length;\n\tif (validLength === 0) {\n\t\twarnEmptyStruct(e);\n\t\treturn;\n\t}\n\temitAttributes(attributes, ctx);\n\tsrcBuilder.add(\"struct \", start, name.start);\n\temitDeclIdent(name, ctx);\n\tif (validLength === 1) {\n\t\tsrcBuilder.appendNext(\" { \");\n\t\temitContentsWithTrimming(validMembers[0], ctx);\n\t\tsrcBuilder.appendNext(\" }\");\n\t\tsrcBuilder.addNl();\n\t} else {\n\t\tsrcBuilder.appendNext(\" {\");\n\t\tsrcBuilder.addNl();\n\t\tvalidMembers.forEach((m) => {\n\t\t\tsrcBuilder.appendNext(\"  \");\n\t\t\temitContentsNoWs(m, ctx);\n\t\t\tsrcBuilder.appendNext(\",\");\n\t\t\tsrcBuilder.addNl();\n\t\t});\n\t\tsrcBuilder.appendNext(\"}\");\n\t\tsrcBuilder.addNl();\n\t}\n}\nfunction warnEmptyStruct(e) {\n\tconst { name, members } = e;\n\tconst condStr = members.length ? \"(with current conditions)\" : \"\";\n\tfailIdentElem(name, `struct '${name.ident.originalName}' has no members ${condStr}`);\n}\nfunction emitSynthetic(e, ctx) {\n\tconst { text } = e;\n\tctx.srcBuilder.addSynthetic(text, text, 0, text.length);\n}\nfunction emitContents(elem, ctx) {\n\tconst validElements = filterValidElements(elem.contents, ctx.conditions);\n\tfor (const e of validElements) lowerAndEmitElem(e, ctx);\n}\n/** Emit contents with leading/trailing whitespace trimming (V2 parser). */\nfunction emitContentsWithTrimming(elem, ctx) {\n\tconst validElements = filterValidElements(elem.contents, ctx.conditions);\n\tconst firstEmit = validElements.findIndex((e) => !isConditionalAttr(e));\n\tconst lastEmit = validElements.findLastIndex((e) => !isConditionalAttr(e));\n\tvalidElements.forEach((elem, i) => {\n\t\tif (elem.kind === \"text\") {\n\t\t\tlet text = elem.srcModule.src.slice(elem.start, elem.end);\n\t\t\tif (i === firstEmit) text = text.trimStart();\n\t\t\tif (i === lastEmit) text = text.trimEnd();\n\t\t\tif (text) ctx.srcBuilder.add(text, elem.start, elem.end);\n\t\t} else lowerAndEmitElem(elem, ctx);\n\t});\n}\nfunction isConditionalAttr(e) {\n\tif (e.kind !== \"attribute\") return false;\n\tconst { kind } = e.attribute;\n\treturn kind === \"@if\" || kind === \"@elif\" || kind === \"@else\";\n}\n/** Emit contents without whitespace. */\nfunction emitContentsNoWs(elem, ctx) {\n\tfilterValidElements(elem.contents, ctx.conditions).forEach((e) => {\n\t\tif (e.kind === \"text\") {\n\t\t\tconst { srcModule, start, end } = e;\n\t\t\tif (srcModule.src.slice(start, end).trim() === \"\") return;\n\t\t}\n\t\tlowerAndEmitElem(e, ctx);\n\t});\n}\nfunction emitRefIdent(e, ctx) {\n\tif (e.ident.std) ctx.srcBuilder.add(e.ident.originalName, e.start, e.end);\n\telse {\n\t\tconst mangledName = displayName(findDecl(e.ident));\n\t\tctx.srcBuilder.add(mangledName, e.start, e.end);\n\t}\n}\nfunction emitDeclIdent(e, ctx) {\n\tconst mangledName = displayName(e.ident);\n\tctx.srcBuilder.add(mangledName, e.start, e.end);\n}\nfunction emitExpression(e, ctx) {\n\tconst { kind } = e;\n\tif (kind === \"literal\") {\n\t\tctx.srcBuilder.add(e.value, e.start, e.end);\n\t\treturn;\n\t}\n\tif (kind === \"ref\") {\n\t\temitRefIdent(e, ctx);\n\t\treturn;\n\t}\n\tif (kind === \"type\") {\n\t\temitContents(e, ctx);\n\t\treturn;\n\t}\n\tif (kind === \"binary-expression\") {\n\t\temitExpression(e.left, ctx);\n\t\tctx.srcBuilder.add(` ${e.operator.value} `, e.operator.span[0], e.operator.span[1]);\n\t\temitExpression(e.right, ctx);\n\t\treturn;\n\t}\n\tif (kind === \"unary-expression\") {\n\t\tctx.srcBuilder.add(e.operator.value, e.operator.span[0], e.operator.span[1]);\n\t\temitExpression(e.expression, ctx);\n\t\treturn;\n\t}\n\tif (kind === \"parenthesized-expression\") {\n\t\temitExpression(e.expression, ctx);\n\t\treturn;\n\t}\n\tif (kind === \"call-expression\") {\n\t\temitExpression(e.function, ctx);\n\t\tif (e.templateArgs) for (const targ of e.templateArgs) lowerAndEmitElem(targ, ctx);\n\t\tfor (const arg of e.arguments) emitExpression(arg, ctx);\n\t\treturn;\n\t}\n\tif (kind === \"component-expression\") {\n\t\temitExpression(e.base, ctx);\n\t\temitExpression(e.access, ctx);\n\t\treturn;\n\t}\n\tif (kind === \"component-member-expression\") {\n\t\temitExpression(e.base, ctx);\n\t\tif (e.access.kind === \"name\") ctx.srcBuilder.add(e.access.name, e.access.start, e.access.end);\n\t\treturn;\n\t}\n\tassertUnreachable(kind);\n}\nfunction emitAttribute(e, ctx) {\n\tconst { kind } = e.attribute;\n\tif (kind === \"@if\" || kind === \"@elif\" || kind === \"@else\") return false;\n\tif (kind === \"@attribute\") {\n\t\tif (!wgslStandardAttributes.has(e.attribute.name)) return false;\n\t\temitStandardAttribute(e, ctx);\n\t\treturn true;\n\t}\n\tif (kind === \"@builtin\") {\n\t\tctx.srcBuilder.add(\"@builtin(\" + e.attribute.param.name + \")\", e.start, e.end);\n\t\treturn true;\n\t}\n\tif (kind === \"@diagnostic\") {\n\t\tconst diagStr = \"@diagnostic\" + diagnosticControlToString(e.attribute.severity, e.attribute.rule);\n\t\tctx.srcBuilder.add(diagStr, e.start, e.end);\n\t\treturn true;\n\t}\n\tif (kind === \"@interpolate\") {\n\t\tconst params = e.attribute.params.map((v) => v.name).join(\", \");\n\t\tctx.srcBuilder.add(`@interpolate(${params})`, e.start, e.end);\n\t\treturn true;\n\t}\n\tassertUnreachable(kind);\n}\nfunction emitStandardAttribute(e, ctx) {\n\tif (e.attribute.kind !== \"@attribute\") return;\n\tconst { params } = e.attribute;\n\tif (!params || params.length === 0) {\n\t\tctx.srcBuilder.add(\"@\" + e.attribute.name, e.start, e.end);\n\t\treturn;\n\t}\n\tctx.srcBuilder.add(\"@\" + e.attribute.name + \"(\", e.start, params[0].start);\n\tfor (let i = 0; i < params.length; i++) {\n\t\temitContents(params[i], ctx);\n\t\tif (i < params.length - 1) ctx.srcBuilder.add(\",\", params[i].end, params[i + 1].start);\n\t}\n\tctx.srcBuilder.add(\")\", params[params.length - 1].end, e.end);\n}\nfunction diagnosticControlToString(severity, rule) {\n\tconst ruleStr = rule[0].name + (rule[1] !== null ? \".\" + rule[1].name : \"\");\n\treturn `(${severity.name}, ${ruleStr})`;\n}\nfunction expressionToString(elem) {\n\tconst { kind } = elem;\n\tswitch (kind) {\n\t\tcase \"binary-expression\": {\n\t\t\tconst left = expressionToString(elem.left);\n\t\t\tconst right = expressionToString(elem.right);\n\t\t\treturn `${left} ${elem.operator.value} ${right}`;\n\t\t}\n\t\tcase \"unary-expression\": return `${elem.operator.value}${expressionToString(elem.expression)}`;\n\t\tcase \"ref\": return elem.ident.originalName;\n\t\tcase \"literal\": return elem.value;\n\t\tcase \"parenthesized-expression\": return `(${expressionToString(elem.expression)})`;\n\t\tcase \"component-expression\": return `${expressionToString(elem.base)}[${elem.access}]`;\n\t\tcase \"component-member-expression\": return `${expressionToString(elem.base)}.${elem.access}`;\n\t\tcase \"call-expression\": {\n\t\t\tconst fn = elem.function;\n\t\t\treturn `${fn.kind === \"ref\" ? fn.ident.originalName : fn.name.originalName}${elem.templateArgs ? `<...>` : \"\"}(${elem.arguments.map(expressionToString).join(\", \")})`;\n\t\t}\n\t\tcase \"type\": return elem.name.originalName;\n\t\tdefault: assertUnreachable(kind);\n\t}\n}\nfunction emitDirective(e, ctx) {\n\tconst { directive } = e;\n\tconst { kind } = directive;\n\tif (kind === \"diagnostic\") {\n\t\tconst diagStr = `diagnostic${diagnosticControlToString(directive.severity, directive.rule)};`;\n\t\tctx.srcBuilder.add(diagStr, e.start, e.end);\n\t} else if (kind === \"enable\") {\n\t\tconst exts = directive.extensions.map((v) => v.name).join(\", \");\n\t\tctx.srcBuilder.add(`enable ${exts};`, e.start, e.end);\n\t} else if (kind === \"requires\") {\n\t\tconst exts = directive.extensions.map((v) => v.name).join(\", \");\n\t\tctx.srcBuilder.add(`requires ${exts};`, e.start, e.end);\n\t} else assertUnreachable(kind);\n}\nfunction displayName(declIdent) {\n\tif (declIdent.isGlobal) {\n\t\tassertThatDebug(declIdent.mangledName, `ERR: mangled name not found for decl ident ${identToString(declIdent)}`);\n\t\treturn declIdent.mangledName;\n\t}\n\treturn declIdent.mangledName || declIdent.originalName;\n}\n/** Trace through refersTo links until we find the declaration. */\nfunction findDecl(ident) {\n\tlet i = ident;\n\tdo {\n\t\tif (i.kind === \"decl\") return i;\n\t\ti = i.refersTo;\n\t} while (i);\n\tthrow new Error(`unresolved identifer: ${ident.originalName}`);\n}\n\n//#endregion\n//#region src/debug/ImportToString.ts\nfunction importToString(tree) {\n\treturn importToStringImpl(tree) + \";\";\n}\nfunction importToStringImpl(tree) {\n\treturn [...tree.segments.map((s) => s.name), segmentToString(tree.finalSegment)].join(\"::\");\n}\nfunction segmentToString(segment) {\n\tif (segment.kind === \"import-item\") {\n\t\tconst { name, as } = segment;\n\t\treturn `${name}${as ? ` as ${as}` : \"\"}`;\n\t} else if (segment.kind === \"import-collection\") return `{${segment.subtrees.map((s) => importToStringImpl(s)).join(\", \")}}`;\n\telse assertUnreachable(segment);\n}\n\n//#endregion\n//#region src/debug/LineWrapper.ts\n/** debug utility for constructing strings that wrap at a fixed column width\n* text beyond the column width is wrapped to start on the next line\n*/\nvar LineWrapper = class {\n\t#fragments = [];\n\t#column = 0;\n\t#spc;\n\t#oneLine = true;\n\t#isHanging = false;\n\t#hangingSpc;\n\tmaxWidth;\n\tindent;\n\tconstructor(indent = 0, maxWidth = 60, hangingIndent = 2) {\n\t\tthis.maxWidth = maxWidth;\n\t\tthis.indent = indent;\n\t\tthis.#spc = \" \".repeat(indent);\n\t\tthis.#hangingSpc = \" \".repeat(hangingIndent);\n\t}\n\t/** add a new line to the constructed string */\n\tnl() {\n\t\tthis.#fragments.push(\"\\n\");\n\t\tthis.#column = 0;\n\t\tthis.#oneLine = false;\n\t\tthis.#isHanging = false;\n\t}\n\t/** add a string, wrapping to the next line if necessary */\n\tadd(s) {\n\t\tif (this.#column + firstLineLength(s) > this.maxWidth) this.hangingNl();\n\t\tif (this.#column === 0) {\n\t\t\tthis.#fragments.push(this.#spc);\n\t\t\tif (this.#isHanging) this.#fragments.push(this.#hangingSpc);\n\t\t\tthis.#column = this.indent;\n\t\t}\n\t\tthis.#fragments.push(s);\n\t\tthis.#column += s.length;\n\t}\n\t/** add a raw block of text with no wrapping */\n\taddBlock(s, andNewLine = true) {\n\t\tthis.#fragments.push(s);\n\t\tif (andNewLine) this.nl();\n\t}\n\t/** @return the constructed string */\n\tget result() {\n\t\treturn this.#fragments.join(\"\");\n\t}\n\t/** true if the result contains no newlines */\n\tget oneLine() {\n\t\treturn this.#oneLine;\n\t}\n\thangingNl() {\n\t\tthis.nl();\n\t\tthis.#isHanging = true;\n\t}\n};\nfunction firstLineLength(s) {\n\tconst i = s.indexOf(\"\\n\");\n\treturn i === -1 ? s.length : i;\n}\n\n//#endregion\n//#region src/debug/ASTtoString.ts\nconst maxLineLength = 150;\nfunction astToString(elem, indent = 0) {\n\tconst { kind } = elem;\n\tconst str = new LineWrapper(indent, maxLineLength);\n\tstr.add(kind);\n\taddElemFields(elem, str);\n\tlet childStrings = [];\n\tif (\"contents\" in elem) childStrings = elem.contents.map((e) => astToString(e, indent + 2));\n\tif (childStrings.length) {\n\t\tstr.nl();\n\t\tstr.addBlock(childStrings.join(\"\\n\"), false);\n\t}\n\treturn str.result;\n}\nfunction addElemFields(elem, str) {\n\tconst { kind } = elem;\n\tif (kind === \"assert\" || kind === \"module\" || kind === \"param\" || kind === \"stuff\" || kind === \"switch-clause\") return;\n\tif (kind === \"text\") str.add(` '${elem.srcModule.src.slice(elem.start, elem.end)}'`);\n\telse if (kind === \"var\" || kind === \"let\" || kind === \"gvar\" || kind === \"const\" || kind === \"override\") {\n\t\taddTypedDeclIdent(elem.name, str);\n\t\tlistAttributeElems(elem.attributes, str);\n\t} else if (kind === \"struct\") str.add(\" \" + elem.name.ident.originalName);\n\telse if (kind === \"member\") {\n\t\tlistAttributeElems(elem.attributes, str);\n\t\tstr.add(` ${elem.name.name}: ${typeRefElemToString(elem.typeRef)}`);\n\t} else if (kind === \"name\") str.add(\" \" + elem.name);\n\telse if (kind === \"memberRef\") {\n\t\tconst extra = elem.extraComponents ? debugContentsToString(elem.extraComponents) : \"\";\n\t\tstr.add(` ${elem.name.ident.originalName}.${elem.member.name}${extra}`);\n\t} else if (kind === \"fn\") addFnFields(elem, str);\n\telse if (kind === \"alias\") {\n\t\tconst prefix = elem.name.ident.kind === \"decl\" ? \"%\" : \"\";\n\t\tstr.add(` ${prefix}${elem.name.ident.originalName}=${typeRefElemToString(elem.typeRef)}`);\n\t} else if (kind === \"attribute\") addAttributeFields(elem.attribute, str);\n\telse if (kind === \"expression\") {\n\t\tconst contents = elem.contents.map((e) => e.kind === \"text\" ? `'${e.srcModule.src.slice(e.start, e.end)}'` : astToString(e)).join(\" \");\n\t\tstr.add(\" \" + contents);\n\t} else if (kind === \"type\") {\n\t\tconst nameStr = typeof elem.name === \"string\" ? elem.name : elem.name.originalName;\n\t\tconst params = elem.templateParams?.map(templateParamToString).join(\", \");\n\t\tstr.add(params ? ` ${nameStr}<${params}>` : ` ${nameStr}`);\n\t} else if (kind === \"synthetic\") str.add(` '${elem.text}'`);\n\telse if (kind === \"import\") {\n\t\tstr.add(\" \" + importToString(elem.imports));\n\t\tlistAttributeElems(elem.attributes, str);\n\t} else if (kind === \"ref\") str.add(\" \" + elem.ident.originalName);\n\telse if (kind === \"typeDecl\") addTypedDeclIdent(elem, str);\n\telse if (kind === \"decl\") str.add(\" %\" + elem.ident.originalName);\n\telse if (kind === \"directive\") addDirective(elem, str);\n\telse if (kind === \"statement\" || kind === \"continuing\") listAttributeElems(elem.attributes, str);\n\telse if (kind === \"literal\") str.add(` literal(${elem.value})`);\n\telse if (kind === \"binary-expression\") str.add(` binop(${elem.operator.value})`);\n\telse if (kind === \"unary-expression\") str.add(` unop(${elem.operator.value})`);\n\telse if (kind === \"call-expression\") str.add(\" call\");\n\telse if (kind === \"parenthesized-expression\") str.add(\" parens\");\n\telse if (kind === \"component-expression\") str.add(\" []\");\n\telse if (kind === \"component-member-expression\") str.add(\" .\");\n\telse assertUnreachable(kind);\n}\nfunction addAttributeFields(attr, str) {\n\tconst { kind } = attr;\n\tif (kind === \"@attribute\") {\n\t\tconst { name, params } = attr;\n\t\tconst paramsStr = params?.length ? `(${params.map(unknownExpressionToString).join(\", \")})` : \"\";\n\t\tstr.add(` @${name}${paramsStr}`);\n\t} else if (kind === \"@builtin\") str.add(` @builtin(${attr.param.name})`);\n\telse if (kind === \"@diagnostic\") str.add(` @diagnostic${diagnosticControlToString(attr.severity, attr.rule)}`);\n\telse if (kind === \"@if\" || kind === \"@elif\") str.add(` ${kind}(${expressionToString(attr.param.expression)})`);\n\telse if (kind === \"@else\") str.add(\" @else\");\n\telse if (kind === \"@interpolate\") str.add(` @interpolate(${attr.params.map((v) => v.name).join(\", \")})`);\n\telse assertUnreachable(kind);\n}\n/** @return string representation of an attribute (for test/debug) */\nfunction attributeToString(attr) {\n\tconst str = new LineWrapper(0, maxLineLength);\n\taddAttributeFields(attr, str);\n\treturn str.result;\n}\nfunction addTypedDeclIdent(elem, str) {\n\tconst { decl, typeRef } = elem;\n\tstr.add(\" %\" + decl.ident.originalName);\n\tif (typeRef) str.add(\" : \" + typeRefElemToString(typeRef));\n}\nfunction addFnFields(elem, str) {\n\tconst { name, params, returnType, attributes } = elem;\n\tconst paramStrs = params.map((p) => {\n\t\tconst { originalName } = p.name.decl.ident;\n\t\treturn `${originalName}: ${typeRefElemToString(p.name.typeRef)}`;\n\t});\n\tstr.add(` ${name.ident.originalName}(${paramStrs.join(\", \")})`);\n\tlistAttributeElems(attributes, str);\n\tif (returnType) str.add(\" -> \" + typeRefElemToString(returnType));\n}\n/** show attribute names in short form to verify collection */\nfunction listAttributeElems(attrs, str) {\n\tattrs?.forEach((a) => {\n\t\tstr.add(\" \" + attributeName(a.attribute));\n\t});\n}\nfunction attributeName(attr) {\n\treturn attr.kind === \"@attribute\" ? \"@\" + attr.name : attr.kind;\n}\nfunction addDirective(elem, str) {\n\tconst { directive, attributes } = elem;\n\tconst { kind } = directive;\n\tif (kind === \"diagnostic\") {\n\t\tconst { severity, rule } = directive;\n\t\tconst control = diagnosticControlToString(severity, rule);\n\t\tstr.add(` diagnostic${control}`);\n\t} else if (kind === \"enable\" || kind === \"requires\") str.add(` ${kind} ${directive.extensions.map((v) => v.name).join(\", \")}`);\n\telse assertUnreachable(kind);\n\tlistAttributeElems(attributes, str);\n}\nfunction unknownExpressionToString(elem) {\n\tif (!(\"contents\" in elem)) return astToString(elem);\n\treturn elem.contents.map((e) => {\n\t\tif (e.kind === \"text\") return `'${e.srcModule.src.slice(e.start, e.end)}'`;\n\t\treturn astToString(e);\n\t}).join(\" \");\n}\nfunction templateParamToString(p) {\n\tif (typeof p === \"string\") return p;\n\tif (p.kind === \"type\") return typeRefElemToString(p);\n\treturn astToString(p);\n}\nfunction typeRefElemToString(elem) {\n\tif (!elem) return \"?type?\";\n\tconst nameStr = typeof elem.name === \"string\" ? elem.name : elem.name.originalName;\n\tconst params = elem.templateParams?.map(templateParamToString).join(\", \");\n\treturn params ? `${nameStr}<${params}>` : nameStr;\n}\nfunction debugContentsToString(elem) {\n\treturn elem.contents.map((c) => {\n\t\tif (c.kind === \"text\") return c.srcModule.src.slice(c.start, c.end);\n\t\tif (c.kind === \"ref\") return c.ident.originalName;\n\t\treturn `?${c.kind}?`;\n\t}).join(\" \");\n}\n\n//#endregion\n//#region src/debug/ScopeToString.ts\n/** A debugging print of the scope tree with identifiers in nested brackets */\nfunction scopeToString(scope, indent = 0, shortIdents = true) {\n\tconst { contents, kind, condAttribute } = scope;\n\tconst str = new LineWrapper(indent);\n\tconst attrStrings = condAttribute && attributeToString(condAttribute);\n\tif (attrStrings) str.add(attrStrings + \" \");\n\tif (kind === \"partial\") str.add(\"-\");\n\tstr.add(\"{ \");\n\tconst last = contents.length - 1;\n\tlet lastWasScope = false;\n\tlet hasBlock = false;\n\tcontents.forEach((elem, i) => {\n\t\tif (childScope(elem)) {\n\t\t\tconst childBlock = scopeToString(elem, indent + 2, shortIdents);\n\t\t\tif (!lastWasScope) str.nl();\n\t\t\tstr.addBlock(childBlock);\n\t\t\tlastWasScope = true;\n\t\t\thasBlock = true;\n\t\t} else {\n\t\t\tif (lastWasScope) str.add(\"  \");\n\t\t\tlastWasScope = false;\n\t\t\tconst ident = elem;\n\t\t\tif (shortIdents) str.add(identShortString(ident));\n\t\t\telse str.add(identToString(ident));\n\t\t\tif (i < last) str.add(\" \");\n\t\t}\n\t});\n\tif (!hasBlock && str.oneLine) str.add(\" }\");\n\telse {\n\t\tif (hasBlock && !lastWasScope) str.nl();\n\t\tstr.add(\"}\");\n\t}\n\tstr.add(` #${scope.id}`);\n\treturn str.result;\n}\n/** A debug print of the scope tree with identifiers in long form in nested brackets */\nfunction scopeToStringLong(scope) {\n\treturn scopeToString(scope, 0, false);\n}\n/** name of an identifier, with decls prefixed with '%' */\nfunction identShortString(ident) {\n\tconst { kind, originalName } = ident;\n\treturn `${kind === \"decl\" ? \"%\" : \"\"}${originalName}`;\n}\nfunction identToString(ident) {\n\tif (!ident) return JSON.stringify(ident);\n\tconst { kind, originalName } = ident;\n\tconst idStr = ident.id ? `#${ident.id}` : \"\";\n\tif (kind === \"ref\") return `${originalName} ${idStr} -> ${identToString(ident.refersTo)}`;\n\telse {\n\t\tconst { mangledName } = ident;\n\t\treturn `%${originalName}${mangledName ? `(${mangledName})` : \"\"} ${idStr} `;\n\t}\n}\n\n//#endregion\n//#region src/LiveDeclarations.ts\n/** create a LiveDecls */\nfunction makeLiveDecls(parent = null) {\n\treturn {\n\t\tdecls: /* @__PURE__ */ new Map(),\n\t\tparent\n\t};\n}\n/** debug routine for logging LiveDecls */\nfunction liveDeclsToString(liveDecls) {\n\tconst { decls, parent } = liveDecls;\n\treturn `decls: { ${Array.from(decls.entries()).map(([name, decl]) => `${name}:${identToString(decl)}`).join(\", \")} }, parent: ${parent ? liveDeclsToString(parent) : \"null\"}`;\n}\n\n//#endregion\n//#region src/Mangler.ts\n/**\n* Construct a globally unique name based on the declaration\n* module path separated by underscores.\n* Corresponds to \"Underscore-count mangling\" from [NameMangling.md](https://github.com/wgsl-tooling-wg/wesl-spec/blob/main/NameMangling.md)\n*/\nfunction underscoreMangle(decl, srcModule) {\n\tconst { modulePath } = srcModule;\n\treturn [...modulePath.split(\"::\"), decl.originalName].map((v) => {\n\t\tconst underscoreCount = (v.match(/_/g) ?? []).length;\n\t\tif (underscoreCount > 0) return \"_\" + underscoreCount + v;\n\t\telse return v;\n\t}).join(\"_\");\n}\n/**\n* Construct a globally unique name based on the declaration\n*/\nfunction lengthPrefixMangle(decl, srcModule) {\n\tfunction codepointCount(text) {\n\t\treturn [...text].length;\n\t}\n\treturn \"_\" + [...srcModule.modulePath.split(\"::\"), decl.originalName].map((v) => codepointCount(v) + v).join(\"\");\n}\n/**\n* ManglerFn to construct a globally unique name\n* using the requested name plus a uniquing number suffix if necessary\n*/\nfunction minimalMangle(_d, _s, proposedName, globalNames) {\n\treturn minimallyMangledName(proposedName, globalNames);\n}\n/**\n* Construct a globally unique name by using the requested name if possible\n* and appending a number suffix necessary\n*/\nfunction minimallyMangledName(proposedName, globalNames) {\n\tlet renamed = proposedName;\n\tlet conflicts = 0;\n\twhile (globalNames.has(renamed)) renamed = proposedName + conflicts++;\n\treturn renamed;\n}\n\n//#endregion\n//#region src/ModulePathUtil.ts\n/** WESL module path utilities for converting between :: and / separators. */\n/**\n* Convert module path segments to relative file path.\n* Resolves package:: and super:: via srcModuleParts context.\n*\n* @returns relative file path e.g., \"utils/helper\", or undefined if external\n*/\nfunction modulePartsToRelativePath(parts, packageName, srcModuleParts) {\n\tconst resolved = srcModuleParts ? resolveModulePath(parts, srcModuleParts) : parts;\n\tconst rootSegment = resolved[0];\n\tif (rootSegment === \"package\" || rootSegment === packageName) return resolved.slice(1).join(\"/\");\n}\n/** String variant of modulePartsToRelativePath. */\nfunction moduleToRelativePath(modulePath, packageName, srcModulePath) {\n\tconst srcParts = srcModulePath?.split(\"::\");\n\treturn modulePartsToRelativePath(modulePath.split(\"::\"), packageName, srcParts);\n}\n/**\n* Resolve package:: and super:: to absolute module path.\n* - package:: replaced with actual package name from source module\n* - super:: climbs up the module path hierarchy\n*/\nfunction resolveModulePath(parts, srcModuleParts) {\n\tconst resolved = parts[0] === \"package\" ? [srcModuleParts[0], ...parts.slice(1)] : parts;\n\tconst lastSuper = resolved.lastIndexOf(\"super\");\n\tif (lastSuper === -1) return resolved;\n\treturn [...srcModuleParts.slice(0, -(lastSuper + 1)), ...resolved.slice(lastSuper + 1)];\n}\n/** Normalize debug root to end with / or be empty. */\nfunction normalizeDebugRoot(root) {\n\tif (root === void 0) return \"./\";\n\tif (root === \"\") return \"\";\n\treturn root.endsWith(\"/\") ? root : root + \"/\";\n}\n\n//#endregion\n//#region src/FlattenTreeImport.ts\n/**\n* Simplify importTree into a flattened map from import paths to module paths.\n*\n* @return map from import path (with 'as' renaming) to module Path\n*/\nfunction flattenTreeImport(imp) {\n\treturn recursiveResolve([], [], imp.segments, imp.finalSegment);\n\t/** recurse through segments of path, producing  */\n\tfunction recursiveResolve(resolvedImportPath, resolvedExportPath, remainingPath, finalSegment) {\n\t\tif (remainingPath.length > 0) {\n\t\t\tconst [segment, ...rest] = remainingPath;\n\t\t\treturn recursiveResolve([...resolvedImportPath, segment.name], [...resolvedExportPath, segment.name], rest, finalSegment);\n\t\t} else if (finalSegment.kind === \"import-collection\") return finalSegment.subtrees.flatMap((elem) => {\n\t\t\treturn recursiveResolve(resolvedImportPath, resolvedExportPath, elem.segments, elem.finalSegment);\n\t\t});\n\t\telse if (finalSegment.kind === \"import-item\") return [{\n\t\t\timportPath: [...resolvedImportPath, finalSegment.as ?? finalSegment.name],\n\t\t\tmodulePath: [...resolvedExportPath, finalSegment.name]\n\t\t}];\n\t\telse assertUnreachable(finalSegment);\n\t}\n}\n\n//#endregion\n//#region src/ParseError.ts\nvar ParseError = class extends Error {\n\tspan;\n\tconstructor(msg, span) {\n\t\tsuper(msg);\n\t\tthis.span = span;\n\t}\n};\n\n//#endregion\n//#region src/parse/ContentsHelpers.ts\n/** Push partial element onto stack for content collection. */\nfunction beginElem(ctx, kind, contents = []) {\n\tctx.state.context.openElems.push({\n\t\tkind,\n\t\tcontents: [...contents]\n\t});\n}\n/** Pop element from stack, fill gaps with TextElems, return contents. */\nfunction finishContents(ctx, start, end) {\n\tconst open = ctx.state.context.openElems.pop();\n\tif (!open) throw new Error(\"No open element to close\");\n\treturn coverWithText(ctx, open.contents, start, end);\n}\n/** Finish element: get end position, close contents, return complete element. */\nfunction finishElem(kind, start, ctx, params) {\n\tconst end = ctx.stream.checkpoint();\n\treturn {\n\t\tkind,\n\t\tstart,\n\t\tend,\n\t\tcontents: finishContents(ctx, start, end),\n\t\t...params\n\t};\n}\n/** Create a TextElem */\nfunction makeText(srcModule, start, end) {\n\treturn {\n\t\tkind: \"text\",\n\t\tstart,\n\t\tend,\n\t\tsrcModule\n\t};\n}\n/** Fill gaps between child elements with TextElems. */\nfunction coverWithText(ctx, contents, start, end) {\n\tconst { srcModule } = ctx.state.stable;\n\tconst sorted = contents.slice().sort((a, b) => a.start - b.start);\n\tconst elems = [];\n\tlet pos = start;\n\tfor (const elem of sorted) {\n\t\tif (pos < elem.start) elems.push(makeText(srcModule, pos, elem.start));\n\t\telems.push(elem);\n\t\tpos = elem.end;\n\t}\n\tif (pos < end) elems.push(makeText(srcModule, pos, end));\n\treturn elems;\n}\n\n//#endregion\n//#region src/parse/ExpressionUtil.ts\nfunction makeLiteral(token) {\n\tconst [start, end] = token.span;\n\treturn {\n\t\tkind: \"literal\",\n\t\tvalue: token.text,\n\t\tstart,\n\t\tend\n\t};\n}\nfunction makeUnaryOperator(token) {\n\treturn {\n\t\tvalue: token.text,\n\t\tspan: token.span\n\t};\n}\nfunction makeBinaryOperator(token) {\n\treturn {\n\t\tvalue: token.text,\n\t\tspan: token.span\n\t};\n}\nfunction makeUnaryExpression(operator, expr) {\n\tconst [start] = operator.span;\n\treturn {\n\t\tkind: \"unary-expression\",\n\t\toperator,\n\t\texpression: expr,\n\t\tstart,\n\t\tend: expr.end\n\t};\n}\nfunction makeBinaryExpression(left, operator, right) {\n\tconst { start } = left;\n\treturn {\n\t\tkind: \"binary-expression\",\n\t\toperator,\n\t\tleft,\n\t\tright,\n\t\tstart,\n\t\tend: right.end\n\t};\n}\nfunction makeComponentExpression(base, access, end) {\n\treturn {\n\t\tkind: \"component-expression\",\n\t\tbase,\n\t\taccess,\n\t\tstart: base.start,\n\t\tend\n\t};\n}\nfunction makeComponentMemberExpression(base, access) {\n\treturn {\n\t\tkind: \"component-member-expression\",\n\t\tbase,\n\t\taccess,\n\t\tstart: base.start,\n\t\tend: access.end\n\t};\n}\nfunction makeCallExpression(fn, templateArgs, args, end) {\n\treturn {\n\t\tkind: \"call-expression\",\n\t\tfunction: fn,\n\t\ttemplateArgs: templateArgs ?? void 0,\n\t\targuments: args,\n\t\tstart: fn.start,\n\t\tend\n\t};\n}\n\n//#endregion\n//#region src/parse/ParseUtil.ts\n/** Match text and throw ParseError if not found. */\nfunction expect(stream, text, context) {\n\tconst token = stream.matchText(text);\n\tif (!token) {\n\t\tconst pos = stream.checkpoint();\n\t\tthrow new ParseError(context ? `Expected '${text}' after ${context}` : `Expected '${text}'`, [pos, pos]);\n\t}\n\treturn token;\n}\n/** Match word token and throw ParseError if not found. */\nfunction expectWord(stream, errorMsg) {\n\tconst token = stream.peek();\n\tif (!token || token.kind !== \"word\") throwParseError(stream, errorMsg);\n\tstream.nextToken();\n\treturn token;\n}\n/** Parse expression and throw ParseError if not found. */\nfunction expectExpression(ctx, errorMsg = \"Expected expression\") {\n\tconst expr = parseExpression(ctx);\n\tif (!expr) throwParseError(ctx.stream, errorMsg);\n\tif (ctx.options.preserveExpressions) ctx.addElem(expr);\n\treturn expr;\n}\n/** Throw a ParseError at the current/next token position. */\nfunction throwParseError(stream, message) {\n\tconst weslStream = stream;\n\tconst token = weslStream.peek();\n\tthrow new ParseError(message, token ? token.span : [weslStream.checkpoint(), weslStream.checkpoint()]);\n}\n/** Parse comma-separated items. Caller handles delimiters. */\nfunction parseCommaList(ctx, parseItem) {\n\tconst items = [];\n\twhile (true) {\n\t\tconst item = parseItem(ctx);\n\t\tif (item === null) break;\n\t\titems.push(item);\n\t\tif (!ctx.stream.matchText(\",\")) break;\n\t}\n\treturn items;\n}\n/** Yield parsed elements until parser returns null. */\nfunction* parseMany(ctx, parse) {\n\tfor (let elem = parse(ctx); elem; elem = parse(ctx)) yield elem;\n}\n/** Create a NameElem from a word token. */\nfunction makeNameElem(token) {\n\tconst [start, end] = token.span;\n\treturn {\n\t\tkind: \"name\",\n\t\tname: token.text,\n\t\tstart,\n\t\tend\n\t};\n}\n/** Create a DeclIdentElem from a name token. */\nfunction createDeclIdentElem(ctx, nameToken, isGlobal) {\n\tconst declIdent = ctx.createDeclIdent(nameToken.text, isGlobal);\n\tconst [start, end] = nameToken.span;\n\treturn {\n\t\tkind: \"decl\",\n\t\tident: declIdent,\n\t\tsrcModule: ctx.srcModule,\n\t\tstart,\n\t\tend\n\t};\n}\n/** Create a RefIdentElem and link it to its RefIdent. */\nfunction makeRefIdentElem(ctx, refIdent, start, end) {\n\tconst elem = {\n\t\tkind: \"ref\",\n\t\tident: refIdent,\n\t\tsrcModule: ctx.srcModule,\n\t\tstart,\n\t\tend\n\t};\n\trefIdent.refIdentElem = elem;\n\treturn elem;\n}\nfunction isConditionalAttribute$1(attr) {\n\tconst { kind } = attr;\n\treturn kind === \"@if\" || kind === \"@elif\" || kind === \"@else\";\n}\n/** @return true if any attribute is a conditional (@if, @elif, @else) */\nfunction hasConditionalAttribute(attributes) {\n\treturn attributes.some((attr) => isConditionalAttribute$1(attr.attribute));\n}\n/** Attach non-empty attributes array to element. */\nfunction attachAttributes(elem, attributes) {\n\tif (attributes?.length) elem.attributes = attributes;\n}\n/** Link a DeclIdentElem's ident to its parent declaration. */\nfunction linkDeclIdentElem(declIdentElem, declElem) {\n\tdeclIdentElem.ident.declElem = declElem;\n}\n/** Link a TypedDeclElem's ident to its parent declaration. */\nfunction linkDeclIdent(typedDecl, declElem) {\n\tlinkDeclIdentElem(typedDecl.decl, declElem);\n}\n\n//#endregion\n//#region src/parse/OperatorBinding.ts\n/**\n* WGSL operator precedence and binding rules (WGSL spec 8.19).\n*\n* WGSL restricts how operators can combine without parentheses:\n* - Shift operators (<<, >>) cannot chain: `a << b << c` is invalid\n* - Relational operators (<, >, ==, etc.) cannot chain: `a < b < c` is invalid\n* - Bitwise operators (&, |, ^) cannot mix: `a & b | c` is invalid\n* - Logical operators (&&, ||) cannot mix: `a && b || c` is invalid\n* - Logical and bitwise cannot mix: `a & b && c` is invalid\n*\n* Valid combinations:\n* - Arithmetic chains freely: `a + b * c - d`\n* - Same bitwise chains: `a & b & c`\n* - Same logical chains: `a || b || c`\n* - Relational with logical: `a < b || c < d`\n*/\nconst binaryPrecedence = {\n\t\"||\": 1,\n\t\"&&\": 2,\n\t\"|\": 3,\n\t\"^\": 4,\n\t\"&\": 5,\n\t\"==\": 6,\n\t\"!=\": 6,\n\t\"<\": 7,\n\t\"<=\": 7,\n\t\">\": 7,\n\t\">=\": 7,\n\t\"<<\": 8,\n\t\">>\": 8,\n\t\"+\": 9,\n\t\"-\": 9,\n\t\"*\": 10,\n\t\"/\": 10,\n\t\"%\": 10\n};\nfunction isBinaryOperator(token) {\n\tif (!token) return false;\n\treturn token.text in binaryPrecedence;\n}\nfunction getPrecedence(opToken) {\n\treturn binaryPrecedence[opToken.text] || 0;\n}\nfunction getOpGroup(op) {\n\tswitch (op) {\n\t\tcase \"*\":\n\t\tcase \"/\":\n\t\tcase \"%\":\n\t\tcase \"+\":\n\t\tcase \"-\": return \"arithmetic\";\n\t\tcase \"<<\":\n\t\tcase \">>\": return \"shift\";\n\t\tcase \"<\":\n\t\tcase \">\":\n\t\tcase \"<=\":\n\t\tcase \">=\":\n\t\tcase \"==\":\n\t\tcase \"!=\": return \"relational\";\n\t\tcase \"&\": return \"bitAnd\";\n\t\tcase \"^\": return \"bitXor\";\n\t\tcase \"|\": return \"bitOr\";\n\t\tcase \"&&\": return \"logicalAnd\";\n\t\tcase \"||\": return \"logicalOr\";\n\t\tdefault: return \"arithmetic\";\n\t}\n}\n/** Validate WGSL 8.19 operator binding restrictions, return op's group. */\nfunction checkOpBinding(stream, op, leftGroup) {\n\tif (!validation) return leftGroup;\n\tconst opGroup = getOpGroup(op);\n\tif (!canBindLeft(op, leftGroup)) throwParseError(stream, `'${op}' requires parentheses after ${leftGroup}`);\n\tif (!canSelfChain(opGroup) && leftGroup === opGroup) throwParseError(stream, `'${op}' cannot be chained`);\n\treturn opGroup;\n}\n/** Check if operator can have leftGroup as its left operand. */\nfunction canBindLeft(op, leftGroup) {\n\tconst opGroup = getOpGroup(op);\n\tif (opGroup === \"shift\") return leftGroup === \"unary\";\n\tif (opGroup === \"bitAnd\") return leftGroup === \"unary\" || leftGroup === \"bitAnd\";\n\tif (opGroup === \"bitXor\") return leftGroup === \"unary\" || leftGroup === \"bitXor\";\n\tif (opGroup === \"bitOr\") return leftGroup === \"unary\" || leftGroup === \"bitOr\";\n\tif (opGroup === \"logicalAnd\") return !isBitwise(leftGroup) && leftGroup !== \"logicalOr\";\n\tif (opGroup === \"logicalOr\") return !isBitwise(leftGroup) && leftGroup !== \"logicalAnd\";\n\treturn true;\n}\n/** Shift and relational operators cannot repeat (no a << b << c or a < b < c). */\nfunction canSelfChain(group) {\n\treturn group !== \"shift\" && group !== \"relational\";\n}\nfunction isBitwise(g) {\n\treturn g === \"bitAnd\" || g === \"bitXor\" || g === \"bitOr\";\n}\n\n//#endregion\n//#region src/parse/ParseIdent.ts\n/** WESL keywords that cannot be used as path segment identifiers. */\nconst weslKeywords = new Set([\n\t\"as\",\n\t\"import\",\n\t\"package\",\n\t\"super\",\n\t\"self\"\n]);\nconst pathPrefixKeywords = new Set([\"package\", \"super\"]);\n/** Parse qualified module path like a::b::c, returning parts and span. */\nfunction parseModulePath(stream) {\n\tconst first = stream.peek();\n\tif (!first || !isPathSegment(first, true)) return null;\n\tconst start = first.span[0];\n\tstream.nextToken();\n\tconst parts = [first.text];\n\twhile (stream.matchText(\"::\")) {\n\t\tconst next = stream.peek();\n\t\tif (!next || !isPathSegment(next, false)) throwParseError(stream, \"Expected identifier after '::'\");\n\t\tstream.nextToken();\n\t\tparts.push(next.text);\n\t}\n\treturn {\n\t\tparts,\n\t\tstart,\n\t\tend: stream.checkpoint()\n\t};\n}\n/**\n* Parse identifier, possibly qualified with :: (e.g., package::bar, super::baz).\n* @param conditionRef - if true, ident gets conditionRef flag and isn't added to scope\n*/\nfunction parseIdent(ctx, conditionRef) {\n\tconst path = parseModulePath(ctx.stream);\n\tif (!path) return null;\n\tconst { parts, start, end } = path;\n\tconst ident = ctx.createRefIdent(parts.join(\"::\"));\n\tif (conditionRef) ident.conditionRef = true;\n\tconst refIdentElem = makeRefIdentElem(ctx, ident, start, end);\n\tif (!conditionRef) {\n\t\tctx.saveIdent(ident);\n\t\tctx.addElem(refIdentElem);\n\t}\n\treturn refIdentElem;\n}\n/** Check if token is valid as a path segment (word or allowed keyword). */\nfunction isPathSegment(token, isFirst) {\n\tif (token.kind === \"word\") return true;\n\tif (token.kind !== \"keyword\") return false;\n\tif (weslKeywords.has(token.text)) return isFirst && pathPrefixKeywords.has(token.text);\n\treturn true;\n}\n\n//#endregion\n//#region src/parse/ParseType.ts\n/**\n* Grammar: type_specifier : template_elaborated_ident\n* Grammar: template_elaborated_ident : ident template_list?\n* WESL extension: qualified names with :: (e.g., pkg::Type)\n*/\nfunction parseSimpleTypeRef(ctx) {\n\tconst path = parseModulePath(ctx.stream);\n\tif (!path) return null;\n\tconst { parts, start, end: nameEnd } = path;\n\tconst refIdent = ctx.createRefIdent(parts.join(\"::\"));\n\tbeginElem(ctx, \"type\");\n\tconst refIdentElem = makeRefIdentElem(ctx, refIdent, start, nameEnd);\n\tctx.saveIdent(refIdent);\n\tctx.addElem(refIdentElem);\n\treturn finishElem(\"type\", start, ctx, {\n\t\tname: refIdent,\n\t\ttemplateParams: ctx.stream.nextTemplateStartToken() ? parseTemplateParams(ctx) : void 0\n\t});\n}\n/** Parse comma-separated template parameters until closing '>'. */\nfunction parseTemplateParams(ctx) {\n\tconst { stream } = ctx;\n\tif (consumeTemplateEnd(stream)) return [];\n\tconst params = [parseTemplateParam(ctx)];\n\twhile (stream.matchText(\",\")) params.push(parseTemplateParam(ctx));\n\tif (!consumeTemplateEnd(stream)) throwParseError(stream, \"Expected '>' or ',' after template parameter\");\n\treturn params;\n}\n/** Consume template end token (>) if present, returning success. */\nfunction consumeTemplateEnd(stream) {\n\tif (!stream.peek()?.text.startsWith(\">\")) return false;\n\tif (!stream.nextTemplateEndToken()) throwParseError(stream, \"Expected '>' to close template parameters\");\n\treturn true;\n}\n/** Grammar: template_arg_expression : expression */\nfunction parseTemplateParam(ctx) {\n\tconst expr = parseExpression(ctx, { inTemplate: true });\n\tif (expr) return expr;\n\tthrowParseError(ctx.stream, \"Expected expression in template parameters\");\n}\n\n//#endregion\n//#region src/parse/ParseCall.ts\n/**\n* Parse a call suffix: optional template args + arguments.\n* Grammar: call_phrase : template_elaborated_ident argument_expression_list\n*/\nfunction parseCallSuffix(ctx, current, parseExpr) {\n\tif (current.kind !== \"ref\" && current.kind !== \"type\") return null;\n\tconst { stream } = ctx;\n\tconst templateArgs = current.kind === \"type\" ? current.templateParams ?? null : parseCallTemplateArgs(ctx);\n\tif (!stream.matchText(\"(\")) return null;\n\tconst args = [];\n\twhile (true) {\n\t\tconst closeEnd = matchCloseParen(stream);\n\t\tif (closeEnd !== null) return makeCallExpression(current, templateArgs, args, closeEnd);\n\t\tconst arg = parseExpr(ctx);\n\t\tif (!arg) throwParseError(stream, \"Expected expression\");\n\t\targs.push(arg);\n\t\tif (stream.matchText(\",\")) continue;\n\t\tconst end = matchCloseParen(stream);\n\t\tif (end !== null) return makeCallExpression(current, templateArgs, args, end);\n\t\tthrowParseError(stream, \"Expected ',' or ')' in function arguments\");\n\t}\n}\n/** Parse optional template args for a call expression. */\nfunction parseCallTemplateArgs(ctx) {\n\tconst { stream } = ctx;\n\tconst pos = stream.checkpoint();\n\tif (!stream.nextTemplateStartToken()) return null;\n\tconst params = parseTemplateParams(ctx);\n\tif (stream.peek()?.text !== \"(\") {\n\t\tstream.reset(pos);\n\t\treturn null;\n\t}\n\treturn params;\n}\n/** Consume closing paren if present, returning its end position or null. */\nfunction matchCloseParen(stream) {\n\tconst token = stream.matchText(\")\");\n\treturn token ? token.span[1] : null;\n}\n\n//#endregion\n//#region src/parse/ParseExpression.ts\n/**\n* Grammar: expression :\n*   relational_expression\n*   | short_circuit_or_expression '||' relational_expression\n*   | short_circuit_and_expression '&&' relational_expression\n*   | bitwise_expression\n*/\nfunction parseExpression(ctx, opts) {\n\tconst { conditionRef, inTemplate } = opts === true ? {\n\t\tconditionRef: true,\n\t\tinTemplate: false\n\t} : opts ?? {};\n\tconst condRef = conditionRef ? true : void 0;\n\tconst startExpr = parseUnaryExpression(ctx, condRef);\n\tif (!startExpr) return null;\n\treturn parseBinaryExpr(ctx, {\n\t\tprec: 1,\n\t\tleft: startExpr,\n\t\tgroup: \"unary\",\n\t\tcondRef,\n\t\tinTemplate\n\t}).expr;\n}\n/**\n* Grammar: unary_expression :\n*   singular_expression | '-' unary_expression | '!' unary_expression\n*   | '~' unary_expression | '*' unary_expression | '&' unary_expression\n*/\nfunction parseUnaryExpression(ctx, conditionRef) {\n\tconst { stream } = ctx;\n\tconst token = stream.peek();\n\tif (!token) return null;\n\tif (\"-!&*~\".includes(token.text)) {\n\t\tstream.nextToken();\n\t\tconst operator = makeUnaryOperator(token);\n\t\tconst operand = parseUnaryExpression(ctx, conditionRef);\n\t\tif (!operand) throwParseError(stream, \"Expected expression after unary operator\");\n\t\treturn makeUnaryExpression(operator, operand);\n\t}\n\treturn parsePrimaryExpr(ctx, conditionRef);\n}\n/**\n* Parse binary operators using precedence climbing algorithm.\n*\n* For `1 + 2 * 3 - 4`:\n*  - While loop handles left-to-right at same precedence: `1+2-3` ==> `(1+2)-3`\n*  - Recursion handles tighter-binding ops on the right: `1+2*3` ==> `1+(2*3)`\n*\n* Also validates WGSL operator mixing rules (e.g. `x < y > z` is illegal).\n*/\nfunction parseBinaryExpr(ctx, args) {\n\tconst { stream } = ctx;\n\tconst { prec: minPrecedence, left, group: leftGroup } = args;\n\tconst { condRef, inTemplate } = args;\n\tlet current = left;\n\tlet currentGroup = leftGroup;\n\twhile (true) {\n\t\tconst opToken = stream.peek();\n\t\tif (!isBinaryOpInContext(opToken, inTemplate)) break;\n\t\tconst precedence = getPrecedence(opToken);\n\t\tif (precedence < minPrecedence) break;\n\t\tstream.nextToken();\n\t\tcurrentGroup = checkOpBinding(stream, opToken.text, currentGroup);\n\t\tlet right = parseUnaryExpression(ctx, condRef);\n\t\tif (!right) throwParseError(stream, \"Expected expression after binary operator\");\n\t\tconst nextToken = stream.peek();\n\t\tif (isBinaryOpInContext(nextToken, inTemplate)) {\n\t\t\tconst nextPrec = getPrecedence(nextToken);\n\t\t\tif (nextPrec > precedence) right = parseBinaryExpr(ctx, {\n\t\t\t\tprec: nextPrec,\n\t\t\t\tleft: right,\n\t\t\t\tgroup: \"unary\",\n\t\t\t\tcondRef,\n\t\t\t\tinTemplate\n\t\t\t}).expr;\n\t\t}\n\t\tcurrent = makeBinaryExpression(current, makeBinaryOperator(opToken), right);\n\t}\n\treturn {\n\t\texpr: current,\n\t\tgroup: currentGroup\n\t};\n}\n/** Grammar: primary_expression : paren_expression | literal | template_elaborated_ident */\nfunction parsePrimaryExpr(ctx, conditionRef) {\n\tconst expr = parseParenExpr(ctx, conditionRef) || parseSimpleLiteral(ctx.stream) || parseTemplateElaboratedIdent(ctx, conditionRef);\n\tif (!expr) return null;\n\tif (conditionRef) return expr;\n\treturn parsePostfixExpression(ctx, expr);\n}\n/** Check if token is a valid binary operator in the current context. */\nfunction isBinaryOpInContext(token, inTemplate) {\n\tif (!isBinaryOperator(token)) return false;\n\tif (inTemplate && token.text.startsWith(\">\")) return false;\n\treturn true;\n}\n/** Grammar: paren_expression : '(' expression ')' */\nfunction parseParenExpr(ctx, conditionRef) {\n\tconst { stream } = ctx;\n\tconst open = stream.matchText(\"(\");\n\tif (!open) return null;\n\tconst expression = parseExpression(ctx, conditionRef);\n\tif (!expression) throwParseError(stream, \"Expected expression after '('\");\n\tconst close = expect(stream, \")\", \"expression\");\n\treturn {\n\t\tkind: \"parenthesized-expression\",\n\t\texpression,\n\t\tstart: open.span[0],\n\t\tend: close.span[1]\n\t};\n}\n/** Grammar: literal : int_literal | float_literal | bool_literal */\nfunction parseSimpleLiteral(stream) {\n\tconst num = stream.matchKind(\"number\");\n\tif (num) return makeLiteral(num);\n\treturn parseBoolean(stream);\n}\n/**\n* Grammar: template_elaborated_ident : ident template_list?\n* Returns RefIdentElem for bare idents, TypeRefElem if templates present.\n*/\nfunction parseTemplateElaboratedIdent(ctx, conditionRef) {\n\tconst refIdent = parseIdent(ctx, conditionRef);\n\tif (!refIdent) return null;\n\tif (!ctx.stream.nextTemplateStartToken()) return refIdent;\n\tconst templateParams = parseTemplateParams(ctx);\n\treturn {\n\t\tkind: \"type\",\n\t\tname: refIdent.ident,\n\t\ttemplateParams,\n\t\tstart: refIdent.start,\n\t\tend: ctx.stream.checkpoint(),\n\t\tcontents: []\n\t};\n}\n/** Parse postfix operators: member access, indexing, function calls. */\nfunction parsePostfixExpression(ctx, base) {\n\tconst next = parsePostfixOp(ctx, base);\n\tif (next) return parsePostfixExpression(ctx, next);\n\treturn base;\n}\n/** Grammar: bool_literal : 'true' | 'false' */\nfunction parseBoolean(stream) {\n\tconst boolToken = stream.matchKind(\"keyword\", \"true\") || stream.matchKind(\"keyword\", \"false\");\n\tif (!boolToken) return null;\n\treturn makeLiteral(boolToken);\n}\nfunction parsePostfixOp(ctx, base) {\n\treturn parseMemberAccess(ctx, base) || parseIndexAccess(ctx, base) || parseCallSuffix(ctx, base, parseExpression);\n}\n/** Parse .member access */\nfunction parseMemberAccess(ctx, base) {\n\tif (!ctx.stream.matchText(\".\")) return null;\n\treturn makeComponentMemberExpression(base, makeNameElem(expectWord(ctx.stream, \"Expected identifier after '.'\")));\n}\n/** Parse [index] access */\nfunction parseIndexAccess(ctx, base) {\n\tconst { stream } = ctx;\n\tif (!stream.matchText(\"[\")) return null;\n\treturn makeComponentExpression(base, expectExpression(ctx, \"Expected expression in array index\"), expect(stream, \"]\", \"array index\").span[1]);\n}\n\n//#endregion\n//#region src/parse/ParseAttribute.ts\n/** Grammar: attribute * */\nfunction parseAttributeList(ctx) {\n\treturn [...parseMany(ctx, parseAttribute)];\n}\n/** WESL Grammar: if_attribute : '@if' '(' translate_time_expression ')' */\nfunction parseIfAttribute(ctx) {\n\treturn parseConditionalAttribute(ctx, \"if\", makeIfAttribute);\n}\n/** WESL Grammar: else_attribute : '@else' */\nfunction parseElseAttribute(ctx) {\n\tif (!ctx.stream.matchSequence(\"@\", \"else\")) return null;\n\treturn makeElseAttribute();\n}\n/** WESL Grammar: elif_attribute : '@elif' '(' translate_time_expression ')' */\nfunction parseElifAttribute(ctx) {\n\treturn parseConditionalAttribute(ctx, \"elif\", makeElifAttribute);\n}\n/**\n* Grammar: attribute :\n*   '@' ident_pattern_token argument_expression_list ?\n*   | align_attr | binding_attr | blend_src_attr | builtin_attr | const_attr\n*   | diagnostic_attr | group_attr | id_attr | interpolate_attr | invariant_attr\n*   | location_attr | must_use_attr | size_attr | workgroup_size_attr\n*   | vertex_attr | fragment_attr | compute_attr\n* WESL extensions: @if, @elif, @else\n*/\nfunction parseAttribute(ctx) {\n\tconst { stream } = ctx;\n\tconst startPos = stream.checkpoint();\n\tif (!stream.matchText(\"@\")) return null;\n\tstream.reset(startPos);\n\tconst weslAttr = parseWeslConditional(ctx);\n\tif (weslAttr) return weslAttr;\n\tconst stdAttr = parseStandardAttribute(ctx);\n\tif (stdAttr) return stdAttr;\n\treturn null;\n}\n/** Parse `@if(expr)` or `@elif(expr)` conditional attributes. */\nfunction parseConditionalAttribute(ctx, keyword, makeAttr) {\n\tconst { stream } = ctx;\n\tconst startPos = stream.checkpoint();\n\tif (!stream.matchSequence(\"@\", keyword)) return null;\n\texpect(stream, \"(\", `@${keyword}`);\n\tconst expr = parseExpression(ctx, true);\n\tif (!expr) return null;\n\tstream.matchText(\",\");\n\texpect(stream, \")\", `@${keyword} expression`);\n\treturn makeAttr(makeTranslateTimeExpressionElem({\n\t\tvalue: expr,\n\t\tspan: [startPos, stream.checkpoint()]\n\t}));\n}\nfunction makeIfAttribute(param) {\n\treturn {\n\t\tkind: \"@if\",\n\t\tparam\n\t};\n}\nfunction makeElseAttribute() {\n\treturn { kind: \"@else\" };\n}\nfunction makeElifAttribute(param) {\n\treturn {\n\t\tkind: \"@elif\",\n\t\tparam\n\t};\n}\n/** Parse WESL conditional attributes (@if, @elif, @else) */\nfunction parseWeslConditional(ctx) {\n\tconst { stream } = ctx;\n\tconst peeked = stream.peek();\n\tif (peeked?.text !== \"@\") return null;\n\tconst startPos = peeked.span[0];\n\tconst ifAttr = parseIfAttribute(ctx);\n\tif (ifAttr) return attributeElem(ifAttr, startPos, stream.checkpoint());\n\tconst elifAttr = parseElifAttribute(ctx);\n\tif (elifAttr) return attributeElem(elifAttr, startPos, stream.checkpoint());\n\tconst elseAttr = parseElseAttribute(ctx);\n\tif (elseAttr) return attributeElem(elseAttr, startPos, stream.checkpoint());\n\treturn null;\n}\n/** Parse a standard attribute (not @if/@elif/@else) */\nfunction parseStandardAttribute(ctx) {\n\tconst { stream } = ctx;\n\tconst resetPos = stream.checkpoint();\n\tconst atToken = stream.matchText(\"@\");\n\tif (!atToken) return null;\n\tconst startPos = atToken.span[0];\n\tconst nameToken = stream.peek();\n\tif (!nameToken || nameToken.kind !== \"word\" && nameToken.kind !== \"keyword\") {\n\t\tstream.reset(resetPos);\n\t\treturn null;\n\t}\n\tstream.nextToken();\n\tconst name = nameToken.text;\n\tif (name === \"builtin\") return parseBuiltinAttribute(ctx, startPos);\n\tif (name === \"interpolate\") return parseInterpolateAttribute(ctx, startPos);\n\tif (name === \"diagnostic\") return parseDiagnosticAttribute(ctx, startPos);\n\tlet params;\n\tif (stream.matchText(\"(\")) {\n\t\tctx.parsingAttrParam = name;\n\t\tparams = parseAttributeParams(ctx);\n\t\tctx.parsingAttrParam = void 0;\n\t\texpect(stream, \")\", \"attribute parameters\");\n\t}\n\tif (name === \"must_use\" && params !== void 0) throw new ParseError(\"@must_use does not accept parameters\", [startPos, stream.checkpoint()]);\n\treturn attributeElem({\n\t\tkind: \"@attribute\",\n\t\tname,\n\t\tparams\n\t}, startPos, stream.checkpoint());\n}\nfunction makeTranslateTimeExpressionElem(args) {\n\treturn {\n\t\tkind: \"translate-time-expression\",\n\t\texpression: args.value,\n\t\tspan: args.span\n\t};\n}\nfunction attributeElem(attribute, start, end) {\n\treturn {\n\t\tkind: \"attribute\",\n\t\tattribute,\n\t\tstart,\n\t\tend,\n\t\tcontents: []\n\t};\n}\nfunction parseBuiltinAttribute(ctx, startPos) {\n\tconst { stream } = ctx;\n\texpect(stream, \"(\", \"@builtin\");\n\tconst nameToken = expectWord(stream, \"Expected identifier in @builtin\");\n\texpect(stream, \")\", \"@builtin parameter\");\n\treturn attributeElem({\n\t\tkind: \"@builtin\",\n\t\tparam: makeNameElem(nameToken)\n\t}, startPos, stream.checkpoint());\n}\nfunction parseInterpolateAttribute(ctx, startPos) {\n\tconst { stream } = ctx;\n\texpect(stream, \"(\", \"@interpolate\");\n\tconst params = parseCommaList(ctx, parseNameElem);\n\texpect(stream, \")\", \"@interpolate parameters\");\n\treturn attributeElem({\n\t\tkind: \"@interpolate\",\n\t\tparams\n\t}, startPos, stream.checkpoint());\n}\nfunction parseNameElem(ctx) {\n\treturn makeNameElem(expectWord(ctx.stream, \"Expected identifier\"));\n}\n/** @diagnostic(severity, rule) or @diagnostic(severity, namespace.rule) */\nfunction parseDiagnosticAttribute(ctx, startPos) {\n\tconst { stream } = ctx;\n\texpect(stream, \"(\", \"@diagnostic\");\n\tconst severity = makeNameElem(expectWord(stream, \"Expected severity in @diagnostic\"));\n\texpect(stream, \",\", \"@diagnostic severity\");\n\tconst firstName = makeNameElem(expectWord(stream, \"Expected rule in @diagnostic\"));\n\tlet rule;\n\tif (stream.matchText(\".\")) rule = [firstName, makeNameElem(expectWord(stream, \"Expected rule after namespace\"))];\n\telse rule = [firstName, null];\n\texpect(stream, \")\", \"@diagnostic parameters\");\n\treturn attributeElem({\n\t\tkind: \"@diagnostic\",\n\t\tseverity,\n\t\trule\n\t}, startPos, stream.checkpoint());\n}\n/** Parse attribute params as expressions to capture identifier refs. */\nfunction parseAttributeParams(ctx) {\n\treturn parseCommaList(ctx, parseAttrParam);\n}\nfunction parseAttrParam(ctx) {\n\tconst { stream } = ctx;\n\tconst start = stream.checkpoint();\n\tbeginElem(ctx, \"expression\");\n\tparseExpression(ctx);\n\tconst end = stream.checkpoint();\n\treturn {\n\t\tkind: \"expression\",\n\t\tstart,\n\t\tend,\n\t\tcontents: finishContents(ctx, start, end)\n\t};\n}\n\n//#endregion\n//#region src/parse/ParseDirective.ts\n/** Grammar: global_directive : diagnostic_directive | enable_directive | requires_directive */\nfunction parseDirective(ctx) {\n\tconst { stream } = ctx;\n\tconst startPos = stream.checkpoint();\n\tconst attributes = parseAttributeList(ctx);\n\tconst attrs = attributes.length > 0 ? attributes : void 0;\n\tconst result = parseExtensionDirective(ctx, \"enable\", attrs) || parseExtensionDirective(ctx, \"requires\", attrs) || parseDiagnosticDirective(ctx, attrs);\n\tif (!result) stream.reset(startPos);\n\treturn result;\n}\n/** Grammar: enable_directive | requires_directive : keyword extension_list ';' */\nfunction parseExtensionDirective(ctx, keyword, attributes) {\n\tconst { stream } = ctx;\n\tconst token = stream.matchText(keyword);\n\tif (!token) return null;\n\tconst extensions = parseCommaList(ctx, parseDirectiveName);\n\texpect(stream, \";\", `${keyword} directive`);\n\treturn makeDirectiveElem({\n\t\tkind: keyword,\n\t\textensions\n\t}, token, stream, attributes);\n}\nfunction parseDirectiveName(ctx) {\n\treturn makeNameElem(expectWord(ctx.stream, \"Expected identifier in name list\"));\n}\n/**\n* Grammar: diagnostic_directive : 'diagnostic' diagnostic_control ';'\n* Grammar: diagnostic_control : '(' severity_control_name ',' diagnostic_rule_name ',' ? ')'\n*/\nfunction parseDiagnosticDirective(ctx, attributes) {\n\tconst { stream } = ctx;\n\tconst token = stream.matchText(\"diagnostic\");\n\tif (!token) return null;\n\texpect(stream, \"(\", \"diagnostic\");\n\tconst severity = makeNameElem(expectWord(stream, \"Expected severity in diagnostic\"));\n\texpect(stream, \",\", \"diagnostic severity\");\n\tconst ruleName = makeNameElem(expectWord(stream, \"Expected rule name in diagnostic\"));\n\tlet subrule = null;\n\tif (stream.matchText(\".\")) subrule = makeNameElem(expectWord(stream, \"Expected subrule name after '.'\"));\n\tstream.matchText(\",\");\n\texpect(stream, \")\", \"diagnostic rule\");\n\texpect(stream, \";\", \"diagnostic directive\");\n\treturn makeDirectiveElem({\n\t\tkind: \"diagnostic\",\n\t\tseverity,\n\t\trule: [ruleName, subrule]\n\t}, token, stream, attributes);\n}\nfunction makeDirectiveElem(directive, token, stream, attributes) {\n\tconst elem = {\n\t\tkind: \"directive\",\n\t\tdirective,\n\t\tstart: attributes?.[0]?.start ?? token.span[0],\n\t\tend: stream.checkpoint()\n\t};\n\tattachAttributes(elem, attributes);\n\treturn elem;\n}\n\n//#endregion\n//#region src/parse/ParseControlFlow.ts\n/**\n* Grammar: if_statement : attribute* if_clause else_if_clause* else_clause?\n* Grammar: if_clause : 'if' expression compound_statement\n*/\nfunction parseIfStatement(ctx, attributes) {\n\tconst startPos = beginStatement(ctx, \"if\", attributes);\n\tif (startPos === null) return null;\n\texpectExpression(ctx, \"Expected condition expression after 'if'\");\n\tconst body = expectCompound(ctx, \"Expected '{' after if condition\");\n\tctx.addElem(body);\n\tparseElseChain(ctx);\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Grammar: switch_statement : attribute* 'switch' expression switch_body */\nfunction parseSwitchStatement(ctx, attributes) {\n\tconst startPos = beginStatement(ctx, \"switch\", attributes);\n\tif (startPos === null) return null;\n\texpectExpression(ctx, \"Expected expression after 'switch'\");\n\texpectSwitchClauses(ctx);\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/**\n* Grammar: else_if_clause : 'else' 'if' expression compound_statement\n* Grammar: else_clause : 'else' compound_statement\n*/\nfunction parseElseChain(ctx) {\n\tconst { stream } = ctx;\n\twhile (stream.matchText(\"else\")) {\n\t\tif (stream.matchText(\"if\")) {\n\t\t\texpectExpression(ctx, \"Expected expression after 'else if'\");\n\t\t\tconst body = expectCompound(ctx, \"Expected '{' after else if\");\n\t\t\tctx.addElem(body);\n\t\t\tcontinue;\n\t\t}\n\t\tconst body = expectCompound(ctx, \"Expected '{' after else\");\n\t\tctx.addElem(body);\n\t\tbreak;\n\t}\n}\n/**\n* Grammar: switch_body : attribute* '{' switch_clause+ '}'\n* Grammar: switch_clause : case_clause | default_alone_clause\n* Grammar: case_clause : 'case' case_selectors ':'? compound_statement\n* Grammar: default_alone_clause : 'default' ':'? compound_statement\n*/\nfunction expectSwitchClauses(ctx) {\n\tconst { stream } = ctx;\n\tparseAttributeList(ctx);\n\texpect(stream, \"{\", \"switch expression\");\n\twhile (!stream.matchText(\"}\")) {\n\t\tconst clauseStart = stream.checkpoint();\n\t\tconst clauseAttrs = parseAttributeList(ctx);\n\t\tbeginElem(ctx, \"switch-clause\", clauseAttrs.length ? clauseAttrs : void 0);\n\t\tif (stream.matchText(\"case\")) {\n\t\t\tparseCaseSelectors(ctx);\n\t\t\tparseCaseBody(ctx, \"Expected '{' after case value\");\n\t\t} else if (stream.matchText(\"default\")) parseCaseBody(ctx, \"Expected '{' after 'default'\");\n\t\telse throwParseError(stream, \"Expected 'case', 'default', or '}' in switch\");\n\t\tconst clauseElem = finishElem(\"switch-clause\", clauseStart, ctx, {});\n\t\tattachAttributes(clauseElem, clauseAttrs.length ? clauseAttrs : void 0);\n\t\tctx.addElem(clauseElem);\n\t}\n}\n/** Grammar: case_selectors : case_selector (',' case_selector)* ','? */\nfunction parseCaseSelectors(ctx) {\n\tconst { stream } = ctx;\n\texpectExpression(ctx, \"Expected expression after 'case'\");\n\twhile (stream.matchText(\",\")) expectExpression(ctx, \"Expected expression after ',' in case values\");\n}\n/**\n* Grammar: case_clause : 'case' case_selectors ':'? compound_statement\n* Grammar: default_alone_clause : 'default' ':'? compound_statement\n*/\nfunction parseCaseBody(ctx, errorMsg) {\n\tctx.stream.matchText(\":\");\n\tconst bodyAttrs = parseAttributeList(ctx);\n\tconst body = parseCompoundStatement(ctx, bodyAttrs.length > 0 ? bodyAttrs : void 0);\n\tif (!body) throwParseError(ctx.stream, errorMsg);\n\tctx.addElem(body);\n}\n\n//#endregion\n//#region src/parse/ParseValueDeclaration.ts\n/** Grammar: 'const' optionally_typed_ident '=' expression (global or local) */\nfunction parseConstDecl(ctx, attributes) {\n\treturn parseValueDecl(ctx, \"const\", true, isModuleScope(ctx), attributes);\n}\n/** Grammar: 'override' optionally_typed_ident ( '=' expression )? */\nfunction parseOverrideDecl(ctx, attributes) {\n\treturn parseValueDecl(ctx, \"override\", false, true, attributes);\n}\n/** Grammar: optionally_typed_ident : ident ( ':' type_specifier )? */\nfunction parseTypedDecl(ctx, isGlobal = true) {\n\tconst nameToken = ctx.stream.matchKind(\"word\");\n\tif (!nameToken) return null;\n\tconst start = nameToken.span[0];\n\tbeginElem(ctx, \"typeDecl\");\n\tconst decl = createDeclIdentElem(ctx, nameToken, isGlobal);\n\tctx.addElem(decl);\n\tctx.saveIdent(decl.ident);\n\tconst { typeRef, typeScope } = parseOptionalType(ctx);\n\tconst end = ctx.stream.checkpoint();\n\treturn {\n\t\tkind: \"typeDecl\",\n\t\tdecl,\n\t\ttypeRef,\n\t\ttypeScope,\n\t\tstart,\n\t\tend,\n\t\tcontents: finishContents(ctx, start, end)\n\t};\n}\n/** Shared parser for const/override declarations. */\nfunction parseValueDecl(ctx, keyword, requiresInit, isGlobal, attributes) {\n\tconst { stream } = ctx;\n\tconst token = stream.matchText(keyword);\n\tif (!token) return null;\n\tconst startPos = getStartWithAttributes(attributes, token.span[0]);\n\tctx.pushScope(\"partial\");\n\tbeginElem(ctx, keyword, attributes);\n\tconst typedDecl = parseTypedDecl(ctx, isGlobal);\n\tif (!typedDecl) throwParseError(stream, `Expected identifier after '${keyword}'`);\n\tctx.addElem(typedDecl);\n\tif (requiresInit) {\n\t\texpect(stream, \"=\", `${keyword} identifier`);\n\t\texpectExpression(ctx);\n\t} else if (stream.matchText(\"=\")) expectExpression(ctx);\n\texpect(stream, \";\", `${keyword} declaration`);\n\tconst endPos = stream.checkpoint();\n\tconst contents = finishContents(ctx, startPos, endPos);\n\ttypedDecl.decl.ident.dependentScope = ctx.currentScope();\n\tctx.popScope();\n\tconst elem = {\n\t\tkind: keyword,\n\t\tname: typedDecl,\n\t\tstart: startPos,\n\t\tend: endPos,\n\t\tcontents\n\t};\n\tattachAttributes(elem, attributes);\n\tlinkDeclIdent(typedDecl, elem);\n\treturn elem;\n}\n/** @return true if ctx is at module level (not inside fn/block) */\nfunction isModuleScope(ctx) {\n\tlet scope = ctx.currentScope();\n\twhile (scope.kind === \"partial\" && scope.parent) scope = scope.parent;\n\treturn scope.parent === null;\n}\n/** Parse optional ': type' annotation, managing scope for type references. */\nfunction parseOptionalType(ctx) {\n\tif (!ctx.stream.matchText(\":\")) return {};\n\tctx.pushScope();\n\tconst typeRef = parseSimpleTypeRef(ctx);\n\tif (!typeRef) throwParseError(ctx.stream, \"Expected type after ':'\");\n\tctx.addElem(typeRef);\n\tconst typeScope = ctx.currentScope();\n\tctx.popScope();\n\treturn {\n\t\ttypeRef,\n\t\ttypeScope\n\t};\n}\n\n//#endregion\n//#region src/parse/ParseGlobalVar.ts\n/**\n* Grammar: global_variable_decl : attribute* variable_decl ( '=' expression )?\n* Grammar: variable_decl : 'var' template_list? optionally_typed_ident\n*/\nfunction parseGlobalVarDecl(ctx, attributes) {\n\tconst { stream } = ctx;\n\tconst varToken = stream.matchText(\"var\");\n\tif (!varToken) return null;\n\tconst startPos = getStartWithAttributes(attributes, varToken.span[0]);\n\tctx.pushScope(\"partial\");\n\tbeginElem(ctx, \"gvar\", attributes);\n\tskipTemplateList(ctx);\n\tconst typedDecl = parseTypedDecl(ctx);\n\tif (!typedDecl) throwParseError(stream, \"Expected identifier after 'var'\");\n\tctx.addElem(typedDecl);\n\tif (stream.matchText(\"=\")) expectExpression(ctx);\n\texpect(stream, \";\", \"var declaration\");\n\ttypedDecl.decl.ident.dependentScope = ctx.currentScope();\n\tctx.popScope();\n\tconst varElem = finishElem(\"gvar\", startPos, ctx, { name: typedDecl });\n\tattachAttributes(varElem, attributes);\n\tlinkDeclIdent(typedDecl, varElem);\n\treturn varElem;\n}\n/** Grammar: 'alias' ident '=' type_specifier */\nfunction parseAliasDecl(ctx, attributes) {\n\tconst { stream } = ctx;\n\tconst aliasToken = stream.matchText(\"alias\");\n\tif (!aliasToken) return null;\n\tconst startPos = getStartWithAttributes(attributes, aliasToken.span[0]);\n\tbeginElem(ctx, \"alias\", attributes);\n\tconst declIdentElem = createDeclIdentElem(ctx, expectWord(stream, \"Expected identifier after 'alias'\"), true);\n\tctx.addElem(declIdentElem);\n\tctx.saveIdent(declIdentElem.ident);\n\texpect(stream, \"=\", \"alias name\");\n\tctx.pushScope();\n\tconst typeRef = parseSimpleTypeRef(ctx);\n\tif (!typeRef) throwParseError(stream, \"Expected type after '=' in alias declaration\");\n\tctx.addElem(typeRef);\n\tdeclIdentElem.ident.dependentScope = ctx.currentScope();\n\tctx.popScope();\n\texpect(stream, \";\", \"alias declaration\");\n\tconst aliasElem = finishElem(\"alias\", startPos, ctx, {\n\t\tname: declIdentElem,\n\t\ttypeRef\n\t});\n\tattachAttributes(aliasElem, attributes);\n\tlinkDeclIdentElem(declIdentElem, aliasElem);\n\treturn aliasElem;\n}\n/** Grammar: 'const_assert' expression */\nfunction parseConstAssert(ctx, attributes) {\n\tconst assertToken = ctx.stream.matchText(\"const_assert\");\n\tif (!assertToken) return null;\n\tconst startPos = getStartWithAttributes(attributes, assertToken.span[0]);\n\tbeginElem(ctx, \"assert\", attributes);\n\texpectExpression(ctx);\n\texpect(ctx.stream, \";\", \"const_assert expression\");\n\tconst elem = finishElem(\"assert\", startPos, ctx, {});\n\tattachAttributes(elem, attributes);\n\treturn elem;\n}\n/** Skip optional template list (e.g., <storage, read_write>). */\nfunction skipTemplateList(ctx) {\n\tconst { stream } = ctx;\n\tif (!stream.nextTemplateStartToken()) return;\n\twhile (true) {\n\t\tconst next = stream.peek();\n\t\tif (!next) throwParseError(stream, \"Unclosed template in var declaration\");\n\t\tif (next.text.startsWith(\">\")) {\n\t\t\tstream.nextTemplateEndToken();\n\t\t\treturn;\n\t\t}\n\t\tstream.nextToken();\n\t}\n}\n\n//#endregion\n//#region src/parse/ParseLocalVar.ts\n/**\n* Grammar: variable_or_value_statement : variable_decl | variable_decl '=' expression\n* Grammar: variable_decl : 'var' template_list? optionally_typed_ident\n*/\nfunction parseLocalVarDecl(ctx, attributes) {\n\treturn parseVarOrLet(ctx, \"var\", true, false, attributes);\n}\n/** Grammar: 'let' optionally_typed_ident '=' expression */\nfunction parseLetDecl(ctx, attributes) {\n\treturn parseVarOrLet(ctx, \"let\", false, true, attributes);\n}\n/** Shared logic for var/let declarations. */\nfunction parseVarOrLet(ctx, keyword, hasTemplate, requiresInit, attributes) {\n\tconst { stream } = ctx;\n\tconst token = stream.matchText(keyword);\n\tif (!token) return null;\n\tconst startPos = getStartWithAttributes(attributes, token.span[0]);\n\tbeginElem(ctx, keyword, attributes);\n\tif (hasTemplate) skipTemplateList(ctx);\n\tconst typedDecl = parseTypedDecl(ctx, false);\n\tif (!typedDecl) throwParseError(stream, `Expected identifier after '${keyword}'`);\n\tctx.addElem(typedDecl);\n\tif (requiresInit) {\n\t\texpect(stream, \"=\", `${keyword} identifier (${keyword} requires initialization)`);\n\t\texpectExpression(ctx);\n\t} else if (stream.matchText(\"=\")) expectExpression(ctx);\n\texpect(stream, \";\", `${keyword} declaration`);\n\tconst elem = finishElem(keyword, startPos, ctx, { name: typedDecl });\n\tattachAttributes(elem, attributes);\n\tlinkDeclIdent(typedDecl, elem);\n\treturn elem;\n}\n\n//#endregion\n//#region src/parse/ParseSimpleStatement.ts\nconst assignmentOps = new Set([\n\t\"=\",\n\t\"+=\",\n\t\"-=\",\n\t\"*=\",\n\t\"/=\",\n\t\"%=\",\n\t\"&=\",\n\t\"|=\",\n\t\"^=\",\n\t\"<<=\",\n\t\">>=\"\n]);\n/**\n* Grammar: return_statement : 'return' expression?\n* Grammar: break_statement : 'break' | 'break' 'if' expression\n* Grammar: continue_statement : 'continue'\n* Grammar: variable_updating_statement : assignment_statement | increment_statement | decrement_statement\n* Grammar: func_call_statement : call_phrase\n*/\nfunction parseSimpleStatement(ctx, attributes) {\n\tconst { stream } = ctx;\n\tconst startPos = getStartWithAttributes(attributes, stream.checkpoint());\n\treturn parseReturnStmt(ctx, startPos, attributes) || parseBreakStmt(ctx, startPos, attributes) || parseKeywordStmt(ctx, startPos, attributes, \"continue\") || parseKeywordStmt(ctx, startPos, attributes, \"discard\") || parseEmptyStmt(stream, startPos) || parsePhonyAssignment(ctx, startPos, attributes) || parseExpressionStmt(ctx, startPos, attributes);\n}\n/** Grammar: return_statement : 'return' expression? ';' */\nfunction parseReturnStmt(ctx, startPos, attributes) {\n\tconst { stream } = ctx;\n\tif (!stream.matchText(\"return\")) return null;\n\tbeginElem(ctx, \"statement\", attributes);\n\tconst expr = parseExpression(ctx);\n\tif (expr && ctx.options.preserveExpressions) ctx.addElem(expr);\n\texpect(stream, \";\", \"return statement\");\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/**\n* Grammar: break_statement : 'break' ';'\n* Grammar: break_if_statement : 'break' 'if' expression ';'\n*/\nfunction parseBreakStmt(ctx, startPos, attributes) {\n\tconst { stream } = ctx;\n\tif (!stream.matchText(\"break\")) return null;\n\tbeginElem(ctx, \"statement\", attributes);\n\tif (stream.matchText(\"if\")) expectExpression(ctx, \"Expected condition after 'break if'\");\n\texpect(stream, \";\", \"break statement\");\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Grammar: continue_statement : 'continue' ';' also handles 'discard' */\nfunction parseKeywordStmt(ctx, startPos, attributes, keyword) {\n\tconst { stream } = ctx;\n\tif (!stream.matchText(keyword)) return null;\n\tbeginElem(ctx, \"statement\", attributes);\n\texpect(stream, \";\", `${keyword} statement`);\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Parse empty statement (just ';'). */\nfunction parseEmptyStmt(stream, start) {\n\tif (!stream.matchText(\";\")) return null;\n\treturn {\n\t\tkind: \"statement\",\n\t\tstart,\n\t\tend: stream.checkpoint(),\n\t\tcontents: []\n\t};\n}\n/** Grammar: assignment_statement : '_' '=' expression ';' (phony assignment) */\nfunction parsePhonyAssignment(ctx, startPos, attributes) {\n\tconst { stream } = ctx;\n\tif (!stream.matchText(\"_\")) return null;\n\tif (!parseAssignmentOperator(stream)) throwParseError(stream, \"Expected assignment operator after '_'\");\n\tbeginElem(ctx, \"statement\", attributes);\n\texpectExpression(ctx, \"Expected expression after assignment operator\");\n\texpect(stream, \";\", \"assignment\");\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/**\n* Parses expression statements: assignments, increments/decrements, or function calls.\n* Grammar: ( assignment_statement | increment_statement | decrement_statement | call_phrase ) ';'\n*/\nfunction parseExpressionStmt(ctx, startPos, attributes) {\n\tconst { stream } = ctx;\n\tbeginElem(ctx, \"statement\", attributes);\n\tconst expr = parseExpression(ctx);\n\tif (!expr) {\n\t\tfinishContents(ctx, startPos, startPos);\n\t\tstream.reset(startPos);\n\t\treturn null;\n\t}\n\tif (ctx.options.preserveExpressions) ctx.addElem(expr);\n\tif (!parseIncDecOperator(stream)) parseAssignmentRhs(ctx);\n\texpect(stream, \";\", \"expression\");\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Grammar: assignment_statement : lhs_expression ( '=' | compound_assignment_operator ) expression */\nfunction parseAssignmentOperator(stream) {\n\treturn !!stream.nextIf(({ text }) => assignmentOps.has(text));\n}\n/** Grammar: ( '=' | compound_assignment_operator ) expression (rhs of assignment_statement) */\nfunction parseAssignmentRhs(ctx) {\n\tif (!parseAssignmentOperator(ctx.stream)) return false;\n\texpectExpression(ctx, \"Expected expression after assignment operator\");\n\treturn true;\n}\n/** Grammar: increment_statement : lhs_expression '++' ; decrement_statement : lhs_expression '--' */\nfunction parseIncDecOperator(stream) {\n\treturn !!stream.nextIf(({ text }) => text === \"++\" || text === \"--\");\n}\n\n//#endregion\n//#region src/parse/ParseLoop.ts\n/**\n* Grammar: for_statement : attribute* 'for' '(' for_header ')' compound_statement\n* Grammar: for_header : for_init? ';' expression? ';' for_update?\n*/\nfunction parseForStatement(ctx, attributes) {\n\tconst { stream } = ctx;\n\tconst startPos = beginStatement(ctx, \"for\", attributes);\n\tif (startPos === null) return null;\n\tctx.pushScope();\n\texpect(stream, \"(\", \"'for'\");\n\tparseForInit(ctx);\n\tconst cond = parseExpression(ctx);\n\tif (cond && ctx.options.preserveExpressions) ctx.addElem(cond);\n\texpect(stream, \";\", \"for loop condition\");\n\tparseForUpdate(ctx);\n\texpect(stream, \")\", \"for loop header\");\n\tconst body = expectCompound(ctx, \"Expected '{' after for loop header\");\n\tctx.addElem(body);\n\tctx.popScope();\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Grammar: while_statement : attribute* 'while' expression compound_statement */\nfunction parseWhileStatement(ctx, attributes) {\n\tconst startPos = beginStatement(ctx, \"while\", attributes);\n\tif (startPos === null) return null;\n\texpectExpression(ctx, \"Expected condition expression after 'while'\");\n\tconst body = expectCompound(ctx, \"Expected '{' after while condition\");\n\tctx.addElem(body);\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Grammar: loop_statement : attribute* 'loop' attribute* '{' statement* continuing_statement? '}' */\nfunction parseLoopStatement(ctx, attributes) {\n\tconst startPos = beginStatement(ctx, \"loop\", attributes);\n\tif (startPos === null) return null;\n\tconst body = expectCompound(ctx, \"Expected '{' after 'loop'\", true);\n\tctx.addElem(body);\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Grammar: continuing_statement : 'continuing' continuing_compound_statement */\nfunction parseContinuingStatement(ctx, attributes) {\n\tconst startPos = beginStatement(ctx, \"continuing\", attributes, \"continuing\");\n\tif (startPos === null) return null;\n\tconst body = expectCompound(ctx, \"Expected '{' after 'continuing'\");\n\tctx.addElem(body);\n\treturn finishBlockStatement(startPos, ctx, attributes, \"continuing\");\n}\n/** Grammar: for_init? ';'\n*           for_init : variable_or_value_statement | variable_updating_statement | func_call_statement\n*/\nfunction parseForInit(ctx) {\n\tconst { stream } = ctx;\n\tconst varDecl = parseLocalVarDecl(ctx);\n\tif (varDecl) ctx.addElem(varDecl);\n\telse {\n\t\tconst expr = parseExpression(ctx);\n\t\tif (expr && ctx.options.preserveExpressions) ctx.addElem(expr);\n\t\texpect(stream, \";\", \"for loop init\");\n\t}\n}\n/** Grammar: for_update : variable_updating_statement | func_call_statement\n*           variable_updating_statement : assignment_statement | increment_statement | decrement_statement */\nfunction parseForUpdate(ctx) {\n\tconst expr = parseExpression(ctx);\n\tif (expr && ctx.options.preserveExpressions) ctx.addElem(expr);\n\tparseIncDecOperator(ctx.stream) || parseAssignmentRhs(ctx);\n}\n\n//#endregion\n//#region src/parse/ParseStatement.ts\n/** Function bodies share scope with parameters (per WGSL spec). */\nfunction parseFunctionBody(ctx) {\n\treturn parseCompoundStatement(ctx, void 0, { noScope: true });\n}\n/**\n* Grammar: '{' statement* '}' (attributes parsed by caller)\n* For loop bodies: '{' statement* continuing_statement? '}'\n*/\nfunction parseCompoundStatement(ctx, attributes, options) {\n\tconst brace = ctx.stream.matchText(\"{\");\n\tif (!brace) return null;\n\tconst startPos = getStartWithAttributes(attributes, brace.span[0]);\n\tbeginElem(ctx, \"statement\", attributes);\n\tconst skipScope = options?.noScope || hasConditionalAttr(attributes);\n\tif (!skipScope) ctx.pushScope();\n\tparseBlockStatements(ctx, options?.loopBody);\n\tif (!skipScope) ctx.popScope();\n\treturn finishBlockStatement(startPos, ctx, attributes);\n}\n/** Grammar: attribute* compound_statement (for control flow bodies) */\nfunction expectCompound(ctx, errorMsg, loopBody) {\n\tconst attrs = parseAttributeList(ctx);\n\tconst block = parseCompoundStatement(ctx, attrs.length > 0 ? attrs : void 0, loopBody ? { loopBody } : void 0);\n\tif (!block) throwParseError(ctx.stream, errorMsg);\n\treturn block;\n}\n/** Get start position from first attribute, or keyword position. */\nfunction getStartWithAttributes(attributes, keywordPos) {\n\treturn attributes?.[0]?.start ?? keywordPos;\n}\n/** Match keyword and begin statement element. Returns start position or null. */\nfunction beginStatement(ctx, keyword, attributes, kind = \"statement\") {\n\tconst keywordPos = ctx.stream.checkpoint();\n\tif (!ctx.stream.matchText(keyword)) return null;\n\tconst startPos = getStartWithAttributes(attributes, keywordPos);\n\tbeginElem(ctx, kind, attributes);\n\treturn startPos;\n}\nfunction finishBlockStatement(start, ctx, attributes, kind = \"statement\") {\n\tconst elem = finishElem(kind, start, ctx, {});\n\tattachAttributes(elem, attributes);\n\treturn elem;\n}\nfunction hasConditionalAttr(attributes) {\n\treturn !!attributes && hasConditionalAttribute(attributes);\n}\n/** Grammar: statement* '}' (after '{' consumed). Loop bodies may end with continuing. */\nfunction parseBlockStatements(ctx, loopBody) {\n\tconst { stream } = ctx;\n\twhile (true) {\n\t\tif (stream.matchText(\"}\")) break;\n\t\tconst stmt = parseStatement(ctx);\n\t\tif (!stmt) throwParseError(stream, \"Expected statement or '}'\");\n\t\tctx.addElem(stmt);\n\t\tif (loopBody && stmt.kind === \"continuing\") {\n\t\t\texpect(stream, \"}\", \"continuing block\");\n\t\t\tbreak;\n\t\t}\n\t}\n}\n/**\n* Grammar: statement :\n*   ';' | return_statement ';' | if_statement | switch_statement | loop_statement\n*   | for_statement | while_statement | func_call_statement ';'\n*   | variable_or_value_statement ';' | break_statement ';' | continue_statement ';'\n*   | 'discard' ';' | variable_updating_statement ';' | compound_statement\n*   | const_assert_statement ';'\n*/\nfunction parseStatement(ctx) {\n\tconst { stream } = ctx;\n\tconst startPos = stream.checkpoint();\n\tconst attributes = parseAttributeList(ctx);\n\tconst token = stream.peek();\n\tif (!token || token.text === \"}\") {\n\t\tstream.reset(startPos);\n\t\treturn null;\n\t}\n\tconst hasConditional = attributes.length > 0 && hasConditionalAttribute(attributes);\n\tif (hasConditional) ctx.pushScope(\"partial\");\n\tconst attrsOrUndef = attributes.length > 0 ? attributes : void 0;\n\tconst stmt = findMap([\n\t\tparseLocalVarDecl,\n\t\tparseLetDecl,\n\t\tparseConstDecl,\n\t\tparseConstAssert,\n\t\tparseCompoundStatement,\n\t\tparseIfStatement,\n\t\tparseSwitchStatement,\n\t\tparseForStatement,\n\t\tparseWhileStatement,\n\t\tparseLoopStatement,\n\t\tparseContinuingStatement,\n\t\tparseSimpleStatement\n\t], (p) => p(ctx, attrsOrUndef));\n\tif (!stmt) return null;\n\tfinalizeConditional$1(ctx, hasConditional, attributes);\n\treturn stmt;\n}\nfunction finalizeConditional$1(ctx, hasConditional, attributes) {\n\tif (hasConditional) {\n\t\tconst partialScope = ctx.popScope();\n\t\tpartialScope.condAttribute = getConditionalAttribute(attributes);\n\t}\n}\nfunction getConditionalAttribute(attributes) {\n\treturn attributes.find((a) => isConditionalAttribute$1(a.attribute))?.attribute;\n}\n\n//#endregion\n//#region src/parse/ParseFn.ts\n/**\n* Grammar: function_decl : attribute* function_header compound_statement\n* Grammar: function_header : 'fn' ident '(' param_list? ')' ( '->' attribute* template_elaborated_ident )?\n* Grammar: param_list : param ( ',' param )* ','?\n*/\nfunction parseFnDecl(ctx, attributes) {\n\tconst { stream } = ctx;\n\tconst fnToken = stream.matchText(\"fn\");\n\tif (!fnToken) return null;\n\tconst startPos = getStartWithAttributes(attributes, fnToken.span[0]);\n\tconst declIdentElem = createDeclIdentElem(ctx, expectWord(stream, \"Expected identifier after 'fn'\"), true);\n\tctx.saveIdent(declIdentElem.ident);\n\tctx.pushScope();\n\tconst dependentScope = ctx.currentScope();\n\tctx.pushScope();\n\tconst params = parseFnParams(ctx);\n\tconst bodyScope = ctx.currentScope();\n\tctx.state.context.scope = dependentScope;\n\tconst { returnType, returnAttributes } = parseFnReturn(ctx);\n\tctx.state.context.scope = bodyScope;\n\tconst body = parseFunctionBody(ctx);\n\tif (!body) throwParseError(stream, \"Expected function body\");\n\tctx.popScope();\n\tdeclIdentElem.ident.dependentScope = ctx.currentScope();\n\tctx.popScope();\n\tconst fnElem = {\n\t\tkind: \"fn\",\n\t\tname: declIdentElem,\n\t\tparams,\n\t\tbody,\n\t\treturnType,\n\t\treturnAttributes,\n\t\tstart: startPos,\n\t\tend: stream.checkpoint(),\n\t\tcontents: buildFnContents(attributes, declIdentElem, params, returnType, body)\n\t};\n\tattachAttributes(fnElem, attributes);\n\tlinkDeclIdentElem(declIdentElem, fnElem);\n\treturn fnElem;\n}\n/** Grammar: '(' param_list? ')' where param_list : param ( ',' param )* ','? */\nfunction parseFnParams(ctx) {\n\tconst { stream } = ctx;\n\tconst params = [];\n\texpect(stream, \"(\", \"function name\");\n\twhile (!stream.matchText(\")\")) {\n\t\tconst param = parseFnParam(ctx);\n\t\tif (!param) throwParseError(stream, \"Expected function parameter or ')'\");\n\t\tparams.push(param);\n\t\tif (stream.matchText(\",\")) continue;\n\t\texpect(stream, \")\", \"function parameter\");\n\t\tbreak;\n\t}\n\treturn params;\n}\n/** Grammar: ( '->' attribute* type_specifier )? */\nfunction parseFnReturn(ctx) {\n\tconst { stream } = ctx;\n\tif (!stream.matchText(\"->\")) return {};\n\tconst attrs = parseAttributeList(ctx);\n\tconst returnType = parseSimpleTypeRef(ctx);\n\tif (!returnType) throwParseError(stream, \"Expected type after '->'\");\n\treturn {\n\t\treturnType,\n\t\treturnAttributes: attrs.length > 0 ? attrs : void 0\n\t};\n}\n/** Build contents array for function element */\nfunction buildFnContents(attributes, decl, params, returnType, body) {\n\tconst base = returnType ? [\n\t\tdecl,\n\t\t...params,\n\t\treturnType,\n\t\tbody\n\t] : [\n\t\tdecl,\n\t\t...params,\n\t\tbody\n\t];\n\treturn attributes?.length ? [...attributes, ...base] : base;\n}\n/** Grammar: param : attribute* optionally_typed_ident */\nfunction parseFnParam(ctx) {\n\tconst attributes = parseAttributeList(ctx);\n\tif (ctx.stream.peek()?.kind !== \"word\") return null;\n\tbeginElem(ctx, \"param\", attributes.length ? attributes : void 0);\n\tconst name = parseTypedDecl(ctx, false);\n\tif (!name) throw new Error(\"Unexpected: peek succeeded but parseTypedDecl failed\");\n\tctx.addElem(name);\n\tconst elem = finishElem(\"param\", getStartWithAttributes(attributes, name.start), ctx, { name });\n\tlinkDeclIdent(name, elem);\n\tattachAttributes(elem, attributes.length > 0 ? attributes : void 0);\n\treturn elem;\n}\n\n//#endregion\n//#region src/parse/ParseImport.ts\n/** WESL Grammar: translation_unit : import_statement* global_directive* global_decl* */\nfunction parseWeslImports(ctx) {\n\treturn [...parseMany(ctx, parseImportStatement)];\n}\n/** Grammar: import_statement : conditional_attribute? 'import' import_relative? (import_collection | import_path_or_item) ';' */\nfunction parseImportStatement(ctx) {\n\tconst { stream } = ctx;\n\tconst condAttr = parseWeslConditional(ctx);\n\tconst parseResult = parseImportStatementBase(stream);\n\tif (!parseResult) {\n\t\tif (condAttr) stream.reset(condAttr.start);\n\t\treturn null;\n\t}\n\tconst { statement: imports, importPos } = parseResult;\n\treturn {\n\t\tkind: \"import\",\n\t\timports,\n\t\tstart: condAttr?.start ?? importPos,\n\t\tend: stream.checkpoint(),\n\t\tattributes: condAttr ? [condAttr] : void 0\n\t};\n}\n/** Parse: import <relative>? <collection_or_path> ';' */\nfunction parseImportStatementBase(stream) {\n\tconst importToken = stream.matchText(\"import\");\n\tif (!importToken) return null;\n\tconst relative = parseImportRelative(stream) ?? [];\n\tconst parsed = parseImportCollection(stream) || parseImportPathOrItem(stream);\n\tif (!parsed) throwParseError(stream, \"invalid import, expected { or name\");\n\tif (!stream.matchText(\";\")) throwParseError(stream, \"invalid import, expected ';'\");\n\treturn {\n\t\tstatement: parsed.kind === \"import-statement\" ? prependSegments(relative, parsed) : makeStatement(relative, parsed),\n\t\timportPos: importToken.span[0]\n\t};\n}\n/** WESL Grammar: import_relative : 'package' '::' | 'super' '::' ('super' '::')* */\nfunction parseImportRelative(stream) {\n\tif (stream.matchSequence(\"package\", \"::\")) return [makeSegment(\"package\")];\n\tconst segments = [];\n\twhile (stream.matchSequence(\"super\", \"::\")) segments.push(makeSegment(\"super\"));\n\treturn segments.length > 0 ? segments : null;\n}\n/** WESL Grammar: import_collection : '{' import_path_or_item (',' import_path_or_item)* ','? '}' */\nfunction parseImportCollection(stream) {\n\tif (!stream.matchText(\"{\")) return null;\n\tconst msg = \"invalid import collection, expected name\";\n\tconst first = parseImportPathOrItem(stream);\n\tif (!first) throwParseError(stream, msg);\n\tconst statements = [first];\n\twhile (stream.matchText(\",\")) {\n\t\tif (stream.peek()?.text === \"}\") break;\n\t\tconst item = parseImportPathOrItem(stream);\n\t\tif (!item) throwParseError(stream, msg + \" after ','\");\n\t\tstatements.push(item);\n\t}\n\tif (!stream.matchText(\"}\")) throwParseError(stream, \"invalid import collection, expected }\");\n\treturn makeCollection(statements);\n}\n/**\n* WESL Grammar: import_path_or_item :\n*   ident '::' (import_collection | import_path_or_item) | ident ('as' ident)?\n*/\nfunction parseImportPathOrItem(stream) {\n\tconst name = parsePackageWord(stream);\n\tif (!name) return null;\n\tif (stream.matchText(\"::\")) {\n\t\tconst segment = makeSegment(name);\n\t\tconst collection = parseImportCollection(stream);\n\t\tif (collection) return makeStatement([segment], collection);\n\t\tconst pathOrItem = parseImportPathOrItem(stream);\n\t\tif (pathOrItem) return prependSegments([segment], pathOrItem);\n\t\tthrowParseError(stream, \"invalid import, expected '{' or name\");\n\t}\n\tif (stream.matchText(\"as\")) {\n\t\tconst alias = stream.matchKind(\"word\");\n\t\tif (!alias) throwParseError(stream, \"invalid alias, expected name\");\n\t\treturn makeStatement([], makeImportItem(name, alias.text));\n\t}\n\treturn makeStatement([], makeImportItem(name));\n}\n/** Prepend path segments to an existing statement */\nfunction prependSegments(segments, statement) {\n\treturn {\n\t\t...statement,\n\t\tsegments: segments.concat(statement.segments)\n\t};\n}\nfunction makeStatement(segments, finalSegment) {\n\treturn {\n\t\tkind: \"import-statement\",\n\t\tsegments,\n\t\tfinalSegment\n\t};\n}\nfunction makeSegment(name) {\n\treturn {\n\t\tkind: \"import-segment\",\n\t\tname\n\t};\n}\nfunction makeCollection(subtrees) {\n\treturn {\n\t\tkind: \"import-collection\",\n\t\tsubtrees\n\t};\n}\n/** @return word/keyword token text usable in import path, or null if it's a WESL keyword */\nfunction parsePackageWord(stream) {\n\tconst token = stream.peek();\n\tif (!token) return null;\n\tconst { text, kind } = token;\n\tif (kind !== \"word\" && kind !== \"keyword\") return null;\n\tif (weslKeywords.has(text)) return null;\n\tstream.nextToken();\n\treturn text;\n}\nfunction makeImportItem(name, as) {\n\treturn {\n\t\tkind: \"import-item\",\n\t\tname,\n\t\tas\n\t};\n}\n\n//#endregion\n//#region src/parse/ParseStruct.ts\n/**\n* Grammar: struct_decl : 'struct' ident struct_body_decl\n* Grammar: struct_body_decl : '{' struct_member ( ',' struct_member )* ','? '}'\n*/\nfunction parseStructDecl(ctx, attributes) {\n\tconst { stream } = ctx;\n\tconst structToken = stream.matchText(\"struct\");\n\tif (!structToken) return null;\n\tconst start = getStartWithAttributes(attributes, structToken.span[0]);\n\tconst identElem = createDeclIdentElem(ctx, expectWord(stream, \"Expected identifier after 'struct'\"), true);\n\tctx.saveIdent(identElem.ident);\n\tbeginElem(ctx, \"struct\", attributes);\n\tctx.addElem(identElem);\n\texpect(stream, \"{\", \"struct name\");\n\tctx.pushScope();\n\tconst members = parseStructMembers(ctx);\n\tidentElem.ident.dependentScope = ctx.currentScope();\n\tctx.popScope();\n\texpect(stream, \"}\", \"struct member\");\n\tconst elem = finishElem(\"struct\", start, ctx, {\n\t\tname: identElem,\n\t\tmembers\n\t});\n\tattachAttributes(elem, attributes);\n\tlinkDeclIdentElem(identElem, elem);\n\treturn elem;\n}\n/** Grammar: struct_body_decl : '{' struct_member (',' struct_member)* ','? '}' */\nfunction parseStructMembers(ctx) {\n\tconst members = parseCommaList(ctx, parseStructMember);\n\tfor (const member of members) ctx.addElem(member);\n\treturn members;\n}\n/** Grammar: struct_member : attribute* member_ident ':' type_specifier */\nfunction parseStructMember(ctx) {\n\tconst { stream } = ctx;\n\tconst checkpoint = stream.checkpoint();\n\tconst attributes = parseAttributeList(ctx);\n\tconst nameToken = stream.matchKind(\"word\");\n\tif (!nameToken) {\n\t\tstream.reset(checkpoint);\n\t\treturn null;\n\t}\n\tconst start = getStartWithAttributes(attributes, nameToken.span[0]);\n\tbeginElem(ctx, \"member\", attributes.length ? attributes : void 0);\n\tconst name = makeNameElem(nameToken);\n\tctx.addElem(name);\n\texpect(stream, \":\", \"struct member name\");\n\tconst typeRef = parseSimpleTypeRef(ctx);\n\tif (!typeRef) throwParseError(stream, \"Expected type after ':'\");\n\tctx.addElem(typeRef);\n\tconst elem = finishElem(\"member\", start, ctx, {\n\t\tname,\n\t\ttypeRef\n\t});\n\tattachAttributes(elem, attributes.length ? attributes : void 0);\n\treturn elem;\n}\n\n//#endregion\n//#region src/parse/ParseModule.ts\nconst declParsers = [\n\tparseConstDecl,\n\tparseOverrideDecl,\n\tparseGlobalVarDecl,\n\tparseAliasDecl,\n\tparseStructDecl,\n\tparseFnDecl,\n\tparseConstAssert\n];\n/** Grammar: translation_unit : global_directive* ( global_decl | global_assert | ';' )* */\nfunction parseModule(ctx) {\n\tparseImports(ctx);\n\tparseDirectives(ctx);\n\twhile (parseNextDeclaration(ctx));\n}\n/** Parse WESL import statements at the start of the module. */\nfunction parseImports(ctx) {\n\tconst importElems = parseWeslImports(ctx);\n\tfor (const importElem of importElems) {\n\t\tctx.addElem(importElem);\n\t\tctx.state.stable.imports.push(importElem.imports);\n\t}\n}\n/** Grammar: global_directive : diagnostic_directive | enable_directive | requires_directive */\nfunction parseDirectives(ctx) {\n\tconst directives = parseMany(ctx, parseDirective);\n\tfor (const elem of directives) ctx.addElem(elem);\n}\n/** Parse one declaration, return true if more may exist. */\nfunction parseNextDeclaration(ctx) {\n\tconst { stream } = ctx;\n\tif (stream.matchText(\";\")) return true;\n\tconst attrs = parseAttributeList(ctx);\n\tconst hasConditional = hasConditionalAttribute(attrs);\n\tif (hasConditional) ctx.pushScope(\"partial\");\n\tconst parsed = parseDecl(ctx, attrs);\n\tif (hasConditional && parsed) finalizeConditional(ctx, attrs);\n\tif (parsed) return true;\n\tif (attrs.length) throwParseError(stream, \"Expected declaration after attributes\");\n\treturn false;\n}\n/** Try each declaration parser until one succeeds. */\nfunction parseDecl(ctx, attrs) {\n\tconst attrsOrUndef = attrs.length ? attrs : void 0;\n\tconst elem = findMap(declParsers, (p) => p(ctx, attrsOrUndef));\n\tif (elem) {\n\t\trecordDecl(ctx, elem, attrs);\n\t\treturn true;\n\t}\n\treturn false;\n}\n/** Pop conditional scope and attach the conditional attribute. */\nfunction finalizeConditional(ctx, attrs) {\n\tconst partialScope = ctx.popScope();\n\tpartialScope.condAttribute = findMap(attrs, ({ attribute }) => isConditionalAttribute(attribute) ? attribute : void 0);\n}\n/** Record a parsed declaration, extending start to include attributes. */\nfunction recordDecl(ctx, elem, attrs) {\n\tif (attrs.length && elem.start > attrs[0].start) elem.start = attrs[0].start;\n\tctx.addElem(elem);\n\tif (elem.kind === \"assert\") {\n\t\tconst { stable } = ctx.state;\n\t\tstable.moduleAsserts ??= [];\n\t\tstable.moduleAsserts.push(elem);\n\t}\n}\nfunction isConditionalAttribute(a) {\n\treturn a.kind === \"@if\" || a.kind === \"@elif\" || a.kind === \"@else\";\n}\n\n//#endregion\n//#region src/parse/ParsingContext.ts\n/** Context for parsers to build AST and manage scopes. */\nvar ParsingContext = class {\n\tsrc;\n\tsrcModule;\n\tstream;\n\tstate;\n\toptions;\n\tconstructor(stream, state, options) {\n\t\tthis.stream = stream;\n\t\tthis.state = state;\n\t\tthis.srcModule = state.stable.srcModule;\n\t\tthis.src = this.srcModule.src;\n\t\tthis.options = options ?? {};\n\t}\n\tposition() {\n\t\treturn this.stream.checkpoint();\n\t}\n\tcurrentScope() {\n\t\treturn this.state.context.scope;\n\t}\n\taddElem(elem) {\n\t\tconst { openElems } = this.state.context;\n\t\tif (openElems.length > 0) openElems[openElems.length - 1].contents.push(elem);\n\t}\n\tpushScope(kind = \"scope\") {\n\t\tconst { scope } = this.state.context;\n\t\tconst newScope = emptyScope(scope, kind);\n\t\tscope.contents.push(newScope);\n\t\tthis.state.context.scope = newScope;\n\t}\n\tpopScope() {\n\t\tconst weslContext = this.state.context;\n\t\tconst completedScope = weslContext.scope;\n\t\tif (completedScope.parent) weslContext.scope = completedScope.parent;\n\t\treturn completedScope;\n\t}\n\tisModuleScope() {\n\t\tlet scope = this.currentScope();\n\t\twhile (scope.kind === \"partial\" && scope.parent) scope = scope.parent;\n\t\treturn scope.parent === null;\n\t}\n\t/** Attribute name being parsed (for marking refs in attr params). */\n\tparsingAttrParam;\n\tcreateRefIdent(name) {\n\t\tconst ref = {\n\t\t\tkind: \"ref\",\n\t\t\toriginalName: name,\n\t\t\tast: this.state.stable,\n\t\t\tid: nextIdentId(),\n\t\t\trefIdentElem: null\n\t\t};\n\t\tif (this.parsingAttrParam) ref.attrParam = this.parsingAttrParam;\n\t\treturn ref;\n\t}\n\tcreateDeclIdent(name, isGlobal = false) {\n\t\treturn {\n\t\t\tkind: \"decl\",\n\t\t\toriginalName: name,\n\t\t\tcontainingScope: this.state.context.scope,\n\t\t\tisGlobal,\n\t\t\tid: nextIdentId(),\n\t\t\tsrcModule: this.srcModule,\n\t\t\tdeclElem: null\n\t\t};\n\t}\n\tsaveIdent(ident) {\n\t\tthis.state.context.scope.contents.push(ident);\n\t}\n};\n\n//#endregion\n//#region src/parse/Keywords.ts\n/** https://www.w3.org/TR/WGSL/#keyword-summary */\nconst keywords = `alias break case const const_assert continue continuing \n  default diagnostic discard else enable false fn for if \n  let loop override requires return struct switch true var while`.split(/\\s+/);\n/** https://www.w3.org/TR/WGSL/#reserved-words */\nconst reservedWords = `NULL Self abstract active alignas alignof as asm asm_fragment async attribute auto await\n  become cast catch class co_await co_return co_yield coherent column_major\n  common compile compile_fragment concept const_cast consteval constexpr constinit crate\n  debugger decltype delete demote demote_to_helper do dynamic_cast\n  enum explicit export extends extern external fallthrough filter final finally friend from fxgroup\n  get goto groupshared highp impl implements import inline instanceof interface layout lowp\n  macro macro_rules match mediump meta mod module move mut mutable\n  namespace new nil noexcept noinline nointerpolation non_coherent noncoherent noperspective null nullptr\n  of operator package packoffset partition pass patch pixelfragment precise precision premerge\n  priv protected pub public readonly ref regardless register reinterpret_cast require resource restrict\n  self set shared sizeof smooth snorm static static_assert static_cast std subroutine super\n  target template this thread_local throw trait try type typedef typeid typename typeof\n  union unless unorm unsafe unsized use using varying virtual volatile wgsl where with writeonly yield`.split(/\\s+/);\n\n//#endregion\n//#region src/parse/stream/CachingStream.ts\nvar CachingStream = class {\n\tcache = new Cache(5);\n\tinner;\n\tconstructor(inner) {\n\t\tthis.inner = inner;\n\t}\n\tcheckpoint() {\n\t\treturn this.inner.checkpoint();\n\t}\n\treset(position) {\n\t\tthis.inner.reset(position);\n\t}\n\tnextToken() {\n\t\tconst startPos = this.checkpoint();\n\t\tconst cachedValue = this.cache.get(startPos);\n\t\tif (cachedValue !== void 0) {\n\t\t\tthis.reset(cachedValue.checkpoint);\n\t\t\treturn cachedValue.token;\n\t\t} else {\n\t\t\tconst token = this.inner.nextToken();\n\t\t\tconst checkpoint = this.checkpoint();\n\t\t\tthis.cache.set(startPos, {\n\t\t\t\ttoken,\n\t\t\t\tcheckpoint\n\t\t\t});\n\t\t\treturn token;\n\t\t}\n\t}\n\tget src() {\n\t\treturn this.inner.src;\n\t}\n};\n/** size limited key value cache */\nvar Cache = class extends Map {\n\tmax;\n\tconstructor(max) {\n\t\tsuper();\n\t\tthis.max = max;\n\t}\n\tset(k, v) {\n\t\tif (this.size > this.max) {\n\t\t\tconst first = this.keys().next().value;\n\t\t\tif (first) this.delete(first);\n\t\t}\n\t\treturn super.set(k, v);\n\t}\n};\n\n//#endregion\n//#region src/parse/stream/RegexHelpers.ts\nfunction toRegexSource(nameExp) {\n\tconst [name, e] = nameExp;\n\tif (typeof e === \"string\") {\n\t\tconst expSrc = `(${escapeRegex(e)})`;\n\t\tverifyNonCapturing(name, new RegExp(expSrc));\n\t\treturn expSrc;\n\t} else {\n\t\tverifyNonCapturing(name, e);\n\t\treturn `(${e.source})`;\n\t}\n}\nfunction verifyNonCapturing(name, exp) {\n\tif (new RegExp(\"|\" + exp.source).exec(\"\").length > 1) throw new Error(`match expression groups must be non-capturing: ${name}: /${exp.source}/. Use (?:...) instead.`);\n}\nconst regexSpecials = /[$+*.?|(){}[\\]\\\\/^]/g;\nfunction escapeRegex(s) {\n\treturn s.replace(regexSpecials, \"\\\\$&\");\n}\n/**\n* @return a regexp to match any of the space separated tokens in the provided string.\n* Regex special characters are escaped, and the matchers are sorted by length\n* so that longer matches are preferred.\n*/\nfunction matchOneOf(syms) {\n\tconst escaped = syms.split(/\\s+/).sort((a, b) => b.length - a.length).filter((s) => s).map(escapeRegex);\n\treturn new RegExp(escaped.join(\"|\"));\n}\n\n//#endregion\n//#region src/parse/stream/MatchersStream.ts\n/** Runs a `RegexMatchers` on an input string */\nvar MatchersStream = class {\n\tposition = 0;\n\ttext;\n\tmatchers;\n\tconstructor(text, matchers) {\n\t\tthis.text = text;\n\t\tthis.matchers = matchers;\n\t}\n\tcheckpoint() {\n\t\treturn this.position;\n\t}\n\treset(position) {\n\t\tthis.position = position;\n\t}\n\tnextToken() {\n\t\tconst result = this.matchers.execAt(this.text, this.position);\n\t\tif (result === null) return null;\n\t\tthis.position = result.span[1];\n\t\treturn result;\n\t}\n\tget src() {\n\t\treturn this.text;\n\t}\n};\n/**\n* The matchers passed to this object must follow certain rules:\n* - They must use non-capturing groups: `(?:...)`\n* - They must NOT use `^` or `$`\n*/\nvar RegexMatchers = class {\n\tgroups;\n\texp;\n\tconstructor(matchers) {\n\t\tthis.groups = Object.keys(matchers);\n\t\tconst expParts = Object.entries(matchers).map(toRegexSource).join(\"|\");\n\t\tthis.exp = new RegExp(expParts, \"dyu\");\n\t}\n\texecAt(text, position) {\n\t\tthis.exp.lastIndex = position;\n\t\tconst matchedIndex = findGroupDex(this.exp.exec(text)?.indices);\n\t\tif (matchedIndex) {\n\t\t\tconst { span, groupDex } = matchedIndex;\n\t\t\treturn {\n\t\t\t\tkind: this.groups[groupDex],\n\t\t\t\tspan,\n\t\t\t\ttext: text.slice(span[0], span[1])\n\t\t\t};\n\t\t} else return null;\n\t}\n};\nfunction findGroupDex(indices) {\n\tif (indices !== void 0) for (let i = 1; i < indices.length; i++) {\n\t\tconst span = indices[i];\n\t\tif (span !== void 0) return {\n\t\t\tspan,\n\t\t\tgroupDex: i - 1\n\t\t};\n\t}\n}\n\n//#endregion\n//#region src/parse/WeslStream.ts\n/** Whitespaces including new lines */\nconst blankspaces = /[ \\t\\n\\v\\f\\r\\u{0085}\\u{200E}\\u{200F}\\u{2028}\\u{2029}]+/u;\nconst symbolSet = \"& && -> @ / ! [ ] { } :: : , == = != >>= >> >= > <<= << <= < % - -- . + ++ | || ( ) ; * ~ ^ // /* */ += -= *= /= %= &= |= ^= _\";\nconst ident = /(?:(?:[_\\p{XID_Start}][\\p{XID_Continue}]+)|(?:[\\p{XID_Start}]))/u;\nconst keywordOrReserved = new Set(keywords.concat(reservedWords));\nconst weslMatcher = new RegexMatchers({\n\tword: ident,\n\tnumber: new RegExp(/(?:0[fh])|(?:[1-9][0-9]*[fh])/.source + /|(?:[0-9]*\\.[0-9]+(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+\\.[0-9]*(?:[eE][+-]?[0-9]+)?[fh]?)/.source + /|(?:[0-9]+[eE][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]*\\.[0-9a-fA-F]+(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+\\.[0-9a-fA-F]*(?:[pP][+-]?[0-9]+[fh]?)?)/.source + /|(?:0[xX][0-9a-fA-F]+[pP][+-]?[0-9]+[fh]?)/.source + /|(?:0[xX][0-9a-fA-F]+[iu]?)/.source + /|(?:0[iu]?)|(?:[1-9][0-9]*[iu]?)/.source),\n\tblankspaces,\n\tcommentStart: /\\/\\/|\\/\\*/,\n\tsymbol: matchOneOf(symbolSet),\n\tinvalid: /[^]/\n});\n/** A stream that produces WESL tokens, skipping over comments and white space */\nvar WeslStream = class {\n\tstream;\n\t/** New line */\n\teolPattern = /[\\n\\v\\f\\u{0085}\\u{2028}\\u{2029}]|\\r\\n?/gu;\n\tblockCommentPattern = /\\/\\*|\\*\\//g;\n\tsrc;\n\tconstructor(src) {\n\t\tthis.src = src;\n\t\tthis.stream = new CachingStream(new MatchersStream(src, weslMatcher));\n\t}\n\tcheckpoint() {\n\t\treturn this.stream.checkpoint();\n\t}\n\treset(position) {\n\t\tthis.stream.reset(position);\n\t}\n\tnextToken() {\n\t\twhile (true) {\n\t\t\tconst token = this.stream.nextToken();\n\t\t\tif (token === null) return null;\n\t\t\tconst kind = token.kind;\n\t\t\tif (kind === \"blankspaces\") continue;\n\t\t\telse if (kind === \"commentStart\") if (token.text === \"//\") this.stream.reset(this.skipToEol(token.span[1]));\n\t\t\telse this.stream.reset(this.skipBlockComment(token.span[1]));\n\t\t\telse if (kind === \"word\") {\n\t\t\t\tconst returnToken = token;\n\t\t\t\tif (keywordOrReserved.has(token.text)) returnToken.kind = \"keyword\";\n\t\t\t\treturn returnToken;\n\t\t\t} else if (kind === \"invalid\") throw new ParseError(\"Invalid token \" + token.text, token.span);\n\t\t\telse return token;\n\t\t}\n\t}\n\t/** Peek at the next token without consuming it */\n\tpeek() {\n\t\tconst pos = this.checkpoint();\n\t\tconst token = this.nextToken();\n\t\tthis.reset(pos);\n\t\treturn token;\n\t}\n\t/** Consume token if text matches, otherwise leave position unchanged */\n\tmatchText(text) {\n\t\tconst token = this.peek();\n\t\tif (token?.text === text) {\n\t\t\tthis.nextToken();\n\t\t\treturn token;\n\t\t}\n\t\treturn null;\n\t}\n\t/** Consume token if kind matches (and optionally text), otherwise leave position unchanged */\n\tmatchKind(kind, text) {\n\t\tconst token = this.peek();\n\t\tif (token?.kind === kind && (!text || token.text === text)) {\n\t\t\tthis.nextToken();\n\t\t\treturn token;\n\t\t}\n\t\treturn null;\n\t}\n\t/** Consume token if predicate matches, otherwise leave position unchanged */\n\tnextIf(predicate) {\n\t\tconst token = this.peek();\n\t\tif (token && predicate(token)) {\n\t\t\tthis.nextToken();\n\t\t\treturn token;\n\t\t}\n\t\treturn null;\n\t}\n\t/** Match a sequence of tokens by text. Resets and returns null if any fails. */\n\tmatchSequence(...texts) {\n\t\tconst startPos = this.checkpoint();\n\t\tconst tokens = [];\n\t\tfor (const text of texts) {\n\t\t\tconst token = this.matchText(text);\n\t\t\tif (!token) {\n\t\t\t\tthis.reset(startPos);\n\t\t\t\treturn null;\n\t\t\t}\n\t\t\ttokens.push(token);\n\t\t}\n\t\treturn tokens;\n\t}\n\tskipToEol(position) {\n\t\tthis.eolPattern.lastIndex = position;\n\t\tif (this.eolPattern.exec(this.src) === null) return this.src.length;\n\t\telse return this.eolPattern.lastIndex;\n\t}\n\tskipBlockComment(start) {\n\t\tlet position = start;\n\t\twhile (true) {\n\t\t\tthis.blockCommentPattern.lastIndex = position;\n\t\t\tconst result = this.blockCommentPattern.exec(this.src);\n\t\t\tif (result === null) throw new ParseError(\"Unclosed block comment!\", [position, position]);\n\t\t\telse if (result[0] === \"*/\") return this.blockCommentPattern.lastIndex;\n\t\t\telse if (result[0] === \"/*\") position = this.skipBlockComment(this.blockCommentPattern.lastIndex);\n\t\t\telse throw new Error(\"Unreachable, invalid block comment pattern\");\n\t\t}\n\t}\n\t/**\n\t* Only matches the `<` token if it is a template\n\t* Precondition: An ident was parsed right before this.\n\t* Runs the [template list discovery algorithm](https://www.w3.org/TR/WGSL/#template-list-discovery).\n\t*/\n\tnextTemplateStartToken() {\n\t\tconst startPosition = this.stream.checkpoint();\n\t\tconst token = this.nextToken();\n\t\tthis.stream.reset(startPosition);\n\t\tif (token === null) return null;\n\t\tif (token.kind !== \"symbol\") return null;\n\t\tif (token.text === \"<\") if (this.isTemplateStart(token.span[1])) {\n\t\t\tthis.stream.reset(token.span[1]);\n\t\t\treturn token;\n\t\t} else {\n\t\t\tthis.stream.reset(startPosition);\n\t\t\treturn null;\n\t\t}\n\t\telse return null;\n\t}\n\tnextTemplateEndToken() {\n\t\tconst startPosition = this.stream.checkpoint();\n\t\tconst token = this.nextToken();\n\t\tthis.stream.reset(startPosition);\n\t\tif (token === null) return null;\n\t\tif (token.kind === \"symbol\" && token.text[0] === \">\") {\n\t\t\tconst tokenPosition = token.span[0];\n\t\t\tthis.stream.reset(tokenPosition + 1);\n\t\t\treturn {\n\t\t\t\tkind: \"symbol\",\n\t\t\t\tspan: [tokenPosition, tokenPosition + 1],\n\t\t\t\ttext: \">\"\n\t\t\t};\n\t\t} else return null;\n\t}\n\tisTemplateStart(afterToken) {\n\t\tthis.stream.reset(afterToken);\n\t\tlet pendingCounter = 1;\n\t\twhile (true) {\n\t\t\tconst nextToken = this.stream.nextToken();\n\t\t\tif (nextToken === null) return false;\n\t\t\tif (nextToken.kind !== \"symbol\") continue;\n\t\t\tif (nextToken.text === \"<\") pendingCounter += 1;\n\t\t\telse if (nextToken.text[0] === \">\") {\n\t\t\t\tif (nextToken.text === \">\" || nextToken.text === \">=\") pendingCounter -= 1;\n\t\t\t\telse if (nextToken.text === \">>=\" || nextToken.text === \">>\") pendingCounter -= 2;\n\t\t\t\telse throw new Error(\"This case should never be reached, looks like we forgot one of the tokens that start with >\");\n\t\t\t\tif (pendingCounter <= 0) return true;\n\t\t\t} else if (nextToken.text === \"(\") this.skipBracketsTo(\")\");\n\t\t\telse if (nextToken.text === \"[\") this.skipBracketsTo(\"]\");\n\t\t\telse if (nextToken.text === \"==\" || nextToken.text === \"!=\" || nextToken.text === \";\" || nextToken.text === \"{\" || nextToken.text === \":\" || nextToken.text === \"&&\" || nextToken.text === \"||\") return false;\n\t\t}\n\t}\n\t/**\n\t* Call this after consuming an opening bracket.\n\t* Skips until a closing bracket. This also consumes the closing bracket.\n\t*/\n\tskipBracketsTo(closingBracket) {\n\t\twhile (true) {\n\t\t\tconst nextToken = this.stream.nextToken();\n\t\t\tif (nextToken === null) {\n\t\t\t\tconst after = this.stream.checkpoint();\n\t\t\t\tthrow new ParseError(\"Unclosed bracket!\", [after, after]);\n\t\t\t}\n\t\t\tif (nextToken.kind !== \"symbol\") continue;\n\t\t\tif (nextToken.text === \"(\") this.skipBracketsTo(\")\");\n\t\t\telse if (nextToken.text === \"[\") this.skipBracketsTo(\"]\");\n\t\t\telse if (nextToken.text === closingBracket) return;\n\t\t}\n\t}\n};\n\n//#endregion\n//#region src/parse/ParseWesl.ts\n/** Parse a WESL source module into an AST. */\nfunction parseWesl(srcModule, options) {\n\tconst { ctx, state } = createParseState(srcModule, options);\n\ttry {\n\t\tbeginElem(ctx, \"module\");\n\t\tparseModule(ctx);\n\t\tconst moduleElem = state.stable.moduleElem;\n\t\tmoduleElem.contents = finishContents(ctx, 0, moduleElem.end);\n\t\treturn state.stable;\n\t} catch (e) {\n\t\tif (e instanceof ParseError) throw new WeslParseError({\n\t\t\tcause: e,\n\t\t\tsrc: srcModule\n\t\t});\n\t\tthrow new WeslParseError({\n\t\t\tcause: new ParseError(e instanceof Error ? e.message : String(e), [0, 0]),\n\t\t\tsrc: srcModule\n\t\t});\n\t}\n}\n/** Initialize parse state: token stream, root scope, and module element. */\nfunction createParseState(srcModule, options) {\n\tconst stream = new WeslStream(srcModule.src);\n\tconst rootScope = emptyScope(null);\n\tconst moduleElem = {\n\t\tkind: \"module\",\n\t\tcontents: [],\n\t\tstart: 0,\n\t\tend: srcModule.src.length\n\t};\n\tconst state = {\n\t\tcontext: {\n\t\t\tscope: rootScope,\n\t\t\topenElems: []\n\t\t},\n\t\tstable: {\n\t\t\tsrcModule,\n\t\t\tmoduleElem,\n\t\t\trootScope,\n\t\t\timports: []\n\t\t}\n\t};\n\treturn {\n\t\tctx: new ParsingContext(stream, state, options),\n\t\tstate\n\t};\n}\n\n//#endregion\n//#region src/ParseWESL.ts\n/** Human-readable error when parsing WESL fails. */\nvar WeslParseError = class extends Error {\n\tspan;\n\tsrc;\n\tconstructor(opts) {\n\t\tconst source = opts.src.src;\n\t\tconst [lineNum, linePos] = offsetToLineNumber(opts.cause.span[0], source);\n\t\tlet message = `${opts.src.debugFilePath}:${lineNum}:${linePos}`;\n\t\tmessage += ` error: ${opts.cause.message}\\n`;\n\t\tmessage += errorHighlight(source, opts.cause.span).join(\"\\n\");\n\t\tsuper(message, { cause: opts.cause });\n\t\tthis.span = opts.cause.span;\n\t\tthis.src = opts.src;\n\t}\n};\n/** Parse a WESL file. */\nfunction parseSrcModule(srcModule, options) {\n\treturn parseWesl(srcModule, options);\n}\n/** @return flattened form of import tree for binding idents. */\nfunction flatImports(ast, conditions) {\n\tif (ast._flatImports && !conditions) return ast._flatImports;\n\tconst importElems = ast.moduleElem.contents.filter((elem) => elem.kind === \"import\");\n\tconst flat = (conditions ? filterValidElements(importElems, conditions) : importElems).map((elem) => elem.imports).flatMap(flattenTreeImport);\n\tif (!conditions) ast._flatImports = flat;\n\treturn flat;\n}\n\n//#endregion\n//#region src/BindIdents.ts\n/** Bind ref idents to declarations and mangle global declaration names. */\nfunction bindIdents(params) {\n\tconst { rootAst, resolver, virtuals, accumulateUnbound } = params;\n\tconst { conditions = {}, mangler = minimalMangle } = params;\n\tconst { discoveryMode } = params;\n\tconst packageName = rootAst.srcModule.modulePath.split(\"::\")[0];\n\tconst rootDecls = discoveryMode ? findAllRootDecls(rootAst.rootScope) : findValidRootDecls(rootAst.rootScope, conditions);\n\tconst { globalNames, knownDecls } = initRootDecls(rootDecls);\n\tconst bindContext = {\n\t\tresolver,\n\t\tconditions,\n\t\tknownDecls,\n\t\tvirtuals,\n\t\tmangler,\n\t\tpackageName,\n\t\tfoundScopes: /* @__PURE__ */ new Set(),\n\t\tglobalNames,\n\t\tglobalStatements: /* @__PURE__ */ new Map(),\n\t\tunbound: accumulateUnbound ? [] : void 0,\n\t\tdiscoveryMode\n\t};\n\tconst liveDecls = {\n\t\tdecls: new Map(rootDecls.map((d) => [d.originalName, d])),\n\t\tparent: null\n\t};\n\tconst fromRootDecls = rootDecls.flatMap((decl) => processDependentScope(decl, bindContext));\n\tconst fromRefs = bindIdentsRecursive(rootAst.rootScope, bindContext, liveDecls);\n\tconst newStatements = [...bindContext.globalStatements.values()];\n\treturn {\n\t\tdecls: [...fromRootDecls, ...fromRefs],\n\t\tglobalNames,\n\t\tnewStatements,\n\t\tunbound: bindContext.unbound\n\t};\n}\n/** Initialize root declarations with mangled names and add to tracking sets. */\nfunction initRootDecls(validRootDecls) {\n\tfor (const d of validRootDecls) d.mangledName = d.originalName;\n\tconst knownDecls = new Set(validRootDecls);\n\treturn {\n\t\tglobalNames: new Set(validRootDecls.map((d) => d.originalName)),\n\t\tknownDecls\n\t};\n}\n/** Get conditional attribute from any scope item. */\nfunction getCondAttr(item) {\n\tif (item.kind === \"decl\" && item.containingScope.kind === \"partial\") return void 0;\n\tif (item.kind === \"decl\") return findConditional(item.declElem?.attributes);\n\tif (item.kind === \"partial\" || item.kind === \"scope\") return item.condAttribute;\n}\n/** Iterate scope contents, yielding only conditionally valid items. */\nfunction* validItems(scope, conditions) {\n\tlet elseValid = false;\n\tfor (const item of scope.contents) {\n\t\tconst cond = validateConditional(getCondAttr(item), elseValid, conditions);\n\t\telseValid = cond.nextElseState;\n\t\tif (cond.valid) yield item;\n\t}\n}\n/** Find all conditionally valid declarations at the root level. */\nfunction findValidRootDecls(rootScope, conditions) {\n\treturn collectDecls(validItems(rootScope, conditions));\n}\n/** Find all declarations at the root level, ignoring conditions. */\nfunction findAllRootDecls(rootScope) {\n\treturn collectDecls(rootScope.contents);\n}\n/** Find a public declaration with the given original name. */\nfunction publicDecl(scope, name, conditions) {\n\treturn getValidRootDecls(scope, conditions).find((d) => d.originalName === name);\n}\n/**\n* Recursively bind references to declarations in this scope and child scopes.\n* Tracks @else state to ensure filtered @else blocks don't pull in unused declarations.\n* @return new declarations found\n*/\nfunction bindIdentsRecursive(scope, bindContext, liveDecls) {\n\tconst { dontFollowDecls, foundScopes } = bindContext;\n\tif (foundScopes.has(scope)) return [];\n\tfoundScopes.add(scope);\n\tconst { newGlobals, newFromChildren } = processScope(scope, bindContext, liveDecls);\n\treturn [\n\t\tnewGlobals,\n\t\tnewFromChildren,\n\t\tdontFollowDecls ? [] : handleDecls(newGlobals, bindContext)\n\t].flat();\n}\n/** Process all identifiers and subscopes in this scope. */\nfunction processScope(scope, bindContext, liveDecls) {\n\tconst newGlobals = [];\n\tconst newFromChildren = [];\n\tconst items = bindContext.discoveryMode ? scope.contents : validItems(scope, bindContext.conditions);\n\tfor (const child of items) if (child.kind === \"decl\") liveDecls.decls.set(child.originalName, child);\n\telse if (child.kind === \"ref\") {\n\t\tconst newDecl = handleRef(child, liveDecls, bindContext);\n\t\tif (newDecl) newGlobals.push(newDecl);\n\t} else {\n\t\tconst newLive = child.kind === \"scope\" ? makeLiveDecls(liveDecls) : liveDecls;\n\t\tnewFromChildren.push(...bindIdentsRecursive(child, bindContext, newLive));\n\t}\n\treturn {\n\t\tnewGlobals,\n\t\tnewFromChildren\n\t};\n}\n/** Process dependent scope for a single declaration. */\nfunction processDependentScope(decl, ctx) {\n\tconst { dependentScope } = decl;\n\tif (!dependentScope) return [];\n\tconst rootDecls = rootLiveDecls(decl, ctx.conditions);\n\tif (!rootDecls) return [];\n\treturn bindIdentsRecursive(dependentScope, ctx, makeLiveDecls(rootDecls));\n}\n/**\n* Trace references to their declarations.\n* Mutates to mangle declarations and mark std references.\n* @return found declaration, or undefined if already processed\n*/\nfunction handleRef(ident, liveDecls, bindContext) {\n\tif (ident.refersTo || ident.std) return;\n\tif (ident.conditionRef) return;\n\tif (ident.attrParam && !wgslStandardAttributes.has(ident.attrParam)) return;\n\tconst foundDecl = findDeclInModule(ident, liveDecls) ?? findQualifiedImport(ident, bindContext);\n\tif (foundDecl) {\n\t\tident.refersTo = foundDecl.decl;\n\t\treturn handleNewDecl(ident, foundDecl, bindContext);\n\t}\n\tif (stdWgsl(ident.originalName)) {\n\t\tident.std = true;\n\t\treturn;\n\t}\n\tif (!bindContext.unbound) failIdent(ident, `unresolved identifier '${ident.originalName}'`);\n}\n/** Follow new global declarations into their dependent scopes. */\nfunction handleDecls(newGlobals, bindContext) {\n\treturn newGlobals.flatMap((decl) => processDependentScope(decl, bindContext));\n}\n/** If found declaration is new, mangle its name. @return the decl if it's global. */\nfunction handleNewDecl(refIdent, foundDecl, ctx) {\n\tconst { decl, moduleAst } = foundDecl;\n\tconst { knownDecls, globalNames, mangler, globalStatements } = ctx;\n\tif (knownDecls.has(decl)) return;\n\tknownDecls.add(decl);\n\tconst name = refIdent.originalName;\n\tsetMangledName(name, decl, globalNames, decl.srcModule, mangler);\n\tif (!decl.isGlobal) return;\n\tfor (const elem of moduleAst.moduleAsserts ?? []) globalStatements.set(elem, {\n\t\tsrcModule: decl.srcModule,\n\t\telem\n\t});\n\treturn decl;\n}\n/** Search current scope and parent scopes for a matching declaration. */\nfunction findDeclInModule(ident, liveDecls) {\n\tconst found = liveDecls.decls.get(ident.originalName);\n\tif (found) return {\n\t\tdecl: found,\n\t\tmoduleAst: ident.ast\n\t};\n\tif (liveDecls.parent) return findDeclInModule(ident, liveDecls.parent);\n}\n/** Match a ref ident to a declaration in another module via import or qualified ident. */\nfunction findQualifiedImport(refIdent, ctx) {\n\tconst { conditions, unbound, discoveryMode } = ctx;\n\tconst conds = discoveryMode ? void 0 : conditions;\n\tconst flatImps = flatImports(refIdent.ast, conds);\n\tconst identParts = refIdent.originalName.split(\"::\");\n\tconst pathParts = matchingImport(identParts, flatImps) ?? qualifiedIdent(identParts);\n\tif (!pathParts) {\n\t\tif (unbound && !stdWgsl(refIdent.originalName)) pushUnbound(unbound, identParts, refIdent);\n\t\treturn;\n\t}\n\tconst result = findExport(pathParts, refIdent.ast.srcModule, ctx);\n\tif (!result) if (unbound) pushUnbound(unbound, pathParts, refIdent);\n\telse failIdent(refIdent, `module not found for '${pathParts.join(\"::\")}'`);\n\treturn result;\n}\n/** Add an unbound reference with position info. */\nfunction pushUnbound(unbound, path, refIdent) {\n\tconst { srcModule, start, end } = refIdent.refIdentElem;\n\tunbound.push({\n\t\tpath,\n\t\tsrcModule,\n\t\tstart,\n\t\tend\n\t});\n}\n/** Find an import statement that matches a provided identifier. */\nfunction matchingImport(identParts, imports) {\n\tconst flat = imports.find((f) => f.importPath.at(-1) === identParts[0]);\n\tif (flat) return [...flat.modulePath, ...identParts.slice(1)];\n}\n/** @return an exported root declIdent for the provided path. */\nfunction findExport(pathParts, srcModule, ctx) {\n\tconst modulePath = resolveModulePath(pathParts, srcModule.modulePath.split(\"::\")).slice(0, -1).join(\"::\");\n\tconst moduleAst = ctx.resolver.resolveModule(modulePath) ?? virtualModule(pathParts[0], ctx);\n\tif (!moduleAst) return void 0;\n\tconst decl = publicDecl(moduleAst.rootScope, last(pathParts), ctx.conditions);\n\tif (decl) return {\n\t\tdecl,\n\t\tmoduleAst\n\t};\n}\n/** @return AST for a virtual module. */\nfunction virtualModule(moduleName, ctx) {\n\tconst found = ctx.virtuals?.[moduleName];\n\tif (!found) return void 0;\n\tif (found.ast) return found.ast;\n\tconst src = found.fn(ctx.conditions);\n\tfound.ast = parseSrcModule({\n\t\tmodulePath: ctx.packageName + \"::\" + moduleName,\n\t\tdebugFilePath: moduleName,\n\t\tsrc\n\t});\n\treturn found.ast;\n}\n/** Get cached valid root declarations, computing on first access. */\nfunction getValidRootDecls(rootScope, conditions) {\n\tconst lexScope = rootScope;\n\tlexScope._validRootDecls ??= findValidRootDecls(rootScope, conditions);\n\treturn lexScope._validRootDecls;\n}\n/** Given a global declIdent, return the liveDecls for its root scope. */\nfunction rootLiveDecls(decl, conditions) {\n\tassertThatDebug(decl.isGlobal, identToString(decl));\n\tlet scope = decl.containingScope;\n\twhile (scope.parent) scope = scope.parent;\n\tassertThatDebug(scope.kind === \"scope\");\n\tconst root = scope;\n\tif (!root._scopeDecls) {\n\t\tconst rootDecls = findValidRootDecls(scope, conditions);\n\t\troot._scopeDecls = { decls: new Map(rootDecls.map((d) => [d.originalName, d])) };\n\t}\n\treturn root._scopeDecls;\n}\n/** Set a globally unique mangled name for this declaration. */\nfunction setMangledName(proposedName, decl, globalNames, srcModule, mangler) {\n\tif (decl.mangledName) return;\n\tconst sep = proposedName.lastIndexOf(\"::\");\n\tconst name = sep === -1 ? proposedName : proposedName.slice(sep + 2);\n\tconst mangledName = decl.isGlobal ? mangler(decl, srcModule, name, globalNames) : decl.originalName;\n\tdecl.mangledName = mangledName;\n\tglobalNames.add(mangledName);\n}\n/** @return true if ident is a standard WGSL type, fn, or enumerant. */\nfunction stdWgsl(name) {\n\treturn stdType(name) || stdFn(name) || stdEnumerant(name);\n}\n/** @return identParts if it's a qualified path (has ::). */\nfunction qualifiedIdent(identParts) {\n\tif (identParts.length > 1) return identParts;\n}\n/** Collect all declarations from scope items, recursing into partial scopes. */\nfunction collectDecls(items) {\n\treturn [...items].flatMap((item) => {\n\t\tconst { kind } = item;\n\t\tif (kind === \"decl\") return [item];\n\t\tif (kind === \"partial\") return collectDecls(item.contents);\n\t\treturn [];\n\t});\n}\n\n//#endregion\n//#region src/PathUtil.ts\n/** simplistic path manipulation utilities */\n/** return path with ./ and foo/.. elements removed */\nfunction normalize(path) {\n\tconst noDots = path.split(\"/\").filter((s) => s !== \".\");\n\tconst noDbl = [];\n\tnoDots.forEach((s) => {\n\t\tif (s !== \"\") if (s === \"..\" && noDbl.length && noDbl[noDbl.length - 1] !== \"..\") noDbl.pop();\n\t\telse noDbl.push(s);\n\t});\n\treturn noDbl.join(\"/\");\n}\n/** return path w/o a suffix.\n* e.g. /foo/bar.wgsl => /foo/bar */\nfunction noSuffix(path) {\n\tconst lastSlash = path.lastIndexOf(\"/\");\n\tconst lastStart = lastSlash === -1 ? 0 : lastSlash + 1;\n\tconst suffix = path.indexOf(\".\", lastStart);\n\tconst suffixStart = suffix === -1 ? path.length : suffix;\n\treturn path.slice(0, suffixStart);\n}\n\n//#endregion\n//#region src/ModuleResolver.ts\nconst libRegex = /^lib\\.w[eg]sl$/i;\n/** Module resolver for in-memory source records. Lazy by default. */\nvar RecordResolver = class {\n\tastCache = /* @__PURE__ */ new Map();\n\tsources;\n\tpackageName;\n\tdebugWeslRoot;\n\tconstructor(sources, options = {}) {\n\t\tconst { packageName = \"package\", debugWeslRoot } = options;\n\t\tthis.sources = sources;\n\t\tthis.packageName = packageName;\n\t\tthis.debugWeslRoot = normalizeDebugRoot(debugWeslRoot);\n\t}\n\tresolveModule(modulePath) {\n\t\tconst cached = this.astCache.get(modulePath);\n\t\tif (cached) return cached;\n\t\tconst source = this.findSource(modulePath);\n\t\tif (source === void 0) return void 0;\n\t\tconst ast = parseSrcModule({\n\t\t\tmodulePath,\n\t\t\tdebugFilePath: this.modulePathToDebugPath(modulePath),\n\t\t\tsrc: source\n\t\t});\n\t\tthis.astCache.set(modulePath, ast);\n\t\treturn ast;\n\t}\n\tfindSource(modulePath) {\n\t\tif (this.sources[modulePath] !== void 0) return this.sources[modulePath];\n\t\tconst filePath = this.moduleToFilePath(modulePath);\n\t\tif (filePath === void 0) return void 0;\n\t\treturn findInVariants(this.sources, filePath);\n\t}\n\t/** Convert module path to file path, or undefined if not local. */\n\tmoduleToFilePath(modulePath) {\n\t\treturn moduleToRelativePath(modulePath, this.packageName);\n\t}\n\tmodulePathToDebugPath(modulePath) {\n\t\tconst filePath = this.moduleToFilePath(modulePath) ?? modulePath;\n\t\treturn this.debugWeslRoot + filePath + \".wesl\";\n\t}\n\t/** Parse all modules and return entries. */\n\tallModules() {\n\t\tfor (const filePath of Object.keys(this.sources)) {\n\t\t\tconst treatLibAsRoot = this.packageName !== \"package\";\n\t\t\tconst modulePath = fileToModulePath(filePath, this.packageName, treatLibAsRoot);\n\t\t\tthis.resolveModule(modulePath);\n\t\t}\n\t\treturn this.astCache.entries();\n\t}\n};\n/** Composite resolver that tries each resolver in order until one succeeds. */\nvar CompositeResolver = class {\n\tresolvers;\n\tconstructor(resolvers) {\n\t\tthis.resolvers = resolvers;\n\t}\n\tresolveModule(modulePath) {\n\t\tfor (const resolver of this.resolvers) {\n\t\t\tconst ast = resolver.resolveModule(modulePath);\n\t\t\tif (ast) return ast;\n\t\t}\n\t}\n};\n/** Lazy resolver for WeslBundle library modules. */\nvar BundleResolver = class {\n\tastCache = /* @__PURE__ */ new Map();\n\tsources;\n\tpackageName;\n\tdebugWeslRoot;\n\tconstructor(bundle, debugWeslRoot) {\n\t\tthis.sources = bundle.modules;\n\t\tthis.packageName = bundle.name;\n\t\tthis.debugWeslRoot = normalizeDebugRoot(debugWeslRoot);\n\t}\n\tresolveModule(modulePath) {\n\t\tconst pkgPrefix = this.packageName + \"::\";\n\t\tif (modulePath !== this.packageName && !modulePath.startsWith(pkgPrefix)) return;\n\t\tconst cached = this.astCache.get(modulePath);\n\t\tif (cached) return cached;\n\t\tconst source = this.findSource(modulePath);\n\t\tif (!source) return void 0;\n\t\tconst ast = parseSrcModule({\n\t\t\tmodulePath,\n\t\t\tdebugFilePath: this.modulePathToDebugPath(modulePath),\n\t\t\tsrc: source\n\t\t});\n\t\tthis.astCache.set(modulePath, ast);\n\t\treturn ast;\n\t}\n\tfindSource(modulePath) {\n\t\tconst filePath = this.moduleToFilePath(modulePath);\n\t\tif (modulePath === this.packageName) {\n\t\t\tconst libSrc = findInVariants(this.sources, \"lib\", [\"wesl\", \"wgsl\"]);\n\t\t\tif (libSrc) return libSrc;\n\t\t}\n\t\treturn findInVariants(this.sources, filePath);\n\t}\n\tmoduleToFilePath(modulePath) {\n\t\treturn moduleToRelativePath(modulePath, this.packageName) ?? modulePath;\n\t}\n\tmodulePathToDebugPath(modulePath) {\n\t\tconst filePath = this.moduleToFilePath(modulePath);\n\t\treturn this.debugWeslRoot + this.packageName + \"/\" + filePath + \".wesl\";\n\t}\n};\n/** Convert file path to module path (e.g., \"foo/bar.wesl\" to \"package::foo::bar\"). */\nfunction fileToModulePath(filePath, packageName, treatLibAsRoot) {\n\tif (filePath.includes(\"::\")) return filePath;\n\tif (treatLibAsRoot && libRegex.test(filePath)) return packageName;\n\tconst moduleSuffix = noSuffix(normalize(filePath)).replaceAll(\"/\", \"::\");\n\treturn packageName + \"::\" + moduleSuffix;\n}\n/** Try path variants with/without ./ prefix and extension suffixes. */\nfunction findInVariants(sources, basePath, extensions = [\"wesl\", \"wgsl\"]) {\n\tfor (const prefix of [\"\", \"./\"]) {\n\t\tconst path = prefix + basePath;\n\t\tif (sources[path] !== void 0) return sources[path];\n\t\tfor (const ext of extensions) {\n\t\t\tconst withExt = `${path}.${ext}`;\n\t\t\tif (sources[withExt] !== void 0) return sources[withExt];\n\t\t}\n\t}\n}\n\n//#endregion\n//#region src/discovery/FindUnboundIdents.ts\n/**\n* Find unbound package references in library sources.\n*\n* Binds local references without following cross-package imports, revealing\n* which external packages are referenced but not resolved.\n*\n* @param resolver - Module resolver that supports batch operations\n* @returns Array of unbound module paths, each as an array of path segments\n*   (e.g., [['foo', 'bar', 'baz'], ['other', 'pkg']])\n*/\nfunction findUnboundIdents(resolver) {\n\treturn findUnboundRefs(resolver).map((ref) => ref.path);\n}\n/** Find unbound references with full position info. */\nfunction findUnboundRefs(resolver) {\n\tconst bindContext = {\n\t\tresolver,\n\t\tconditions: {},\n\t\tknownDecls: /* @__PURE__ */ new Set(),\n\t\tfoundScopes: /* @__PURE__ */ new Set(),\n\t\tglobalNames: /* @__PURE__ */ new Set(),\n\t\tglobalStatements: /* @__PURE__ */ new Map(),\n\t\tmangler: minimalMangle,\n\t\tpackageName: \"package\",\n\t\tunbound: [],\n\t\tdontFollowDecls: true,\n\t\tdiscoveryMode: true\n\t};\n\tfor (const [, ast] of resolver.allModules()) {\n\t\tconst rootDecls = findAllRootDecls(ast.rootScope);\n\t\tconst liveDecls = {\n\t\t\tdecls: new Map(rootDecls.map((d) => [d.originalName, d])),\n\t\t\tparent: null\n\t\t};\n\t\tfor (const s of filterMap(rootDecls, (decl) => decl.dependentScope)) bindIdentsRecursive(s, bindContext, makeLiveDecls(liveDecls));\n\t\tbindIdentsRecursive(ast.rootScope, bindContext, liveDecls);\n\t}\n\treturn bindContext.unbound;\n}\n/** Thin decorator that records which modules were resolved. */\nvar TrackingResolver = class {\n\tvisited = /* @__PURE__ */ new Set();\n\t#inner;\n\tconstructor(inner) {\n\t\tthis.#inner = inner;\n\t}\n\tresolveModule(modulePath) {\n\t\tconst ast = this.#inner.resolveModule(modulePath);\n\t\tif (ast) this.visited.add(modulePath);\n\t\treturn ast;\n\t}\n};\n/**\n* Discover reachable modules and unbound external refs from a single root.\n*\n* Traces the import graph from `rootModuleName`, returning only the reachable\n* local modules in `weslSrc` and unresolved external references in `unbound`.\n*/\nfunction discoverModules(weslSrc, resolver, rootModuleName, packageName = \"package\") {\n\tconst tracking = new TrackingResolver(resolver);\n\tconst rootAst = tracking.resolveModule(rootModuleName);\n\tif (!rootAst) throw new Error(`root module not found: '${rootModuleName}'`);\n\tconst result = bindIdents({\n\t\trootAst,\n\t\tresolver: tracking,\n\t\taccumulateUnbound: true,\n\t\tdiscoveryMode: true\n\t});\n\tconst moduleToKey = new Map(Object.keys(weslSrc).map((key) => [fileToModulePath(key, packageName, false), key]));\n\tconst reachable = [...tracking.visited].map((m) => moduleToKey.get(m)).filter((key) => key !== void 0).map((key) => [key, weslSrc[key]]);\n\tconst unbound = (result.unbound ?? []).map((ref) => ref.path);\n\treturn {\n\t\tweslSrc: Object.fromEntries(reachable),\n\t\tunbound\n\t};\n}\n\n//#endregion\n//#region src/discovery/PackageNameUtils.ts\n/** Package name sanitization for WESL.\n*\n* Converts typical npm package names to WGSL-safe identifiers using double-underscore encoding.\n* NPM package names can contain `@`, `/`, and `-`, which are not allowed in WGSL identifiers.\n*\n* ## Encoding Scheme\n*\n* ```\n* @     ==>  (remove)\n* /     ==>  __  (double underscore)\n* -     ==>  _   (single underscore)\n* ```\n*\n* ## Forward Mapping (npm ==> WGSL identifier)\n*\n* ```\n* my_package          ==>  my_package\n* random-wgsl         ==>  random_wgsl\n* @scope/my-pkg       ==>  scope__my_pkg\n* ```\n*\n* ## Reverse Mapping (WGSL identifier ==> npm package)\n*\n* ```\n* scope__my_pkg       ==>  try: @scope/my_pkg, @scope/my-pkg\n* random_wgsl         ==>  try: random_wgsl, random-wgsl\n* ```\n*/\n/** Convert npm package name to WGSL-safe identifier using double-underscore encoding. */\nfunction sanitizePackageName(npmName) {\n\treturn npmName.replace(/^@/, \"\").replaceAll(\"/\", \"__\").replaceAll(\"-\", \"_\");\n}\n/** Generate npm package name variations from sanitized WESL identifier.\n*\n* Uses double-underscore encoding to distinguish scoped vs unscoped packages:\n* - Has __ → scoped package (try @scope/pkg variants)\n* - No __ → unscoped package (try pkg variants)\n*\n* Examples:\n*   \"lygia__shader_utils\" → [\"@lygia/shader_utils\", \"@lygia/shader-utils\"]\n*   \"random_wgsl\" → [\"random_wgsl\", \"random-wgsl\"]\n*/\nfunction* npmNameVariations(sanitizedPath) {\n\tconst [pkg, sub] = breakAt(sanitizedPath, \"/\");\n\tlet pkgName = pkg;\n\tlet scopePrefix = \"\";\n\tif (pkg.includes(\"__\")) {\n\t\tconst [scope, ...rest] = pkg.split(\"__\");\n\t\tpkgName = rest.join(\"__\");\n\t\tscopePrefix = `@${scope}/`;\n\t}\n\tyield `${scopePrefix}${pkgName}${sub}`;\n\tyield `${scopePrefix}${pkgName.replaceAll(\"_\", \"-\")}${sub}`;\n}\n/** Break string at first occurrence of delimiter.\n* @returns [before, after] where after includes the delimiter */\nfunction breakAt(str, delimiter) {\n\tconst index = str.indexOf(delimiter);\n\tif (index === -1) return [str, \"\"];\n\treturn [str.slice(0, index), str.slice(index)];\n}\n\n//#endregion\n//#region src/LinkedWesl.ts\n/**\n* Multiple WESL files that have been linked together to produce WGSL code.\n*\n* Call {@link LinkedWesl.createShaderModule} on a {@link WeslDevice}\n* to make the error reporting aware of the WESL code.\n*/\nvar LinkedWesl = class {\n\tsourceMap;\n\tconstructor(sourceMap) {\n\t\tthis.sourceMap = sourceMap;\n\t}\n\t/**\n\t* Creates a {@link GPUShaderModule}.\n\t* When errors occur, they will point at the original WESL source code.\n\t*\n\t* The compilation info {@link GPUShaderModule.getCompilationInfo}\n\t* can be remapped with {@link mapGPUCompilationInfo}\n\t* @param device GPUDevice. Preferably a {@link WeslDevice} for better error reporting.\n\t* @param descriptor - Description of the {@link GPUShaderModule} to create.\n\t*/\n\tcreateShaderModule(device, descriptor) {\n\t\tif (!(\"injectError\" in device)) return device.createShaderModule({\n\t\t\t...descriptor,\n\t\t\tcode: this.dest\n\t\t});\n\t\tdevice.pushErrorScope(\"validation\");\n\t\tconst module = device.createShaderModule({\n\t\t\t...descriptor,\n\t\t\tcode: this.dest\n\t\t});\n\t\tdevice.popErrorScope();\n\t\tconst { promise, resolve } = Promise.withResolvers();\n\t\tdevice.injectError(\"validation\", promise);\n\t\tmodule.getCompilationInfo().then((compilationInfo) => {\n\t\t\tif (compilationInfo.messages.length === 0) {\n\t\t\t\tresolve(null);\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst mappedCompilationInfo = this.mapGPUCompilationInfo(compilationInfo);\n\t\t\tconst errorMessage = compilationInfoToErrorMessage(mappedCompilationInfo, module);\n\t\t\tassertThatDebug(errorMessage !== null);\n\t\t\tconst error = new GPUValidationError(errorMessage);\n\t\t\terror.cause = /* @__PURE__ */ new Error(\"createShaderModule failed\");\n\t\t\terror.compilationInfo = mappedCompilationInfo;\n\t\t\tresolve(error);\n\t\t});\n\t\treturn module;\n\t}\n\t/**\n\t* Use {@link LinkedWesl.createShaderModule} for a\n\t* better error reporting experience.\n\t*/\n\tget dest() {\n\t\treturn this.sourceMap.dest.text;\n\t}\n\t/** Turns raw compilation info into compilation info\n\t* that points at the WESL sources. */\n\tmapGPUCompilationInfo(compilationInfo) {\n\t\treturn {\n\t\t\t__brand: compilationInfo.__brand,\n\t\t\tmessages: compilationInfo.messages.map((v) => this.mapGPUCompilationMessage(v))\n\t\t};\n\t}\n\tmapGPUCompilationMessage(message) {\n\t\tconst srcMap = this.sourceMap;\n\t\tconst srcPosition = srcMap.destToSrc(message.offset);\n\t\tconst length = (message.length > 0 ? srcMap.destToSrc(message.offset + message.length) : srcPosition).position - srcPosition.position;\n\t\tconst [lineNum, linePos] = offsetToLineNumber(srcPosition.position, srcPosition.src.text);\n\t\treturn {\n\t\t\t__brand: message.__brand,\n\t\t\ttype: message.type,\n\t\t\tmessage: message.message,\n\t\t\toffset: srcPosition.position,\n\t\t\tlength,\n\t\t\tlineNum,\n\t\t\tlinePos,\n\t\t\tmodule: {\n\t\t\t\turl: srcPosition.src.path ?? \"\",\n\t\t\t\ttext: srcPosition.src.text\n\t\t\t}\n\t\t};\n\t}\n};\n/**\n* Tries to imitate the way the browser logs the compilation info.\n* Does not do the remapping.\n* @returns A string with errors, or `null` if there were no compilation messages.\n*/\nfunction compilationInfoToErrorMessage(compilationInfo, shaderModule) {\n\tif (compilationInfo.messages.length === 0) return null;\n\tlet result = `Compilation log for [Invalid ShaderModule (${shaderModule.label || \"unlabled\"})]:\\n`;\n\tconst errorCount = compilationInfo.messages.filter((v) => v.type === \"error\").length;\n\tif (errorCount > 0) result += `${errorCount} error(s) generated while compiling the shader:\\n`;\n\tfor (const message of compilationInfo.messages) {\n\t\tconst { lineNum, linePos } = message;\n\t\tresult += `${message.module.url}:${lineNum}:${linePos}`;\n\t\tresult += ` ${message.type}: ${message.message}\\n`;\n\t\tconst source = message.module.text;\n\t\tif (source) result += errorHighlight(source, [message.offset, message.offset + message.length]).join(\"\\n\");\n\t}\n\treturn result;\n}\n\n//#endregion\n//#region src/SrcMap.ts\n/** map text ranges in multiple src texts to a single dest text */\nvar SrcMap = class SrcMap {\n\tentries;\n\tdest;\n\tconstructor(dest, entries = []) {\n\t\tthis.dest = dest;\n\t\tthis.entries = entries;\n\t}\n\t/** add a new mapping from src to dest ranges (must be non-overlapping in destination) */\n\taddEntries(newEntries) {\n\t\tthis.entries.push(...newEntries);\n\t}\n\t/** given positions in the dest string, return corresponding positions in the src strings */\n\tmapPositions(...positions) {\n\t\treturn positions.map((p) => this.destToSrc(p));\n\t}\n\t/** internally compress adjacent entries where possible */\n\tcompact() {\n\t\tif (!this.entries.length) return;\n\t\tlet prev = this.entries[0];\n\t\tconst newEntries = [prev];\n\t\tfor (let i = 1; i < this.entries.length; i++) {\n\t\t\tconst e = this.entries[i];\n\t\t\tif (e.src.path === prev.src.path && e.src.text === prev.src.text && prev.destEnd === e.destStart && prev.srcEnd === e.srcStart && prev.srcEnd - prev.srcStart === prev.destEnd - prev.destStart) {\n\t\t\t\tprev.destEnd = e.destEnd;\n\t\t\t\tprev.srcEnd = e.srcEnd;\n\t\t\t} else {\n\t\t\t\tnewEntries.push(e);\n\t\t\t\tprev = e;\n\t\t\t}\n\t\t}\n\t\tthis.entries = newEntries;\n\t}\n\t/** sort in destination order */\n\tsort() {\n\t\tthis.entries.sort((a, b) => a.destStart - b.destStart);\n\t}\n\t/**\n\t* This SrcMap's destination is a src for the other srcmap,\n\t* so combine the two and return the result.\n\t*/\n\tmerge(other) {\n\t\tif (other === this) return this;\n\t\tconst mappedEntries = other.entries.filter((e) => e.src.path === this.dest.path && e.src.text === this.dest.text);\n\t\tif (mappedEntries.length === 0) {\n\t\t\tconsole.log(\"other source map does not link to this one\");\n\t\t\treturn other;\n\t\t}\n\t\tsortSrc(mappedEntries);\n\t\tconst newEntries = mappedEntries.map((e) => {\n\t\t\tconst { src, position: srcStart } = this.destToSrc(e.srcStart);\n\t\t\tconst { src: endSrc, position: srcEnd } = this.destToSrc(e.srcEnd);\n\t\t\tif (endSrc !== src) throw new Error(\"NYI, need to split\");\n\t\t\treturn {\n\t\t\t\tsrc,\n\t\t\t\tsrcStart,\n\t\t\t\tsrcEnd,\n\t\t\t\tdestStart: e.destStart,\n\t\t\t\tdestEnd: e.destEnd\n\t\t\t};\n\t\t});\n\t\tconst otherSources = other.entries.filter((e) => e.src.path !== this.dest.path || e.src.text !== this.dest.text);\n\t\tconst newMap = new SrcMap(other.dest, [...otherSources, ...newEntries]);\n\t\tnewMap.sort();\n\t\treturn newMap;\n\t}\n\t/** @return the source position corresponding to a provided destination position */\n\tdestToSrc(destPos) {\n\t\tconst entry = this.entries.find((e) => e.destStart <= destPos && e.destEnd >= destPos);\n\t\tif (!entry) return {\n\t\t\tsrc: this.dest,\n\t\t\tposition: destPos\n\t\t};\n\t\treturn {\n\t\t\tsrc: entry.src,\n\t\t\tposition: entry.srcStart + destPos - entry.destStart\n\t\t};\n\t}\n};\n/** sort entries in place by src start position */\nfunction sortSrc(entries) {\n\tentries.sort((a, b) => a.srcStart - b.srcStart);\n}\n/** Incrementally append to a string, tracking source references */\nvar SrcMapBuilder = class {\n\t#fragments = [];\n\t#destLength = 0;\n\t#entries = [];\n\tsource;\n\tconstructor(source) {\n\t\tthis.source = source;\n\t}\n\t/** append a string fragment to the destination string */\n\tadd(fragment, srcStart, srcEnd) {\n\t\tconst destStart = this.#destLength;\n\t\tthis.#destLength += fragment.length;\n\t\tconst destEnd = this.#destLength;\n\t\tthis.#fragments.push(fragment);\n\t\tthis.#entries.push({\n\t\t\tsrc: this.source,\n\t\t\tsrcStart,\n\t\t\tsrcEnd,\n\t\t\tdestStart,\n\t\t\tdestEnd\n\t\t});\n\t}\n\t/**\n\t* Append a fragment to the destination string,\n\t* mapping source to the previous,\n\t* and guessing that the source fragment is just as long as the dest fragment.\n\t*/\n\tappendNext(fragment) {\n\t\tconst lastEnd = this.#entries.at(-1)?.destEnd ?? 0;\n\t\tthis.add(fragment, lastEnd, lastEnd + fragment.length);\n\t}\n\taddSynthetic(fragment, syntheticSource, srcStart, srcEnd) {\n\t\tconst destStart = this.#destLength;\n\t\tthis.#destLength += fragment.length;\n\t\tconst destEnd = this.#destLength;\n\t\tthis.#fragments.push(fragment);\n\t\tthis.#entries.push({\n\t\t\tsrc: { text: syntheticSource },\n\t\t\tsrcStart,\n\t\t\tsrcEnd,\n\t\t\tdestStart,\n\t\t\tdestEnd\n\t\t});\n\t}\n\t/** append a synthetic newline, mapped to previous source location */\n\taddNl() {\n\t\tconst { srcStart, srcEnd } = this.#entries.at(-1) ?? {\n\t\t\tsrcStart: 0,\n\t\t\tsrcEnd: 0\n\t\t};\n\t\tthis.add(\"\\n\", srcStart, srcEnd);\n\t}\n\t/** copy a string fragment from the src to the destination string */\n\taddCopy(srcStart, srcEnd) {\n\t\tconst fragment = this.source.text.slice(srcStart, srcEnd);\n\t\tthis.add(fragment, srcStart, srcEnd);\n\t}\n\t/** return a SrcMap */\n\tstatic build(builders) {\n\t\tconst map = new SrcMap({ text: builders.map((b) => b.#fragments.join(\"\")).join(\"\") }, builders.flatMap((b) => b.#entries));\n\t\tmap.compact();\n\t\treturn map;\n\t}\n};\n\n//#endregion\n//#region src/Linker.ts\n/**\n* Link a set of WESL source modules (typically the text from .wesl files) into a single WGSL string.\n* Linking starts with a specified 'root' source module, and recursively incorporates code\n* referenced from other modules (in local files or libraries).\n*\n* Unreferenced (dead) code outside the root module is not included in the output WGSL.\n* Additionally the caller can specify conditions for to control conditional compilation.\n* Only code that is valid with the current conditions is included in the output.\n*/\nasync function link(params) {\n\treturn new LinkedWesl(_linkSync(params));\n}\n/** linker api for benchmarking */\nfunction _linkSync(params) {\n\tconst { weslSrc, libs = [], packageName, debugWeslRoot } = params;\n\tconst { resolver } = params;\n\tconst resolvers = [];\n\tif (resolver) resolvers.push(resolver);\n\telse if (weslSrc) resolvers.push(new RecordResolver(weslSrc, {\n\t\tpackageName,\n\t\tdebugWeslRoot\n\t}));\n\telse throw new Error(\"Either resolver or weslSrc must be provided\");\n\tif (libs.length > 0) {\n\t\tconst libResolvers = createLibraryResolvers(libs, debugWeslRoot);\n\t\tresolvers.push(...libResolvers);\n\t}\n\tconst finalResolver = resolvers.length === 1 ? resolvers[0] : new CompositeResolver(resolvers);\n\treturn linkRegistry({\n\t\t...params,\n\t\tresolver: finalResolver\n\t});\n}\nfunction createLibraryResolvers(libs, debugWeslRoot) {\n\treturn flattenLibraryTree(libs).map((lib) => new BundleResolver(lib, debugWeslRoot));\n}\n/** Flatten library dependency tree, deduplicating by object identity rather than package name.\n*\n* Some packages (like Lygia) provide multiple bundles in the same npm package\n* to enable tree shaking. All bundles share the same package name, so we deduplicate\n* by object identity to keep them distinct. Also handles circular dependencies correctly. */\nfunction flattenLibraryTree(libs) {\n\tconst result = [];\n\tconst seen = /* @__PURE__ */ new Set();\n\tfunction visit(bundle) {\n\t\tif (seen.has(bundle)) return;\n\t\tseen.add(bundle);\n\t\tresult.push(bundle);\n\t\tbundle.dependencies?.forEach(visit);\n\t}\n\tlibs.forEach(visit);\n\treturn result;\n}\n/** Link wesl from a registry of already parsed modules.\n*\n* This entry point is intended for users who want to link multiple times\n* from the same sources. (e.g. linking with different conditions\n* each time, or perhaps to produce multiple wgsl shaders\n* that share some sources.)\n*/\nfunction linkRegistry(params) {\n\tconst { transformedAst, newDecls, newStatements } = bindAndTransform(params);\n\treturn SrcMapBuilder.build(emitWgsl(transformedAst.moduleElem, transformedAst.srcModule, newDecls, newStatements, params.conditions));\n}\n/** Bind identifiers and apply transform plugins */\nfunction bindAndTransform(params) {\n\tconst { resolver, mangler, constants, config } = params;\n\tconst { rootModuleName = \"main\", conditions = {} } = params;\n\tconst rootAst = getRootModule(resolver, normalizeModuleName(rootModuleName), rootModuleName);\n\tconst { globalNames, decls: newDecls, newStatements } = bindIdents({\n\t\trootAst,\n\t\tresolver,\n\t\tconditions,\n\t\tvirtuals: setupVirtualLibs(params.virtualLibs, constants),\n\t\tmangler\n\t});\n\treturn {\n\t\ttransformedAst: applyTransformPlugins(rootAst, globalNames, config),\n\t\tnewDecls,\n\t\tnewStatements\n\t};\n}\n/** Convert root module name to module path format.\n* Accepts: module path (package::foo), file path (./foo.wesl), or name (foo) */\nfunction normalizeModuleName(name) {\n\tif (name.includes(\"::\")) return name;\n\tif (name.includes(\"/\") || name.endsWith(\".wesl\") || name.endsWith(\".wgsl\")) return \"package::\" + name.replace(/\\.(wesl|wgsl)$/, \"\").replace(/^\\.\\//, \"\").replaceAll(\"/\", \"::\");\n\treturn \"package::\" + name;\n}\n/** Resolve root module AST or throw if not found. */\nfunction getRootModule(resolver, modulePath, rootModuleName) {\n\tconst rootAst = resolver.resolveModule(modulePath);\n\tif (!rootAst) {\n\t\tif (debug) console.log(`root module not found: ${modulePath} (from ${rootModuleName})`);\n\t\tthrow new Error(`Root module not found: ${rootModuleName}`);\n\t}\n\treturn rootAst;\n}\n/** Create virtual library set from code generators and host constants. */\nfunction setupVirtualLibs(virtualLibs, constants) {\n\tlet libs = virtualLibs;\n\tif (constants) {\n\t\tconst constantsGen = () => Object.entries(constants).map(([name, value]) => `const ${name} = ${value};`).join(\"\\n\");\n\t\tlibs = {\n\t\t\t...libs,\n\t\t\tconstants: constantsGen\n\t\t};\n\t}\n\treturn libs && mapValues(libs, (fn) => ({ fn }));\n}\nfunction applyTransformPlugins(rootModule, globalNames, config) {\n\tconst { moduleElem, srcModule } = rootModule;\n\tconst startAst = {\n\t\tmoduleElem,\n\t\tsrcModule,\n\t\tglobalNames,\n\t\tnotableElems: {}\n\t};\n\treturn filterMap(config?.plugins ?? [], (plugin) => plugin.transform).reduce((ast, transform) => transform(ast), startAst);\n}\nfunction emitWgsl(rootModuleElem, srcModule, newDecls, newStatements, conditions = {}) {\n\tconst prologueBuilders = newStatements.map((s) => emitStatement(s, conditions));\n\tconst rootBuilder = new SrcMapBuilder({\n\t\ttext: srcModule.src,\n\t\tpath: srcModule.debugFilePath\n\t});\n\tlowerAndEmit({\n\t\tsrcBuilder: rootBuilder,\n\t\trootElems: [rootModuleElem],\n\t\tconditions,\n\t\textracting: false\n\t});\n\tconst declBuilders = newDecls.map((decl) => emitDecl(decl, conditions));\n\treturn [\n\t\t...prologueBuilders,\n\t\trootBuilder,\n\t\t...declBuilders\n\t];\n}\nfunction emitStatement(s, conditions) {\n\tconst { elem, srcModule } = s;\n\tconst { src: text, debugFilePath: path } = srcModule;\n\tconst builder = new SrcMapBuilder({\n\t\ttext,\n\t\tpath\n\t});\n\tlowerAndEmit({\n\t\tsrcBuilder: builder,\n\t\trootElems: [elem],\n\t\tconditions\n\t});\n\tbuilder.addNl();\n\treturn builder;\n}\n/** Skip conditional filtering because findValidRootDecls already validated these declarations */\nfunction emitDecl(decl, conditions) {\n\tconst { src: text, debugFilePath: path } = decl.srcModule;\n\tconst builder = new SrcMapBuilder({\n\t\ttext,\n\t\tpath\n\t});\n\tlowerAndEmit({\n\t\tsrcBuilder: builder,\n\t\trootElems: [decl.declElem],\n\t\tconditions,\n\t\tskipConditionalFiltering: true\n\t});\n\treturn builder;\n}\n\n//#endregion\n//#region src/LinkerUtil.ts\nfunction visitAst(elem, visitor) {\n\tvisitor(elem);\n\tif (elem.contents) elem.contents.forEach((child) => {\n\t\tvisitAst(child, visitor);\n\t});\n}\n\n//#endregion\n//#region src/RawEmit.ts\nfunction attributeToString$1(e) {\n\tconst { kind } = e.attribute;\n\tif (kind === \"@attribute\") {\n\t\tconst { params } = e.attribute;\n\t\tif (params === void 0 || params.length === 0) return \"@\" + e.attribute.name;\n\t\telse return `@${e.attribute.name}(${params.map((param) => contentsToString(param)).join(\", \")})`;\n\t} else if (kind === \"@builtin\") return \"@builtin(\" + e.attribute.param.name + \")\";\n\telse if (kind === \"@diagnostic\") return \"@diagnostic\" + diagnosticControlToString(e.attribute.severity, e.attribute.rule);\n\telse if (kind === \"@if\") return `@if(${expressionToString(e.attribute.param.expression)})`;\n\telse if (kind === \"@elif\") return `@elif(${expressionToString(e.attribute.param.expression)})`;\n\telse if (kind === \"@else\") return \"@else\";\n\telse if (kind === \"@interpolate\") return `@interpolate(${e.attribute.params.map((v) => v.name).join(\", \")})`;\n\telse assertUnreachable(kind);\n}\nfunction typeListToString(params) {\n\treturn `<${params.map(typeParamToString).join(\", \")}>`;\n}\nfunction typeParamToString(param) {\n\tif (param === void 0) return \"?\";\n\tif (param.kind === \"type\") return typeRefToString(param);\n\treturn expressionToString(param);\n}\nfunction typeRefToString(t) {\n\tif (!t) return \"?\";\n\tconst { name, templateParams } = t;\n\tconst params = templateParams ? typeListToString(templateParams) : \"\";\n\treturn `${refToString(name)}${params}`;\n}\nfunction refToString(ref) {\n\tif (typeof ref === \"string\") return ref;\n\tif (ref.std) return ref.originalName;\n\tconst decl = findDecl(ref);\n\treturn decl.mangledName || decl.originalName;\n}\nfunction contentsToString(elem) {\n\tif (elem.kind === \"translate-time-expression\") throw new Error(\"Not supported\");\n\telse if (elem.kind === \"expression\" || elem.kind === \"stuff\") return elem.contents.map((c) => {\n\t\tconst { kind } = c;\n\t\tif (kind === \"text\") return c.srcModule.src.slice(c.start, c.end);\n\t\telse if (kind === \"ref\") return refToString(c.ident);\n\t\telse return `?${c.kind}?`;\n\t}).join(\" \");\n\telse if (elem.kind === \"name\") return elem.name;\n\telse assertUnreachable(elem);\n}\n\n//#endregion\n//#region src/Reflection.ts\nconst textureStorage = matchOneOf(textureStorageTypes);\nconst textureTypes = matchOneOf(sampledTextureTypes);\nconst multiNames = matchOneOf(multisampledTextureTypes);\n\n//#endregion\n//#region src/TransformBindingStructs.ts\nfunction bindingStructsPlugin() {\n\treturn { transform: lowerBindingStructs };\n}\n/**\n* Transform binding structures into binding variables by mutating the AST.\n*\n* First we find all the binding structs:\n*   . find all the structs in the module by filtering the moduleElem.contents\n*     . for each struct:\n*       . mark any structs with that contain @group or @binding annotations as 'binding structs' and save them in a list\n*       . (later) create reverse links from structs to struct members\n*       . (later) visit all the binding structs and traverse to referencing structs, marking the referencing structs as binding structs too\n* Generate synethic AST nodes for binding variables\n*\n* Find all references to binding struct members\n*   . find the componound idents by traversing moduleElem.contents\n*   . filter to find the compound idents that refer to 'binding structs'\n*     . go from each ident to its declaration,\n*     . declaration to typeRef reference\n*     . typeRef to type declaration\n*     . check type declaration to see if it's a binding struct\n*     . record the intermediate declaration (e.g. a fn param b:Bindings from 'fn(b:Bindings)' )\n* rewrite references to binding struct members as synthetic elements\n*\n* Remove the binding structs from the AST\n* Remove the intermediate fn param declarations from the AST\n* Add the new binding variables to the AST\n*\n* @return the binding structs and the mutated AST\n*/\nfunction lowerBindingStructs(ast) {\n\tconst clonedAst = structuredClone(ast);\n\tconst { moduleElem, globalNames, notableElems } = clonedAst;\n\tconst bindingStructs = markBindingStructs(moduleElem);\n\tmarkEntryTypes(moduleElem, bindingStructs);\n\tconst newVars = bindingStructs.flatMap((s) => transformBindingStruct(s, globalNames));\n\tconst bindingRefs = findRefsToBindingStructs(moduleElem);\n\tbindingRefs.forEach(({ memberRef, struct }) => {\n\t\ttransformBindingReference(memberRef, struct);\n\t});\n\tbindingRefs.forEach(({ intermediates }) => {\n\t\tintermediates.forEach((e) => {\n\t\t\te.contents = [];\n\t\t});\n\t});\n\tconst contents = removeBindingStructs(moduleElem);\n\tmoduleElem.contents = [...newVars, ...contents];\n\tnotableElems.bindingStructs = bindingStructs;\n\treturn {\n\t\t...clonedAst,\n\t\tmoduleElem\n\t};\n}\nfunction markEntryTypes(moduleElem, bindingStructs) {\n\tconst fnFound = fnReferencesBindingStruct(moduleElem.contents.filter((e) => e.kind === \"fn\"), bindingStructs);\n\tif (fnFound) {\n\t\tconst { fn, struct } = fnFound;\n\t\tstruct.entryFn = fn;\n\t}\n}\nfunction fnReferencesBindingStruct(fns, bindingStructs) {\n\tfor (const fn of fns) {\n\t\tconst { params } = fn;\n\t\tfor (const p of params) {\n\t\t\tconst referencedElem = ((p.name?.typeRef?.name)?.refersTo)?.declElem;\n\t\t\tconst struct = bindingStructs.find((s) => s === referencedElem);\n\t\t\tif (struct) return {\n\t\t\t\tfn,\n\t\t\t\tstruct\n\t\t\t};\n\t\t}\n\t}\n}\nfunction removeBindingStructs(moduleElem) {\n\treturn moduleElem.contents.filter((elem) => elem.kind !== \"struct\" || !elem.bindingStruct);\n}\n/** mutate the AST, marking StructElems as bindingStructs\n*  (if they contain ptrs with @group @binding annotations)\n* @return the binding structs\n*/\nfunction markBindingStructs(moduleElem) {\n\tconst bindingStructs = moduleElem.contents.filter((elem) => elem.kind === \"struct\").filter(containsBinding);\n\tbindingStructs.forEach((struct) => {\n\t\tstruct.bindingStruct = true;\n\t});\n\treturn bindingStructs;\n}\n/** @return true if this struct contains a member with marked with @binding or @group */\nfunction containsBinding(struct) {\n\treturn struct.members.some(({ attributes }) => bindingAttribute(attributes));\n}\nfunction bindingAttribute(attributes) {\n\tif (!attributes) return false;\n\treturn attributes.some(({ attribute }) => attribute.kind === \"@attribute\" && (attribute.name === \"binding\" || attribute.name === \"group\"));\n}\n/** convert each member of the binding struct into a synthetic global variable */\nfunction transformBindingStruct(s, globalNames) {\n\treturn s.members.map((member) => {\n\t\tconst { typeRef, name: memberName } = member;\n\t\tconst { name: typeName } = typeRef;\n\t\tconst typeParameters = typeRef?.templateParams;\n\t\tconst varName = minimallyMangledName(memberName.name, globalNames);\n\t\tmember.mangledVarName = varName;\n\t\tglobalNames.add(varName);\n\t\tconst attributes = member.attributes?.map(attributeToString$1).join(\" \") ?? \"\";\n\t\tconst varTypes = lowerPtrMember(typeName, typeParameters) ?? lowerStdTypeMember(typeName, typeParameters) ?? lowerStorageTextureMember(typeName, typeParameters);\n\t\tif (!varTypes) {\n\t\t\tconsole.log(\"unhandled case transforming member\", typeName);\n\t\t\treturn syntheticVar(attributes, varName, \"\", \"??\");\n\t\t}\n\t\tconst { storage: storageType, varType } = varTypes;\n\t\treturn syntheticVar(attributes, varName, storageType, varType);\n\t});\n}\nfunction lowerPtrMember(typeName, typeParameters) {\n\tif (typeName.originalName === \"ptr\") {\n\t\tconst origParams = typeParameters ?? [];\n\t\tconst newParams = [origParams[0]];\n\t\tif (origParams[2]) newParams.push(origParams[2]);\n\t\treturn {\n\t\t\tstorage: typeListToString(newParams),\n\t\t\tvarType: typeParamToString(origParams?.[1])\n\t\t};\n\t}\n}\nfunction lowerStdTypeMember(typeName, typeParameters) {\n\tif (typeof typeName !== \"string\") return {\n\t\tvarType: (typeName.std ? typeName.originalName : \"??\") + (typeParameters ? typeListToString(typeParameters) : \"\"),\n\t\tstorage: \"\"\n\t};\n}\nfunction lowerStorageTextureMember(typeName, typeParameters) {\n\tif (textureStorage.test(typeName.originalName)) return {\n\t\tvarType: typeName + (typeParameters ? typeListToString(typeParameters) : \"\"),\n\t\tstorage: \"\"\n\t};\n}\nfunction syntheticVar(attributes, varName, storageTemplate, varType) {\n\treturn {\n\t\tkind: \"synthetic\",\n\t\ttext: `${attributes} var${storageTemplate} ${varName} : ${varType};\\n`\n\t};\n}\n/** find all simple member references in the module that refer to binding structs */\nfunction findRefsToBindingStructs(moduleElem) {\n\tconst members = [];\n\tvisitAst(moduleElem, (elem) => {\n\t\tif (elem.kind === \"memberRef\") members.push(elem);\n\t});\n\treturn filterMap(members, refersToBindingStruct);\n}\n/** @return true if this memberRef refers to a binding struct */\nfunction refersToBindingStruct(memberRef) {\n\tconst found = traceToStruct(memberRef.name.ident);\n\tif (found?.struct.bindingStruct) return {\n\t\tmemberRef,\n\t\t...found\n\t};\n}\n/** If this identifier ultimately refers to a struct type, return the struct declaration */\nfunction traceToStruct(ident) {\n\tconst declElem = findDecl(ident).declElem;\n\tif (declElem && declElem.kind === \"param\") {\n\t\tconst name = declElem.name.typeRef?.name;\n\t\tif (typeof name !== \"string\") {\n\t\t\tif (name?.std) return;\n\t\t\tconst structElem = findDecl(name).declElem;\n\t\t\tif (structElem?.kind === \"struct\") return {\n\t\t\t\tstruct: structElem,\n\t\t\t\tintermediates: [declElem]\n\t\t\t};\n\t\t\treturn;\n\t\t}\n\t}\n}\n/** Mutate the member reference elem to instead contain synthetic elem text.\n* The new text is the mangled var name of the struct member that the memberRef refers to. */\nfunction transformBindingReference(memberRef, struct) {\n\tconst refName = memberRef.member.name;\n\tconst structMember = struct.members.find((m) => m.name.name === refName);\n\tif (!structMember || !structMember.mangledVarName) {\n\t\tif (debug) console.log(`missing mangledVarName for ${refName}`);\n\t\treturn {\n\t\t\tkind: \"synthetic\",\n\t\t\ttext: refName\n\t\t};\n\t}\n\tconst { extraComponents } = memberRef;\n\tconst extraText = extraComponents ? contentsToString(extraComponents) : \"\";\n\tconst synthElem = {\n\t\tkind: \"synthetic\",\n\t\ttext: structMember.mangledVarName + extraText\n\t};\n\tmemberRef.contents = [synthElem];\n\treturn synthElem;\n}\n\n//#endregion\n//#region src/WeslDevice.ts\n/**\n* Creates {@link WeslDevice} for usage with WESL.\n* Does not impact your existing code, wherever a {@link GPUDevice} can be used,\n* a {@link WeslDevice} is also valid.\n*\n* WESL uses a {@link WeslDevice} to display errors referencing the WESL source\n* instead of referencing the generated WGSL code.\n*/\nasync function requestWeslDevice(adapter, descriptor) {\n\tif (!adapter) throw new Error(\"No GPU adapter\");\n\treturn adapter.requestDevice(descriptor).then(makeWeslDevice);\n}\n/**\n* Mutates a {@link GPUDevice} for usage with WESL.\n* Does not impact your existing code, wherever a {@link GPUDevice} can be used,\n* a {@link WeslDevice} is also valid.\n*\n* WESL uses a {@link WeslDevice} to display errors referencing the WESL source\n* instead of referencing the generated WGSL code.\n*/\nfunction makeWeslDevice(device) {\n\tconst errorScopeStack = [];\n\tdevice.injectError = (type, error) => {\n\t\tconst errorScope = errorScopeStack.findLast((v) => v.filter === type);\n\t\tif (errorScope !== void 0) errorScope.errors.push(error);\n\t\telse error.then((e) => {\n\t\t\tif (e !== null) dispatchError(e);\n\t\t});\n\t};\n\tfunction dispatchError(e) {\n\t\tdevice.addEventListener(\"uncapturederror\", (ev) => {\n\t\t\tif (!ev.defaultPrevented) if (\"compilationInfo\" in ev.error) {\n\t\t\t\tconst error = ev.error;\n\t\t\t\tif (error.compilationInfo) for (const message of error.compilationInfo.messages) throwClickableError({\n\t\t\t\t\turl: message.module.url,\n\t\t\t\t\ttext: message.module.text ?? null,\n\t\t\t\t\tlineNumber: message.lineNum,\n\t\t\t\t\tlineColumn: message.linePos,\n\t\t\t\t\tlength: message.length,\n\t\t\t\t\terror: /* @__PURE__ */ new Error(message.type + \": \" + message.message)\n\t\t\t\t});\n\t\t\t\telse console.error(ev.error.message);\n\t\t\t} else console.error(ev.error.message);\n\t\t}, { once: true });\n\t\tdevice.dispatchEvent(new GPUUncapturedErrorEvent(\"uncapturederror\", { error: e }));\n\t}\n\tdevice.pushErrorScope = ((baseFn) => {\n\t\treturn function(filter) {\n\t\t\terrorScopeStack.push({\n\t\t\t\tfilter,\n\t\t\t\terrors: []\n\t\t\t});\n\t\t\treturn baseFn.call(this, filter);\n\t\t};\n\t})(device.pushErrorScope);\n\tdevice.popErrorScope = ((baseFn) => {\n\t\treturn function() {\n\t\t\tconst errorScope = errorScopeStack.pop();\n\t\t\tif (errorScope === void 0) throw new DOMException(\"popErrorScope called on empty error scope stack\", \"OperationError\");\n\t\t\terrorScope.errors.push(baseFn.call(this));\n\t\t\treturn Promise.all(errorScope.errors).then((values) => values.find((v) => v !== null) ?? null);\n\t\t};\n\t})(device.popErrorScope);\n\treturn device;\n}\n\n//#endregion\nexport { BundleResolver, CompositeResolver, LinkedWesl, ParseError, RecordResolver, SrcMap, SrcMapBuilder, TrackingResolver, WeslParseError, WeslStream, _linkSync, astToString, attributeToString, bindAndTransform, bindIdents, bindIdentsRecursive, bindingStructsPlugin, childIdent, childScope, containsScope, debug, debugContentsToString, discoverModules, emptyScope, errorHighlight, fileToModulePath, filterMap, filterValidElements, findAllRootDecls, findMap, findRefsToBindingStructs, findUnboundIdents, findUnboundRefs, findValidRootDecls, flatImports, groupBy, grouped, identToString, last, lengthPrefixMangle, link, linkRegistry, liveDeclsToString, log, lowerBindingStructs, makeLiveDecls, makeWeslDevice, mapForward, mapValues, markBindingStructs, markEntryTypes, mergeScope, minimalMangle, minimallyMangledName, modulePartsToRelativePath, moduleToRelativePath, multiKeySet, multisampledTextureTypes, nextIdentId, noSuffix, normalize, normalizeDebugRoot, normalizeModuleName, npmNameVariations, offsetToLineNumber, overlapTail, parseSrcModule, partition, publicDecl, replaceWords, requestWeslDevice, resetScopeIds, resolveModulePath, sampledTextureTypes, sanitizePackageName, scan, scopeToString, scopeToStringLong, srcLog, stdEnumerant, stdEnumerants, stdFn, stdFns, stdType, stdTypes, textureStorageTypes, transformBindingReference, transformBindingStruct, underscoreMangle, validation, wgslStandardAttributes, withLoggerAsync };"]}