{"version":3,"file":"5a3a367428254c857d025850c30ea2998bc580c9-d5fcc7b3d4a52f582898.js","mappings":";iHAEA,IAAIA,EAASC,OAAOC,UAAUC,eAC1BC,EAAQH,OAAOC,UAAUG,SACzBC,EAAiBL,OAAOK,eACxBC,EAAON,OAAOO,yBAEdC,EAAU,SAAiBC,GAC7B,MAA6B,mBAAlBC,MAAMF,QACRE,MAAMF,QAAQC,GAGI,mBAApBN,EAAMQ,KAAKF,EACpB,EAEIG,EAAgB,SAAuBC,GACzC,IAAKA,GAA2B,oBAApBV,EAAMQ,KAAKE,GACrB,OAAO,EAGT,IASIC,EATAC,EAAoBhB,EAAOY,KAAKE,EAAK,eACrCG,EAAmBH,EAAII,aAAeJ,EAAII,YAAYhB,WAAaF,EAAOY,KAAKE,EAAII,YAAYhB,UAAW,iBAE9G,GAAIY,EAAII,cAAgBF,IAAsBC,EAC5C,OAAO,EAOT,IAAKF,KAAOD,GAIZ,YAAsB,IAARC,GAAuBf,EAAOY,KAAKE,EAAKC,EACxD,EAGII,EAAc,SAAqBC,EAAQC,GACzCf,GAAmC,cAAjBe,EAAQC,KAC5BhB,EAAec,EAAQC,EAAQC,KAAM,CACnCC,YAAY,EACZC,cAAc,EACdC,MAAOJ,EAAQK,SACfC,UAAU,IAGZP,EAAOC,EAAQC,MAAQD,EAAQK,QAEnC,EAGIE,EAAc,SAAqBd,EAAKQ,GAC1C,GAAa,cAATA,EAAsB,CACxB,IAAKtB,EAAOY,KAAKE,EAAKQ,GACpB,OACK,GAAIf,EAGT,OAAOA,EAAKO,EAAKQ,GAAMG,KAE3B,CAEA,OAAOX,EAAIQ,EACb,EAEAO,EAAOC,QAAU,SAASC,IACxB,IAAIV,EAASC,EAAMU,EAAKC,EAAMC,EAAaC,EACvCf,EAASgB,UAAU,GACnBC,EAAI,EACJC,EAASF,UAAUE,OACnBC,GAAO,EAaX,IAXsB,kBAAXnB,IACTmB,EAAOnB,EACPA,EAASgB,UAAU,IAAM,CAAC,EAE1BC,EAAI,IAGQ,MAAVjB,GAAoC,iBAAXA,GAAyC,mBAAXA,KACzDA,EAAS,CAAC,GAGLiB,EAAIC,IAAUD,EAGnB,GAAe,OAFfhB,EAAUe,UAAUC,IAIlB,IAAKf,KAAQD,EACXW,EAAMJ,EAAYR,EAAQE,GAGtBF,KAFJa,EAAOL,EAAYP,EAASC,MAItBiB,GAAQN,IAASpB,EAAcoB,KAAUC,EAAczB,EAAQwB,MAC7DC,GACFA,GAAc,EACdC,EAAQH,GAAOvB,EAAQuB,GAAOA,EAAM,IAEpCG,EAAQH,GAAOnB,EAAcmB,GAAOA,EAAM,CAAC,EAI7Cb,EAAYC,EAAQ,CAClBE,KAAMA,EACNI,SAAUK,EAAOQ,EAAMJ,EAAOF,WAEP,IAATA,GAChBd,EAAYC,EAAQ,CAClBE,KAAMA,EACNI,SAAUO,KAStB,OAAOb,CACT,qBCxHA,IAAIoB,EAAgB,kCAChBC,EAAgB,MAChBC,EAAmB,OAEnBC,EAAiB,yCACjBC,EAAc,QACdC,EAAc,uDACdC,EAAkB,UAElBC,EAAa,aAKbC,EAAe,GA+OnB,SAASC,EAAKC,GACZ,OAAOA,EAAMA,EAAIC,QAAQJ,EAAYC,GAAgBA,CACvD,CArOAnB,EAAOC,QAAU,SAAUsB,EAAO/B,GAChC,GAAqB,iBAAV+B,EACT,MAAM,IAAIC,UAAU,mCAGtB,IAAKD,EAAO,MAAO,GACnB/B,EAAUA,GAAW,CAAC,EAKtB,IAAIiC,EAAS,EACTC,EAAS,EAOb,SAASC,EAAeN,GACtB,IAAIO,EAAQP,EAAIQ,MAAMjB,GAClBgB,IAAOH,GAAUG,EAAMnB,QAC3B,IAAID,EAAIa,EAAIS,YArCF,MAsCVJ,GAAUlB,EAAIa,EAAIZ,OAASD,EAAIkB,EAASL,EAAIZ,MAC9C,CAQA,SAASsB,IACP,IAAIC,EAAQ,CACVC,KAAMR,EACNC,OAAQA,GAEV,OAAO,SAAUQ,GAGf,OAFAA,EAAKH,SAAW,IAAII,EAASH,GAC7BI,IACOF,CACT,CACF,CAWA,SAASC,EAASH,GAChBK,KAAKL,MAAQA,EACbK,KAAKC,IAAM,CACTL,KAAMR,EACNC,OAAQA,GAEVW,KAAKE,OAAS/C,EAAQ+C,MACxB,CAMAJ,EAAS9D,UAAUmE,QAAUjB,EAC7B,IAAIkB,EAAa,GAQjB,SAASC,EAAMC,GACb,IAAIC,EAAM,IAAIC,MAAMrD,EAAQ+C,OAAS,IAAMd,EAAS,IAAMC,EAAS,KAAOiB,GAO1E,GANAC,EAAIE,OAASH,EACbC,EAAIG,SAAWvD,EAAQ+C,OACvBK,EAAIX,KAAOR,EACXmB,EAAIlB,OAASA,EACbkB,EAAIL,OAAShB,GAET/B,EAAQwD,OAGV,MAAMJ,EAFNH,EAAWQ,KAAKL,EAIpB,CASA,SAASf,EAAMqB,GACb,IAAIC,EAAID,EAAGE,KAAK7B,GAChB,GAAK4B,EAAL,CACA,IAAI9B,EAAM8B,EAAE,GAGZ,OAFAxB,EAAeN,GACfE,EAAQA,EAAM8B,MAAMhC,EAAIZ,QACjB0C,CAJO,CAKhB,CAMA,SAASf,IACPP,EAAMhB,EACR,CASA,SAASyC,EAASC,GAChB,IAAIC,EAGJ,IAFAD,EAAQA,GAAS,GAEVC,EAAIC,MACC,IAAND,GACFD,EAAMN,KAAKO,GAIf,OAAOD,CACT,CASA,SAASE,IACP,IAAIC,EAAM3B,IACV,GA7JgB,KA6JKR,EAAMoC,OAAO,IA5JvB,KA4JyCpC,EAAMoC,OAAO,GAAjE,CAGA,IAFA,IAAInD,EAAI,EAEDW,GAAgBI,EAAMoC,OAAOnD,KA/JzB,KA+J4Ce,EAAMoC,OAAOnD,IAhKpD,KAgK2Ee,EAAMoC,OAAOnD,EAAI,OACxGA,EAKJ,GAFAA,GAAK,EAEDW,IAAiBI,EAAMoC,OAAOnD,EAAI,GACpC,OAAOkC,EAAM,0BAGf,IAAIrB,EAAME,EAAM8B,MAAM,EAAG7C,EAAI,GAK7B,OAJAkB,GAAU,EACVC,EAAeN,GACfE,EAAQA,EAAM8B,MAAM7C,GACpBkB,GAAU,EACHgC,EAAI,CACTE,KA5Ka,UA6KbH,QAASpC,GApBgE,CAsB7E,CASA,SAASwC,IACP,IAAIH,EAAM3B,IAEN+B,EAAOjC,EAAMf,GACjB,GAAKgD,EAAL,CAGA,GAFAL,KAEK5B,EAAMd,GAAc,OAAO2B,EAAM,wBAEtC,IAAIqB,EAAMlC,EAAMb,GACZgD,EAAMN,EAAI,CACZE,KAlMiB,cAmMjBK,SAAU7C,EAAK0C,EAAK,GAAGxC,QAAQX,EAAeQ,IAC9CvB,MAAOmE,EAAM3C,EAAK2C,EAAI,GAAGzC,QAAQX,EAAeQ,IAAiBA,IAInE,OADAU,EAAMZ,GACC+C,CAbU,CAcnB,CAyBA,OADA5B,IAhBA,WACE,IAGI8B,EAHAC,EAAQ,GAKZ,IAJAb,EAASa,GAIFD,EAAOL,MACC,IAATK,IACFC,EAAMlB,KAAKiB,GACXZ,EAASa,IAIb,OAAOA,CACT,CAGOC,EACT,qBChPApE,EAAOC,QAAU,SAAkBhB,GACjC,OAAc,MAAPA,GAAkC,MAAnBA,EAAII,aAA2D,mBAA7BJ,EAAII,YAAYgF,UAA2BpF,EAAII,YAAYgF,SAASpF,EAC9H,kCCNA,IAAIqF,EAAc,CAAC,EAwCnB,SAASC,EAAOC,EAAQC,EAASC,GAC/B,IAAIlE,EACAmE,EACAC,EACAC,EACAC,EACAC,EAAS,GAcb,IAZuB,iBAAZN,IAETC,EAAcD,EACdA,EAAUF,EAAOS,mBAGQ,IAAhBN,IACTA,GAAc,GAGhBI,EAtDF,SAAwBL,GACtB,IAAIjE,EACAyE,EACAH,EAAQR,EAAYG,GAExB,GAAIK,EACF,OAAOA,EAKT,IAFAA,EAAQR,EAAYG,GAAW,GAE1BjE,EAAI,EAAGA,EAAI,IAAKA,IACnByE,EAAKC,OAAOC,aAAa3E,GAErB,cAAc4E,KAAKH,GAErBH,EAAM7B,KAAKgC,GAEXH,EAAM7B,KAAK,KAAO,IAAMzC,EAAEhC,SAAS,IAAI6G,eAAehC,OAAO,IAIjE,IAAK7C,EAAI,EAAGA,EAAIiE,EAAQhE,OAAQD,IAC9BsE,EAAML,EAAQa,WAAW9E,IAAMiE,EAAQjE,GAGzC,OAAOsE,CACT,CA2BUS,CAAed,GAElBjE,EAAI,EAAGmE,EAAIH,EAAO/D,OAAQD,EAAImE,EAAGnE,IAGpC,GAFAoE,EAAOJ,EAAOc,WAAW9E,GAErBkE,GAAwB,KAATE,GAEhBpE,EAAI,EAAImE,GACL,iBAAiBS,KAAKZ,EAAOnB,MAAM7C,EAAI,EAAGA,EAAI,IAChDuE,GAAUP,EAAOnB,MAAM7C,EAAGA,EAAI,GAC9BA,GAAK,OAKT,GAAIoE,EAAO,IACTG,GAAUD,EAAMF,QAIlB,GAAIA,GAAQ,OAAUA,GAAQ,MAA9B,CACE,GAAIA,GAAQ,OAAUA,GAAQ,OAAUpE,EAAI,EAAImE,IAC9CE,EAAWL,EAAOc,WAAW9E,EAAI,KAEjB,OAAUqE,GAAY,MAAQ,CAC5CE,GAAUS,mBAAmBhB,EAAOhE,GAAKgE,EAAOhE,EAAI,IACpDA,IACA,QACF,CAGFuE,GAAU,WAEZ,MAEAA,GAAUS,mBAAmBhB,EAAOhE,IAGtC,OAAOuE,CACT,CAEAR,EAAOS,aAAe,uBACtBT,EAAOkB,eAAiB,YACxBzF,EAAOC,QAAUsE,qrBCzFV,SAASmB,EAAkB9F,GAEhC,OAAKA,GAA0B,iBAAVA,EAKjB,aAAcA,GAAS,SAAUA,EAC5BmC,EAASnC,EAAMmC,UAIpB,UAAWnC,GAAS,QAASA,EACxBmC,EAASnC,GAId,SAAUA,GAAS,WAAYA,EAC1B+F,EAAM/F,GAIR,GAnBE,EAoBX,CAMA,SAAS+F,EAAMA,GACb,OAAOC,EAAMD,GAASA,EAAM1D,MAAQ,IAAM2D,EAAMD,GAASA,EAAMjE,OACjE,CAOA,SAASK,EAAS2B,GAChB,OAAOiC,EAAMjC,GAAOA,EAAI1B,OAAS,IAAM2D,EAAMjC,GAAOA,EAAIpB,IAC1D,CAOA,SAASsD,EAAMhG,GACb,OAAOA,GAA0B,iBAAVA,EAAqBA,EAAQ,CACtD,CCxDO,MAAMiG,UAAqBhD,MAShCxD,YAAYyD,EAAQgD,EAAOC,GAEzB,MAAMC,EAAQ,CAAC,KAAM,MAGrB,IAAIjE,EAAW,CAEbC,MAAO,CACLC,KAAM,KACNP,OAAQ,MAGVY,IAAK,CACHL,KAAM,KACNP,OAAQ,OAUZ,GAPAuE,QAEqB,iBAAVH,IACTC,EAASD,EACTA,OAAQI,GAGY,iBAAXH,EAAqB,CAC9B,MAAMH,EAAQG,EAAOI,QAAQ,MAEd,IAAXP,EACFI,EAAM,GAAKD,GAEXC,EAAM,GAAKD,EAAO1C,MAAM,EAAGuC,GAC3BI,EAAM,GAAKD,EAAO1C,MAAMuC,EAAQ,GAEpC,CAEIE,IAEE,SAAUA,GAAS,aAAcA,EAC/BA,EAAM/D,WACRA,EAAW+D,EAAM/D,UAGZ,UAAW+D,GAAS,QAASA,EACpC/D,EAAW+D,GAEJ,SAAUA,GAAS,WAAYA,KACtC/D,EAASC,MAAQ8D,IAKrBzD,KAAK5C,KAAOiG,EAAkBI,IAAU,MACxCzD,KAAK+D,QAA4B,iBAAXtD,EAAsBA,EAAOsD,QAAUtD,EAC7DT,KAAKgE,MAA0B,iBAAXvD,EAAsBA,EAAOuD,MAAQ,GAMzDhE,KAAKS,OAAST,KAAK+D,QAOnB/D,KAAKiE,MAMLjE,KAAKJ,KAAOF,EAASC,MAAMC,KAM3BI,KAAKX,OAASK,EAASC,MAAMN,OAM7BW,KAAKE,OAASyD,EAAM,GAMpB3D,KAAKkE,OAASP,EAAM,GAOpB3D,KAAKN,SAAWA,EAYhBM,KAAKmE,OAOLnE,KAAKoE,SAMLpE,KAAKqE,KAMLrE,KAAKsE,IAMLtE,KAAKuE,IAEP,EAGFf,EAAaxH,UAAUqI,KAAO,GAC9Bb,EAAaxH,UAAUoB,KAAO,GAC9BoG,EAAaxH,UAAUyE,OAAS,GAChC+C,EAAaxH,UAAU+H,QAAU,GACjCP,EAAaxH,UAAUgI,MAAQ,GAC/BR,EAAaxH,UAAUiI,MAAQ,KAC/BT,EAAaxH,UAAUqD,OAAS,KAChCmE,EAAaxH,UAAU4D,KAAO,KAC9B4D,EAAaxH,UAAUkE,OAAS,KAChCsD,EAAaxH,UAAUkI,OAAS,KAChCV,EAAaxH,UAAU0D,SAAW,KCnH3B,MAAM8E,EAAO,CAClBC,SAcF,SAAkBD,EAAME,GACtB,QAAYb,IAARa,GAAoC,iBAARA,EAC9B,MAAM,IAAIvF,UAAU,mCAGtBwF,EAAWH,GACX,IAKII,EALAjF,EAAQ,EACRM,GAAO,EACPsD,EAAQiB,EAAKpG,OAKjB,QAAYyF,IAARa,GAAoC,IAAfA,EAAItG,QAAgBsG,EAAItG,OAASoG,EAAKpG,OAAQ,CACrE,KAAOmF,KACL,GAA+B,KAA3BiB,EAAKvB,WAAWM,IAKlB,GAAIqB,EAAc,CAChBjF,EAAQ4D,EAAQ,EAChB,KACF,OACStD,EAAM,IAGf2E,GAAe,EACf3E,EAAMsD,EAAQ,GAIlB,OAAOtD,EAAM,EAAI,GAAKuE,EAAKxD,MAAMrB,EAAOM,EAC1C,CAEA,GAAIyE,IAAQF,EACV,MAAO,GAGT,IAAIK,GAAoB,EACpBC,EAAWJ,EAAItG,OAAS,EAE5B,KAAOmF,KACL,GAA+B,KAA3BiB,EAAKvB,WAAWM,IAKlB,GAAIqB,EAAc,CAChBjF,EAAQ4D,EAAQ,EAChB,KACF,OAEIsB,EAAmB,IAGrBD,GAAe,EACfC,EAAmBtB,EAAQ,GAGzBuB,GAAY,IAEVN,EAAKvB,WAAWM,KAAWmB,EAAIzB,WAAW6B,KACxCA,EAAW,IAGb7E,EAAMsD,IAKRuB,GAAY,EACZ7E,EAAM4E,IAMVlF,IAAUM,EACZA,EAAM4E,EACG5E,EAAM,IACfA,EAAMuE,EAAKpG,QAGb,OAAOoG,EAAKxD,MAAMrB,EAAOM,EAC3B,EAlGE8E,QAyGF,SAAiBP,GAGf,GAFAG,EAAWH,GAES,IAAhBA,EAAKpG,OACP,MAAO,IAGT,IAII4G,EAJA/E,GAAO,EACPsD,EAAQiB,EAAKpG,OAKjB,OAASmF,GACP,GAA+B,KAA3BiB,EAAKvB,WAAWM,IAGlB,GAAIyB,EAAgB,CAClB/E,EAAMsD,EACN,KACF,OACUyB,IAEVA,GAAiB,GAIrB,OAAO/E,EAAM,EAA2B,KAAvBuE,EAAKvB,WAAW,GAE/B,IAAM,IAAc,IAARhD,GAAoC,KAAvBuE,EAAKvB,WAAW,GAEzC,KAAOuB,EAAKxD,MAAM,EAAGf,EACzB,EAxIEgF,QA+IF,SAAiBT,GACfG,EAAWH,GACX,IASIQ,EATAzB,EAAQiB,EAAKpG,OACb6B,GAAO,EACPiF,EAAY,EACZC,GAAY,EAGZC,EAAc,EAKlB,KAAO7B,KAAS,CACd,MAAMhB,EAAOiC,EAAKvB,WAAWM,GAE7B,GAAa,KAAThB,EAaAtC,EAAM,IAGR+E,GAAiB,EACjB/E,EAAMsD,EAAQ,GAGH,KAAThB,EAIE4C,EAAW,EACbA,EAAW5B,EACc,IAAhB6B,IACTA,EAAc,GAEPD,GAAY,IAGrBC,GAAe,QA3Bf,GAAIJ,EAAgB,CAClBE,EAAY3B,EAAQ,EACpB,KACF,CA0BJ,CAEA,GAAI4B,EAAW,GAAKlF,EAAM,GACV,IAAhBmF,GACgB,IAAhBA,GAAqBD,IAAalF,EAAM,GAAKkF,IAAaD,EAAY,EACpE,MAAO,GAGT,OAAOV,EAAKxD,MAAMmE,EAAUlF,EAC9B,EAzMEoF,KAgNF,WACE,IAGIC,EAHA/B,GAAS,EAKb,IAAK,IAAIgC,EAAOrH,UAAUE,OAAQoH,EAAW,IAAI/I,MAAM8I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IACnFD,EAASC,GAAQvH,UAAUuH,GAG7B,OAASlC,EAAQiC,EAASpH,QACxBuG,EAAWa,EAASjC,IAEhBiC,EAASjC,KACX+B,OAAoBzB,IAAXyB,EAAuBE,EAASjC,GAAS+B,EAAS,IAAME,EAASjC,IAI9E,YAAkBM,IAAXyB,EAAuB,IAAMI,EAAUJ,EAChD,EAlOEK,IAAK,KA4OP,SAASD,EAAUlB,GACjBG,EAAWH,GACX,MAAMoB,EAAkC,KAAvBpB,EAAKvB,WAAW,GAIjC,IAAI1F,EAuBN,SAAyBiH,EAAMqB,GAC7B,IAOItD,EAGAuD,EAVApD,EAAS,GACTqD,EAAoB,EACpBC,GAAa,EACbC,EAAO,EACP1C,GAAS,EAQb,OAASA,GAASiB,EAAKpG,QAAQ,CAC7B,GAAImF,EAAQiB,EAAKpG,OACfmE,EAAOiC,EAAKvB,WAAWM,OAClB,IAAa,KAAThB,EAGT,MAEAA,EAAO,EAET,CAEA,GAAa,KAATA,EAEF,CACA,GAAIyD,IAAczC,EAAQ,GAAc,IAAT0C,QACxB,GAAID,IAAczC,EAAQ,GAAc,IAAT0C,EAAY,CAChD,GAAIvD,EAAOtE,OAAS,GAA2B,IAAtB2H,GAAoE,KAAzCrD,EAAOO,WAAWP,EAAOtE,OAAS,IAE1C,KAAzCsE,EAAOO,WAAWP,EAAOtE,OAAS,GAGnC,GAAIsE,EAAOtE,OAAS,GAGlB,GAFA0H,EAAiBpD,EAAOjD,YAAY,KAEhCqG,IAAmBpD,EAAOtE,OAAS,EAAG,CACpC0H,EAAiB,GACnBpD,EAAS,GACTqD,EAAoB,IAEpBrD,EAASA,EAAO1B,MAAM,EAAG8E,GACzBC,EAAoBrD,EAAOtE,OAAS,EAAIsE,EAAOjD,YAAY,MAG7DuG,EAAYzC,EACZ0C,EAAO,EACP,QACF,OACK,GAAIvD,EAAOtE,OAAS,EAAG,CAC5BsE,EAAS,GACTqD,EAAoB,EACpBC,EAAYzC,EACZ0C,EAAO,EACP,QACF,CAGEJ,IACFnD,EAASA,EAAOtE,OAAS,EAAIsE,EAAS,MAAQ,KAC9CqD,EAAoB,EAExB,MACMrD,EAAOtE,OAAS,EAClBsE,GAAU,IAAM8B,EAAKxD,MAAMgF,EAAY,EAAGzC,GAE1Cb,EAAS8B,EAAKxD,MAAMgF,EAAY,EAAGzC,GAGrCwC,EAAoBxC,EAAQyC,EAAY,EAG1CA,EAAYzC,EACZ0C,EAAO,CACT,MAAoB,KAAT1D,GAER0D,GAAQ,EACTA,IAEAA,GAAQ,CAEZ,CAEA,OAAOvD,CACT,CA7GcwD,CAAgB1B,GAAOoB,GAYnC,OAVqB,IAAjBrI,EAAMa,QAAiBwH,IACzBrI,EAAQ,KAGNA,EAAMa,OAAS,GAA0C,KAArCoG,EAAKvB,WAAWuB,EAAKpG,OAAS,KAGpDb,GAAS,KAGJqI,EAAW,IAAMrI,EAAQA,CAClC,CAsGA,SAASoH,EAAWH,GAClB,GAAoB,iBAATA,EACT,MAAM,IAAIrF,UAAU,mCAAqCgH,KAAKC,UAAU5B,GAE5E,CC7ZO,MAAM6B,EAAO,CAClBC,IAGF,WACE,MAAO,GACT,GCcO,SAASC,EAAMC,GACpB,OAAyB,OAAlBA,GAAmD,iBAAlBA,GACxCA,EAAcC,MACdD,EAAc9C,MAChB,CCpBO,SAASgD,EAAUlC,GACxB,GAAoB,iBAATA,EACTA,EAAO,IAAImC,IAAInC,QACV,IAAK+B,EAAM/B,GAAO,CAEvB,MAAMnE,EAAQ,IAAIlB,UAAU,+EAAiFqF,EAAO,KAEpH,MADAnE,EAAMkC,KAAO,uBACPlC,CACR,CAEA,GAAsB,UAAlBmE,EAAKoC,SAAsB,CAE7B,MAAMvG,EAAQ,IAAIlB,UAAU,kCAE5B,MADAkB,EAAMkC,KAAO,yBACPlC,CACR,CAEA,OAMF,SAA6BiE,GAC3B,GAAqB,KAAjBA,EAAIuC,SAAiB,CAEvB,MAAMxG,EAAQ,IAAIlB,UAAU,wDAE5B,MADAkB,EAAMkC,KAAO,4BACPlC,CACR,CAEA,MAAMyG,EAAWxC,EAAIwC,SACrB,IAAIvD,GAAS,EAEb,OAASA,EAAQuD,EAAS1I,QACxB,GAAmC,KAA/B0I,EAAS7D,WAAWM,IAEc,KAAnCuD,EAAS7D,WAAWM,EAAQ,GAE7B,CACA,MAAMwD,EAAQD,EAAS7D,WAAWM,EAAQ,GAE1C,GAAc,KAAVwD,GAES,MAAVA,EAED,CAEA,MAAM1G,EAAQ,IAAIlB,UAAU,uDAE5B,MADAkB,EAAMkC,KAAO,4BACPlC,CACR,CACF,CAGF,OAAO2G,mBAAmBF,EAC5B,CAvCSG,CAAoBzC,EAC7B,CC8BA,MAAM0C,EAAQ,CAAC,UAAW,OAAQ,WAAY,OAAQ,UAAW,WAC1D,MAAMC,EAkBXnK,YAAYO,GAEV,IAAIJ,EAMFA,EAJGI,EAEuB,iBAAVA,GAAsB,IAAOA,GAEnC,CACRA,SAEOgJ,EAAMhJ,GACL,CACRiH,KAAMjH,GAIEA,EAZA,CAAC,EAsBbyC,KAAKoH,KAAO,CAAC,EAMbpH,KAAKqH,SAAW,GAOhBrH,KAAKsH,QAAU,GAMftH,KAAKsG,IAAMD,EAAKC,MAQhBtG,KAAKzC,MASLyC,KAAKuH,OASLvH,KAAK0C,OASL1C,KAAKwH,IAIL,IAcI/F,EAdA8B,GAAS,EAEb,OAASA,EAAQ2D,EAAM9I,QAAQ,CAC7B,MAAMqD,EAAOyF,EAAM3D,GAGf9B,KAAQtE,QAA6B0G,IAAlB1G,EAAQsE,KAE7BzB,KAAKyB,GAAiB,YAATA,EAAqB,IAAItE,EAAQsE,IAAStE,EAAQsE,GAEnE,CAMA,IAAKA,KAAQtE,EAEN+J,EAAMO,SAAShG,KAAOzB,KAAKyB,GAAQtE,EAAQsE,GAEpD,CAOI+C,WACF,OAAOxE,KAAKsH,QAAQtH,KAAKsH,QAAQlJ,OAAS,EAC5C,CAUIoG,SAAKA,GACH+B,EAAM/B,KACRA,EAAOkC,EAAUlC,IAGnBkD,EAAelD,EAAM,QAEjBxE,KAAKwE,OAASA,GAChBxE,KAAKsH,QAAQ1G,KAAK4D,EAEtB,CAMIO,cACF,MAA4B,iBAAd/E,KAAKwE,KAAoBA,EAAKO,QAAQ/E,KAAKwE,WAAQX,CACnE,CAOIkB,YAAQA,GACV,EAAW/E,KAAKyE,SAAU,WAC1BzE,KAAKwE,KAAOA,EAAKa,KAAKN,GAAW,GAAI/E,KAAKyE,SAC5C,CAMIA,eACF,MAA4B,iBAAdzE,KAAKwE,KAAoBA,EAAKC,SAASzE,KAAKwE,WAAQX,CACpE,CASIY,aAASA,GACXiD,EAAejD,EAAU,YACzBkD,EAAWlD,EAAU,YACrBzE,KAAKwE,KAAOA,EAAKa,KAAKrF,KAAK+E,SAAW,GAAIN,EAC5C,CAMIQ,cACF,MAA4B,iBAAdjF,KAAKwE,KAAoBA,EAAKS,QAAQjF,KAAKwE,WAAQX,CACnE,CASIoB,YAAQA,GAIV,GAHA0C,EAAW1C,EAAS,WACpB,EAAWjF,KAAK+E,QAAS,WAErBE,EAAS,CACX,GAA8B,KAA1BA,EAAQhC,WAAW,GAGrB,MAAM,IAAIzC,MAAM,iCAGlB,GAAIyE,EAAQwC,SAAS,IAAK,GACxB,MAAM,IAAIjH,MAAM,yCAEpB,CAEAR,KAAKwE,KAAOA,EAAKa,KAAKrF,KAAK+E,QAAS/E,KAAK4H,MAAQ3C,GAAW,IAC9D,CAMI2C,WACF,MAA4B,iBAAd5H,KAAKwE,KAAoBA,EAAKC,SAASzE,KAAKwE,KAAMxE,KAAKiF,cAAWpB,CAClF,CASI+D,SAAKA,GACPF,EAAeE,EAAM,QACrBD,EAAWC,EAAM,QACjB5H,KAAKwE,KAAOA,EAAKa,KAAKrF,KAAK+E,SAAW,GAAI6C,GAAQ5H,KAAKiF,SAAW,IACpE,CAYA9I,SAAS0L,GACP,OAAQ7H,KAAKzC,OAAS,IAAIpB,SAAS0L,EACrC,CAiBA9D,QAAQtD,EAAQgD,EAAOC,GACrB,MAAMK,EAAU,IAAIP,EAAa/C,EAAQgD,EAAOC,GAShD,OAPI1D,KAAKwE,OACPT,EAAQ3G,KAAO4C,KAAKwE,KAAO,IAAMT,EAAQ3G,KACzC2G,EAAQM,KAAOrE,KAAKwE,MAGtBT,EAAQE,OAAQ,EAChBjE,KAAKqH,SAASzG,KAAKmD,GACZA,CACT,CAgBA+D,KAAKrH,EAAQgD,EAAOC,GAClB,MAAMK,EAAU/D,KAAK+D,QAAQtD,EAAQgD,EAAOC,GAE5C,OADAK,EAAQE,MAAQ,KACTF,CACT,CAkBAgE,KAAKtH,EAAQgD,EAAOC,GAClB,MAAMK,EAAU/D,KAAK+D,QAAQtD,EAAQgD,EAAOC,GAE5C,MADAK,EAAQE,OAAQ,EACVF,CACR,EAWF,SAAS4D,EAAWK,EAAM5K,GACxB,GAAI4K,GAAQA,EAAKP,SAASjD,EAAKmB,KAC7B,MAAM,IAAInF,MAAM,IAAMpD,EAAO,uCAAyCoH,EAAKmB,IAAM,IAErF,CAUA,SAAS+B,EAAeM,EAAM5K,GAC5B,IAAK4K,EACH,MAAM,IAAIxH,MAAM,IAAMpD,EAAO,oBAEjC,CAUA,SAAS,EAAWoH,EAAMpH,GACxB,IAAKoH,EACH,MAAM,IAAIhE,MAAM,YAAcpD,EAAO,kCAEzC,CCtaO,SAAS6K,EAAK5H,GACnB,GAAIA,EACF,MAAMA,CAEV,yBCXe,SAAS1D,EAAcY,GACpC,GAAqB,iBAAVA,GAAgC,OAAVA,EAC/B,OAAO,EAGT,MAAMvB,EAAYD,OAAOmM,eAAe3K,GACxC,QAAsB,OAAdvB,GAAsBA,IAAcD,OAAOC,WAAkD,OAArCD,OAAOmM,eAAelM,IAA0BmM,OAAOC,eAAe7K,GAAY4K,OAAOE,YAAY9K,EACvK,CC+FO,SAAS+K,EAAKC,EAAYC,GAE/B,IAAIC,EACJ,OAQA,WACE,IAAK,IAAIC,EAAQxK,UAAUE,OAAQuK,EAAa,IAAIlM,MAAMiM,GAAQE,EAAQ,EAAGA,EAAQF,EAAOE,IAC1FD,EAAWC,GAAS1K,UAAU0K,GAGhC,MAAMC,EAAoBN,EAAWnK,OAASuK,EAAWvK,OAGzD,IAAIsE,EAEAmG,GACFF,EAAW/H,KAAKkI,GAGlB,IACEpG,EAAS6F,EAAWQ,MAAM/I,KAAM2I,EAclC,CAbE,MAAOtI,GACP,MAAM2I,EAEN3I,EAKA,GAAIwI,GAAqBJ,EACvB,MAAMO,EAGR,OAAOF,EAAKE,EACd,CAEKH,IACCnG,aAAkBuG,QACpBvG,EAAOwG,KAAKA,EAAMJ,GACTpG,aAAkBlC,MAC3BsI,EAAKpG,GAELwG,EAAKxG,GAGX,EAOA,SAASoG,EAAKzI,GACZ,IAAKoI,EAAQ,CACXA,GAAS,EAET,IAAK,IAAIU,EAAQjL,UAAUE,OAAQgL,EAAS,IAAI3M,MAAM0M,EAAQ,EAAIA,EAAQ,EAAI,GAAIE,EAAQ,EAAGA,EAAQF,EAAOE,IAC1GD,EAAOC,EAAQ,GAAKnL,UAAUmL,GAGhCb,EAASnI,KAAU+I,EACrB,CACF,CAQA,SAASF,EAAK3L,GACZuL,EAAK,KAAMvL,EACb,CACF,CC3JO,MAAM+L,EAOb,SAASC,IACP,MAAMC,EDjBD,WAEL,MAAMC,EAAM,GAGNC,EAAW,CACfC,IAMF,WACE,IAAK,IAAIpE,EAAOrH,UAAUE,OAAQwL,EAAS,IAAInN,MAAM8I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IACjFmE,EAAOnE,GAAQvH,UAAUuH,GAG3B,IAAIoE,GAAmB,EAGvB,MAAMrB,EAAWoB,EAAOE,MAExB,GAAwB,mBAAbtB,EACT,MAAM,IAAIrJ,UAAU,2CAA6CqJ,GAWnE,SAASuB,EAAK1J,GACZ,MAAM2J,EAAKP,IAAMI,GACjB,IAAItG,GAAS,EAEb,GAAIlD,EACFmI,EAASnI,OADX,CAMA,IAAK,IAAI4J,EAAQ/L,UAAUE,OAAQgL,EAAS,IAAI3M,MAAMwN,EAAQ,EAAIA,EAAQ,EAAI,GAAIC,EAAQ,EAAGA,EAAQD,EAAOC,IAC1Gd,EAAOc,EAAQ,GAAKhM,UAAUgM,GAGhC,OAAS3G,EAAQqG,EAAOxL,QACA,OAAlBgL,EAAO7F,SAAqCM,IAAlBuF,EAAO7F,KACnC6F,EAAO7F,GAASqG,EAAOrG,IAK3BqG,EAASR,EAELY,EACF1B,EAAK0B,EAAID,EAATzB,IAAkBc,GAElBZ,EAAS,QAASY,EAnBpB,CAqBF,CApCAW,EAAK,QAASH,EAqChB,EAxDEO,IA4DF,SAAaC,GACX,GAA0B,mBAAfA,EACT,MAAM,IAAIjL,UAAU,+CAAiDiL,GAIvE,OADAX,EAAI7I,KAAKwJ,GACFV,CACT,GAjEA,OAAOA,CAkET,CC1DuBW,GAGfC,EAAY,GAGlB,IAGIC,EAHAC,EAAY,CAAC,EAIbC,GAAe,EAsBnB,OAnBAC,EAAUtD,KAyCV,SAAcvK,EAAKU,GACjB,GAAmB,iBAARV,EAET,OAAyB,IAArBqB,UAAUE,QACZuM,EAAe,OAAQJ,GACvBC,EAAU3N,GAAOU,EACVmN,GAIFE,EAAIlO,KAAK8N,EAAW3N,IAAQ2N,EAAU3N,IAAQ,KAIvD,GAAIA,EAGF,OAFA8N,EAAe,OAAQJ,GACvBC,EAAY3N,EACL6N,EAIT,OAAOF,CACT,EA9DAE,EAAUG,YAAShH,EACnB6G,EAAUI,cAAWjH,EAErB6G,EAAUK,OA+DV,WACE,GAAIR,EACF,OAAOG,EAGT,OAASD,EAAcH,EAAUlM,QAAQ,CACvC,MAAO4M,KAAa7N,GAAWmN,EAAUG,GAEzC,IAAmB,IAAftN,EAAQ,GACV,UAGiB,IAAfA,EAAQ,KACVA,EAAQ,QAAK0G,GAKf,MAAMoH,EAAcD,EAAStO,KAAKgO,KAAcvN,GAErB,mBAAhB8N,GACTzB,EAAaW,IAAIc,EAErB,CAIA,OAFAV,GAAS,EACTE,EAAcS,OAAOC,kBACdT,CACT,EAzFAA,EAAUJ,UAAYA,EAEtBI,EAAUP,IA+FV,SAAa5M,GACX,IAAK,IAAIgI,EAAOrH,UAAUE,OAAQjB,EAAU,IAAIV,MAAM8I,EAAO,EAAIA,EAAO,EAAI,GAAIE,EAAO,EAAGA,EAAOF,EAAME,IACrGtI,EAAQsI,EAAO,GAAKvH,UAAUuH,GAIhC,IAAI2F,EAGJ,GAFAT,EAAe,MAAOJ,GAElBhN,cACG,GAAqB,mBAAVA,EAChB8N,EAAU9N,KAAUJ,OACf,IAAqB,iBAAVI,EAOhB,MAAM,IAAI4B,UAAU,+BAAiC5B,EAAQ,KANzDd,MAAMF,QAAQgB,GAChB+N,EAAQ/N,GAERgO,EAAUhO,EAId,CAEI6N,IACFZ,EAAUY,SAAWrP,OAAOyP,OAAOhB,EAAUY,UAAY,CAAC,EAAGA,IAG/D,OAAOV,EAMP,SAASe,EAAIlO,GACX,GAAqB,mBAAVA,EACT8N,EAAU9N,OACL,IAAqB,iBAAVA,EAQhB,MAAM,IAAI4B,UAAU,+BAAiC5B,EAAQ,KAP7D,GAAId,MAAMF,QAAQgB,GAAQ,CACxB,MAAOmO,KAAWvO,GAAWI,EAC7B8N,EAAUK,KAAWvO,EACvB,MACEoO,EAAUhO,EAId,CACF,CAOA,SAASgO,EAAU7I,GACjB4I,EAAQ5I,EAAOiJ,SAEXjJ,EAAO0I,WACTA,EAAWrP,OAAOyP,OAAOJ,GAAY,CAAC,EAAG1I,EAAO0I,UAEpD,CAOA,SAASE,EAAQK,GACf,IAAIpI,GAAS,EAEb,GAAIoI,aACG,KAAIlP,MAAMF,QAAQoP,GAMvB,MAAM,IAAIxM,UAAU,oCAAsCwM,EAAU,KALpE,OAASpI,EAAQoI,EAAQvN,QAAQ,CAE/BqN,EADcE,EAAQpI,GAExB,CAGF,CACF,CAQA,SAAS8H,EAAUK,EAAQnO,GACzB,IAGIqO,EAHArI,GAAS,EAKb,OAASA,EAAQ+G,EAAUlM,QACzB,GAAIkM,EAAU/G,GAAO,KAAOmI,EAAQ,CAClCE,EAAQtB,EAAU/G,GAClB,KACF,CAGEqI,GACE,EAAWA,EAAM,KAAO,EAAWrO,KACrCA,EAAQ,KAAO,EAAMqO,EAAM,GAAIrO,IAGjCqO,EAAM,GAAKrO,GAGX+M,EAAU1J,KAAK,IAAI1C,WAEvB,CACF,EA1MAwM,EAAUmB,MA8MV,SAAeC,GACbpB,EAAUK,SACV,MAAM1G,EAAO0H,EAAMD,GACbjB,EAASH,EAAUG,OAGzB,GAFAmB,EAAa,QAASnB,GAElBoB,EAAQpB,EAAQ,SAElB,OAAO,IAAIA,EAAOhI,OAAOwB,GAAOA,GAAMwH,QAIxC,OAAOhB,EAAOhI,OAAOwB,GAAOA,EAC9B,EA1NAqG,EAAUtE,UA8NV,SAAmBvG,EAAMiM,GACvBpB,EAAUK,SACV,MAAM1G,EAAO0H,EAAMD,GACbhB,EAAWJ,EAAUI,SAI3B,GAHAoB,EAAe,YAAapB,GAC5BqB,EAAWtM,GAEPoM,EAAQnB,EAAU,WAEpB,OAAO,IAAIA,EAASjL,EAAMwE,GAAM+H,UAIlC,OAAOtB,EAASjL,EAAMwE,EACxB,EA1OAqG,EAAUf,IAmPV,SAAa9J,EAAMiM,EAAKtD,GACtB2D,EAAWtM,GACX6K,EAAUK,SAELvC,GAA2B,mBAARsD,IACtBtD,EAAWsD,EACXA,OAAMjI,GAGR,IAAK2E,EACH,OAAO,IAAIS,QAAQoD,GAUrB,SAASA,EAASC,EAASC,GAUzB,SAASzD,EAAKzI,EAAOmM,EAAMnI,GACzBmI,EAAOA,GAAQ3M,EAEXQ,EACFkM,EAAOlM,GACEiM,EACTA,EAAQE,GAGRhE,EAAS,KAAMgE,EAAMnI,EAEzB,CAnBAmF,EAAaG,IAAI9J,EAAMkM,EAAMD,GAAMhD,EAoBrC,CA7BAuD,EAAS,KAAM7D,EA8BjB,EA7RAkC,EAAU+B,QAiSV,SAAiB5M,EAAMwE,GAErB,IAAI3B,EAGAgK,EAIJ,OAHAhC,EAAUf,IAAI9J,EAAMwE,EAAMyE,GAC1B6D,EAAW,UAAW,MAAOD,GAEtBhK,EAOP,SAASoG,EAAKzI,EAAOmM,GACnBvE,EAAK5H,GACLqC,EAAS8J,EACTE,GAAW,CACb,CACF,EApTAhC,EAAUkC,QA4TV,SAAiBd,EAAKtD,GAKpB,GAJAkC,EAAUK,SACViB,EAAa,UAAWtB,EAAUG,QAClCqB,EAAe,UAAWxB,EAAUI,WAE/BtC,EACH,OAAO,IAAIS,QAAQoD,GAUrB,SAASA,EAASC,EAASC,GACzB,MAAMlI,EAAO0H,EAAMD,GAwBnB,SAAShD,EAAKzI,EAAOgE,GACfhE,IAAUgE,EACZkI,EAAOlM,GACEiM,EACTA,EAAQjI,GAGRmE,EAAS,KAAMnE,EAEnB,CAhCAqG,EAAUf,IAAIe,EAAUmB,MAAMxH,GAAOA,GAAM,CAAChE,EAAOmM,EAAMnI,KACvD,IAAIhE,GAAUmM,GAASnI,EAEhB,CAEL,MAAM3B,EAASgI,EAAUtE,UAAUoG,EAAMnI,GAErC3B,UA2LY,iBADInF,EAzLYmF,IA0LJ,IAASnF,GAzLnC8G,EAAK9G,MAAQmF,EAEb2B,EAAK3B,OAASA,GAGhBoG,EAAKzI,EAAOgE,EACd,MAbEyE,EAAKzI,GA+Lf,IAA8B9C,CAlLtB,GAkBJ,CA1CA8O,EAAS,KAAM7D,EA2CjB,EA/WAkC,EAAUmC,YAmXV,SAAqBf,GAEnB,IAAIY,EACJhC,EAAUK,SACViB,EAAa,cAAetB,EAAUG,QACtCqB,EAAe,cAAexB,EAAUI,UACxC,MAAMzG,EAAO0H,EAAMD,GAGnB,OAFApB,EAAUkC,QAAQvI,EAAMyE,GACxB6D,EAAW,cAAe,UAAWD,GAC9BrI,EAMP,SAASyE,EAAKzI,GACZqM,GAAW,EACXzE,EAAK5H,EACP,CACF,EApYOqK,EAIP,SAASA,IACP,MAAMoC,EAAcvD,IACpB,IAAIhG,GAAS,EAEb,OAASA,EAAQ+G,EAAUlM,QACzB0O,EAAY3C,OAAOG,EAAU/G,IAI/B,OADAuJ,EAAY1F,KAAK,KAAO,EAAM,CAAC,EAAGoD,IAC3BsC,CACT,CAuXF,CA7auBvD,GAAOwB,SACxBH,EAAM,CAAC,EAAE3O,eAsbf,SAASgQ,EAAQ1O,EAAOH,GACtB,MAAwB,mBAAVG,GAEdA,EAAMvB,YAcR,SAAcuB,GAEZ,IAAIV,EAEJ,IAAKA,KAAOU,EACV,GAAIqN,EAAIlO,KAAKa,EAAOV,GAClB,OAAO,EAIX,OAAO,CACT,CArBEkQ,CAAKxP,EAAMvB,YAAcoB,KAAQG,EAAMvB,UACzC,CA8BA,SAASgQ,EAAa5O,EAAMG,GAC1B,GAAqB,mBAAVA,EACT,MAAM,IAAI4B,UAAU,WAAa/B,EAAO,qBAE5C,CAUA,SAAS8O,EAAe9O,EAAMG,GAC5B,GAAqB,mBAAVA,EACT,MAAM,IAAI4B,UAAU,WAAa/B,EAAO,uBAE5C,CAUA,SAASuN,EAAevN,EAAMmN,GAC5B,GAAIA,EACF,MAAM,IAAI/J,MAAM,gBAAkBpD,EAAO,mHAE7C,CASA,SAAS+O,EAAWtM,GAGlB,IAAK,EAAWA,IAA8B,iBAAdA,EAAK0B,KACnC,MAAM,IAAIpC,UAAU,uBAAyBU,EAAO,IAExD,CAWA,SAAS8M,EAAWvP,EAAM4P,EAAWN,GACnC,IAAKA,EACH,MAAM,IAAIlM,MAAM,IAAMpD,EAAO,0BAA4B4P,EAAY,YAEzE,CAOA,SAASjB,EAAMxO,GACb,OAQF,SAAyBA,GACvB,OAAO0P,QAAQ1P,GAA0B,iBAAVA,GAAsB,YAAaA,GAAS,aAAcA,EAC3F,CAVS2P,CAAgB3P,GAASA,EAAQ,IAAI4J,EAAM5J,EACpD,CChjBO,SAAS,EAASsC,EAAM1C,GAC7B,IAAI,gBACFgQ,GAAkB,GAChBhQ,GAAW,CAAC,EAChB,OAAOiQ,EAAIvN,EAAMsN,EACnB,CAOA,SAASC,EAAIvN,EAAMsN,GACjB,OAAOtN,GAAwB,iBAATA,IACtBA,EAAKtC,QACL4P,EAAkBtN,EAAKwN,IAAM,KAC7B,aAAcxN,GAAQ,EAAIA,EAAKyN,SAAUH,IAAoB1Q,MAAMF,QAAQsD,IAAS,EAAIA,EAAMsN,KAAqB,EACrH,CAQA,SAAS,EAAIvD,EAAQuD,GAKnB,IAHA,IAAIzK,EAAS,GACTa,GAAS,IAEJA,EAAQqG,EAAOxL,QACtBsE,EAAOa,GAAS6J,EAAIxD,EAAOrG,GAAQ4J,GAGrC,OAAOzK,EAAO2C,KAAK,GACrB,CCjCO,SAASkI,EAAOC,EAAM7N,EAAO8N,EAAQC,GAC1C,MAAMzN,EAAMuN,EAAKpP,OACjB,IAGIuK,EAHAgF,EAAa,EAajB,GAPEhO,EADEA,EAAQ,GACDA,EAAQM,EAAM,EAAIA,EAAMN,EAEzBA,EAAQM,EAAMA,EAAMN,EAG9B8N,EAASA,EAAS,EAAIA,EAAS,EAE3BC,EAAMtP,OAAS,IACjBuK,EAAalM,MAAMmR,KAAKF,GACxB/E,EAAWkF,QAAQlO,EAAO8N,GAE1B,GAAGF,OAAOxE,MAAMyE,EAAM7E,QAKtB,IAFI8E,GAAQ,GAAGF,OAAOxE,MAAMyE,EAAM,CAAC7N,EAAO8N,IAEnCE,EAAaD,EAAMtP,QACxBuK,EAAa+E,EAAM1M,MAAM2M,EAAYA,EAAa,KAClDhF,EAAWkF,QAAQlO,EAAO,GAE1B,GAAG4N,OAAOxE,MAAMyE,EAAM7E,GACtBgF,GAAc,IACdhO,GAAS,GAGf,CAcO,SAASiB,EAAK4M,EAAME,GACzB,OAAIF,EAAKpP,OAAS,GAChBmP,EAAOC,EAAMA,EAAKpP,OAAQ,EAAGsP,GACtBF,GAGFE,CACT,CC/DA,MAAM,EAAiB,CAAC,EAAEzR,eAQnB,SAAS6R,EAAkBC,GAEhC,MAAMC,EAAM,CAAC,EACb,IAAIzK,GAAS,EAEb,OAASA,EAAQwK,EAAW3P,QAC1B6P,EAAgBD,EAAKD,EAAWxK,IAGlC,OAAOyK,CACT,CASA,SAASC,EAAgBD,EAAKE,GAE5B,IAAIC,EAEJ,IAAKA,KAAQD,EAAW,CACtB,MACME,GADQ,EAAe1R,KAAKsR,EAAKG,GAAQH,EAAIG,QAAQtK,KACpCmK,EAAIG,GAAQ,CAAC,GAC9BE,EAAQH,EAAUC,GAGxB,IAAI5L,EAEJ,IAAKA,KAAQ8L,EAAO,CACb,EAAe3R,KAAK0R,EAAM7L,KAAO6L,EAAK7L,GAAQ,IACnD,MAAMhF,EAAQ8Q,EAAM9L,GACpB+L,EACAF,EAAK7L,GAAO9F,MAAMF,QAAQgB,GAASA,EAAQA,EAAQ,CAACA,GAAS,GAC/D,CACF,CACF,CAWA,SAAS+Q,EAAWC,EAAUf,GAC5B,IAAIjK,GAAS,EAGb,MAAMiL,EAAS,GAEf,OAASjL,EAAQiK,EAAKpP,SAGC,UAApBoP,EAAKjK,GAAOkI,IAAkB8C,EAAWC,GAAQ5N,KAAK4M,EAAKjK,IAG9DgK,EAAOgB,EAAU,EAAG,EAAGC,EACzB,CCvEO,MCWMC,EAAaC,GAAW,YAQxBC,EAAaD,GAAW,MAexBE,EAAgBF,GAAW,cAS3BG,EAAoBH,GAAW,cAU/BI,EAAmBJ,GAAW,kBAkB9BK,EAAaL,GAAW,uBAW9B,SAASM,EAAazM,GAC3B,OAEW,OAATA,IAAkBA,EAAO,IAAe,MAATA,EAEnC,CASO,SAAS0M,GAA0B1M,GACxC,OAAgB,OAATA,IAAkBA,EAAO,GAAc,KAATA,EACvC,CAeO,SAAS2M,GAAmB3M,GACjC,OAAgB,OAATA,GAAiBA,GAAQ,CAClC,CAeO,SAAS4M,GAAc5M,GAC5B,OAAiB,IAAVA,IAAyB,IAAVA,GAAwB,KAATA,CACvC,CAiBO,MAAM6M,GAAoBV,GAAW,MAkB/BW,GAAqBX,GDvKK,+vCC+KvC,SAASA,GAAWY,GAClB,OAQA,SAAe/M,GACb,OAAgB,OAATA,GAAiB+M,EAAMvM,KAAKF,OAAOC,aAAaP,GACzD,CACF,CCpLO,SAASgN,GAAaC,EAASC,EAAIlO,EAAMmO,GAC9C,MAAMC,EAAQD,EAAMA,EAAM,EAAIxE,OAAOC,kBACrC,IAAIyE,EAAO,EACX,OAGA,SAAerN,GACb,GAAI4M,GAAc5M,GAEhB,OADAiN,EAAQK,MAAMtO,GACPuO,EAAOvN,GAGhB,OAAOkN,EAAGlN,EACZ,EAIA,SAASuN,EAAOvN,GACd,OAAI4M,GAAc5M,IAASqN,IAASD,GAClCH,EAAQO,QAAQxN,GACTuN,IAGTN,EAAQQ,KAAKzO,GACNkO,EAAGlN,GACZ,CACF,CC7BO,MAAMpC,GAAU,CACrB8P,SAIF,SAA2BT,GACzB,MAAMU,EAAeV,EAAQW,QAAQnQ,KAAKoQ,OAAO9B,WAAW+B,gBAO5D,SAAoC9N,GAClC,GAAa,OAATA,EAEF,YADAiN,EAAQO,QAAQxN,GAOlB,OAHAiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNT,GAAaC,EAASU,EAAc,aAC7C,IAIA,SAA0B3N,GAExB,OADAiN,EAAQK,MAAM,aACPS,EAAU/N,EACnB,IArBA,IAAIgO,EACJ,OAAOL,EAwBP,SAASI,EAAU/N,GACjB,MAAMiO,EAAQhB,EAAQK,MAAM,YAAa,CACvCY,YAAa,OACbF,aAQF,OALIA,IACFA,EAASxG,KAAOyG,GAGlBD,EAAWC,EACJpJ,EAAK7E,EACd,CAIA,SAAS6E,EAAK7E,GACZ,OAAa,OAATA,GACFiN,EAAQQ,KAAK,aACbR,EAAQQ,KAAK,kBACbR,EAAQO,QAAQxN,IAId2M,GAAmB3M,IACrBiN,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,aACNM,IAITd,EAAQO,QAAQxN,GACT6E,EACT,CACF,GC1DO,MAAM,GAAW,CACtB6I,SASF,SAA4BT,GAC1B,MAAMkB,EAAO1Q,KAGPgE,EAAQ,GACd,IAGI2M,EAGAC,EAGAC,EATAC,EAAY,EAUhB,OAAOnR,EAGP,SAASA,EAAM4C,GAWb,GAAIuO,EAAY9M,EAAM5F,OAAQ,CAC5B,MAAM2S,EAAO/M,EAAM8M,GAEnB,OADAJ,EAAKM,eAAiBD,EAAK,GACpBvB,EAAQW,QAAQY,EAAK,GAAGE,aAAcC,EAAkBC,EAAxD3B,CAA4EjN,EACrF,CAGA,OAAO4O,EAAmB5O,EAC5B,CAIA,SAAS2O,EAAiB3O,GAKxB,GAJAuO,IAIIJ,EAAKM,eAAeI,WAAY,CAClCV,EAAKM,eAAeI,gBAAavN,EAE7B8M,GACFU,IAKF,MAAMC,EAAmBZ,EAAKa,OAAOnT,OACrC,IAGIkF,EAHAkO,EAAkBF,EAKtB,KAAOE,KACL,GAAwC,SAApCd,EAAKa,OAAOC,GAAiB,IAA0D,cAAzCd,EAAKa,OAAOC,GAAiB,GAAGjQ,KAAsB,CACtG+B,EAAQoN,EAAKa,OAAOC,GAAiB,GAAGvR,IACxC,KACF,CAGFwR,EAAeX,GAEf,IAAIvN,EAAQ+N,EAEZ,KAAO/N,EAAQmN,EAAKa,OAAOnT,QACzBsS,EAAKa,OAAOhO,GAAO,GAAGtD,IAAMlE,OAAOyP,OAAO,CAAC,EAAGlI,GAC9CC,IAOF,OAHAgK,EAAOmD,EAAKa,OAAQC,EAAkB,EAAG,EAAGd,EAAKa,OAAOvQ,MAAMsQ,IAE9DZ,EAAKa,OAAOnT,OAASmF,EACd4N,EAAmB5O,EAC5B,CAEA,OAAO5C,EAAM4C,EACf,CAIA,SAAS4O,EAAmB5O,GAM1B,GAAIuO,IAAc9M,EAAM5F,OAAQ,CAI9B,IAAKuS,EACH,OAAOe,EAAkBnP,GAM3B,GAAIoO,EAAUgB,kBAAoBhB,EAAUgB,iBAAiBC,SAC3D,OAAOC,EAAUtP,GAMnBmO,EAAKoB,UAAY7E,QAAQ0D,EAAUgB,mBAAqBhB,EAAUoB,8BACpE,CAIA,OADArB,EAAKM,eAAiB,CAAC,EAChBxB,EAAQwC,MAAMC,GAAoBC,EAAsBC,EAAxD3C,CAA+EjN,EACxF,CAIA,SAAS2P,EAAqB3P,GAG5B,OAFIoO,GAAWU,IACfI,EAAeX,GACRY,EAAkBnP,EAC3B,CAIA,SAAS4P,EAAsB5P,GAG7B,OAFAmO,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAMzS,MAAQkR,IAAc9M,EAAM5F,OACxDyS,EAAkBH,EAAK2B,MAAMC,OACtBT,EAAUtP,EACnB,CAIA,SAASmP,EAAkBnP,GAGzB,OADAmO,EAAKM,eAAiB,CAAC,EAChBxB,EAAQW,QAAQ8B,GAAoBM,EAAmBV,EAAvDrC,CAAkEjN,EAC3E,CAIA,SAASgQ,EAAkBhQ,GAIzB,OAHAuO,IACA9M,EAAMpD,KAAK,CAAC8P,EAAKiB,iBAAkBjB,EAAKM,iBAEjCU,EAAkBnP,EAC3B,CAIA,SAASsP,EAAUtP,GACjB,OAAa,OAATA,GACEoO,GAAWU,IACfI,EAAe,QACfjC,EAAQO,QAAQxN,KAIlBoO,EAAYA,GAAaD,EAAKN,OAAOoC,KAAK9B,EAAK2B,OAC/C7C,EAAQK,MAAM,YAAa,CACzBY,YAAa,OACbF,SAAUK,EACV6B,WAAY9B,IAEP+B,EAAanQ,GACtB,CAIA,SAASmQ,EAAanQ,GACpB,OAAa,OAATA,GACFoQ,EAAanD,EAAQQ,KAAK,cAAc,GACxCyB,EAAe,QACfjC,EAAQO,QAAQxN,IAId2M,GAAmB3M,IACrBiN,EAAQO,QAAQxN,GAChBoQ,EAAanD,EAAQQ,KAAK,cAE1Bc,EAAY,EACZJ,EAAKoB,eAAYjO,EACVlE,IAGT6P,EAAQO,QAAQxN,GACTmQ,EACT,CAQA,SAASC,EAAanC,EAAOoC,GAC3B,MAAMC,EAASnC,EAAKoC,YAAYtC,GAwChC,GAvCIoC,GAAKC,EAAOjS,KAAK,MACrB4P,EAAMD,SAAWK,EACbA,IAAYA,EAAW7G,KAAOyG,GAClCI,EAAaJ,EACbG,EAAUoC,WAAWvC,EAAM7Q,OAC3BgR,EAAUqC,MAAMH,GAkCZnC,EAAKN,OAAOgC,KAAK5B,EAAM7Q,MAAMC,MAAO,CACtC,IAAI2D,EAAQoN,EAAUY,OAAOnT,OAE7B,KAAOmF,KACL,GACAoN,EAAUY,OAAOhO,GAAO,GAAG5D,MAAM2S,OAASzB,KACzCF,EAAUY,OAAOhO,GAAO,GAAGtD,KAC5B0Q,EAAUY,OAAOhO,GAAO,GAAGtD,IAAIqS,OAASzB,GAGtC,OAMJ,MAAMS,EAAmBZ,EAAKa,OAAOnT,OACrC,IAGI6U,EAGA3P,EANAkO,EAAkBF,EAQtB,KAAOE,KACL,GAAwC,SAApCd,EAAKa,OAAOC,GAAiB,IAA0D,cAAzCd,EAAKa,OAAOC,GAAiB,GAAGjQ,KAAsB,CACtG,GAAI0R,EAAM,CACR3P,EAAQoN,EAAKa,OAAOC,GAAiB,GAAGvR,IACxC,KACF,CAEAgT,GAAO,CACT,CAOF,IAJAxB,EAAeX,GAEfvN,EAAQ+N,EAED/N,EAAQmN,EAAKa,OAAOnT,QACzBsS,EAAKa,OAAOhO,GAAO,GAAGtD,IAAMlE,OAAOyP,OAAO,CAAC,EAAGlI,GAC9CC,IAIFgK,EAAOmD,EAAKa,OAAQC,EAAkB,EAAG,EAAGd,EAAKa,OAAOvQ,MAAMsQ,IAE9DZ,EAAKa,OAAOnT,OAASmF,CACvB,CACF,CAOA,SAASkO,EAAe7B,GACtB,IAAIrM,EAAQS,EAAM5F,OAElB,KAAOmF,KAAUqM,GAAM,CACrB,MAAMhE,EAAQ5H,EAAMT,GACpBmN,EAAKM,eAAiBpF,EAAM,GAC5BA,EAAM,GAAGoE,KAAKtT,KAAKgU,EAAMlB,EAC3B,CAEAxL,EAAM5F,OAASwR,CACjB,CAEA,SAASyB,IACPV,EAAUqC,MAAM,CAAC,OACjBpC,OAAa/M,EACb8M,OAAY9M,EACZ6M,EAAKM,eAAeI,gBAAavN,CACnC,CACF,GAnUMoO,GAAqB,CACzBhC,SAsUF,SAA2BT,EAASC,EAAIyD,GACtC,OAAO3D,GAAaC,EAASA,EAAQW,QAAQnQ,KAAKoQ,OAAO9B,WAAW6E,SAAU1D,EAAIyD,GAAM,aAAclT,KAAKoQ,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAAS,qBAAkB5D,EAAY,EACnL,GCzVO,MAAMyP,GAAY,CACvBrD,SAKF,SAA2BT,EAASC,EAAIyD,GACtC,OAAO3D,GAAaC,GAGpB,SAAyBjN,GACvB,OAAgB,OAATA,GAAiB2M,GAAmB3M,GAAQkN,EAAGlN,GAAQ2Q,EAAI3Q,EACpE,GAL8C,aAMhD,EAXEgR,SAAS,GCEJ,SAASC,GAAYjC,GAE1B,MAAMkC,EAAQ,CAAC,EACf,IAGIC,EAGAC,EAGAC,EAGAC,EAGAlL,EAGAmL,EAGAC,EArBAxQ,GAAS,EAuBb,OAASA,EAAQgO,EAAOnT,QAAQ,CAC9B,KAAOmF,KAASkQ,GACdlQ,EAAQkQ,EAAMlQ,GAMhB,GAHAmQ,EAAQnC,EAAOhO,GAGXA,GAA2B,cAAlBmQ,EAAM,GAAGnS,MAAsD,mBAA9BgQ,EAAOhO,EAAQ,GAAG,GAAGhC,OACjEuS,EAAYJ,EAAM,GAAGjB,WAAWlB,OAChCqC,EAAa,EAETA,EAAaE,EAAU1V,QAA4C,oBAAlC0V,EAAUF,GAAY,GAAGrS,OAC5DqS,GAAc,GAGZA,EAAaE,EAAU1V,QAA4C,YAAlC0V,EAAUF,GAAY,GAAGrS,MAC5D,OAASqS,EAAaE,EAAU1V,QACQ,YAAlC0V,EAAUF,GAAY,GAAGrS,MAIS,cAAlCuS,EAAUF,GAAY,GAAGrS,OAC3BuS,EAAUF,GAAY,GAAGI,6BAA8B,EACvDJ,KAOR,GAAiB,UAAbF,EAAM,GACJA,EAAM,GAAGjD,cACX1U,OAAOyP,OAAOiI,EAAOQ,GAAW1C,EAAQhO,IACxCA,EAAQkQ,EAAMlQ,GACdwQ,GAAO,QAGN,GAAIL,EAAM,GAAGQ,WAAY,CAI5B,IAHAN,EAAarQ,EACboQ,OAAY9P,EAEL+P,MACLC,EAAatC,EAAOqC,GAEO,eAAvBC,EAAW,GAAGtS,MAAgD,oBAAvBsS,EAAW,GAAGtS,OACjC,UAAlBsS,EAAW,KACTF,IACFpC,EAAOoC,GAAW,GAAGpS,KAAO,mBAG9BsS,EAAW,GAAGtS,KAAO,aACrBoS,EAAYC,GAOdD,IAEFD,EAAM,GAAGzT,IAAMlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOoC,GAAW,GAAGhU,OAEtDgJ,EAAa4I,EAAOvQ,MAAM2S,EAAWpQ,GACrCoF,EAAWkF,QAAQ6F,GACnBnG,EAAOgE,EAAQoC,EAAWpQ,EAAQoQ,EAAY,EAAGhL,GAErD,CACF,CAEA,OAAQoL,CACV,CASA,SAASE,GAAW1C,EAAQ4C,GAC1B,MAAM3D,EAAQe,EAAO4C,GAAY,GAC3BC,EAAU7C,EAAO4C,GAAY,GACnC,IAAIE,EAAgBF,EAAa,EAGjC,MAAMG,EAAiB,GACjBC,EAAY/D,EAAMiC,YAAc2B,EAAQhE,OAAOI,EAAMC,aAAaD,EAAM7Q,OACxE6U,EAAcD,EAAUhD,OAGxBkC,EAAQ,GAGRgB,EAAO,CAAC,EAGd,IAAI5B,EAGAtC,EACAhN,GAAS,EAGTmR,EAAUlE,EACVmE,EAAS,EACThV,EAAQ,EACZ,MAAMiV,EAAS,CAACjV,GAGhB,KAAO+U,GAAS,CAEd,KAAOnD,IAAS8C,GAAe,KAAOK,IAGtCJ,EAAe1T,KAAKyT,GAEfK,EAAQjC,aACXI,EAASuB,EAAQtB,YAAY4B,GAExBA,EAAQ3K,MACX8I,EAAOjS,KAAK,MAGV2P,GACFgE,EAAUxB,WAAW2B,EAAQ/U,OAG3B+U,EAAQV,8BACVO,EAAUM,oCAAqC,GAGjDN,EAAUvB,MAAMH,GAEZ6B,EAAQV,8BACVO,EAAUM,wCAAqChR,IAKnD0M,EAAWmE,EACXA,EAAUA,EAAQ3K,IACpB,CAMA,IAFA2K,EAAUlE,IAEDjN,EAAQiR,EAAYpW,QAED,SAA1BoW,EAAYjR,GAAO,IAA+C,UAA9BiR,EAAYjR,EAAQ,GAAG,IAAkBiR,EAAYjR,GAAO,GAAGhC,OAASiT,EAAYjR,EAAQ,GAAG,GAAGhC,MAAQiT,EAAYjR,GAAO,GAAG5D,MAAMC,OAAS4U,EAAYjR,GAAO,GAAGtD,IAAIL,OAC3MD,EAAQ4D,EAAQ,EAChBqR,EAAOhU,KAAKjB,GAEZ+U,EAAQjC,gBAAa5O,EACrB6Q,EAAQnE,cAAW1M,EACnB6Q,EAAUA,EAAQ3K,MAqBtB,IAhBAwK,EAAUhD,OAAS,GAIfmD,GAEFA,EAAQjC,gBAAa5O,EACrB6Q,EAAQnE,cAAW1M,GAEnB+Q,EAAO9K,MAKTvG,EAAQqR,EAAOxW,OAERmF,KAAS,CACd,MAAMvC,EAAQwT,EAAYxT,MAAM4T,EAAOrR,GAAQqR,EAAOrR,EAAQ,IACxD5D,EAAQ2U,EAAexK,MAC7B2J,EAAM5F,QAAQ,CAAClO,EAAOA,EAAQqB,EAAM5C,OAAS,IAC7CmP,EAAOgE,EAAQ5R,EAAO,EAAGqB,EAC3B,CAIA,IAFAuC,GAAS,IAEAA,EAAQkQ,EAAMrV,QACrBqW,EAAKE,EAASlB,EAAMlQ,GAAO,IAAMoR,EAASlB,EAAMlQ,GAAO,GACvDoR,GAAUlB,EAAMlQ,GAAO,GAAKkQ,EAAMlQ,GAAO,GAAK,EAGhD,OAAOkR,CACT,CCxNO,MAAM,GAAU,CACrBxE,SAuBF,SAAyBT,EAASC,GAEhC,IAAIc,EACJ,OAGA,SAAehO,GAKb,OAJAiN,EAAQK,MAAM,WACdU,EAAWf,EAAQK,MAAM,eAAgB,CACvCY,YAAa,YAERrJ,EAAK7E,EACd,EAIA,SAAS6E,EAAK7E,GACZ,OAAa,OAATA,EACKuS,EAAWvS,GAGhB2M,GAAmB3M,GACdiN,EAAQwC,MAAM+C,GAAuBC,EAAiBF,EAAtDtF,CAAkEjN,IAI3EiN,EAAQO,QAAQxN,GACT6E,EACT,CAIA,SAAS0N,EAAWvS,GAGlB,OAFAiN,EAAQQ,KAAK,gBACbR,EAAQQ,KAAK,WACNP,EAAGlN,EACZ,CAIA,SAASyS,EAAgBzS,GAQvB,OAPAiN,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,gBACbO,EAASxG,KAAOyF,EAAQK,MAAM,eAAgB,CAC5CY,YAAa,UACbF,aAEFA,EAAWA,EAASxG,KACb3C,CACT,CACF,EAxEEkF,QAeF,SAAwBiF,GAEtB,OADAiC,GAAYjC,GACLA,CACT,GAdMwD,GAAwB,CAC5B9E,SAuEF,SAA8BT,EAASC,EAAIyD,GACzC,MAAMxC,EAAO1Q,KACb,OAGA,SAAwBuC,GAKtB,OAJAiN,EAAQQ,KAAK,gBACbR,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNT,GAAaC,EAASyF,EAAU,aACzC,EAIA,SAASA,EAAS1S,GAChB,GAAa,OAATA,GAAiB2M,GAAmB3M,GACtC,OAAO2Q,EAAI3Q,GAGb,MAAM2S,EAAOxE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAE9C,OAAKsS,EAAKN,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAAS,iBAAmByN,GAAyB,eAAjBA,EAAK,GAAG3T,MAAyB2T,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAM9W,QAAU,EACrJqR,EAAGlN,GAGLiN,EAAQsC,UAAUpB,EAAKN,OAAO9B,WAAWkE,KAAMU,EAAKzD,EAApDD,CAAwDjN,EACjE,CACF,EAlGEgR,SAAS,GCbJ,MAAMf,GAAO,CAClBvC,SAIF,SAAwBT,GACtB,MAAMkB,EAAO1Q,KACPoV,EAAU5F,EAAQW,QACxBmD,IAKA,SAAuB/Q,GACrB,GAAa,OAATA,EAEF,YADAiN,EAAQO,QAAQxN,GAQlB,OAJAiN,EAAQK,MAAM,mBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,mBACbU,EAAKiB,sBAAmB9N,EACjBuR,CACT,GAfA5F,EAAQW,QAAQnQ,KAAKoQ,OAAO9B,WAAW+G,YAAaC,EAAgB/F,GAAaC,EAASA,EAAQW,QAAQnQ,KAAKoQ,OAAO9B,WAAWkE,KAAM8C,EAAgB9F,EAAQW,QAAQ,GAASmF,IAAkB,gBAClM,OAAOF,EAkBP,SAASE,EAAe/S,GACtB,GAAa,OAATA,EASJ,OAJAiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACbU,EAAKiB,sBAAmB9N,EACjBuR,EARL5F,EAAQO,QAAQxN,EASpB,CACF,GC1CO,MAAMgT,GAAW,CACtBC,WAAYC,MAEDtT,GAASuT,GAAkB,UAC3B,GAAOA,GAAkB,QAMtC,SAASA,GAAkBC,GACzB,MAAO,CACL1F,SAKF,SAAwBT,GACtB,MAAMkB,EAAO1Q,KACPsO,EAAatO,KAAKoQ,OAAO9B,WAAWqH,GACpCC,EAAOpG,EAAQW,QAAQ7B,EAAY3O,EAAOkW,GAChD,OAAOlW,EAGP,SAASA,EAAM4C,GACb,OAAOuT,EAAQvT,GAAQqT,EAAKrT,GAAQsT,EAAQtT,EAC9C,CAIA,SAASsT,EAAQtT,GACf,GAAa,OAATA,EAOJ,OAFAiN,EAAQK,MAAM,QACdL,EAAQO,QAAQxN,GACT6E,EANLoI,EAAQO,QAAQxN,EAOpB,CAIA,SAAS6E,EAAK7E,GACZ,OAAIuT,EAAQvT,IACViN,EAAQQ,KAAK,QACN4F,EAAKrT,KAIdiN,EAAQO,QAAQxN,GACT6E,EACT,CAOA,SAAS0O,EAAQvT,GACf,GAAa,OAATA,EACF,OAAO,EAGT,MAAMiL,EAAOc,EAAW/L,GACxB,IAAIgB,GAAS,EAEb,GAAIiK,EACF,OAASjK,EAAQiK,EAAKpP,QAAQ,CAC5B,MAAM2S,EAAOvD,EAAKjK,GAElB,IAAKwN,EAAKR,UAAYQ,EAAKR,SAAS7T,KAAKgU,EAAMA,EAAKH,UAClD,OAAO,CAEX,CAGF,OAAO,CACT,CACF,EAlEEiF,WAAYC,GAAyB,SAAVE,EAAmBI,QAAyBlS,GAmE3E,CAOA,SAAS4R,GAAeO,GACtB,OAGA,SAAwBzE,EAAQ6C,GAC9B,IAGIvE,EAHAtM,GAAS,EAMb,OAASA,GAASgO,EAAOnT,aACTyF,IAAVgM,EACE0B,EAAOhO,IAAoC,SAA1BgO,EAAOhO,GAAO,GAAGhC,OACpCsO,EAAQtM,EACRA,KAEQgO,EAAOhO,IAAoC,SAA1BgO,EAAOhO,GAAO,GAAGhC,OAExCgC,IAAUsM,EAAQ,IACpB0B,EAAO1B,GAAO,GAAG5P,IAAMsR,EAAOhO,EAAQ,GAAG,GAAGtD,IAC5CsR,EAAOhE,OAAOsC,EAAQ,EAAGtM,EAAQsM,EAAQ,GACzCtM,EAAQsM,EAAQ,GAGlBA,OAAQhM,GAIZ,OAAOmS,EAAgBA,EAAczE,EAAQ6C,GAAW7C,CAC1D,CACF,CAcA,SAASwE,GAAuBxE,EAAQ6C,GACtC,IAAID,EAAa,EAEjB,OAASA,GAAc5C,EAAOnT,QAC5B,IAAK+V,IAAe5C,EAAOnT,QAAyC,eAA/BmT,EAAO4C,GAAY,GAAG5S,OAA6D,SAAnCgQ,EAAO4C,EAAa,GAAG,GAAG5S,KAAiB,CAC9H,MAAM6F,EAAOmK,EAAO4C,EAAa,GAAG,GAC9B8B,EAAS7B,EAAQtB,YAAY1L,GACnC,IAKI8O,EALA3S,EAAQ0S,EAAO7X,OACf+X,GAAe,EACfvG,EAAO,EAKX,KAAOrM,KAAS,CACd,MAAM6S,EAAQH,EAAO1S,GAErB,GAAqB,iBAAV6S,EAAoB,CAG7B,IAFAD,EAAcC,EAAMhY,OAEyB,KAAtCgY,EAAMnT,WAAWkT,EAAc,IACpCvG,IACAuG,IAGF,GAAIA,EAAa,MACjBA,GAAe,CACjB,MACK,IAAe,IAAXC,EACPF,GAAO,EACPtG,SACK,IAAe,IAAXwG,EACJ,CAEL7S,IACA,KACF,CACF,CAEA,GAAIqM,EAAM,CACR,MAAMY,EAAQ,CACZjP,KAAM4S,IAAe5C,EAAOnT,QAAU8X,GAAQtG,EAAO,EAAI,aAAe,oBACxEjQ,MAAO,CACLC,KAAMwH,EAAKnH,IAAIL,KACfP,OAAQ+H,EAAKnH,IAAIZ,OAASuQ,EAC1B0C,OAAQlL,EAAKnH,IAAIqS,OAAS1C,EAC1ByG,OAAQjP,EAAKzH,MAAM0W,OAAS9S,EAC5B+S,aAAc/S,EAAQ4S,EAAc/O,EAAKzH,MAAM2W,aAAeH,GAEhElW,IAAKlE,OAAOyP,OAAO,CAAC,EAAGpE,EAAKnH,MAE9BmH,EAAKnH,IAAMlE,OAAOyP,OAAO,CAAC,EAAGgF,EAAM7Q,OAE/ByH,EAAKzH,MAAM2S,SAAWlL,EAAKnH,IAAIqS,OACjCvW,OAAOyP,OAAOpE,EAAMoJ,IAEpBe,EAAOhE,OAAO4G,EAAY,EAAG,CAAC,QAAS3D,EAAO4D,GAAU,CAAC,OAAQ5D,EAAO4D,IACxED,GAAc,EAElB,CAEAA,GACF,CAGF,OAAO5C,CACT,CChMO,SAASiE,GAAWlH,EAAYiD,EAAQ6C,GAE7C,MAAM3L,EAAS,GACf,IAAIlF,GAAS,EAEb,OAASA,EAAQ+K,EAAWlQ,QAAQ,CAClC,MAAMkO,EAAUgC,EAAW/K,GAAOiS,WAE9BlJ,IAAY7D,EAAOhB,SAAS6E,KAC9BiF,EAASjF,EAAQiF,EAAQ6C,GACzB3L,EAAO7H,KAAK0L,GAEhB,CAEA,OAAOiF,CACT,CCcO,SAASgF,GAAgBnG,EAAQoG,EAAY5I,GAElD,IAAItK,EAAQvH,OAAOyP,OAAOoC,EAAO7R,OAAOyP,OAAO,CAAC,EAAGoC,GAAQ,CACzDhO,KAAM,EACNP,OAAQ,EACRiT,OAAQ,GACP,CACD+D,OAAQ,EACRC,cAAe,IAIjB,MAAMG,EAAc,CAAC,EAGfC,EAAuB,GAG7B,IAAIT,EAAS,GAGTjS,EAAQ,GAGR2S,GAAW,EAOf,MAAMnH,EAAU,CACdO,QA+IF,SAAiBxN,GACX2M,GAAmB3M,IACrBe,EAAM1D,OACN0D,EAAMjE,OAAS,EACfiE,EAAMgP,SAAoB,IAAV/P,EAAc,EAAI,EAClCqU,MACmB,IAAVrU,IACTe,EAAMjE,SACNiE,EAAMgP,UAIJhP,EAAMgT,aAAe,EACvBhT,EAAM+S,UAEN/S,EAAMgT,eAIFhT,EAAMgT,eAAiBL,EAAO3S,EAAM+S,QAAQjY,SAC9CkF,EAAMgT,cAAgB,EACtBhT,EAAM+S,WAKVjC,EAAQ7D,SAAWhO,EAEnBoU,GAAW,CACb,EA3KE9G,MA+KF,SAAetO,EAAMsV,GAGnB,MAAMrG,EAAQqG,GAAU,CAAC,EAKzB,OAJArG,EAAMjP,KAAOA,EACbiP,EAAM7Q,MAAQ0S,IACd+B,EAAQ7C,OAAO3Q,KAAK,CAAC,QAAS4P,EAAO4D,IACrCpQ,EAAMpD,KAAK4P,GACJA,CACT,EAvLER,KA2LF,SAAczO,GACZ,MAAMiP,EAAQxM,EAAM8F,MAGpB,OAFA0G,EAAMvQ,IAAMoS,IACZ+B,EAAQ7C,OAAO3Q,KAAK,CAAC,OAAQ4P,EAAO4D,IAC7B5D,CACT,EA/LEL,QAAS2G,GAuMX,SAA+BC,EAAWjP,GACxCkP,EAAUD,EAAWjP,EAAK8F,KAC5B,IAxMEoE,MAAO8E,EAAiBG,GACxBnF,UAAWgF,EAAiBG,EAAmB,CAC7CnF,WAAW,KASTsC,EAAU,CACd7D,SAAU,KACVhO,KAAM,KACNyO,eAAgB,CAAC,EACjBO,OAAQ,GACRnB,SACA0C,cACAqC,eA8CF,SAAwB3E,EAAO0G,GAC7B,OAsYJ,SAAyBjB,EAAQiB,GAC/B,IAAI3T,GAAS,EAGb,MAAMb,EAAS,GAGf,IAAIyU,EAEJ,OAAS5T,EAAQ0S,EAAO7X,QAAQ,CAC9B,MAAMgY,EAAQH,EAAO1S,GAGrB,IAAIhG,EAEJ,GAAqB,iBAAV6Y,EACT7Y,EAAQ6Y,OACH,OAAQA,GACb,KAAM,EAEF7Y,EAAQ,KACR,MAGJ,KAAM,EAEFA,EAAQ,KACR,MAGJ,KAAM,EAEFA,EAAQ,OACR,MAGJ,KAAM,EAEFA,EAAQ2Z,EAAa,IAAM,KAC3B,MAGJ,KAAM,EAEF,IAAKA,GAAcC,EAAO,SAC1B5Z,EAAQ,IACR,MAGJ,QAGIA,EAAQsF,OAAOC,aAAasT,GAIlCe,GAAmB,IAAXf,EACR1T,EAAO9B,KAAKrD,EACd,CAEA,OAAOmF,EAAO2C,KAAK,GACrB,CAncW+R,CAAgBtE,EAAYtC,GAAQ0G,EAC7C,EA/CE7E,MACAU,WA8DF,SAAoBxV,GAClBkZ,EAAYlZ,EAAMqC,MAAQrC,EAAM8B,OAChCuX,GACF,EAhEE5D,MAwBF,SAAehS,GAIb,GAHAiV,EAASrV,EAAKqV,EAAQjV,GACtBqW,IAEkC,OAA9BpB,EAAOA,EAAO7X,OAAS,GACzB,MAAO,GAMT,OAHA4Y,EAAUR,EAAY,GAEtBpC,EAAQ7C,OAASiE,GAAWkB,EAAsBtC,EAAQ7C,OAAQ6C,GAC3DA,EAAQ7C,MACjB,GA5BA,IAOI+F,EAPAC,EAAQf,EAAWvG,SAASvT,KAAK0X,EAAS5E,GAa9C,OAJIgH,EAAWhB,YACbkB,EAAqB9V,KAAK4V,GAGrBpC,EA4BP,SAAStB,EAAYtC,GACnB,OA2VJ,SAAqByF,EAAQzF,GAC3B,MAAMgH,EAAahH,EAAM7Q,MAAM0W,OACzBoB,EAAmBjH,EAAM7Q,MAAM2W,aAC/BoB,EAAWlH,EAAMvQ,IAAIoW,OACrBsB,EAAiBnH,EAAMvQ,IAAIqW,aAGjC,IAAIsB,EAEAJ,IAAeE,EAEjBE,EAAO,CAAC3B,EAAOuB,GAAYxW,MAAMyW,EAAkBE,KAEnDC,EAAO3B,EAAOjV,MAAMwW,EAAYE,GAE5BD,GAAoB,IAEtBG,EAAK,GAAKA,EAAK,GAAG5W,MAAMyW,IAGtBE,EAAiB,GAEnBC,EAAKhX,KAAKqV,EAAOyB,GAAU1W,MAAM,EAAG2W,KAIxC,OAAOC,CACT,CAtXWC,CAAY5B,EAAQzF,EAC7B,CAIA,SAAS6B,IACP,OAAOtW,OAAOyP,OAAO,CAAC,EAAGlI,EAC3B,CAuBA,SAAS+T,IAEP,IAAIS,EAEJ,KAAOxU,EAAM+S,OAASJ,EAAO7X,QAAQ,CACnC,MAAMgY,EAAQH,EAAO3S,EAAM+S,QAE3B,GAAqB,iBAAVD,EAOT,IANA0B,EAAaxU,EAAM+S,OAEf/S,EAAMgT,aAAe,IACvBhT,EAAMgT,aAAe,GAGhBhT,EAAM+S,SAAWyB,GAAcxU,EAAMgT,aAAeF,EAAMhY,QAC/D2Z,EAAG3B,EAAMnT,WAAWK,EAAMgT,oBAG5ByB,EAAG3B,EAEP,CACF,CASA,SAAS2B,EAAGxV,GACVoU,OAAW9S,EACXyT,EAAe/U,EACfgV,EAAQA,EAAMhV,EAChB,CAyEA,SAAS0U,EAAkBe,EAAGlQ,GAC5BA,EAAKmQ,SACP,CASA,SAASnB,EAAiBoB,EAAUrB,GAClC,OAWA,SAAcvI,EAAY6J,EAAaC,GAErC,IAAIC,EAGAC,EAGA3G,EAGA7J,EACJ,OAAOrL,MAAMF,QAAQ+R,GAErBiK,EAAuBjK,GAAc,aAAcA,EACjDiK,EAAuB,CAACjK,IAQ1B,SAA+B9G,GAC7B,OAAO7H,EAGP,SAASA,EAAM4C,GACb,MAAMiW,EAAe,OAATjW,GAAiBiF,EAAIjF,GAC3ByL,EAAe,OAATzL,GAAiBiF,EAAI6L,KAKjC,OAAOkF,EAJM,IAGT9b,MAAMF,QAAQic,GAAOA,EAAMA,EAAM,CAACA,GAAO,MAAS/b,MAAMF,QAAQyR,GAAOA,EAAMA,EAAM,CAACA,GAAO,IACxFuK,CAA6BhW,EACtC,CACF,CArByCkW,CAAsBnK,GA8B/D,SAASiK,EAAuB/K,GAI9B,OAHA6K,EAAmB7K,EACnB8K,EAAiB,EAEG,IAAhB9K,EAAKpP,OACAga,EAGFM,EAAgBlL,EAAK8K,GAC9B,CASA,SAASI,EAAgB3B,GACvB,OAGA,SAAexU,GAKbuF,EAmER,WACE,MAAM6Q,EAAatG,IACbuG,EAAgBxE,EAAQ7D,SACxBsI,EAAwBzE,EAAQzC,iBAChCmH,EAAmB1E,EAAQ7C,OAAOnT,OAClC2a,EAAatc,MAAMmR,KAAK5J,GAC9B,MAAO,CACLiU,UACArK,KAAMkL,GAQR,SAASb,IACP3U,EAAQqV,EACRvE,EAAQ7D,SAAWqI,EACnBxE,EAAQzC,iBAAmBkH,EAC3BzE,EAAQ7C,OAAOnT,OAAS0a,EACxB9U,EAAQ+U,EACRnC,GACF,CACF,CA3FeoC,GACPrH,EAAmBoF,EAEdA,EAAUxD,UACba,EAAQzC,iBAAmBoF,GAG7B,GAAIA,EAAU3Z,MAAQgX,EAAQhE,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAASsP,EAAU3Z,MAC9E,OAAO8V,EAAI3Q,GAGb,OAAOwU,EAAU9G,SAASvT,KAG1Bma,EAAS9a,OAAOyP,OAAOzP,OAAOkd,OAAO7E,GAAUyC,GAAUzC,EAAS5E,EAASC,EAAIyD,EAHxE6D,CAG6ExU,EACtF,CACF,CAIA,SAASkN,EAAGlN,GAGV,OAFAoU,GAAW,EACXuB,EAASvG,EAAkB7J,GACpBqQ,CACT,CAIA,SAASjF,EAAI3Q,GAIX,OAHAoU,GAAW,EACX7O,EAAKmQ,YAECK,EAAiBD,EAAiBja,OAC/Bsa,EAAgBL,EAAiBC,IAGnCF,CACT,CACF,CACF,CAQA,SAASpB,EAAUD,EAAWnJ,GACxBmJ,EAAUvB,aAAekB,EAAqBjP,SAASsP,IACzDL,EAAqB9V,KAAKmW,GAGxBA,EAAUzK,SACZiB,EAAO6G,EAAQ7C,OAAQ3D,EAAMwG,EAAQ7C,OAAOnT,OAASwP,EAAMmJ,EAAUzK,QAAQ8H,EAAQ7C,OAAOvQ,MAAM4M,GAAOwG,IAGvG2C,EAAUmC,YACZ9E,EAAQ7C,OAASwF,EAAUmC,UAAU9E,EAAQ7C,OAAQ6C,GAEzD,CAyCA,SAASwC,IACHtT,EAAM1D,QAAQ6W,GAAenT,EAAMjE,OAAS,IAC9CiE,EAAMjE,OAASoX,EAAYnT,EAAM1D,MACjC0D,EAAMgP,QAAUmE,EAAYnT,EAAM1D,MAAQ,EAE9C,CACF,CC9dO,MAAMuZ,GAAgB,CAC3B/b,KAAM,gBACN6S,SAIF,SAA+BT,EAASC,EAAIyD,GAC1C,IAGIkG,EAHAxJ,EAAO,EAIX,OAGA,SAAerN,GAGb,OAFAiN,EAAQK,MAAM,iBACduJ,EAAS7W,EACFuT,EAAQvT,EACjB,EAIA,SAASuT,EAAQvT,GACf,OAAIA,IAAS6W,GACX5J,EAAQK,MAAM,yBACPwJ,EAAS9W,IAGd4M,GAAc5M,GACTgN,GAAaC,EAASsG,EAAS,aAA/BvG,CAA6ChN,GAGlDqN,EAAO,GAAc,OAATrN,IAAkB2M,GAAmB3M,GAC5C2Q,EAAI3Q,IAGbiN,EAAQQ,KAAK,iBACNP,EAAGlN,GACZ,CAIA,SAAS8W,EAAS9W,GAChB,OAAIA,IAAS6W,GACX5J,EAAQO,QAAQxN,GAChBqN,IACOyJ,IAGT7J,EAAQQ,KAAK,yBACN8F,EAAQvT,GACjB,CACF,GC3CO,MAAMiL,GAAO,CAClBpQ,KAAM,OACN6S,SAuBF,SAA2BT,EAASC,EAAIyD,GACtC,MAAMxC,EAAO1Q,KACPkV,EAAOxE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAC9C,IAAIkb,EAAcpE,GAAyB,eAAjBA,EAAK,GAAG3T,KAAwB2T,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAM9W,OAAS,EACrGwR,EAAO,EACX,OAGA,SAAerN,GACb,MAAMgX,EAAO7I,EAAKM,eAAezP,OAAkB,KAATgB,GAAwB,KAATA,GAAwB,KAATA,EAAc,gBAAkB,eAExG,GAAa,kBAATgX,GAA4B7I,EAAKM,eAAeoI,QAAU7W,IAASmO,EAAKM,eAAeoI,OAASzK,EAAWpM,GAAO,CAQpH,GAPKmO,EAAKM,eAAezP,OACvBmP,EAAKM,eAAezP,KAAOgY,EAC3B/J,EAAQK,MAAM0J,EAAM,CAClBrF,YAAY,KAIH,kBAATqF,EAEF,OADA/J,EAAQK,MAAM,kBACE,KAATtN,GAAwB,KAATA,EAAciN,EAAQwC,MAAMmH,GAAejG,EAAKsG,EAAlChK,CAA4CjN,GAAQiX,EAASjX,GAGnG,IAAKmO,EAAKoB,WAAsB,KAATvP,EAGrB,OAFAiN,EAAQK,MAAM,kBACdL,EAAQK,MAAM,iBACP4J,EAAOlX,EAElB,CAEA,OAAO2Q,EAAI3Q,EACb,EAIA,SAASkX,EAAOlX,GACd,OAAIoM,EAAWpM,MAAWqN,EAAO,IAC/BJ,EAAQO,QAAQxN,GACTkX,KAGH/I,EAAKoB,WAAalC,EAAO,KAAOc,EAAKM,eAAeoI,OAAS7W,IAASmO,EAAKM,eAAeoI,OAAkB,KAAT7W,GAAwB,KAATA,IACtHiN,EAAQQ,KAAK,iBACNwJ,EAASjX,IAGX2Q,EAAI3Q,EACb,CAMA,SAASiX,EAASjX,GAKhB,OAJAiN,EAAQK,MAAM,kBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,kBACbU,EAAKM,eAAeoI,OAAS1I,EAAKM,eAAeoI,QAAU7W,EACpDiN,EAAQwC,MAAMsB,GACrB5C,EAAKoB,UAAYoB,EAAMwG,EAASlK,EAAQW,QAAQwJ,GAAmCC,EAAaC,GAClG,CAIA,SAASH,EAAQnX,GAGf,OAFAmO,EAAKM,eAAe8I,kBAAmB,EACvCR,IACOM,EAAYrX,EACrB,CAIA,SAASsX,EAAYtX,GACnB,OAAI4M,GAAc5M,IAChBiN,EAAQK,MAAM,4BACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,4BACN4J,GAGF1G,EAAI3Q,EACb,CAIA,SAASqX,EAAYrX,GAEnB,OADAmO,EAAKM,eAAepB,KAAO0J,EAAc5I,EAAKyE,eAAe3F,EAAQQ,KAAK,mBAAmB,GAAM5R,OAC5FqR,EAAGlN,EACZ,CACF,EAhHE0O,aAAc,CACZhB,SAsHJ,SAAkCT,EAASC,EAAIyD,GAC7C,MAAMxC,EAAO1Q,KAEb,OADA0Q,EAAKM,eAAeI,gBAAavN,EAC1B2L,EAAQwC,MAAMsB,GAAWoG,EAASK,GAGzC,SAASL,EAAQnX,GAIf,OAHAmO,EAAKM,eAAegJ,kBAAoBtJ,EAAKM,eAAegJ,mBAAqBtJ,EAAKM,eAAe8I,iBAG9FvK,GAAaC,EAASC,EAAI,iBAAkBiB,EAAKM,eAAepB,KAAO,EAAvEL,CAA0EhN,EACnF,CAIA,SAASwX,EAASxX,GAChB,OAAImO,EAAKM,eAAegJ,oBAAsB7K,GAAc5M,IAC1DmO,EAAKM,eAAegJ,uBAAoBnW,EACxC6M,EAAKM,eAAe8I,sBAAmBjW,EAChCoW,EAAiB1X,KAG1BmO,EAAKM,eAAegJ,uBAAoBnW,EACxC6M,EAAKM,eAAe8I,sBAAmBjW,EAChC2L,EAAQW,QAAQ+J,GAAiBzK,EAAIwK,EAArCzK,CAAuDjN,GAChE,CAIA,SAAS0X,EAAiB1X,GAKxB,OAHAmO,EAAKM,eAAeI,YAAa,EAEjCV,EAAKoB,eAAYjO,EACV0L,GAAaC,EAASA,EAAQW,QAAQ3C,GAAMiC,EAAIyD,GAAM,aAAcxC,EAAKN,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAAS,qBAAkB5D,EAAY,EAA/I0L,CAAkJhN,EAC3J,CACF,GAxJEyN,KA+KF,SAAyBR,GACvBA,EAAQQ,KAAKhQ,KAAKgR,eAAezP,KACnC,GA7KMoY,GAAoC,CACxC1J,SAmLF,SAA0CT,EAASC,EAAIyD,GACrD,MAAMxC,EAAO1Q,KACb,OAAOuP,GAAaC,GAGpB,SAAqBjN,GACnB,MAAM2S,EAAOxE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAC9C,OAAQ+Q,GAAc5M,IAAS2S,GAAyB,6BAAjBA,EAAK,GAAG3T,KAAsCkO,EAAGlN,GAAQ2Q,EAAI3Q,EACtG,GAN0C,2BAA4BmO,EAAKN,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAAS,qBAAkB5D,EAAY,EAOnJ,EA3LE0P,SAAS,GAIL2G,GAAkB,CACtBjK,SAoJF,SAAwBT,EAASC,EAAIyD,GACnC,MAAMxC,EAAO1Q,KACb,OAAOuP,GAAaC,GAGpB,SAAqBjN,GACnB,MAAM2S,EAAOxE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAC9C,OAAO8W,GAAyB,mBAAjBA,EAAK,GAAG3T,MAA6B2T,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAM9W,SAAWsS,EAAKM,eAAepB,KAAOH,EAAGlN,GAAQ2Q,EAAI3Q,EACjJ,GAN0C,iBAAkBmO,EAAKM,eAAepB,KAAO,EAOzF,EA5JE2D,SAAS,GC3BJ,MAAM4G,GAAa,CACxB/c,KAAM,aACN6S,SAQF,SAAiCT,EAASC,EAAIyD,GAC5C,MAAMxC,EAAO1Q,KACb,OAGA,SAAeuC,GACb,GAAa,KAATA,EAAa,CACf,MAAMgV,EAAQ7G,EAAKM,eAanB,OAXKuG,EAAM6C,OACT5K,EAAQK,MAAM,aAAc,CAC1BqE,YAAY,IAEdqD,EAAM6C,MAAO,GAGf5K,EAAQK,MAAM,oBACdL,EAAQK,MAAM,oBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,oBACNqK,CACT,CAEA,OAAOnH,EAAI3Q,EACb,EAIA,SAAS8X,EAAM9X,GACb,OAAI4M,GAAc5M,IAChBiN,EAAQK,MAAM,8BACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,8BACbR,EAAQQ,KAAK,oBACNP,IAGTD,EAAQQ,KAAK,oBACNP,EAAGlN,GACZ,CACF,EA/CE0O,aAAc,CACZhB,SAkDJ,SAAwCT,EAASC,EAAIyD,GACnD,OAAO3D,GAAaC,EAASA,EAAQW,QAAQgK,GAAY1K,EAAIyD,GAAM,aAAclT,KAAKoQ,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAAS,qBAAkB5D,EAAY,EAC9J,GAlDEmM,KAsDF,SAAcR,GACZA,EAAQQ,KAAK,aACf,GCrDO,SAASsK,GAAmB9K,EAASC,EAAIyD,EAAK3R,EAAMgZ,EAAaC,EAAmBC,EAASC,EAAYhL,GAC9G,MAAMC,EAAQD,GAAOxE,OAAOC,kBAC5B,IAAIwP,EAAU,EACd,OAGA,SAAepY,GACb,GAAa,KAATA,EAMF,OALAiN,EAAQK,MAAMtO,GACdiO,EAAQK,MAAM0K,GACd/K,EAAQK,MAAM2K,GACdhL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAKwK,GACNI,EAGT,GAAa,OAATrY,GAA0B,KAATA,GAAeyM,EAAazM,GAC/C,OAAO2Q,EAAI3Q,GASb,OANAiN,EAAQK,MAAMtO,GACdiO,EAAQK,MAAM4K,GACdjL,EAAQK,MAAM6K,GACdlL,EAAQK,MAAM,cAAe,CAC3BY,YAAa,WAERoK,EAAetY,EACxB,EAIA,SAASqY,EAA0BrY,GACjC,OAAa,KAATA,GACFiN,EAAQK,MAAM2K,GACdhL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAKwK,GACbhL,EAAQQ,KAAKuK,GACb/K,EAAQQ,KAAKzO,GACNkO,IAGTD,EAAQK,MAAM6K,GACdlL,EAAQK,MAAM,cAAe,CAC3BY,YAAa,WAERqK,EAAoBvY,GAC7B,CAIA,SAASuY,EAAoBvY,GAC3B,OAAa,KAATA,GACFiN,EAAQQ,KAAK,eACbR,EAAQQ,KAAK0K,GACNE,EAA0BrY,IAGtB,OAATA,GAA0B,KAATA,GAAe2M,GAAmB3M,GAC9C2Q,EAAI3Q,IAGbiN,EAAQO,QAAQxN,GACA,KAATA,EAAcwY,EAA4BD,EACnD,CAIA,SAASC,EAA0BxY,GACjC,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCiN,EAAQO,QAAQxN,GACTuY,GAGFA,EAAoBvY,EAC7B,CAIA,SAASsY,EAAetY,GACtB,OAAa,KAATA,IACIoY,EAAUhL,EAAcuD,EAAI3Q,IAClCiN,EAAQO,QAAQxN,GACTsY,GAGI,KAATtY,EACGoY,KAQLnL,EAAQO,QAAQxN,GACTsY,IARLrL,EAAQQ,KAAK,eACbR,EAAQQ,KAAK0K,GACblL,EAAQQ,KAAKyK,GACbjL,EAAQQ,KAAKzO,GACNkO,EAAGlN,IAOD,OAATA,GAAiB0M,GAA0B1M,GACzCoY,EAAgBzH,EAAI3Q,IACxBiN,EAAQQ,KAAK,eACbR,EAAQQ,KAAK0K,GACblL,EAAQQ,KAAKyK,GACbjL,EAAQQ,KAAKzO,GACNkO,EAAGlN,IAGRyM,EAAazM,GAAc2Q,EAAI3Q,IACnCiN,EAAQO,QAAQxN,GACA,KAATA,EAAcyY,EAAuBH,EAC9C,CAIA,SAASG,EAAqBzY,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCiN,EAAQO,QAAQxN,GACTsY,GAGFA,EAAetY,EACxB,CACF,CC3HO,SAAS0Y,GAAazL,EAASC,EAAIyD,EAAK3R,EAAM2Z,EAAYR,GAC/D,MAAMhK,EAAO1Q,KACb,IAGIoH,EAHAwI,EAAO,EAIX,OAGA,SAAerN,GAMb,OALAiN,EAAQK,MAAMtO,GACdiO,EAAQK,MAAMqL,GACd1L,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAKkL,GACb1L,EAAQK,MAAM6K,GACP5E,CACT,EAIA,SAASA,EAAQvT,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,IAAgB6E,GAQ3C,KAAT7E,IAAgBqN,GAAQ,2BAA4Bc,EAAKN,OAAO9B,YAAcsB,EAAO,IAC5EsD,EAAI3Q,GAGA,KAATA,GACFiN,EAAQQ,KAAK0K,GACblL,EAAQK,MAAMqL,GACd1L,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAKkL,GACb1L,EAAQQ,KAAKzO,GACNkO,GAGLP,GAAmB3M,IACrBiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACN8F,IAGTtG,EAAQK,MAAM,cAAe,CAC3BY,YAAa,WAER0K,EAAM5Y,GACf,CAIA,SAAS4Y,EAAM5Y,GACb,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAe2M,GAAmB3M,IAASqN,IAAS,KACtFJ,EAAQQ,KAAK,eACN8F,EAAQvT,KAGjBiN,EAAQO,QAAQxN,GAChB6E,EAAOA,IAAS+H,GAAc5M,GACd,KAATA,EAAc6Y,EAAcD,EACrC,CAIA,SAASC,EAAY7Y,GACnB,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAChCiN,EAAQO,QAAQxN,GAChBqN,IACOuL,GAGFA,EAAM5Y,EACf,CACF,CC/EO,SAAS8Y,GAAa7L,EAASC,EAAIyD,EAAK3R,EAAM2Z,EAAYR,GAE/D,IAAItB,EACJ,OAGA,SAAe7W,GAMb,OALAiN,EAAQK,MAAMtO,GACdiO,EAAQK,MAAMqL,GACd1L,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAKkL,GACb9B,EAAkB,KAAT7W,EAAc,GAAKA,EACrB+Y,CACT,EAIA,SAASA,EAAkB/Y,GACzB,OAAIA,IAAS6W,GACX5J,EAAQK,MAAMqL,GACd1L,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAKkL,GACb1L,EAAQQ,KAAKzO,GACNkO,IAGTD,EAAQK,MAAM6K,GACPa,EAAahZ,GACtB,CAIA,SAASgZ,EAAahZ,GACpB,OAAIA,IAAS6W,GACX5J,EAAQQ,KAAK0K,GACNY,EAAkBlC,IAGd,OAAT7W,EACK2Q,EAAI3Q,GAIT2M,GAAmB3M,IACrBiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNT,GAAaC,EAAS+L,EAAc,gBAG7C/L,EAAQK,MAAM,cAAe,CAC3BY,YAAa,WAER+K,EAAMjZ,GACf,CAIA,SAASiZ,EAAMjZ,GACb,OAAIA,IAAS6W,GAAmB,OAAT7W,GAAiB2M,GAAmB3M,IACzDiN,EAAQQ,KAAK,eACNuL,EAAahZ,KAGtBiN,EAAQO,QAAQxN,GACA,KAATA,EAAckZ,EAAcD,EACrC,CAIA,SAASC,EAAYlZ,GACnB,OAAIA,IAAS6W,GAAmB,KAAT7W,GACrBiN,EAAQO,QAAQxN,GACTiZ,GAGFA,EAAMjZ,EACf,CACF,CCrFO,SAASmZ,GAAkBlM,EAASC,GAEzC,IAAIwD,EACJ,OAGA,SAAStT,EAAM4C,GACb,GAAI2M,GAAmB3M,GAKrB,OAJAiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACbiD,GAAO,EACAtT,EAGT,GAAIwP,GAAc5M,GAChB,OAAOgN,GAAaC,EAAS7P,EAAOsT,EAAO,aAAe,aAAnD1D,CAAiEhN,GAG1E,OAAOkN,EAAGlN,EACZ,CACF,CC1BO,SAASoZ,GAAoBpe,GAClC,OAAOA,EACN0B,QAAQ,cAAe,KACvBA,QAAQ,SAAU,IAMlB2c,cAAc5Y,aACjB,CCFO,MAAM6Y,GAAa,CACxBze,KAAM,aACN6S,SAUF,SAA4BT,EAASC,EAAIyD,GACvC,MAAMxC,EAAO1Q,KAGb,IAAI8b,EACJ,OAGA,SAAevZ,GAEb,OADAiN,EAAQK,MAAM,cACPoL,GAAave,KAAKgU,EAAMlB,EAASuM,EAAY7I,EAAK,kBAAmB,wBAAyB,wBAA9F+H,CAAuH1Y,EAChI,EAIA,SAASwZ,EAAWxZ,GAGlB,OAFAuZ,EAAaH,GAAoBjL,EAAKyE,eAAezE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAAG,IAAI4C,MAAM,GAAI,IAE1F,KAATuB,GACFiN,EAAQK,MAAM,oBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,oBAEN0L,GAAkBlM,EAAS8K,GAAmB9K,EAASA,EAAQW,QAAQ6L,GAAgBzM,GAAaC,EAAS6K,EAAO,cAAe9K,GAAaC,EAAS6K,EAAO,eAAgBnH,EAAK,wBAAyB,+BAAgC,qCAAsC,2BAA4B,iCAGlTA,EAAI3Q,EACb,CAIA,SAAS8X,EAAM9X,GACb,OAAa,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,cAERU,EAAKN,OAAO6L,QAAQxU,SAASqU,IAChCpL,EAAKN,OAAO6L,QAAQrb,KAAKkb,GAGpBrM,EAAGlN,IAGL2Q,EAAI3Q,EACb,CACF,GAlDMyZ,GAAiB,CACrB/L,SAqDF,SAAuBT,EAASC,EAAIyD,GAClC,OAGA,SAAe3Q,GACb,OAAO0M,GAA0B1M,GAAQmZ,GAAkBlM,EAAShB,EAA3BkN,CAAmCnZ,GAAQ2Q,EAAI3Q,EAC1F,EAIA,SAASiM,EAAOjM,GACd,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzB8Y,GAAa7L,EAASD,GAAaC,EAAS6K,EAAO,cAAenH,EAAK,kBAAmB,wBAAyB,wBAAnHmI,CAA4I9Y,GAG9I2Q,EAAI3Q,EACb,CAIA,SAAS8X,EAAM9X,GACb,OAAgB,OAATA,GAAiB2M,GAAmB3M,GAAQkN,EAAGlN,GAAQ2Q,EAAI3Q,EACpE,CACF,EA3EEgR,SAAS,GCXJ,MAAM2I,GAAe,CAC1B9e,KAAM,eACN6S,SAUF,SAA8BT,EAASC,EAAIyD,GACzC,MAAMxC,EAAO1Q,KACb,OAGA,SAAeuC,GAEb,OADAiN,EAAQK,MAAM,gBACPN,GAAaC,EAAS2M,EAAkB,aAAc,EAAtD5M,CAA6DhN,EACtE,EAIA,SAAS4Z,EAAiB5Z,GACxB,MAAM2S,EAAOxE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAC9C,OAAO8W,GAAyB,eAAjBA,EAAK,GAAG3T,MAAyB2T,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAM9W,QAAU,EAAIge,EAAY7Z,GAAQ2Q,EAAI3Q,EAC9H,CAIA,SAAS6Z,EAAY7Z,GACnB,OAAa,OAATA,EACK8X,EAAM9X,GAGX2M,GAAmB3M,GACdiN,EAAQW,QAAQkM,GAAiBD,EAAa/B,EAA9C7K,CAAqDjN,IAG9DiN,EAAQK,MAAM,iBACP1P,EAAQoC,GACjB,CAIA,SAASpC,EAAQoC,GACf,OAAa,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,iBACNoM,EAAY7Z,KAGrBiN,EAAQO,QAAQxN,GACTpC,EACT,CAIA,SAASka,EAAM9X,GAEb,OADAiN,EAAQQ,KAAK,gBACNP,EAAGlN,EACZ,CACF,GAxDM8Z,GAAkB,CACtBpM,SA2DF,SAAiCT,EAASC,EAAIyD,GAC5C,MAAMxC,EAAO1Q,KACb,OAAOL,EAGP,SAASA,EAAM4C,GAEb,OAAImO,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAMzS,MACvBsT,EAAI3Q,GAGT2M,GAAmB3M,IACrBiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNrQ,GAGF4P,GAAaC,EAAS4M,EAAa,aAAc,EAAjD7M,CAAwDhN,EACjE,CAIA,SAAS6Z,EAAY7Z,GACnB,MAAM2S,EAAOxE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAC9C,OAAO8W,GAAyB,eAAjBA,EAAK,GAAG3T,MAAyB2T,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAM9W,QAAU,EAAIqR,EAAGlN,GAAQ2M,GAAmB3M,GAAQ5C,EAAM4C,GAAQ2Q,EAAI3Q,EAC9J,CACF,EArFEgR,SAAS,GCPJ,MAAM+I,GAAa,CACxBlf,KAAM,aACN6S,SAiDF,SAA4BT,EAASC,EAAIyD,GACvC,MAAMxC,EAAO1Q,KACb,IAAI4P,EAAO,EACX,OAGA,SAAerN,GAGb,OAFAiN,EAAQK,MAAM,cACdL,EAAQK,MAAM,sBACP0M,EAAgBha,EACzB,EAIA,SAASga,EAAgBha,GACvB,OAAa,KAATA,GAAeqN,IAAS,GAC1BJ,EAAQO,QAAQxN,GACTga,GAGI,OAATha,GAAiB0M,GAA0B1M,IAC7CiN,EAAQQ,KAAK,sBACNU,EAAKoB,UAAYrC,EAAGlN,GAAQia,EAAaja,IAG3C2Q,EAAI3Q,EACb,CAIA,SAASia,EAAaja,GACpB,OAAa,KAATA,GACFiN,EAAQK,MAAM,sBACPwJ,EAAS9W,IAGL,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,cACNP,EAAGlN,IAGR4M,GAAc5M,GACTgN,GAAaC,EAASgN,EAAc,aAApCjN,CAAkDhN,IAG3DiN,EAAQK,MAAM,kBACPzI,EAAK7E,GACd,CAIA,SAAS8W,EAAS9W,GAChB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT8W,IAGT7J,EAAQQ,KAAK,sBACNwM,EAAaja,GACtB,CAIA,SAAS6E,EAAK7E,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAe0M,GAA0B1M,IAC5DiN,EAAQQ,KAAK,kBACNwM,EAAaja,KAGtBiN,EAAQO,QAAQxN,GACT6E,EACT,CACF,EAxHEkF,QAIF,SAA2BiF,EAAQ6C,GACjC,IAIIjU,EAGAyV,EAPAd,EAAavD,EAAOnT,OAAS,EAC7B8R,EAAe,EAQkB,eAAjCqB,EAAOrB,GAAc,GAAG3O,OAC1B2O,GAAgB,GAId4E,EAAa,EAAI5E,GAA+C,eAA/BqB,EAAOuD,GAAY,GAAGvT,OACzDuT,GAAc,GAGmB,uBAA/BvD,EAAOuD,GAAY,GAAGvT,OAAkC2O,IAAiB4E,EAAa,GAAKA,EAAa,EAAI5E,GAAmD,eAAnCqB,EAAOuD,EAAa,GAAG,GAAGvT,QACxJuT,GAAc5E,EAAe,IAAM4E,EAAa,EAAI,GAGlDA,EAAa5E,IACf/P,EAAU,CACRoB,KAAM,iBACN5B,MAAO4R,EAAOrB,GAAc,GAAGvQ,MAC/BM,IAAKsR,EAAOuD,GAAY,GAAG7U,KAE7B2V,EAAO,CACLrU,KAAM,YACN5B,MAAO4R,EAAOrB,GAAc,GAAGvQ,MAC/BM,IAAKsR,EAAOuD,GAAY,GAAG7U,IAE3BwQ,YAAa,QAEflD,EAAOgE,EAAQrB,EAAc4E,EAAa5E,EAAe,EAAG,CAAC,CAAC,QAAS/P,EAASiU,GAAU,CAAC,QAASwB,EAAMxB,GAAU,CAAC,OAAQwB,EAAMxB,GAAU,CAAC,OAAQjU,EAASiU,MAGjK,OAAO7C,CACT,GChDO,MAAMkL,GAAkB,CAC7Brf,KAAM,kBACN6S,SAiEF,SAAiCT,EAASC,EAAIyD,GAC5C,MAAMxC,EAAO1Q,KACb,IAGIoZ,EAGAsD,EANAnZ,EAAQmN,EAAKa,OAAOnT,OAQxB,KAAOmF,KAGL,GAAmC,eAA/BmN,EAAKa,OAAOhO,GAAO,GAAGhC,MAAwD,eAA/BmP,EAAKa,OAAOhO,GAAO,GAAGhC,MAAwD,YAA/BmP,EAAKa,OAAOhO,GAAO,GAAGhC,KAAoB,CAC1Imb,EAA2C,cAA/BhM,EAAKa,OAAOhO,GAAO,GAAGhC,KAClC,KACF,CAGF,OAGA,SAAegB,GACb,IAAKmO,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAMzS,QAAU8Q,EAAKoB,WAAa4K,GAI3D,OAHAlN,EAAQK,MAAM,qBACdL,EAAQK,MAAM,6BACduJ,EAAS7W,EACFoa,EAAgBpa,GAGzB,OAAO2Q,EAAI3Q,EACb,EAIA,SAASoa,EAAgBpa,GACvB,OAAIA,IAAS6W,GACX5J,EAAQO,QAAQxN,GACToa,IAGTnN,EAAQQ,KAAK,6BACNT,GAAaC,EAASoN,EAAoB,aAA1CrN,CAAwDhN,GACjE,CAIA,SAASqa,EAAmBra,GAC1B,OAAa,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,qBACNP,EAAGlN,IAGL2Q,EAAI3Q,EACb,CACF,EAvHE2W,UAIF,SAAkC3H,EAAQ6C,GACxC,IAGIjU,EAGAyV,EAGAiG,EATAtY,EAAQgO,EAAOnT,OAYnB,KAAOmF,KACL,GAAyB,UAArBgO,EAAOhO,GAAO,GAAgB,CAChC,GAA8B,YAA1BgO,EAAOhO,GAAO,GAAGhC,KAAoB,CACvCpB,EAAUoD,EACV,KACF,CAE8B,cAA1BgO,EAAOhO,GAAO,GAAGhC,OACnBqU,EAAOrS,EAEX,KAEgC,YAA1BgO,EAAOhO,GAAO,GAAGhC,MAEnBgQ,EAAOhE,OAAOhK,EAAO,GAGlBsY,GAAwC,eAA1BtK,EAAOhO,GAAO,GAAGhC,OAClCsa,EAAatY,GAKnB,MAAMsZ,EAAU,CACdtb,KAAM,gBACN5B,MAAO5D,OAAOyP,OAAO,CAAC,EAAG+F,EAAOqE,GAAM,GAAGjW,OACzCM,IAAKlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOA,EAAOnT,OAAS,GAAG,GAAG6B,MAGtDsR,EAAOqE,GAAM,GAAGrU,KAAO,oBAGnBsa,GACFtK,EAAOhE,OAAOqI,EAAM,EAAG,CAAC,QAASiH,EAASzI,IAC1C7C,EAAOhE,OAAOsO,EAAa,EAAG,EAAG,CAAC,OAAQtK,EAAOpR,GAAS,GAAIiU,IAC9D7C,EAAOpR,GAAS,GAAGF,IAAMlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOsK,GAAY,GAAG5b,MAEjEsR,EAAOpR,GAAS,GAAK0c,EAKvB,OADAtL,EAAO3Q,KAAK,CAAC,OAAQic,EAASzI,IACvB7C,CACT,GChEO,MAAMuL,GAAiB,CAAC,UAAW,UAAW,QAAS,OAAQ,WAAY,aAAc,OAAQ,UAAW,SAAU,MAAO,WAAY,KAAM,UAAW,SAAU,MAAO,MAAO,KAAM,KAAM,WAAY,aAAc,SAAU,SAAU,OAAQ,QAAS,WAAY,KAAM,KAAM,KAAM,KAAM,KAAM,KAAM,OAAQ,SAAU,KAAM,OAAQ,SAAU,SAAU,KAAM,OAAQ,OAAQ,OAAQ,WAAY,MAAO,WAAY,KAAM,WAAY,SAAU,IAAK,QAAS,UAAW,UAAW,QAAS,QAAS,KAAM,QAAS,KAAM,QAAS,QAAS,KAAM,QAAS,MAYhiBC,GAAe,CAAC,MAAO,SAAU,QAAS,YCV1CC,GAAW,CACtB5f,KAAM,WACN6S,SAmCF,SAA0BT,EAASC,EAAIyD,GACrC,MAAMxC,EAAO1Q,KAGb,IAAIuZ,EAGA0D,EAGAC,EAGA3Z,EAGA6V,EACJ,OAGA,SAAe7W,GAIb,OAHAiN,EAAQK,MAAM,YACdL,EAAQK,MAAM,gBACdL,EAAQO,QAAQxN,GACT6X,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT4a,GAGI,KAAT5a,GACFiN,EAAQO,QAAQxN,GACT6a,GAGI,KAAT7a,GACFiN,EAAQO,QAAQxN,GAChBgX,EAAO,EAGA7I,EAAKoB,UAAYrC,EAAK4N,GAG3B5O,EAAWlM,IACbiN,EAAQO,QAAQxN,GAChB2a,EAASra,OAAOC,aAAaP,GAC7B0a,GAAW,EACJK,GAGFpK,EAAI3Q,EACb,CAIA,SAAS4a,EAAiB5a,GACxB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GAChBgX,EAAO,EACAgE,GAGI,KAAThb,GACFiN,EAAQO,QAAQxN,GAChBgX,EAAO,EACP2D,EAAS,SACT3Z,EAAQ,EACDia,GAGL/O,EAAWlM,IACbiN,EAAQO,QAAQxN,GAChBgX,EAAO,EACA7I,EAAKoB,UAAYrC,EAAK4N,GAGxBnK,EAAI3Q,EACb,CAIA,SAASgb,EAAkBhb,GACzB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTmO,EAAKoB,UAAYrC,EAAK4N,GAGxBnK,EAAI3Q,EACb,CAIA,SAASib,EAAgBjb,GACvB,OAAIA,IAAS2a,EAAOja,WAAWM,MAC7BiM,EAAQO,QAAQxN,GACTgB,IAAU2Z,EAAO9e,OAASsS,EAAKoB,UAAYrC,EAAKwB,EAAeuM,GAGjEtK,EAAI3Q,EACb,CAIA,SAAS6a,EAAc7a,GACrB,OAAIkM,EAAWlM,IACbiN,EAAQO,QAAQxN,GAChB2a,EAASra,OAAOC,aAAaP,GACtB+a,GAGFpK,EAAI3Q,EACb,CAIA,SAAS+a,EAAQ/a,GACf,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAe0M,GAA0B1M,GAC9D,KAATA,GAAe0a,GAAYF,GAAatV,SAASyV,EAAOtB,gBAC1DrC,EAAO,EACA7I,EAAKoB,UAAYrC,EAAGlN,GAAQ0O,EAAa1O,IAG9Cua,GAAerV,SAASyV,EAAOtB,gBACjCrC,EAAO,EAEM,KAAThX,GACFiN,EAAQO,QAAQxN,GACTkb,GAGF/M,EAAKoB,UAAYrC,EAAGlN,GAAQ0O,EAAa1O,KAGlDgX,EAAO,EAEA7I,EAAKoB,YAAcpB,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAMzS,MAAQsT,EAAI3Q,GAAQ0a,EAAWS,EAA4Bnb,GAAQob,EAAwBpb,IAGtI,KAATA,GAAesM,EAAkBtM,IACnCiN,EAAQO,QAAQxN,GAChB2a,GAAUra,OAAOC,aAAaP,GACvB+a,GAGFpK,EAAI3Q,EACb,CAIA,SAASkb,EAAiBlb,GACxB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTmO,EAAKoB,UAAYrC,EAAKwB,GAGxBiC,EAAI3Q,EACb,CAIA,SAASob,EAAwBpb,GAC/B,OAAI4M,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACTob,GAGFC,EAAYrb,EACrB,CAIA,SAASmb,EAA4Bnb,GACnC,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTqb,GAGI,KAATrb,GAAwB,KAATA,GAAekM,EAAWlM,IAC3CiN,EAAQO,QAAQxN,GACTsb,GAGL1O,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACTmb,GAGFE,EAAYrb,EACrB,CAIA,SAASsb,EAAsBtb,GAC7B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAesM,EAAkBtM,IAChFiN,EAAQO,QAAQxN,GACTsb,GAGFC,EAA2Bvb,EACpC,CAIA,SAASub,EAA2Bvb,GAClC,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTwb,GAGL5O,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACTub,GAGFJ,EAA4Bnb,EACrC,CAIA,SAASwb,EAA6Bxb,GACpC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzD2Q,EAAI3Q,GAGA,KAATA,GAAwB,KAATA,GACjBiN,EAAQO,QAAQxN,GAChB6W,EAAS7W,EACFyb,GAGL7O,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACTwb,IAGT3E,EAAS,KACF6E,EAA+B1b,GACxC,CAIA,SAASyb,EAA6Bzb,GACpC,OAAa,OAATA,GAAiB2M,GAAmB3M,GAC/B2Q,EAAI3Q,GAGTA,IAAS6W,GACX5J,EAAQO,QAAQxN,GACT2b,IAGT1O,EAAQO,QAAQxN,GACTyb,EACT,CAIA,SAASC,EAA+B1b,GACtC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAe0M,GAA0B1M,GAChIub,EAA2Bvb,IAGpCiN,EAAQO,QAAQxN,GACT0b,EACT,CAIA,SAASC,EAAkC3b,GACzC,OAAa,KAATA,GAAwB,KAATA,GAAe4M,GAAc5M,GACvCmb,EAA4Bnb,GAG9B2Q,EAAI3Q,EACb,CAIA,SAASqb,EAAYrb,GACnB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT4b,GAGFjL,EAAI3Q,EACb,CAIA,SAAS4b,EAAc5b,GACrB,OAAI4M,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACT4b,GAGO,OAAT5b,GAAiB2M,GAAmB3M,GAAQ0O,EAAa1O,GAAQ2Q,EAAI3Q,EAC9E,CAIA,SAAS0O,EAAa1O,GACpB,OAAa,KAATA,GAAwB,IAATgX,GACjB/J,EAAQO,QAAQxN,GACT6b,GAGI,KAAT7b,GAAwB,IAATgX,GACjB/J,EAAQO,QAAQxN,GACT8b,GAGI,KAAT9b,GAAwB,IAATgX,GACjB/J,EAAQO,QAAQxN,GACT+b,GAGI,KAAT/b,GAAwB,IAATgX,GACjB/J,EAAQO,QAAQxN,GACT8a,GAGI,KAAT9a,GAAwB,IAATgX,GACjB/J,EAAQO,QAAQxN,GACTgc,IAGLrP,GAAmB3M,IAAmB,IAATgX,GAAuB,IAATA,EAIlC,OAAThX,GAAiB2M,GAAmB3M,GAC/Bic,EAAyBjc,IAGlCiN,EAAQO,QAAQxN,GACT0O,GAREzB,EAAQwC,MAAMyM,GAAoBH,EAAmBE,EAArDhP,CAA+EjN,EAS1F,CAIA,SAASic,EAAyBjc,GAEhC,OADAiN,EAAQQ,KAAK,gBACN0O,EAAkBnc,EAC3B,CAIA,SAASmc,EAAkBnc,GACzB,OAAa,OAATA,EACKuG,EAAKvG,GAGV2M,GAAmB3M,GACdiN,EAAQW,QAAQ,CACrBF,SAAU0O,EACVpL,SAAS,GACRmL,EAAmB5V,EAHf0G,CAGqBjN,IAG9BiN,EAAQK,MAAM,gBACPoB,EAAa1O,GACtB,CAIA,SAASoc,EAAYnP,EAASC,EAAIyD,GAChC,OAGA,SAAe3Q,GAIb,OAHAiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNM,CACT,EAIA,SAASA,EAAU/N,GACjB,OAAOmO,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAMzS,MAAQsT,EAAI3Q,GAAQkN,EAAGlN,EAC5D,CACF,CAIA,SAAS6b,EAA0B7b,GACjC,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT8a,GAGFpM,EAAa1O,EACtB,CAIA,SAAS8b,EAAuB9b,GAC9B,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GAChB2a,EAAS,GACF0B,GAGF3N,EAAa1O,EACtB,CAIA,SAASqc,EAAsBrc,GAC7B,OAAa,KAATA,GAAewa,GAAatV,SAASyV,EAAOtB,gBAC9CpM,EAAQO,QAAQxN,GACT+b,GAGL7P,EAAWlM,IAAS2a,EAAO9e,OAAS,GACtCoR,EAAQO,QAAQxN,GAChB2a,GAAUra,OAAOC,aAAaP,GACvBqc,GAGF3N,EAAa1O,EACtB,CAIA,SAASgc,EAAgChc,GACvC,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT8a,GAGFpM,EAAa1O,EACtB,CAIA,SAAS8a,EAA8B9a,GACrC,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT+b,GAII,KAAT/b,GAAwB,IAATgX,GACjB/J,EAAQO,QAAQxN,GACT8a,GAGFpM,EAAa1O,EACtB,CAIA,SAAS+b,EAAkB/b,GACzB,OAAa,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,gBACNlH,EAAKvG,KAGdiN,EAAQO,QAAQxN,GACT+b,EACT,CAIA,SAASxV,EAAKvG,GAEZ,OADAiN,EAAQQ,KAAK,YACNP,EAAGlN,EACZ,CACF,EA5fE2W,UAWF,SAA2B3H,GACzB,IAAIhO,EAAQgO,EAAOnT,OAEnB,KAAOmF,MACoB,UAArBgO,EAAOhO,GAAO,IAA4C,aAA1BgO,EAAOhO,GAAO,GAAGhC,QAKnDgC,EAAQ,GAAmC,eAA9BgO,EAAOhO,EAAQ,GAAG,GAAGhC,OAEpCgQ,EAAOhO,GAAO,GAAG5D,MAAQ4R,EAAOhO,EAAQ,GAAG,GAAG5D,MAE9C4R,EAAOhO,EAAQ,GAAG,GAAG5D,MAAQ4R,EAAOhO,EAAQ,GAAG,GAAG5D,MAElD4R,EAAOhE,OAAOhK,EAAQ,EAAG,IAG3B,OAAOgO,CACT,EA7BEK,UAAU,GAIN6M,GAAqB,CACzBxO,SA0fF,SAA2BT,EAASC,EAAIyD,GACtC,OAGA,SAAe3Q,GAKb,OAJAiN,EAAQQ,KAAK,gBACbR,EAAQK,MAAM,mBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,mBACNR,EAAQW,QAAQmD,GAAW7D,EAAIyD,EACxC,CACF,EApgBEK,SAAS,GCZJ,MAAMsL,GAAa,CACxBzhB,KAAM,aACN6S,SAKF,SAA4BT,EAASC,EAAIyD,GACvC,MAAMxC,EAAO1Q,KAGP8e,EAAwB,CAC5B7O,SA+JF,SAA8BT,EAASC,EAAIyD,GACzC,IAAItD,EAAO,EACX,OAAOL,GAAaC,EAASuP,EAAsB,aAAc/e,KAAKoQ,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAAS,qBAAkB5D,EAAY,GAG5I,SAASkb,EAAqBxc,GAG5B,OAFAiN,EAAQK,MAAM,mBACdL,EAAQK,MAAM,2BACP8M,EAAgBpa,EACzB,CAIA,SAASoa,EAAgBpa,GACvB,OAAIA,IAAS6W,GACX5J,EAAQO,QAAQxN,GAChBqN,IACO+M,GAGL/M,EAAOoP,EAAiB9L,EAAI3Q,IAChCiN,EAAQQ,KAAK,2BACNT,GAAaC,EAASoN,EAAoB,aAA1CrN,CAAwDhN,GACjE,CAIA,SAASqa,EAAmBra,GAC1B,OAAa,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,mBACNP,EAAGlN,IAGL2Q,EAAI3Q,EACb,CACF,EAjMEgR,SAAS,GAIL0L,EAAc,CAClBhP,SAoIF,SAA6BT,EAASC,EAAIyD,GACxC,MAAMxC,EAAO1Q,KACb,OAAOL,EAGP,SAASA,EAAM4C,GAIb,OAHAiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNM,CACT,CAIA,SAASA,EAAU/N,GACjB,OAAOmO,EAAKN,OAAOgC,KAAK1B,EAAK2B,MAAMzS,MAAQsT,EAAI3Q,GAAQkN,EAAGlN,EAC5D,CACF,EApJEgR,SAAS,GAEL2B,EAAOlV,KAAKuR,OAAOvR,KAAKuR,OAAOnT,OAAS,GACxC8gB,EAAgBhK,GAAyB,eAAjBA,EAAK,GAAG3T,KAAwB2T,EAAK,GAAGC,eAAeD,EAAK,IAAI,GAAM9W,OAAS,EAC7G,IAGIgb,EAHA4F,EAAW,EAIf,OAGA,SAAezc,GAKb,OAJAiN,EAAQK,MAAM,cACdL,EAAQK,MAAM,mBACdL,EAAQK,MAAM,2BACduJ,EAAS7W,EACF4c,EAAa5c,EACtB,EAIA,SAAS4c,EAAa5c,GACpB,OAAIA,IAAS6W,GACX5J,EAAQO,QAAQxN,GAChByc,IACOG,IAGT3P,EAAQQ,KAAK,2BACNgP,EAAW,EAAI9L,EAAI3Q,GAAQgN,GAAaC,EAAS4P,EAAU,aAAhC7P,CAA8ChN,GAClF,CAIA,SAAS6c,EAAS7c,GAChB,OAAa,OAATA,GAAiB2M,GAAmB3M,GAC/B8c,EAAU9c,IAGnBiN,EAAQK,MAAM,uBACdL,EAAQK,MAAM,cAAe,CAC3BY,YAAa,WAER3I,EAAKvF,GACd,CAIA,SAASuF,EAAKvF,GACZ,OAAa,OAATA,GAAiB0M,GAA0B1M,IAC7CiN,EAAQQ,KAAK,eACbR,EAAQQ,KAAK,uBACNT,GAAaC,EAAS8P,EAAW,aAAjC/P,CAA+ChN,IAG3C,KAATA,GAAeA,IAAS6W,EAAelG,EAAI3Q,IAC/CiN,EAAQO,QAAQxN,GACTuF,EACT,CAIA,SAASwX,EAAU/c,GACjB,OAAa,OAATA,GAAiB2M,GAAmB3M,GAC/B8c,EAAU9c,IAGnBiN,EAAQK,MAAM,uBACdL,EAAQK,MAAM,cAAe,CAC3BY,YAAa,WAER8O,EAAKhd,GACd,CAIA,SAASgd,EAAKhd,GACZ,OAAa,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,eACbR,EAAQQ,KAAK,uBACNqP,EAAU9c,IAGN,KAATA,GAAeA,IAAS6W,EAAelG,EAAI3Q,IAC/CiN,EAAQO,QAAQxN,GACTgd,EACT,CAIA,SAASF,EAAU9c,GAEjB,OADAiN,EAAQQ,KAAK,mBACNU,EAAKoB,UAAYrC,EAAGlN,GAAQ2N,EAAa3N,EAClD,CAIA,SAAS2N,EAAa3N,GACpB,OAAa,OAATA,EACK8X,EAAM9X,GAGX2M,GAAmB3M,GACdiN,EAAQW,QAAQ8O,EAAazP,EAAQW,QAAQ2O,EAAuBzE,EAAO6E,EAAgB3P,GAAaC,EAASU,EAAc,aAAcgP,EAAgB,GAAKhP,GAAemK,EAAjL7K,CAAwLjN,IAGjMiN,EAAQK,MAAM,iBACPmF,EAAgBzS,GACzB,CAIA,SAASyS,EAAgBzS,GACvB,OAAa,OAATA,GAAiB2M,GAAmB3M,IACtCiN,EAAQQ,KAAK,iBACNE,EAAa3N,KAGtBiN,EAAQO,QAAQxN,GACTyS,EACT,CAIA,SAASqF,EAAM9X,GAEb,OADAiN,EAAQQ,KAAK,cACNP,EAAGlN,EACZ,CA6DF,EA5MEqP,UAAU,GCVZ,MAAM,GAAUuB,SAASqM,cAAc,KAMhC,SAASC,GAA8BliB,GAC5C,MAAMmiB,EAAqB,IAAMniB,EAAQ,IACzC,GAAQoiB,UAAYD,EACpB,MAAME,EAAO,GAAQC,YASrB,OAAyC,KAArCD,EAAK3c,WAAW2c,EAAKxhB,OAAS,IAErB,SAAVb,KAQIqiB,IAASF,GAA6BE,EAC/C,CCrBO,MAAMF,GAAqB,CAChCtiB,KAAM,qBACN6S,SAIF,SAAoCT,EAASC,EAAIyD,GAC/C,MAAMxC,EAAO1Q,KACb,IAGI0P,EAGA3M,EANA6M,EAAO,EAOX,OAGA,SAAerN,GAKb,OAJAiN,EAAQK,MAAM,sBACdL,EAAQK,MAAM,4BACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,4BACNoK,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAa,KAATA,GACFiN,EAAQK,MAAM,mCACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,mCACN8P,IAGTtQ,EAAQK,MAAM,2BACdH,EAAM,GACN3M,EAAO8L,EACAtR,EAAMgF,GACf,CAIA,SAASud,EAAQvd,GACf,OAAa,KAATA,GAAwB,MAATA,GACjBiN,EAAQK,MAAM,uCACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,uCACbR,EAAQK,MAAM,2BACdH,EAAM,EACN3M,EAAO6L,EACArR,IAGTiS,EAAQK,MAAM,2BACdH,EAAM,EACN3M,EAAO4L,EACApR,EAAMgF,GACf,CAIA,SAAShF,EAAMgF,GAEb,IAAIiO,EAEJ,OAAa,KAATjO,GAAeqN,GACjBY,EAAQhB,EAAQQ,KAAK,2BAEjBjN,IAAS8L,GAAsB4Q,GAA8B/O,EAAKyE,eAAe3E,KAIrFhB,EAAQK,MAAM,4BACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,4BACbR,EAAQQ,KAAK,sBACNP,GAPEyD,EAAI3Q,IAUXQ,EAAKR,IAASqN,IAASF,GACzBF,EAAQO,QAAQxN,GACThF,GAGF2V,EAAI3Q,EACb,CACF,GC3FO,MAAMwd,GAAkB,CAC7B3iB,KAAM,kBACN6S,SAIF,SAAiCT,EAASC,EAAIyD,GAC5C,OAGA,SAAe3Q,GAKb,OAJAiN,EAAQK,MAAM,mBACdL,EAAQK,MAAM,gBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,gBACNoK,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAIuM,EAAiBvM,IACnBiN,EAAQK,MAAM,wBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,wBACbR,EAAQQ,KAAK,mBACNP,GAGFyD,EAAI3Q,EACb,CACF,GC9BO,MAAMyd,GAAa,CACxB5iB,KAAM,aACN6S,SAIF,SAA4BT,EAASC,GACnC,OAGA,SAAelN,GAIb,OAHAiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNT,GAAaC,EAASC,EAAI,aACnC,CACF,GCNO,MAAMwQ,GAAW,CACtB7iB,KAAM,WACN6S,SAyHF,SAA0BT,EAASC,EAAIyD,GACrC,MAAMxC,EAAO1Q,KACb,IAGIkgB,EAGAjE,EANA1Y,EAAQmN,EAAKa,OAAOnT,OAQxB,KAAOmF,KACL,IAAoC,eAA/BmN,EAAKa,OAAOhO,GAAO,GAAGhC,MAAwD,cAA/BmP,EAAKa,OAAOhO,GAAO,GAAGhC,QAA0BmP,EAAKa,OAAOhO,GAAO,GAAG4c,UAAW,CACnID,EAAaxP,EAAKa,OAAOhO,GAAO,GAChC,KACF,CAGF,OAGA,SAAehB,GACb,IAAK2d,EACH,OAAOhN,EAAI3Q,GAIb,OAAI2d,EAAWE,UAAkBC,EAAS9d,IAC1C0Z,EAAUvL,EAAKN,OAAO6L,QAAQxU,SAASkU,GAAoBjL,EAAKyE,eAAe,CAC7ExV,MAAOugB,EAAWjgB,IAClBA,IAAKyQ,EAAK2B,UAEZ7C,EAAQK,MAAM,YACdL,EAAQK,MAAM,eACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,eACbR,EAAQQ,KAAK,YACNsQ,EACT,EAIA,SAASA,EAAc/d,GAErB,OAAa,KAATA,EACKiN,EAAQW,QAAQoQ,GAAmB9Q,EAAIwM,EAAUxM,EAAK4Q,EAAtD7Q,CAAgEjN,GAI5D,KAATA,EACKiN,EAAQW,QAAQqQ,GAAwB/Q,EAAIwM,EAAUzM,EAAQW,QAAQsQ,GAA6BhR,EAAI4Q,GAAYA,EAAnH7Q,CAA6HjN,GAI/H0Z,EAAUxM,EAAGlN,GAAQ8d,EAAS9d,EACvC,CAIA,SAAS8d,EAAS9d,GAEhB,OADA2d,EAAWC,WAAY,EAChBjN,EAAI3Q,EACb,CACF,EAtLE2W,UA0CF,SAA2B3H,EAAQ6C,GACjC,IAII5D,EAGA4J,EAGAsG,EAGAC,EAbApd,EAAQgO,EAAOnT,OACfkU,EAAS,EAcb,KAAO/O,KAGL,GAFAiN,EAAQe,EAAOhO,GAAO,GAElB6W,EAAM,CAER,GAAmB,SAAf5J,EAAMjP,MAAkC,cAAfiP,EAAMjP,MAAwBiP,EAAM4P,UAC/D,MAKuB,UAArB7O,EAAOhO,GAAO,IAAiC,cAAfiN,EAAMjP,OACxCiP,EAAM4P,WAAY,EAEtB,MAAO,GAAIM,GACT,GAAyB,UAArBnP,EAAOhO,GAAO,KAAkC,eAAfiN,EAAMjP,MAAwC,cAAfiP,EAAMjP,QAA0BiP,EAAM2P,YACxG/F,EAAO7W,EAEY,cAAfiN,EAAMjP,MAAsB,CAC9B+Q,EAAS,EACT,KACF,MAEsB,aAAf9B,EAAMjP,OACfmf,EAAQnd,GAIZ,MAAMqd,EAAQ,CACZrf,KAA+B,cAAzBgQ,EAAO6I,GAAM,GAAG7Y,KAAuB,OAAS,QACtD5B,MAAO5D,OAAOyP,OAAO,CAAC,EAAG+F,EAAO6I,GAAM,GAAGza,OACzCM,IAAKlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOA,EAAOnT,OAAS,GAAG,GAAG6B,MAEhDkb,EAAQ,CACZ5Z,KAAM,QACN5B,MAAO5D,OAAOyP,OAAO,CAAC,EAAG+F,EAAO6I,GAAM,GAAGza,OACzCM,IAAKlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOmP,GAAO,GAAGzgB,MAEpC2V,EAAO,CACXrU,KAAM,YACN5B,MAAO5D,OAAOyP,OAAO,CAAC,EAAG+F,EAAO6I,EAAO9H,EAAS,GAAG,GAAGrS,KACtDA,IAAKlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOmP,EAAQ,GAAG,GAAG/gB,QAgB9C,OAdAghB,EAAQ,CAAC,CAAC,QAASC,EAAOxM,GAAU,CAAC,QAAS+G,EAAO/G,IAErDuM,EAAQ/f,EAAK+f,EAAOpP,EAAOvQ,MAAMoZ,EAAO,EAAGA,EAAO9H,EAAS,IAE3DqO,EAAQ/f,EAAK+f,EAAO,CAAC,CAAC,QAAS/K,EAAMxB,KAErCuM,EAAQ/f,EAAK+f,EAAOnL,GAAWpB,EAAQhE,OAAO9B,WAAWuS,WAAWxN,KAAM9B,EAAOvQ,MAAMoZ,EAAO9H,EAAS,EAAGoO,EAAQ,GAAItM,IAEtHuM,EAAQ/f,EAAK+f,EAAO,CAAC,CAAC,OAAQ/K,EAAMxB,GAAU7C,EAAOmP,EAAQ,GAAInP,EAAOmP,EAAQ,GAAI,CAAC,OAAQvF,EAAO/G,KAEpGuM,EAAQ/f,EAAK+f,EAAOpP,EAAOvQ,MAAM0f,EAAQ,IAEzCC,EAAQ/f,EAAK+f,EAAO,CAAC,CAAC,OAAQC,EAAOxM,KACrC7G,EAAOgE,EAAQ6I,EAAM7I,EAAOnT,OAAQuiB,GAC7BpP,CACT,EAnHEiE,WAmBF,SAA4BjE,GAC1B,IAGIf,EAHAjN,GAAS,EAKb,OAASA,EAAQgO,EAAOnT,QACtBoS,EAAQe,EAAOhO,GAAO,GAEH,eAAfiN,EAAMjP,MAAwC,cAAfiP,EAAMjP,MAAuC,aAAfiP,EAAMjP,OAErEgQ,EAAOhE,OAAOhK,EAAQ,EAAkB,eAAfiN,EAAMjP,KAAwB,EAAI,GAC3DiP,EAAMjP,KAAO,OACbgC,KAIJ,OAAOgO,CACT,GAjCMgP,GAAoB,CACxBtQ,SAoLF,SAA0BT,EAASC,EAAIyD,GACrC,OAGA,SAAe3Q,GAKb,OAJAiN,EAAQK,MAAM,YACdL,EAAQK,MAAM,kBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,kBACN0L,GAAkBlM,EAAS4K,EACpC,EAIA,SAASA,EAAK7X,GACZ,OAAa,KAATA,EACKtC,EAAIsC,GAGN+X,GAAmB9K,EAASsR,EAAkB5N,EAAK,sBAAuB,6BAA8B,mCAAoC,yBAA0B,4BAA6B,GAAnMoH,CAAuM/X,EAChN,CAIA,SAASue,EAAiBve,GACxB,OAAO0M,GAA0B1M,GAAQmZ,GAAkBlM,EAASuR,EAA3BrF,CAAoCnZ,GAAQtC,EAAIsC,EAC3F,CAIA,SAASwe,EAAQxe,GACf,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzB8Y,GAAa7L,EAASkM,GAAkBlM,EAASvP,GAAMiT,EAAK,gBAAiB,sBAAuB,sBAApGmI,CAA2H9Y,GAG7HtC,EAAIsC,EACb,CAIA,SAAStC,EAAIsC,GACX,OAAa,KAATA,GACFiN,EAAQK,MAAM,kBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,kBACbR,EAAQQ,KAAK,YACNP,GAGFyD,EAAI3Q,EACb,CACF,GAnOMie,GAAyB,CAC7BvQ,SAsOF,SAA+BT,EAASC,EAAIyD,GAC1C,MAAMxC,EAAO1Q,KACb,OAGA,SAAeuC,GACb,OAAO0Y,GAAave,KAAKgU,EAAMlB,EAASwR,EAAY9N,EAAK,YAAa,kBAAmB,kBAAlF+H,CAAqG1Y,EAC9G,EAIA,SAASye,EAAWze,GAClB,OAAOmO,EAAKN,OAAO6L,QAAQxU,SAASkU,GAAoBjL,EAAKyE,eAAezE,EAAKa,OAAOb,EAAKa,OAAOnT,OAAS,GAAG,IAAI4C,MAAM,GAAI,KAAOyO,EAAGlN,GAAQ2Q,EAAI3Q,EACtJ,CACF,GAhPMke,GAA8B,CAClCxQ,SAmPF,SAAoCT,EAASC,EAAIyD,GAC/C,OAGA,SAAe3Q,GAKb,OAJAiN,EAAQK,MAAM,aACdL,EAAQK,MAAM,mBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,mBACNoK,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAa,KAATA,GACFiN,EAAQK,MAAM,mBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,mBACbR,EAAQQ,KAAK,aACNP,GAGFyD,EAAI3Q,EACb,CACF,GC1SO,MAAM0e,GAAkB,CAC7B7jB,KAAM,kBACN6S,SAKF,SAAiCT,EAASC,EAAIyD,GAC5C,MAAMxC,EAAO1Q,KACb,OAGA,SAAeuC,GAKb,OAJAiN,EAAQK,MAAM,cACdL,EAAQK,MAAM,oBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,oBACNoK,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAa,KAATA,GACFiN,EAAQK,MAAM,eACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,eACbR,EAAQQ,KAAK,cACNqK,GAGFnH,EAAI3Q,EACb,CAIA,SAAS8X,EAAM9X,GAQb,OAAgB,KAATA,GAAe,2BAA4BmO,EAAKN,OAAO9B,WAAa4E,EAAI3Q,GAAQkN,EAAGlN,EAC5F,CACF,EA3CEiT,WAAYyK,GAASzK,YCMhB,SAAS0L,GAAkB3e,GAChC,OAAa,OAATA,GAAiB0M,GAA0B1M,IAAS6M,GAAkB7M,GACjE,EAGL8M,GAAmB9M,GACd,OADT,CAGF,CCVO,MAAM4e,GAAY,CACvB/jB,KAAM,YACN6S,SA8HF,SAA2BT,EAASC,GAClC,MAAM2R,EAAmBphB,KAAKoQ,OAAO9B,WAAW8S,iBAAiB/N,KAC3D9C,EAAWvQ,KAAKuQ,SAChB/B,EAAS0S,GAAkB3Q,GAGjC,IAAI6I,EACJ,OAGA,SAAe7W,GAGb,OAFAiN,EAAQK,MAAM,qBACduJ,EAAS7W,EACF8W,EAAS9W,EAClB,EAIA,SAAS8W,EAAS9W,GAChB,GAAIA,IAAS6W,EAEX,OADA5J,EAAQO,QAAQxN,GACT8W,EAGT,MAAM7I,EAAQhB,EAAQQ,KAAK,qBACrBqK,EAAQ6G,GAAkB3e,GAC1B6X,GAAQC,GAAmB,IAAVA,GAAe7L,GAAU4S,EAAiB3Z,SAASlF,GACpEme,GAASlS,GAAqB,IAAXA,GAAgB6L,GAAS+G,EAAiB3Z,SAAS8I,GAG5E,OAFAC,EAAM6Q,MAAQpU,QAAmB,KAAXmM,EAAgBgB,EAAOA,IAAS5L,IAAWkS,IACjElQ,EAAM8Q,OAASrU,QAAmB,KAAXmM,EAAgBsH,EAAQA,IAAUrG,IAAUD,IAC5D3K,EAAGlN,EACZ,CACF,EA7JEiT,WAQF,SAA6BjE,EAAQ6C,GACnC,IAGIgG,EAGAwG,EAGAhL,EAGA2L,EAGA5E,EAGAxS,EAGAqX,EAGAlP,EAxBA/O,GAAS,EA6Bb,OAASA,EAAQgO,EAAOnT,QAEtB,GAAyB,UAArBmT,EAAOhO,GAAO,IAA4C,sBAA1BgO,EAAOhO,GAAO,GAAGhC,MAAgCgQ,EAAOhO,GAAO,GAAG+d,OAGpG,IAFAlH,EAAO7W,EAEA6W,KAEL,GAAwB,SAApB7I,EAAO6I,GAAM,IAA0C,sBAAzB7I,EAAO6I,GAAM,GAAG7Y,MAAgCgQ,EAAO6I,GAAM,GAAGiH,OAClGjN,EAAQe,eAAe5D,EAAO6I,GAAM,IAAInX,WAAW,KAAOmR,EAAQe,eAAe5D,EAAOhO,GAAO,IAAIN,WAAW,GAAI,CAKhH,IAAKsO,EAAO6I,GAAM,GAAGkH,QAAU/P,EAAOhO,GAAO,GAAG8d,SAAW9P,EAAOhO,GAAO,GAAGtD,IAAIqS,OAASf,EAAOhO,GAAO,GAAG5D,MAAM2S,QAAU,MAAQf,EAAO6I,GAAM,GAAGna,IAAIqS,OAASf,EAAO6I,GAAM,GAAGza,MAAM2S,OAASf,EAAOhO,GAAO,GAAGtD,IAAIqS,OAASf,EAAOhO,GAAO,GAAG5D,MAAM2S,QAAU,GAC3P,SAIFnI,EAAMoH,EAAO6I,GAAM,GAAGna,IAAIqS,OAASf,EAAO6I,GAAM,GAAGza,MAAM2S,OAAS,GAAKf,EAAOhO,GAAO,GAAGtD,IAAIqS,OAASf,EAAOhO,GAAO,GAAG5D,MAAM2S,OAAS,EAAI,EAAI,EAC7I,MAAM3S,EAAQ5D,OAAOyP,OAAO,CAAC,EAAG+F,EAAO6I,GAAM,GAAGna,KAC1CA,EAAMlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOhO,GAAO,GAAG5D,OAC/C8hB,GAAU9hB,GAAQwK,GAClBsX,GAAUxhB,EAAKkK,GACfoX,EAAkB,CAChBhgB,KAAM4I,EAAM,EAAI,iBAAmB,mBACnCxK,QACAM,IAAKlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAO6I,GAAM,GAAGna,MAEzC0c,EAAkB,CAChBpb,KAAM4I,EAAM,EAAI,iBAAmB,mBACnCxK,MAAO5D,OAAOyP,OAAO,CAAC,EAAG+F,EAAOhO,GAAO,GAAG5D,OAC1CM,OAEF2V,EAAO,CACLrU,KAAM4I,EAAM,EAAI,aAAe,eAC/BxK,MAAO5D,OAAOyP,OAAO,CAAC,EAAG+F,EAAO6I,GAAM,GAAGna,KACzCA,IAAKlE,OAAOyP,OAAO,CAAC,EAAG+F,EAAOhO,GAAO,GAAG5D,QAE1CihB,EAAQ,CACNrf,KAAM4I,EAAM,EAAI,SAAW,WAC3BxK,MAAO5D,OAAOyP,OAAO,CAAC,EAAG+V,EAAgB5hB,OACzCM,IAAKlE,OAAOyP,OAAO,CAAC,EAAGmR,EAAgB1c,MAEzCsR,EAAO6I,GAAM,GAAGna,IAAMlE,OAAOyP,OAAO,CAAC,EAAG+V,EAAgB5hB,OACxD4R,EAAOhO,GAAO,GAAG5D,MAAQ5D,OAAOyP,OAAO,CAAC,EAAGmR,EAAgB1c,KAC3DuhB,EAAa,GAETjQ,EAAO6I,GAAM,GAAGna,IAAIqS,OAASf,EAAO6I,GAAM,GAAGza,MAAM2S,SACrDkP,EAAa5gB,EAAK4gB,EAAY,CAAC,CAAC,QAASjQ,EAAO6I,GAAM,GAAIhG,GAAU,CAAC,OAAQ7C,EAAO6I,GAAM,GAAIhG,MAIhGoN,EAAa5gB,EAAK4gB,EAAY,CAAC,CAAC,QAASZ,EAAOxM,GAAU,CAAC,QAASmN,EAAiBnN,GAAU,CAAC,OAAQmN,EAAiBnN,GAAU,CAAC,QAASwB,EAAMxB,KAEnJoN,EAAa5gB,EAAK4gB,EAAYhM,GAAWpB,EAAQhE,OAAO9B,WAAWuS,WAAWxN,KAAM9B,EAAOvQ,MAAMoZ,EAAO,EAAG7W,GAAQ6Q,IAEnHoN,EAAa5gB,EAAK4gB,EAAY,CAAC,CAAC,OAAQ5L,EAAMxB,GAAU,CAAC,QAASuI,EAAiBvI,GAAU,CAAC,OAAQuI,EAAiBvI,GAAU,CAAC,OAAQwM,EAAOxM,KAE7I7C,EAAOhO,GAAO,GAAGtD,IAAIqS,OAASf,EAAOhO,GAAO,GAAG5D,MAAM2S,QACvDA,EAAS,EACTkP,EAAa5gB,EAAK4gB,EAAY,CAAC,CAAC,QAASjQ,EAAOhO,GAAO,GAAI6Q,GAAU,CAAC,OAAQ7C,EAAOhO,GAAO,GAAI6Q,MAEhG9B,EAAS,EAGX/E,EAAOgE,EAAQ6I,EAAO,EAAG7W,EAAQ6W,EAAO,EAAGoH,GAC3Cje,EAAQ6W,EAAOoH,EAAWpjB,OAASkU,EAAS,EAC5C,KACF,CAMN/O,GAAS,EAET,OAASA,EAAQgO,EAAOnT,QACQ,sBAA1BmT,EAAOhO,GAAO,GAAGhC,OACnBgQ,EAAOhO,GAAO,GAAGhC,KAAO,QAI5B,OAAOgQ,CACT,GAiDA,SAASkQ,GAAUne,EAAOgP,GACxBhP,EAAMjE,QAAUiT,EAChBhP,EAAMgP,QAAUA,EAChBhP,EAAMgT,cAAgBhE,CACxB,CCxLO,MAAMoP,GAAW,CACtBtkB,KAAM,WACN6S,SAIF,SAA0BT,EAASC,EAAIyD,GACrC,IAAItD,EAAO,EACX,OAGA,SAAerN,GAMb,OALAiN,EAAQK,MAAM,YACdL,EAAQK,MAAM,kBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,kBACbR,EAAQK,MAAM,oBACPuK,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAIkM,EAAWlM,IACbiN,EAAQO,QAAQxN,GACTof,GAGF5S,EAAWxM,GAAQqf,EAAWrf,GAAQ2Q,EAAI3Q,EACnD,CAIA,SAASof,EAAmBpf,GAC1B,OAAgB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAesM,EAAkBtM,GAAQsf,EAAyBtf,GAAQqf,EAAWrf,EAC5H,CAIA,SAASsf,EAAyBtf,GAChC,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTuf,IAGK,KAATvf,GAAwB,KAATA,GAAwB,KAATA,GAAesM,EAAkBtM,KAAUqN,IAAS,IACrFJ,EAAQO,QAAQxN,GACTsf,GAGFD,EAAWrf,EACpB,CAIA,SAASuf,EAAUvf,GACjB,OAAa,KAATA,GACFiN,EAAQQ,KAAK,oBACN/P,EAAIsC,IAGA,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAeyM,EAAazM,GACvD2Q,EAAI3Q,IAGbiN,EAAQO,QAAQxN,GACTuf,EACT,CAIA,SAASF,EAAWrf,GAClB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GAChBqN,EAAO,EACAmS,GAGLhT,EAAWxM,IACbiN,EAAQO,QAAQxN,GACTqf,GAGF1O,EAAI3Q,EACb,CAIA,SAASwf,EAAiBxf,GACxB,OAAOsM,EAAkBtM,GAAQyf,EAAWzf,GAAQ2Q,EAAI3Q,EAC1D,CAIA,SAASyf,EAAWzf,GAClB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GAChBqN,EAAO,EACAmS,GAGI,KAATxf,GAEFiN,EAAQQ,KAAK,oBAAoBzO,KAAO,gBACjCtB,EAAIsC,IAGN0f,EAAW1f,EACpB,CAIA,SAAS0f,EAAW1f,GAClB,OAAc,KAATA,GAAesM,EAAkBtM,KAAUqN,IAAS,IACvDJ,EAAQO,QAAQxN,GACA,KAATA,EAAc0f,EAAaD,GAG7B9O,EAAI3Q,EACb,CAIA,SAAStC,EAAIsC,GAKX,OAJAiN,EAAQK,MAAM,kBACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,kBACbR,EAAQQ,KAAK,YACNP,CACT,CACF,GChIO,MAAMyS,GAAW,CACtB9kB,KAAM,WACN6S,SAIF,SAA0BT,EAASC,EAAIyD,GACrC,MAAMxC,EAAO1Q,KAGb,IAAIoZ,EAGA8D,EAGA3Z,EAGA4U,EACJ,OAGA,SAAe5V,GAIb,OAHAiN,EAAQK,MAAM,YACdL,EAAQK,MAAM,gBACdL,EAAQO,QAAQxN,GACT6X,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT4f,GAGI,KAAT5f,GACFiN,EAAQO,QAAQxN,GACT6a,GAGI,KAAT7a,GACFiN,EAAQO,QAAQxN,GACT6f,GAGL3T,EAAWlM,IACbiN,EAAQO,QAAQxN,GACT8f,GAGFnP,EAAI3Q,EACb,CAIA,SAAS4f,EAAgB5f,GACvB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT+f,GAGI,KAAT/f,GACFiN,EAAQO,QAAQxN,GAChB2a,EAAS,SACT3Z,EAAQ,EACDgf,GAGL9T,EAAWlM,IACbiN,EAAQO,QAAQxN,GACTf,GAGF0R,EAAI3Q,EACb,CAIA,SAAS+f,EAAY/f,GACnB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTigB,GAGFtP,EAAI3Q,EACb,CAIA,SAASigB,EAAajgB,GACpB,OAAa,OAATA,GAA0B,KAATA,EACZ2Q,EAAI3Q,GAGA,KAATA,GACFiN,EAAQO,QAAQxN,GACTkgB,GAGFrhB,EAAQmB,EACjB,CAIA,SAASkgB,EAAiBlgB,GACxB,OAAa,OAATA,GAA0B,KAATA,EACZ2Q,EAAI3Q,GAGNnB,EAAQmB,EACjB,CAIA,SAASnB,EAAQmB,GACf,OAAa,OAATA,EACK2Q,EAAI3Q,GAGA,KAATA,GACFiN,EAAQO,QAAQxN,GACTmgB,GAGLxT,GAAmB3M,IACrB4V,EAAc/W,EACPuhB,EAAapgB,KAGtBiN,EAAQO,QAAQxN,GACTnB,EACT,CAIA,SAASshB,EAAangB,GACpB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTtC,GAGFmB,EAAQmB,EACjB,CAIA,SAASggB,EAAUhgB,GACjB,OAAIA,IAAS2a,EAAOja,WAAWM,MAC7BiM,EAAQO,QAAQxN,GACTgB,IAAU2Z,EAAO9e,OAASwkB,EAAQL,GAGpCrP,EAAI3Q,EACb,CAIA,SAASqgB,EAAMrgB,GACb,OAAa,OAATA,EACK2Q,EAAI3Q,GAGA,KAATA,GACFiN,EAAQO,QAAQxN,GACTsgB,GAGL3T,GAAmB3M,IACrB4V,EAAcyK,EACPD,EAAapgB,KAGtBiN,EAAQO,QAAQxN,GACTqgB,EACT,CAIA,SAASC,EAAWtgB,GAClB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTugB,GAGFF,EAAMrgB,EACf,CAIA,SAASugB,EAASvgB,GAChB,OAAa,KAATA,EACKtC,EAAIsC,GAGA,KAATA,GACFiN,EAAQO,QAAQxN,GACTugB,GAGFF,EAAMrgB,EACf,CAIA,SAASf,EAAYe,GACnB,OAAa,OAATA,GAA0B,KAATA,EACZtC,EAAIsC,GAGT2M,GAAmB3M,IACrB4V,EAAc3W,EACPmhB,EAAapgB,KAGtBiN,EAAQO,QAAQxN,GACTf,EACT,CAIA,SAAS4gB,EAAY7f,GACnB,OAAa,OAATA,EACK2Q,EAAI3Q,GAGA,KAATA,GACFiN,EAAQO,QAAQxN,GACTwgB,GAGL7T,GAAmB3M,IACrB4V,EAAciK,EACPO,EAAapgB,KAGtBiN,EAAQO,QAAQxN,GACT6f,EACT,CAIA,SAASW,EAAiBxgB,GACxB,OAAgB,KAATA,EAActC,EAAIsC,GAAQ6f,EAAY7f,EAC/C,CAIA,SAAS6a,EAAc7a,GACrB,OAAIkM,EAAWlM,IACbiN,EAAQO,QAAQxN,GACTygB,GAGF9P,EAAI3Q,EACb,CAIA,SAASygB,EAASzgB,GAChB,OAAa,KAATA,GAAesM,EAAkBtM,IACnCiN,EAAQO,QAAQxN,GACTygB,GAGFC,EAAgB1gB,EACzB,CAIA,SAAS0gB,EAAgB1gB,GACvB,OAAI2M,GAAmB3M,IACrB4V,EAAc8K,EACPN,EAAapgB,IAGlB4M,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACT0gB,GAGFhjB,EAAIsC,EACb,CAIA,SAAS8f,EAAQ9f,GACf,OAAa,KAATA,GAAesM,EAAkBtM,IACnCiN,EAAQO,QAAQxN,GACT8f,GAGI,KAAT9f,GAAwB,KAATA,GAAe0M,GAA0B1M,GACnD2gB,EAAe3gB,GAGjB2Q,EAAI3Q,EACb,CAIA,SAAS2gB,EAAe3gB,GACtB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACTtC,GAGI,KAATsC,GAAwB,KAATA,GAAekM,EAAWlM,IAC3CiN,EAAQO,QAAQxN,GACT4gB,GAGLjU,GAAmB3M,IACrB4V,EAAc+K,EACPP,EAAapgB,IAGlB4M,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACT2gB,GAGFjjB,EAAIsC,EACb,CAIA,SAAS4gB,EAAqB5gB,GAC5B,OAAa,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAesM,EAAkBtM,IAChFiN,EAAQO,QAAQxN,GACT4gB,GAGFC,EAA0B7gB,EACnC,CAIA,SAAS6gB,EAA0B7gB,GACjC,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GACT8gB,GAGLnU,GAAmB3M,IACrB4V,EAAciL,EACPT,EAAapgB,IAGlB4M,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACT6gB,GAGFF,EAAe3gB,EACxB,CAIA,SAAS8gB,EAA4B9gB,GACnC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACzD2Q,EAAI3Q,GAGA,KAATA,GAAwB,KAATA,GACjBiN,EAAQO,QAAQxN,GAChB6W,EAAS7W,EACF+gB,GAGLpU,GAAmB3M,IACrB4V,EAAckL,EACPV,EAAapgB,IAGlB4M,GAAc5M,IAChBiN,EAAQO,QAAQxN,GACT8gB,IAGT7T,EAAQO,QAAQxN,GAChB6W,OAASvV,EACF0f,EACT,CAIA,SAASD,EAA4B/gB,GACnC,OAAIA,IAAS6W,GACX5J,EAAQO,QAAQxN,GACTihB,GAGI,OAATjhB,EACK2Q,EAAI3Q,GAGT2M,GAAmB3M,IACrB4V,EAAcmL,EACPX,EAAapgB,KAGtBiN,EAAQO,QAAQxN,GACT+gB,EACT,CAIA,SAASE,EAAiCjhB,GACxC,OAAa,KAATA,GAAwB,KAATA,GAAe0M,GAA0B1M,GACnD2gB,EAAe3gB,GAGjB2Q,EAAI3Q,EACb,CAIA,SAASghB,EAA8BhhB,GACrC,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,GAAwB,KAATA,EACxE2Q,EAAI3Q,GAGA,KAATA,GAAe0M,GAA0B1M,GACpC2gB,EAAe3gB,IAGxBiN,EAAQO,QAAQxN,GACTghB,EACT,CAMA,SAASZ,EAAapgB,GAKpB,OAJAiN,EAAQQ,KAAK,gBACbR,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACNT,GAAaC,EAAS4M,EAAa,aAAc1L,EAAKN,OAAO9B,WAAW8E,QAAQC,KAAK5L,SAAS,qBAAkB5D,EAAY,EACrI,CAIA,SAASuY,EAAY7Z,GAEnB,OADAiN,EAAQK,MAAM,gBACPsI,EAAY5V,EACrB,CAIA,SAAStC,EAAIsC,GACX,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,gBACbR,EAAQQ,KAAK,YACNP,GAGFyD,EAAI3Q,EACb,CACF,GCldO,MAAMkhB,GAAiB,CAC5BrmB,KAAM,iBACN6S,SAKF,SAAgCT,EAASC,EAAIyD,GAC3C,MAAMxC,EAAO1Q,KACb,OAGA,SAAeuC,GAMb,OALAiN,EAAQK,MAAM,aACdL,EAAQK,MAAM,eACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,eACbR,EAAQQ,KAAK,aACNqK,CACT,EAIA,SAASA,EAAM9X,GAQb,OAAgB,KAATA,GAAe,2BAA4BmO,EAAKN,OAAO9B,WAAa4E,EAAI3Q,GAAQkN,EAAGlN,EAC5F,CACF,EA9BEiT,WAAYyK,GAASzK,YCHhB,MAAMkO,GAAkB,CAC7BtmB,KAAM,kBACN6S,SAIF,SAAiCT,EAASC,EAAIyD,GAC5C,OAGA,SAAe3Q,GAIb,OAHAiN,EAAQK,MAAM,mBACdL,EAAQK,MAAM,gBACdL,EAAQO,QAAQxN,GACT6X,CACT,EAIA,SAASA,EAAK7X,GACZ,OAAI2M,GAAmB3M,IACrBiN,EAAQQ,KAAK,gBACbR,EAAQQ,KAAK,mBACNP,EAAGlN,IAGL2Q,EAAI3Q,EACb,CACF,GCzBO,MAAMohB,GAAW,CACtBvmB,KAAM,WACN6S,SAkEF,SAA0BT,EAASC,EAAIyD,GAErC,IAGItD,EAGAY,EANAwO,EAAW,EAOf,OAGA,SAAezc,GAGb,OAFAiN,EAAQK,MAAM,YACdL,EAAQK,MAAM,oBACP0R,EAAgBhf,EACzB,EAIA,SAASgf,EAAgBhf,GACvB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GAChByc,IACOuC,IAGT/R,EAAQQ,KAAK,oBACN4T,EAAIrhB,GACb,CAIA,SAASqhB,EAAIrhB,GAEX,OAAa,OAATA,EACK2Q,EAAI3Q,GAKA,KAATA,GACFiO,EAAQhB,EAAQK,MAAM,oBACtBD,EAAO,EACA+M,EAAgBpa,IAIZ,KAATA,GACFiN,EAAQK,MAAM,SACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,SACN4T,GAGL1U,GAAmB3M,IACrBiN,EAAQK,MAAM,cACdL,EAAQO,QAAQxN,GAChBiN,EAAQQ,KAAK,cACN4T,IAITpU,EAAQK,MAAM,gBACPzI,EAAK7E,GACd,CAKA,SAAS6E,EAAK7E,GACZ,OAAa,OAATA,GAA0B,KAATA,GAAwB,KAATA,GAAe2M,GAAmB3M,IACpEiN,EAAQQ,KAAK,gBACN4T,EAAIrhB,KAGbiN,EAAQO,QAAQxN,GACT6E,EACT,CAKA,SAASuV,EAAgBpa,GAEvB,OAAa,KAATA,GACFiN,EAAQO,QAAQxN,GAChBqN,IACO+M,GAIL/M,IAASoP,GACXxP,EAAQQ,KAAK,oBACbR,EAAQQ,KAAK,YACNP,EAAGlN,KAIZiO,EAAMjP,KAAO,eACN6F,EAAK7E,GACd,CACF,EAvKE+J,QAKF,SAAyBiF,GACvB,IAIIhO,EAGAsM,EAPAgU,EAAgBtS,EAAOnT,OAAS,EAChC0lB,EAAiB,EAQrB,KAAwC,eAAnCvS,EAAOuS,GAAgB,GAAGviB,MAA4D,UAAnCgQ,EAAOuS,GAAgB,GAAGviB,MAAwD,eAAlCgQ,EAAOsS,GAAe,GAAGtiB,MAA2D,UAAlCgQ,EAAOsS,GAAe,GAAGtiB,MAGjL,IAFAgC,EAAQugB,IAECvgB,EAAQsgB,GACf,GAA8B,iBAA1BtS,EAAOhO,GAAO,GAAGhC,KAAyB,CAE5CgQ,EAAOuS,GAAgB,GAAGviB,KAAO,kBACjCgQ,EAAOsS,GAAe,GAAGtiB,KAAO,kBAChCuiB,GAAkB,EAClBD,GAAiB,EACjB,KACF,CAKJtgB,EAAQugB,EAAiB,EACzBD,IAEA,OAAStgB,GAASsgB,QACFhgB,IAAVgM,EACEtM,IAAUsgB,GAA2C,eAA1BtS,EAAOhO,GAAO,GAAGhC,OAC9CsO,EAAQtM,GAEDA,IAAUsgB,GAA2C,eAA1BtS,EAAOhO,GAAO,GAAGhC,OACrDgQ,EAAO1B,GAAO,GAAGtO,KAAO,eAEpBgC,IAAUsM,EAAQ,IACpB0B,EAAO1B,GAAO,GAAG5P,IAAMsR,EAAOhO,EAAQ,GAAG,GAAGtD,IAC5CsR,EAAOhE,OAAOsC,EAAQ,EAAGtM,EAAQsM,EAAQ,GACzCgU,GAAiBtgB,EAAQsM,EAAQ,EACjCtM,EAAQsM,EAAQ,GAGlBA,OAAQhM,GAIZ,OAAO0N,CACT,EArDEhB,SAyDF,SAAkBhO,GAEhB,OAAgB,KAATA,GAA+D,oBAAhDvC,KAAKuR,OAAOvR,KAAKuR,OAAOnT,OAAS,GAAG,GAAGmD,IAC/D,GCpEO,MAAM,GAAW,CACtB,GAAMiM,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAMA,GACN,GAAM2M,IAIK9J,GAAiB,CAC5B,GAAMwL,IAIKxG,GAAc,CACzB,EAAE,GAAI6G,GACN,EAAE,GAAIA,GACN,GAAMA,IAIK,GAAO,CAClB,GAAMI,GACN,GAAMnD,GACN,GAAM,CAACsD,GAAiBtD,IACxB,GAAM6D,GACN,GAAMP,GACN,GAAMtD,GACN,GAAM0F,GACN,IAAOA,IAII,GAAS,CACpB,GAAMa,GACN,GAAMK,IAIK,GAAO,CAClB,EAAE,GAAIC,GACN,EAAE,GAAIA,GACN,EAAE,GAAIA,GACN,GAAMiB,GACN,GAAMvB,GACN,GAAMyB,GACN,GAAM,CAACO,GAAUQ,IACjB,GAAMuB,GACN,GAAM,CAACC,GAAiB3D,IACxB,GAAME,GACN,GAAMkB,GACN,GAAMwC,IAIK9C,GAAa,CACxBxN,KAAM,CAAC8N,GAAW,KAIPC,GAAmB,CAC9B/N,KAAM,CAAC,GAAI,KAIAD,GAAU,CACrBC,KAAM,ICpER,MAAM0Q,GAAS,cCJR,SAASC,GAAgCzmB,EAAOgM,GACrD,MAAMhH,EAAO2I,OAAO+Y,SAAS1mB,EAAOgM,GAEpC,OACAhH,EAAO,GAAc,KAATA,GAAeA,EAAO,IAAMA,EAAO,IAC/CA,EAAO,KAAOA,EAAO,KACrBA,EAAO,OAASA,EAAO,OACvBA,EAAO,OAASA,EAAO,OAA4B,QAAX,MAAPA,IAA8C,QAAX,MAAPA,IAC7DA,EAAO,QACE,IAGFM,OAAOC,aAAaP,EAC7B,CCrBA,MAAM2hB,GAA6B,oEAW5B,SAASC,GAAa5mB,GAC3B,OAAOA,EAAM0B,QAAQilB,GAA4BE,GACnD,CAQA,SAASA,GAAOC,EAAIC,EAAIC,GACtB,GAAID,EAEF,OAAOA,EAMT,GAAa,KAFAC,EAAGthB,WAAW,GAEV,CACf,MAAMuhB,EAAOD,EAAGthB,WAAW,GACrBwhB,EAAe,MAATD,GAAyB,KAATA,EAC5B,OAAOR,GAAgCO,EAAGvjB,MAAMyjB,EAAM,EAAI,GAAIA,EAAM,GAAK,GAC3E,CAEA,OAAOhF,GAA8B8E,IAAOF,CAC9C,CCqDA,MAAM,GAAM,CAAC,EAAEpoB,eAOFyoB,GAcb,SAAUnnB,EAAOsK,EAAU1K,GAMzB,MALwB,iBAAb0K,IACT1K,EAAU0K,EACVA,OAAWhE,GAWf,WACE,IAAI1G,EAAUe,UAAUE,OAAS,QAAsByF,IAAjB3F,UAAU,GAAmBA,UAAU,GAAK,CAAC,EAInF,MAAMymB,EAASC,GAAU,CACvBC,WAAY,GACZC,eAAgB,CAAC,WAAY,WAAY,UAAW,YAAa,UACjEjV,MAAO,CACL6R,SAAUqD,EAAOC,IACjBC,iBAAkBC,EAClBC,cAAeD,EACfE,WAAYL,EAAOlI,IACnB1C,WAAY4K,EAAO5K,GACnB4F,gBAAiBmF,EACjBxF,mBAAoBwF,EACpBrG,WAAYkG,EAAOM,GACnBC,oBAAqBpI,EACrBqI,oBAAqBrI,EACrBhB,aAAc6I,EAAOM,EAAUnI,GAC/ByG,SAAUoB,EAAOpB,EAAUzG,GAC3BsI,aAAcN,EACd9d,KAAM8d,EACNO,cAAeP,EACfrJ,WAAYkJ,EAAOlJ,GACnB6J,4BAA6BxI,EAC7ByI,sBAAuBzI,EACvB0I,sBAAuB1I,EACvB2I,SAAUd,EAAOc,IACjBnC,gBAAiBqB,EAAOe,IACxBC,kBAAmBhB,EAAOe,IAC1B9I,SAAU+H,EAAOiB,GAAM9I,GACvB+I,aAAcf,EACdhD,SAAU6C,EAAOiB,GAAM9I,GACvBgJ,aAAchB,EACdiB,MAAOpB,EAAOoB,IACdhL,MAAO+B,EACP8H,KAAMD,EAAOC,IACboB,SAAUrB,EAAOqB,IACjBC,cAAeC,EACfC,YAAaxB,EAAOvX,GAAMgZ,GAC1BC,cAAe1B,EAAOvX,IACtBkP,UAAWqI,EAAOrI,IAClBgK,UAAWC,EACXC,gBAAiB1J,EACjB2J,0BAA2B3J,EAC3B4J,oBAAqB5J,EACrB6J,cAAehC,EAAOlI,IACtBmK,OAAQjC,EAAOiC,IACf7N,cAAe4L,EAAO5L,KAExBnJ,KAAM,CACJoV,WAAY6B,IACZC,mBAAoBC,EACpBzF,SAAUuF,IACV9B,cAAeiC,EACfnC,iBAAkBoC,EAClBlN,WAAY8M,IACZK,qBAAsBC,EACtBC,oCAAqCC,EACrCC,gCAAiCD,EACjCE,wBAAyBC,EACzB/I,WAAYoI,EAAOY,GACnBC,gBAAiBC,EACjBzC,oBAAqB0C,EACrBzC,oBAAqB0C,EACrBxC,cAAe8B,EACfrL,aAAc+K,EAAOiB,GACrBvE,SAAUsD,EAAOkB,GACjB3C,aAAc+B,EACdngB,KAAMmgB,EACN1L,WAAYoL,IACZvB,4BAA6B0C,EAC7BzC,sBAAuB0C,EACvBzC,sBAAuB0C,EACvBzC,SAAUoB,IACVvD,gBAAiBuD,EAAOsB,GACxBxC,kBAAmBkB,EAAOsB,GAC1BvL,SAAUiK,EAAOuB,GACjBvC,aAAcsB,EACdrF,SAAU+E,EAAOwB,GACjBvC,aAAcqB,EACdpB,MAAOc,EAAOyB,GACdvN,MAAOwN,EACPC,UAAWC,EACX7I,WAAY8I,EACZ9D,KAAMiC,EAAO8B,GACb3C,SAAUa,IACVV,YAAaU,IACbR,cAAeQ,IACfvK,UAAWuK,IACXL,gBAAiBoC,EACjBnC,0BAA2BoC,EAC3BnC,oBAAqBoC,EACrBC,SAAUC,EACVrC,cAAeE,EAAOoC,GACtBC,0BAA2BC,EAC3BC,kBAAmBC,EACnBzC,OAAQC,IACR9N,cAAe8N,MAEhB9pB,EAAQusB,iBAAmB,IAGxBtiB,EAAO,CAAC,EACd,OAAOgF,EAMP,SAASA,EAAQmF,GAEf,IAAI/E,EAAO,CACTjL,KAAM,OACN+L,SAAU,IAIZ,MAGMqc,EAAa,GAGbC,EAAY,GAGZxV,EAAU,CACdpQ,MAVY,CAACwI,GAWbmd,aACAhF,SACA9U,QACAG,OACAkN,SACA2M,SACAC,UACAC,WAEF,IAAIxmB,GAAS,EAEb,OAASA,EAAQgO,EAAOnT,QAGtB,GAA8B,gBAA1BmT,EAAOhO,GAAO,GAAGhC,MAAoD,kBAA1BgQ,EAAOhO,GAAO,GAAGhC,KAC9D,GAAyB,UAArBgQ,EAAOhO,GAAO,GAChBqmB,EAAUhpB,KAAK2C,OACV,CAELA,EAAQymB,EAAYzY,EADPqY,EAAU9f,MACWvG,EACpC,CAMJ,IAFAA,GAAS,IAEAA,EAAQgO,EAAOnT,QAAQ,CAC9B,MAAM6rB,EAAUtF,EAAOpT,EAAOhO,GAAO,IAEjC,GAAI7G,KAAKutB,EAAS1Y,EAAOhO,GAAO,GAAGhC,OACrC0oB,EAAQ1Y,EAAOhO,GAAO,GAAGhC,MAAM7E,KAAKX,OAAOyP,OAAO,CAChD2J,eAAgB5D,EAAOhO,GAAO,GAAG4R,gBAChCf,GAAU7C,EAAOhO,GAAO,GAE/B,CAEA,GAAIomB,EAAWvrB,OAAS,EAAG,CACzB,MAAM8W,EAAOyU,EAAWA,EAAWvrB,OAAS,IAC5B8W,EAAK,IAAMgV,IACnBxtB,KAAK0X,OAASvQ,EAAWqR,EAAK,GACxC,CAiBA,IAdA1I,EAAK9M,SAAW,CACdC,MAAO2D,EAAMiO,EAAOnT,OAAS,EAAImT,EAAO,GAAG,GAAG5R,MAAQ,CACpDC,KAAM,EACNP,OAAQ,EACRiT,OAAQ,IAEVrS,IAAKqD,EAAMiO,EAAOnT,OAAS,EAAImT,EAAOA,EAAOnT,OAAS,GAAG,GAAG6B,IAAM,CAChEL,KAAM,EACNP,OAAQ,EACRiT,OAAQ,KAGZ/O,GAAS,IAEAA,EAAQohB,EAAOE,WAAWzmB,QACjCoO,EAAOmY,EAAOE,WAAWthB,GAAOiJ,IAASA,EAG3C,OAAOA,CACT,CASA,SAASwd,EAAYzY,EAAQ5R,EAAOvB,GAClC,IAKIgoB,EAGAzS,EAGAwW,EAGA3Q,EAdAjW,EAAQ5D,EAAQ,EAChByqB,GAAoB,EACpBC,GAAa,EAcjB,OAAS9mB,GAASnF,GAAQ,CACxB,MAAMsV,EAAQnC,EAAOhO,GAuBrB,GArBsB,kBAAlBmQ,EAAM,GAAGnS,MAA8C,gBAAlBmS,EAAM,GAAGnS,MAA4C,eAAlBmS,EAAM,GAAGnS,MAClE,UAAbmS,EAAM,GACR0W,IAEAA,IAGF5Q,OAAW3V,GACgB,oBAAlB6P,EAAM,GAAGnS,KACD,UAAbmS,EAAM,MACJ0S,GAAa5M,GAAa4Q,GAAqBD,IACjDA,EAAsB5mB,GAGxBiW,OAAW3V,GAEc,eAAlB6P,EAAM,GAAGnS,MAA2C,kBAAlBmS,EAAM,GAAGnS,MAA8C,mBAAlBmS,EAAM,GAAGnS,MAA+C,mBAAlBmS,EAAM,GAAGnS,MAA+C,6BAAlBmS,EAAM,GAAGnS,OAErKiY,OAAW3V,IAGRumB,GAAiC,UAAb1W,EAAM,IAAoC,mBAAlBA,EAAM,GAAGnS,OAAmD,IAAtB6oB,GAAwC,SAAb1W,EAAM,KAAoC,kBAAlBA,EAAM,GAAGnS,MAA8C,gBAAlBmS,EAAM,GAAGnS,MAAyB,CAC/M,GAAI6kB,EAAU,CACZ,IAAIkE,EAAY/mB,EAGhB,IAFAoQ,OAAY9P,EAELymB,KAAa,CAClB,MAAMC,EAAYhZ,EAAO+Y,GAEzB,GAA0B,eAAtBC,EAAU,GAAGhpB,MAA+C,oBAAtBgpB,EAAU,GAAGhpB,KAA4B,CACjF,GAAqB,SAAjBgpB,EAAU,GAAe,SAEzB5W,IACFpC,EAAOoC,GAAW,GAAGpS,KAAO,kBAC5B8oB,GAAa,GAGfE,EAAU,GAAGhpB,KAAO,aACpBoS,EAAY2W,CACd,MAAO,GAA0B,eAAtBC,EAAU,GAAGhpB,MAA+C,qBAAtBgpB,EAAU,GAAGhpB,MAAqD,+BAAtBgpB,EAAU,GAAGhpB,MAA+D,qBAAtBgpB,EAAU,GAAGhpB,MAAqD,mBAAtBgpB,EAAU,GAAGhpB,KAE1M,KAEJ,CAEI4oB,KAAyBxW,GAAawW,EAAsBxW,KAE9DyS,EAASoE,SAAU,GAIrBpE,EAASnmB,IAAMlE,OAAOyP,OAAO,CAAC,EAAGmI,EAAYpC,EAAOoC,GAAW,GAAGhU,MAAQ+T,EAAM,GAAGzT,KACnFsR,EAAOhE,OAAOoG,GAAapQ,EAAO,EAAG,CAAC,OAAQ6iB,EAAU1S,EAAM,KAC9DnQ,IACAnF,GACF,CAGsB,mBAAlBsV,EAAM,GAAGnS,OACX6kB,EAAW,CACT7kB,KAAM,WAENipB,SAAS,EACT7qB,MAAO5D,OAAOyP,OAAO,CAAC,EAAGkI,EAAM,GAAG/T,QAGpC4R,EAAOhE,OAAOhK,EAAO,EAAG,CAAC,QAAS6iB,EAAU1S,EAAM,KAClDnQ,IACAnF,IACA+rB,OAAsBtmB,EACtB2V,GAAW,EAEf,CACF,CAIA,OADAjI,EAAO5R,GAAO,GAAG6qB,QAAUH,EACpBjsB,CACT,CAOA,SAAS0rB,EAAQjtB,EAAKU,GACpB6J,EAAKvK,GAAOU,CACd,CASA,SAASwsB,EAAQltB,GACf,OAAOuK,EAAKvK,EACd,CAOA,SAASyG,EAAMmnB,GACb,MAAO,CACL7qB,KAAM6qB,EAAE7qB,KACRP,OAAQorB,EAAEprB,OACViT,OAAQmY,EAAEnY,OAEd,CAQA,SAASyS,EAAO9L,EAAQyR,GACtB,OAAOtQ,EAOP,SAASA,EAAK5J,GACZX,EAAMnT,KAAKsD,KAAMiZ,EAAOzI,GAAQA,GAC5Bka,GAAKA,EAAIhuB,KAAKsD,KAAMwQ,EAC1B,CACF,CAIA,SAAS0M,IACPld,KAAKgE,MAAMpD,KAAK,CACdW,KAAM,WACN+L,SAAU,IAEd,CAYA,SAASuC,EAAMhQ,EAAM2Q,EAAOma,GAU1B,OATe3qB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAEvCkP,SAAS1M,KAAKf,GACrBG,KAAKgE,MAAMpD,KAAKf,GAChBG,KAAK2pB,WAAW/oB,KAAK,CAAC4P,EAAOma,IAE7B9qB,EAAKH,SAAW,CACdC,MAAO2D,EAAMkN,EAAM7Q,QAEdE,CACT,CAOA,SAASonB,EAAOyD,GACd,OAAOhK,EAOP,SAASA,EAAMlQ,GACTka,GAAKA,EAAIhuB,KAAKsD,KAAMwQ,GACxBR,EAAKtT,KAAKsD,KAAMwQ,EAClB,CACF,CAUA,SAASR,EAAKQ,EAAOoa,GACnB,MAAM/qB,EAAOG,KAAKgE,MAAM8F,MAClBsQ,EAAOpa,KAAK2pB,WAAW7f,MAE7B,IAAKsQ,EACH,MAAM,IAAI5Z,MAAM,iBAAmBgQ,EAAMjP,KAAO,MAAQ8B,EAAkB,CACxE1D,MAAO6Q,EAAM7Q,MACbM,IAAKuQ,EAAMvQ,MACR,oBACA,GAAIma,EAAK,GAAG7Y,OAASiP,EAAMjP,KAChC,GAAIqpB,EACFA,EAAYluB,KAAKsD,KAAMwQ,EAAO4J,EAAK,QAC9B,EACWA,EAAK,IAAM8P,IACnBxtB,KAAKsD,KAAMwQ,EAAO4J,EAAK,GACjC,CAIF,OADAva,EAAKH,SAASO,IAAMqD,EAAMkN,EAAMvQ,KACzBJ,CACT,CAOA,SAASgqB,IACP,OAAO,EAAS7pB,KAAKgE,MAAM8F,MAC7B,CAOA,SAAS0c,IACPsD,EAAQ,+BAA+B,EACzC,CAIA,SAASxD,EAAqB9V,GAC5B,GAAIuZ,EAAQ,+BAAgC,CAG1C/pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GACtBuB,MAAQuL,OAAO+Y,SAASjkB,KAAKmV,eAAe3E,GAAQ,IAC7DsZ,EAAQ,8BACV,CACF,CAIA,SAAS9B,IACP,MAAM5gB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1BysB,KAAOzjB,CACd,CAIA,SAAS6gB,IACP,MAAM7gB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1BmhB,KAAOnY,CACd,CAIA,SAAS2gB,IAEHgC,EAAQ,oBACZ/pB,KAAKkd,SACL4M,EAAQ,kBAAkB,GAC5B,CAIA,SAASjC,IACP,MAAMzgB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1Bb,MAAQ6J,EAAKnI,QAAQ,2BAA4B,IACtD6qB,EAAQ,iBACV,CAIA,SAAS5B,IACP,MAAM9gB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1Bb,MAAQ6J,EAAKnI,QAAQ,eAAgB,GAC5C,CAIA,SAASopB,EAA4B7X,GAEnC,MAAM2K,EAAQnb,KAAK6pB,SACbhqB,EAENG,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC/ByB,EAAKsb,MAAQA,EACbtb,EAAKic,WAAaH,GAAoB3b,KAAKmV,eAAe3E,IAAQoL,aACpE,CAIA,SAAS0M,IACP,MAAMlhB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1Bod,MAAQpU,CACf,CAIA,SAASghB,IACP,MAAMhhB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1BkG,IAAM8C,CACb,CAIA,SAAS+f,EAAyB3W,GAChC,MAAM3Q,EAENG,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAE/B,IAAKyB,EAAKirB,MAAO,CACf,MAAMA,EAAQ9qB,KAAKmV,eAAe3E,GAAOpS,OACzCyB,EAAKirB,MAAQA,CACf,CACF,CAIA,SAASrB,IACPK,EAAQ,gCAAgC,EAC1C,CAIA,SAASP,EAAgC/Y,GAGvCxQ,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1B0sB,MAAqD,KAA7C9qB,KAAKmV,eAAe3E,GAAOvN,WAAW,GAAY,EAAI,CACrE,CAIA,SAASomB,IACPS,EAAQ,+BACV,CAIA,SAAS5E,EAAY1U,GACnB,MAAMua,EAEN/qB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAG/B,IAAI8W,EAAO6V,EAAOzd,SAASyd,EAAOzd,SAASlP,OAAS,GAE/C8W,GAAsB,SAAdA,EAAK3T,OAEhB2T,EAAOU,KAEPV,EAAKxV,SAAW,CACdC,MAAO2D,EAAMkN,EAAM7Q,QAGrBorB,EAAOzd,SAAS1M,KAAKsU,IAGvBlV,KAAKgE,MAAMpD,KAAKsU,EAClB,CAIA,SAASqS,EAAW/W,GAClB,MAAM0E,EAAOlV,KAAKgE,MAAM8F,MACxBoL,EAAK3X,OAASyC,KAAKmV,eAAe3E,GAClC0E,EAAKxV,SAASO,IAAMqD,EAAMkN,EAAMvQ,IAClC,CAIA,SAAS6oB,EAAiBtY,GACxB,MAAM4D,EAAUpU,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAE/C,GAAI2rB,EAAQ,eAAgB,CAI1B,OAHa3V,EAAQ9G,SAAS8G,EAAQ9G,SAASlP,OAAS,GACnDsB,SAASO,IAAMqD,EAAMkN,EAAMvQ,UAChC6pB,EAAQ,cAEV,EAEKC,EAAQ,iCAAmCpF,EAAOG,eAAerd,SAAS2M,EAAQ7S,QACrF2jB,EAAYxoB,KAAKsD,KAAMwQ,GACvB+W,EAAW7qB,KAAKsD,KAAMwQ,GAE1B,CAIA,SAAS+X,IACPuB,EAAQ,eAAe,EACzB,CAIA,SAAStB,IACP,MAAMphB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1Bb,MAAQ6J,CACf,CAIA,SAASqhB,IACP,MAAMrhB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1Bb,MAAQ6J,CACf,CAIA,SAAS+gB,IACP,MAAM/gB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1Bb,MAAQ6J,CACf,CAIA,SAAS2hB,IACP,MAAM3U,EAENpU,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAE3B2rB,EAAQ,gBACV3V,EAAQ7S,MAAQ,YAEhB6S,EAAQ4W,cAAgBjB,EAAQ,kBAAoB,kBAE7C3V,EAAQ9P,WACR8P,EAAQoH,eAGRpH,EAAQ0H,kBAER1H,EAAQ+G,OAGjB2O,EAAQ,gBACV,CAIA,SAASpB,IACP,MAAMtU,EAENpU,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAE3B2rB,EAAQ,gBACV3V,EAAQ7S,MAAQ,YAEhB6S,EAAQ4W,cAAgBjB,EAAQ,kBAAoB,kBAE7C3V,EAAQ9P,WACR8P,EAAQoH,eAGRpH,EAAQ0H,kBAER1H,EAAQ+G,OAGjB2O,EAAQ,gBACV,CAIA,SAASjB,EAAgBrY,GACvB,MAAMya,EAENjrB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GACzB+D,EAASnC,KAAKmV,eAAe3E,GACnCya,EAAS9P,MAAQgJ,GAAahiB,GAC9B8oB,EAASnP,WAAaH,GAAoBxZ,GAAQyZ,aACpD,CAIA,SAAS+M,IACP,MAAMuC,EAENlrB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GACzBb,EAAQyC,KAAK6pB,SACbhqB,EAENG,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAE/B0rB,EAAQ,eAAe,GAEL,SAAdjqB,EAAK0B,KAEP1B,EAAKyN,SAAW4d,EAAS5d,SAEzBzN,EAAKwN,IAAM9P,CAEf,CAIA,SAAS0rB,IACP,MAAM7hB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1BkG,IAAM8C,CACb,CAIA,SAAS8hB,IACP,MAAM9hB,EAAOpH,KAAK6pB,SAGlB7pB,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1Bod,MAAQpU,CACf,CAIA,SAASgiB,IACPU,EAAQ,cACV,CAIA,SAASnD,IACPmD,EAAQ,gBAAiB,YAC3B,CAIA,SAASd,EAAsBxY,GAC7B,MAAM2K,EAAQnb,KAAK6pB,SACbhqB,EAENG,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC/ByB,EAAKsb,MAAQA,EACbtb,EAAKic,WAAaH,GAAoB3b,KAAKmV,eAAe3E,IAAQoL,cAClEkO,EAAQ,gBAAiB,OAC3B,CAIA,SAASrC,EAA+BjX,GACtCsZ,EAAQ,yBAA0BtZ,EAAMjP,KAC1C,CAIA,SAASqmB,EAA8BpX,GACrC,MAAMpJ,EAAOpH,KAAKmV,eAAe3E,GAC3BjP,EAAOwoB,EAAQ,0BAGrB,IAAIxsB,EAEAgE,GACFhE,EAAQymB,GAAgC5c,EAAe,oCAAT7F,EAA6C,GAAK,IAChGuoB,EAAQ,2BAKRvsB,EAAQkiB,GAA8BrY,GAGxC,MAAM8N,EAAOlV,KAAKgE,MAAM8F,MACxBoL,EAAK3X,OAASA,EACd2X,EAAKxV,SAASO,IAAMqD,EAAMkN,EAAMvQ,IAClC,CAIA,SAASonB,EAAuB7W,GAC9B+W,EAAW7qB,KAAKsD,KAAMwQ,GAGtBxQ,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1BkG,IAAMtE,KAAKmV,eAAe3E,EACjC,CAIA,SAAS4W,EAAoB5W,GAC3B+W,EAAW7qB,KAAKsD,KAAMwQ,GAGtBxQ,KAAKgE,MAAMhE,KAAKgE,MAAM5F,OAAS,GAC1BkG,IAAM,UAAYtE,KAAKmV,eAAe3E,EAC7C,CAOA,SAAS2J,IACP,MAAO,CACL5Y,KAAM,aACN+L,SAAU,GAEd,CAIA,SAAS+X,IACP,MAAO,CACL9jB,KAAM,OACNspB,KAAM,KACNtL,KAAM,KACNhiB,MAAO,GAEX,CAIA,SAASomB,IACP,MAAO,CACLpiB,KAAM,aACNhE,MAAO,GAEX,CAIA,SAASse,IACP,MAAO,CACLta,KAAM,aACNua,WAAY,GACZX,MAAO,KACPK,MAAO,KACPlX,IAAK,GAET,CAIA,SAASuhB,KACP,MAAO,CACLtkB,KAAM,WACN+L,SAAU,GAEd,CAIA,SAASuP,KAEP,MAAO,CACLtb,KAAM,UACNupB,WAAOjnB,EACPyJ,SAAU,GAEd,CAIA,SAASwY,KACP,MAAO,CACLvkB,KAAM,QAEV,CAIA,SAASykB,KACP,MAAO,CACLzkB,KAAM,OACNhE,MAAO,GAEX,CAIA,SAAS4oB,KACP,MAAO,CACL5kB,KAAM,QACNia,MAAO,KACPlX,IAAK,GACL+I,IAAK,KAET,CAIA,SAAS2X,KACP,MAAO,CACLzjB,KAAM,OACNia,MAAO,KACPlX,IAAK,GACLgJ,SAAU,GAEd,CAOA,SAASE,GAAKgD,GACZ,MAAO,CACLjP,KAAM,OACN4pB,QAAwB,gBAAf3a,EAAMjP,KACf5B,MAAO,KAEPyrB,OAAQ5a,EAAMga,QACdld,SAAU,GAEd,CAOA,SAAS8Y,GAAS5V,GAChB,MAAO,CACLjP,KAAM,WAEN6pB,OAAQ5a,EAAMga,QACda,QAAS,KACT/d,SAAU,GAEd,CAIA,SAASoP,KACP,MAAO,CACLnb,KAAM,YACN+L,SAAU,GAEd,CAIA,SAAS0Z,KACP,MAAO,CACLzlB,KAAM,SACN+L,SAAU,GAEd,CAIA,SAASsI,KACP,MAAO,CACLrU,KAAM,OACNhE,MAAO,GAEX,CAIA,SAAS4b,KACP,MAAO,CACL5X,KAAM,gBAEV,CACF,CAz/BS+pB,CAASnuB,EAATmuB,CC9GF,SAAqB/Z,GAC1B,MAAQiC,GAAYjC,KAGpB,OAAOA,CACT,CDyG2Bga,CEpGpB,WAKL,MAIMnb,EAAS,CACb6L,QAAS,GACT7J,KAAM,CAAC,EACP9D,WAPiBR,EACnB,CAAC,GAAmB0d,QALNttB,UAAUE,OAAS,QAAsByF,IAAjB3F,UAAU,GAAmBA,UAAU,GAAK,CAAC,GAKhD6P,YAAc,KAO/C5N,QAAS8Y,EAAO9Y,IAChBgT,SAAU8F,EAAO,IACjBzG,KAAMyG,EAAOzG,IACbrQ,OAAQ8W,EAAO9W,IACfyT,KAAMqD,EAAO,KAEf,OAAO7I,EAKP,SAAS6I,EAAO7D,GACd,OAGA,SAAiBxH,GACf,OAAO2I,GAAgBnG,EAAQgF,EAASxH,EAC1C,CACF,CACF,CFoEuC/B,CAAM1O,GAASgW,WAAWH,MHpG1D,WACL,IAOIyY,EAPApsB,EAAS,EACT6d,EAAS,GAGTvd,GAAQ,EAIZ,OAGA,SAAsBpC,EAAOsK,EAAU5H,GAErC,MAAMgW,EAAS,GAGf,IAAIzW,EAGAuK,EAGAsK,EAGAqX,EAGAnpB,EAcJ,IAZAhF,EAAQ2f,EAAS3f,EAAMpB,SAAS0L,GAChCwM,EAAgB,EAChB6I,EAAS,GAELvd,IAC0B,QAAxBpC,EAAM0F,WAAW,IACnBoR,IAGF1U,OAAQkE,GAGHwQ,EAAgB9W,EAAMa,QAAQ,CAMnC,GALA2lB,GAAO4H,UAAYtX,EACnB7U,EAAQukB,GAAOhjB,KAAKxD,GACpBmuB,EAAclsB,QAAyBqE,IAAhBrE,EAAM+D,MAAsB/D,EAAM+D,MAAQhG,EAAMa,OACvEmE,EAAOhF,EAAM0F,WAAWyoB,IAEnBlsB,EAAO,CACV0d,EAAS3f,EAAMyD,MAAMqT,GACrB,KACF,CAEA,GAAa,KAAT9R,GAAe8R,IAAkBqX,GAAeD,EAClDxV,EAAOrV,MAAM,GACb6qB,OAAmB5nB,OAYnB,OAVI4nB,IACFxV,EAAOrV,MAAM,GACb6qB,OAAmB5nB,GAGjBwQ,EAAgBqX,IAClBzV,EAAOrV,KAAKrD,EAAMyD,MAAMqT,EAAeqX,IACvCrsB,GAAUqsB,EAAcrX,GAGlB9R,GACN,KAAK,EAED0T,EAAOrV,KAAK,OACZvB,IACA,MAGJ,KAAK,EAKD,IAHA0K,EAA+B,EAAxB6hB,KAAKC,KAAKxsB,EAAS,GAC1B4W,EAAOrV,MAAM,GAENvB,IAAW0K,GAAMkM,EAAOrV,MAAM,GAErC,MAGJ,KAAK,GAEDqV,EAAOrV,MAAM,GACbvB,EAAS,EACT,MAGJ,QAEIosB,GAAmB,EACnBpsB,EAAS,EAKjBgV,EAAgBqX,EAAc,CAChC,CAQA,OANIzrB,IACEwrB,GAAkBxV,EAAOrV,MAAM,GAC/Bsc,GAAQjH,EAAOrV,KAAKsc,GACxBjH,EAAOrV,KAAK,OAGPqV,CACT,CACF,CGZuE6V,GAAavuB,EAAOsK,GAAU,KACrG,EAggCA,SAAS+c,GAAUmH,EAAUhe,GAC3B,IAAIxK,GAAS,EAEb,OAASA,EAAQwK,EAAW3P,QAAQ,CAClC,MAAMb,EAAQwQ,EAAWxK,GAErB9G,MAAMF,QAAQgB,GAChBqnB,GAAUmH,EAAUxuB,GAEpB2Q,GAAU6d,EAAUxuB,EAExB,CAEA,OAAOwuB,CACT,CAQA,SAAS7d,GAAU6d,EAAU7d,GAE3B,IAAIrR,EAEJ,IAAKA,KAAOqR,EACV,GAAI,GAAIxR,KAAKwR,EAAWrR,GAAM,CAC5B,MAAM2Q,EAAe,mBAAR3Q,GAAoC,eAARA,EAInCuR,GAHQ,GAAI1R,KAAKqvB,EAAUlvB,GAAOkvB,EAASlvB,QAAOgH,KAGjCkoB,EAASlvB,GAAO2Q,EAAO,GAAK,CAAC,GAC9Ca,EAAQH,EAAUrR,GAEpBwR,IACEb,EAEFue,EAASlvB,GAAO,IAAIuR,KAASC,GAE7BtS,OAAOyP,OAAO4C,EAAMC,GAG1B,CAEJ,CAIA,SAAS6b,GAAe9b,EAAMC,GAC5B,MAAID,EACI,IAAI5N,MAAM,iBAAmB4N,EAAK7M,KAAO,MAAQ8B,EAAkB,CACvE1D,MAAOyO,EAAKzO,MACZM,IAAKmO,EAAKnO,MACP,0BAA4BoO,EAAM9M,KAAO,MAAQ8B,EAAkB,CACtE1D,MAAO0O,EAAM1O,MACbM,IAAKoO,EAAMpO,MACR,aAEC,IAAIO,MAAM,oCAAsC6N,EAAM9M,KAAO,MAAQ8B,EAAkB,CAC3F1D,MAAO0O,EAAM1O,MACbM,IAAKoO,EAAMpO,MACR,kBAET,CGvrCA,OCMe,SAAqB9C,GAgBlCpB,OAAOyP,OAAOxL,KAAM,CAClB6K,OAfaiB,IAEb,MAAMV,EAENpL,KAAKoH,KAAK,YACV,OAAOsd,GAAa5Y,EAAK/P,OAAOyP,OAAO,CAAC,EAAGJ,EAAUjO,EAAS,CAI5D4Q,WAAY/N,KAAKoH,KAAK,wBAA0B,GAChDsiB,gBAAiB1pB,KAAKoH,KAAK,2BAA6B,KACvD,GAMP,ECZW4kB,GAWX,SAAUzqB,EAAM0qB,EAAO1uB,GAErB,IAAIsC,EAAO,CACT0B,KAAMsB,OAAOtB,IAef,OAZI,MAAChE,GAA4D,iBAAV0uB,IAAsBxvB,MAAMF,QAAQ0vB,GAGzFlwB,OAAOyP,OAAO3L,EAAMosB,GAFpB1uB,EAAQ0uB,EAKNxvB,MAAMF,QAAQgB,GAChBsC,EAAKyN,SAAW/P,EACPA,UACTsC,EAAKtC,MAAQsF,OAAOtF,IAGfsC,CACT,ECKO,MA8CMqsB,GAkBb,SAAUnpB,GACR,GAAIA,QACF,OAAO0M,GAGT,GAAoB,iBAAT1M,EACT,OAqFJ,SAAqBiP,GACnB,OAAOma,GAAY5qB,GAKnB,SAASA,EAAK1B,GACZ,OAAOA,GAAQA,EAAK0B,OAASyQ,CAC/B,CACF,CA9FWoa,CAAYrpB,GAGrB,GAAoB,iBAATA,EACT,OAAOtG,MAAMF,QAAQwG,GAczB,SAAoBspB,GAElB,MAAMC,EAAS,GACf,IAAI/oB,GAAS,EAEb,OAASA,EAAQ8oB,EAAMjuB,QACrBkuB,EAAO/oB,GAAS2oB,GAAQG,EAAM9oB,IAGhC,OAAO4oB,GAAYI,GAOnB,SAASA,IACP,IAAIhpB,GAAS,EAEb,IAAK,IAAIgC,EAAOrH,UAAUE,OAAQuK,EAAa,IAAIlM,MAAM8I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IACrFkD,EAAWlD,GAAQvH,UAAUuH,GAG/B,OAASlC,EAAQ+oB,EAAOluB,QACtB,GAAIkuB,EAAO/oB,GAAO7G,KAAKsD,QAAS2I,GAAa,OAAO,EAGtD,OAAO,CACT,CACF,CA3CiC6jB,CAAWzpB,GAqD5C,SAAsBiP,GACpB,OAAOma,GAAYne,GAMnB,SAASA,EAAInO,GAEX,IAAIhD,EAEJ,IAAKA,KAAOmV,EAEV,GAAInS,EAAKhD,KAASmV,EAAMnV,GAAM,OAAO,EAGvC,OAAO,CACT,CACF,CAvEoD4vB,CAAa1pB,GAG/D,GAAoB,mBAATA,EACT,OAAOopB,GAAYppB,GAGrB,MAAM,IAAIvC,MAAM,+CAClB,EA2FA,SAAS2rB,GAAYna,GACnB,OAOA,WACE,IAAK,IAAI/H,EAAQ/L,UAAUE,OAAQuK,EAAa,IAAIlM,MAAMwN,GAAQC,EAAQ,EAAGA,EAAQD,EAAOC,IAC1FvB,EAAWuB,GAAShM,UAAUgM,GAIhC,OAAO+C,QAAQ+E,EAAMtV,KAAKsD,QAAS2I,GACrC,CACF,CAGA,SAAS8G,KACP,OAAO,CACT,CCnOO,MAoBMid,GAcb,SAAUlgB,EAAMzJ,EAAM4pB,EAASC,GACT,mBAAT7pB,GAA0C,mBAAZ4pB,IACvCC,EAAUD,EAEVA,EAAU5pB,EACVA,EAAO,MAGT,MAAM8pB,EAAKX,GAAQnpB,GACb+pB,EAAOF,GAAW,EAAI,GAQ5B,SAASG,EAAQltB,EAAM0D,EAAOypB,GAG5B,MAAMzvB,EAAwB,iBAATsC,GAA8B,OAATA,EAAgBA,EAAO,CAAC,EAGlE,IAAIzC,EAEsB,iBAAfG,EAAMgE,OACfnE,EAAgC,iBAAlBG,EAAM+f,QAAuB/f,EAAM+f,QAAgC,iBAAf/f,EAAMH,KAAoBG,EAAMH,UAAOyG,EACzG9H,OAAOK,eAAe6wB,EAAO,OAAQ,CACnC1vB,MAAO,SAAiBA,EAAMgE,MAAQnE,EAAO,IAAMA,EAAO,IAAM,IAAO,OAI3E,OAAO6vB,EAEP,SAASA,IAEP,IAGIC,EAGA5a,EAGA6a,EATAzqB,EAAS,GAWb,KAAKK,GAAQ8pB,EAAGhtB,EAAM0D,EAAOypB,EAAQA,EAAQ5uB,OAAS,IAAM,SAC1DsE,EAmCR,SAAkBnF,GAChB,GAAId,MAAMF,QAAQgB,GAChB,OAAOA,EAGT,GAAqB,iBAAVA,EACT,MAAO,CA3Ha,KA2HFA,GAGpB,MAAO,CAACA,EACV,CA7CiB6vB,CAAST,EAAQ9sB,EAAMmtB,IAxEpB,QA0ERtqB,EAAO,IACT,OAAOA,EAKX,GAAI7C,EAAKyN,UArFK,SAqFO5K,EAAO,GAM1B,IAJA4P,GAAUsa,EAAU/sB,EAAKyN,SAASlP,QAAU,GAAK0uB,EAEjDK,EAAeH,EAAQxB,OAAO3rB,GAEvByS,GAAU,GAAKA,EAASzS,EAAKyN,SAASlP,QAAQ,CAInD,GAFA8uB,EAAYH,EAAQltB,EAAKyN,SAASgF,GAASA,EAAQ6a,EAAvCJ,GAxFF,QA0FNG,EAAU,GACZ,OAAOA,EAGT5a,EAAiC,iBAAjB4a,EAAU,GAAkBA,EAAU,GAAK5a,EAASwa,CACtE,CAGF,OAAOpqB,CACT,CACF,CAlEAqqB,CAAQvgB,EAAM,KAAM,GAApBugB,EAmEF,EC7GO,MAAME,GAcb,SAAUzgB,EAAMzJ,EAAM4pB,EAASC,GACT,mBAAT7pB,GAA0C,mBAAZ4pB,IACvCC,EAAUD,EACVA,EAAU5pB,EACVA,EAAO,MAGT2pB,GAAalgB,EAAMzJ,GAMnB,SAAkBlD,EAAMmtB,GACtB,MAAMjC,EAASiC,EAAQA,EAAQ5uB,OAAS,GACxC,OAAOuuB,EAAQ9sB,EAAMkrB,EAASA,EAAOzd,SAASxJ,QAAQjE,GAAQ,KAAMkrB,EACtE,GATmC6B,EAUrC,ECrCaS,GAAa,GAAM,SACnBC,GAAW,GAAM,OAoB9B,SAAS,GAAM/rB,GACb,OAQA,SAAe1B,GACb,MAAMyD,EAAQzD,GAAQA,EAAKH,UAAYG,EAAKH,SAAS6B,IAAS,CAAC,EAC/D,MAAO,CACL3B,KAAM0D,EAAM1D,MAAQ,KACpBP,OAAQiE,EAAMjE,QAAU,KACxBiT,OAAQhP,EAAMgP,QAAU,EAAIhP,EAAMgP,OAAS,KAE/C,CACF,CC7CA,MAAM,GAAM,CAAC,EAAErW,eA0Cf,SAASsxB,GAAMhwB,GACb,OAAOsF,OAAOtF,GAAS,IAAIyF,aAC7B,CC1CA,MAAM,GAAM,CAAC,EAAE/G,eAOf,SAASuxB,GAAQC,EAAG5tB,GAClB,MAAMuH,EAAOvH,EAAKuH,MAAQ,CAAC,EAE3B,MAAI,UAAWvH,KAAU,GAAInD,KAAK0K,EAAM,UAAY,GAAI1K,KAAK0K,EAAM,gBAAkB,GAAI1K,KAAK0K,EAAM,cAC3FqmB,EAAEC,QAAQ7tB,EAAMmsB,GAAE,OAAQnsB,EAAKtC,QAGjCkwB,EAAE5tB,EAAM,MAAO,GAAI4tB,EAAG5tB,GAC/B,CAOO,SAAS,GAAI4tB,EAAG5tB,EAAMkrB,GAC3B,MAAMxpB,EAAO1B,GAAQA,EAAK0B,KAG1B,IAAIyI,EAEJ,IAAKzI,EACH,MAAM,IAAIf,MAAM,uBAAyBX,EAAO,KAWlD,OAPEmK,EADE,GAAItN,KAAK+wB,EAAEE,SAAUpsB,GAClBksB,EAAEE,SAASpsB,GACPksB,EAAEG,aAAeH,EAAEG,YAAYnmB,SAASlG,GAC5CssB,GAEAJ,EAAEK,gBAGa,mBAAP9jB,EAAoBA,EAAKwjB,IAASC,EAAG5tB,EAAMkrB,EAC5D,CAMA,SAAS8C,GAAWJ,EAAG5tB,GAErB,MAAO,aAAcA,EAAO,IAAKA,EAC/ByN,SAAU,GAAImgB,EAAG5tB,IACfA,CACN,CAOO,SAAS,GAAI4tB,EAAG1C,GAErB,MAAMnhB,EAAS,GAEf,GAAI,aAAcmhB,EAAQ,CACxB,MAAMgD,EAAQhD,EAAOzd,SACrB,IAAI/J,GAAS,EAEb,OAASA,EAAQwqB,EAAM3vB,QAAQ,CAC7B,MAAMsE,EAAS,GAAI+qB,EAAGM,EAAMxqB,GAAQwnB,GAEpC,GAAIroB,EAAQ,CACV,GAAIa,GAAmC,UAA1BwqB,EAAMxqB,EAAQ,GAAGhC,OACvB9E,MAAMF,QAAQmG,IAA2B,SAAhBA,EAAOnB,OACnCmB,EAAOnF,MAAQmF,EAAOnF,MAAM0B,QAAQ,OAAQ,MAGzCxC,MAAMF,QAAQmG,IAA2B,YAAhBA,EAAOnB,MAAoB,CACvD,MAAMijB,EAAO9hB,EAAO4K,SAAS,GAEzBkX,GAAsB,SAAdA,EAAKjjB,OACfijB,EAAKjnB,MAAQinB,EAAKjnB,MAAM0B,QAAQ,OAAQ,IAE5C,CAGExC,MAAMF,QAAQmG,GAChBkH,EAAOhJ,QAAQ8B,GAEfkH,EAAOhJ,KAAK8B,EAEhB,CACF,CACF,CAEA,OAAOkH,CACT,CCtGA,MAAMokB,GAAsB,CAC1B,IAAK,OACL,IAAK,MACL,IAAK,KACL,IAAK,MCkBA,SAASC,GAAY3pB,EAAKsC,GAC/B,MAAMrJ,EDND,SAAgBA,GACrB,OAAOA,EAAM0B,QAAQ,WAMrB,SAAiB1B,GAEf,MAAO,IAAMywB,GAAoBzwB,GAAS,GAC5C,GACF,CCLgB2E,CA8BhB,SAAsB3E,GAEpB,MAAMmF,EAAS,GACf,IAAIa,GAAS,EACT5D,EAAQ,EACRuuB,EAAO,EAEX,OAAS3qB,EAAQhG,EAAMa,QAAQ,CAC7B,MAAMmE,EAAOhF,EAAM0F,WAAWM,GAG9B,IAAItE,EAAU,GAEd,GAAa,KAATsD,GAAesM,EAAkBtR,EAAM0F,WAAWM,EAAQ,KAAOsL,EAAkBtR,EAAM0F,WAAWM,EAAQ,IAC9G2qB,EAAO,OAEJ,GAAI3rB,EAAO,IACT,oBAAoBQ,KAAKF,OAAOC,aAAaP,MAChDtD,EAAU4D,OAAOC,aAAaP,SAG7B,GAAIA,EAAO,OAASA,EAAO,MAAO,CACrC,MAAMwH,EAAOxM,EAAM0F,WAAWM,EAAQ,GAElChB,EAAO,OAASwH,EAAO,OAASA,EAAO,OACzC9K,EAAU4D,OAAOC,aAAaP,EAAMwH,GACpCmkB,EAAO,GAGPjvB,EAAU,GAEd,MAEEA,EAAU4D,OAAOC,aAAaP,GAG5BtD,IACFyD,EAAO9B,KAAKrD,EAAMyD,MAAMrB,EAAO4D,GAAQJ,mBAAmBlE,IAC1DU,EAAQ4D,EAAQ2qB,EAAO,EACvBjvB,EAAU,IAGRivB,IACF3qB,GAAS2qB,EACTA,EAAO,EAEX,CAEA,OAAOxrB,EAAO2C,KAAK,IAAM9H,EAAMyD,MAAMrB,EACvC,CA/EuBwuB,CAAa7pB,GAAO,KAEzC,IAAKsC,EACH,OAAOrJ,EAGT,MAAM6wB,EAAQ7wB,EAAMuG,QAAQ,KACtBuqB,EAAe9wB,EAAMuG,QAAQ,KAC7BwqB,EAAa/wB,EAAMuG,QAAQ,KAC3ByqB,EAAQhxB,EAAMuG,QAAQ,KAE5B,OACAsqB,EAAQ,GACRG,GAAS,GAAKH,EAAQG,GAASF,GAAgB,GAAKD,EAAQC,GAAgBC,GAAc,GAAKF,EAAQE,GACvG1nB,EAAS7D,KAAKxF,EAAMyD,MAAM,EAAGotB,IACpB7wB,EAGF,EACT,CC7BO,SAAS,GAAKwwB,EAAOS,GAE1B,MAAM9rB,EAAS,GACf,IAAIa,GAAS,EAMb,IAJIirB,GACF9rB,EAAO9B,KAAKorB,GAAE,OAAQ,SAGfzoB,EAAQwqB,EAAM3vB,QACjBmF,GAAOb,EAAO9B,KAAKorB,GAAE,OAAQ,OACjCtpB,EAAO9B,KAAKmtB,EAAMxqB,IAOpB,OAJIirB,GAAST,EAAM3vB,OAAS,GAC1BsE,EAAO9B,KAAKorB,GAAE,OAAQ,OAGjBtpB,CACT,CCrBO,SAAS+rB,GAAkBhB,EAAG5tB,GACnC,MAAM6uB,EAAK7rB,OAAOhD,EAAKic,YACjB6S,EAASV,GAAYS,EAAG9S,eACxBrY,EAAQkqB,EAAEmB,cAAc9qB,QAAQ4qB,GAGtC,IAAIG,GAEW,IAAXtrB,GACFkqB,EAAEmB,cAAchuB,KAAK8tB,GACrBjB,EAAEqB,eAAeJ,GAAM,EACvBG,EAAUpB,EAAEmB,cAAcxwB,SAE1BqvB,EAAEqB,eAAeJ,KACjBG,EAAUtrB,EAAQ,GAGpB,MAAMwrB,EAAetB,EAAEqB,eAAeJ,GACtC,OAAOjB,EAAE5tB,EAAM,MAAO,CAAC4tB,EAAE5tB,EAAKH,SAAU,IAAK,CAC3C+G,KAAM,IAAMgnB,EAAEuB,cAAgB,MAAQL,EACtCD,GAAIjB,EAAEuB,cAAgB,SAAWL,GAAUI,EAAe,EAAI,IAAMA,EAAe,IACnFE,iBAAiB,EACjBC,gBAAiB,kBAChB,CAAClD,GAAE,OAAQnpB,OAAOgsB,OACvB,4BCnBO,SAASM,GAAO1B,EAAG5tB,GACxB,MAAMuvB,EAAUvvB,EAAKmrB,cACrB,IAAIqE,EAAS,IAQb,GANgB,cAAZD,EACFC,GAAU,KACW,SAAZD,IACTC,GAAU,KAAOxvB,EAAKsb,OAAStb,EAAKic,YAAc,KAGlC,mBAAdjc,EAAK0B,KACP,OAAOyqB,GAAE,OAAQ,KAAOnsB,EAAKwN,IAAMgiB,GAGrC,MAAMC,EAAW,GAAI7B,EAAG5tB,GAClB2kB,EAAO8K,EAAS,GAElB9K,GAAsB,SAAdA,EAAKjjB,KACfijB,EAAKjnB,MAAQ,IAAMinB,EAAKjnB,MAExB+xB,EAASzhB,QAAQme,GAAE,OAAQ,MAG7B,MAAM9W,EAAOoa,EAASA,EAASlxB,OAAS,GAQxC,OANI8W,GAAsB,SAAdA,EAAK3T,KACf2T,EAAK3X,OAAS8xB,EAEdC,EAAS1uB,KAAKorB,GAAE,OAAQqD,IAGnBC,CACT,CCiDA,SAASC,GAAc1vB,GACrB,MAAMurB,EAASvrB,EAAKurB,OACpB,OAAOA,QAA0CvrB,EAAKyN,SAASlP,OAAS,EAAIgtB,CAC9E,CCvDA,SAASoE,GAASjyB,EAAOoC,EAAOM,GAC9B,IAAIuX,EAAa,EACbE,EAAWna,EAAMa,OAErB,GAAIuB,EAAO,CACT,IAAI4C,EAAOhF,EAAMkyB,YAAYjY,GAE7B,KApDQ,IAoDDjV,GAjDG,KAiDaA,GACrBiV,IACAjV,EAAOhF,EAAMkyB,YAAYjY,EAE7B,CAEA,GAAIvX,EAAK,CACP,IAAIsC,EAAOhF,EAAMkyB,YAAY/X,EAAW,GAExC,KA7DQ,IA6DDnV,GA1DG,KA0DaA,GACrBmV,IACAnV,EAAOhF,EAAMkyB,YAAY/X,EAAW,EAExC,CAEA,OAAOA,EAAWF,EAAaja,EAAMyD,MAAMwW,EAAYE,GAAY,EACrE,CC9CO,MAAMiW,GAAW,CACtB+B,WCZK,SAAoBjC,EAAG5tB,GAC5B,OAAO4tB,EAAE5tB,EAAM,aAAc,GAAK,GAAI4tB,EAAG5tB,IAAO,GAClD,EDWE8vB,MEXK,SAAmBlC,EAAG5tB,GAC3B,MAAO,CAAC4tB,EAAE5tB,EAAM,MAAOmsB,GAAE,OAAQ,MACnC,EFUEzpB,KGbK,SAAckrB,EAAG5tB,GACtB,MAAMtC,EAAQsC,EAAKtC,MAAQsC,EAAKtC,MAAQ,KAAO,GAGzCstB,EAAOhrB,EAAKgrB,MAAQhrB,EAAKgrB,KAAKrrB,MAAM,uBAGpCysB,EAAQ,CAAC,EAEXpB,IACFoB,EAAM2D,UAAY,CAAC,YAAc/E,IAGnC,MAAMtoB,EAAOkrB,EAAE5tB,EAAM,OAAQosB,EAAO,CAACD,GAAE,OAAQzuB,KAQ/C,OANIsC,EAAK0f,OACPhd,EAAK6E,KAAO,CACVmY,KAAM1f,EAAK0f,OAIRkO,EAAE5tB,EAAKH,SAAU,MAAO,CAAC6C,GAClC,EHREstB,OIhBK,SAAuBpC,EAAG5tB,GAC/B,OAAO4tB,EAAE5tB,EAAM,MAAO,GAAI4tB,EAAG5tB,GAC/B,EJeEgmB,SKjBK,SAAkB4H,EAAG5tB,GAC1B,OAAO4tB,EAAE5tB,EAAM,KAAM,GAAI4tB,EAAG5tB,GAC9B,ELgBE4uB,kBAAiB,GACjBqB,SMZK,SAAkBrC,EAAG5tB,GAC1B,MAAMkwB,EAAetC,EAAEsC,aACvB,IAAIC,EAAK,EAET,KAAOA,KAAMD,GAAcC,IAE3B,MAAMlU,EAAajZ,OAAOmtB,GAU1B,OATAD,EAAajU,GAAc,CACzBva,KAAM,qBACNua,aACAxO,SAAU,CAAC,CACT/L,KAAM,YACN+L,SAAUzN,EAAKyN,WAEjB5N,SAAUG,EAAKH,UAEV+uB,GAAkBhB,EAAG,CAC1BlsB,KAAM,oBACNua,aACApc,SAAUG,EAAKH,UAEnB,ENREmd,QOpBK,SAAiB4Q,EAAG5tB,GACzB,OAAO4tB,EAAE5tB,EAAM,IAAMA,EAAKirB,MAAO,GAAI2C,EAAG5tB,GAC1C,EPmBEmmB,KQnBK,SAAcyH,EAAG5tB,GACtB,OAAO4tB,EAAEwC,UAAYxC,EAAEC,QAAQ7tB,EAAMmsB,GAAE,MAAOnsB,EAAKtC,QAAU,IAC/D,ERkBE2yB,eSpBK,SAAwBzC,EAAG5tB,GAChC,MAAM2Y,EAAMiV,EAAE5R,WAAWhc,EAAKic,YAE9B,IAAKtD,EACH,OAAO2W,GAAO1B,EAAG5tB,GAKnB,MAAMosB,EAAQ,CACZnuB,IAAK,KAAU0a,EAAIlU,KAAO,IAC1B+I,IAAKxN,EAAKwN,KAOZ,OAJkB,OAAdmL,EAAIgD,YAAgC3X,IAAd2U,EAAIgD,QAC5ByQ,EAAMzQ,MAAQhD,EAAIgD,OAGbiS,EAAE5tB,EAAM,MAAOosB,EACxB,ETEE9F,MUtBK,SAAesH,EAAG5tB,GAEvB,MAAMosB,EAAQ,CACZnuB,IAAK,KAAU+B,EAAKyE,KACpB+I,IAAKxN,EAAKwN,KAOZ,OAJmB,OAAfxN,EAAK2b,YAAiC3X,IAAfhE,EAAK2b,QAC9ByQ,EAAMzQ,MAAQ3b,EAAK2b,OAGdiS,EAAE5tB,EAAM,MAAOosB,EACxB,EVWEkE,WWxBK,SAAoB1C,EAAG5tB,GAC5B,OAAO4tB,EAAE5tB,EAAM,OAAQ,CAACmsB,GAAE,OAAQnsB,EAAKtC,MAAM0B,QAAQ,YAAa,OACpE,EXuBEmxB,cYtBK,SAAuB3C,EAAG5tB,GAC/B,MAAM2Y,EAAMiV,EAAE5R,WAAWhc,EAAKic,YAE9B,IAAKtD,EACH,OAAO2W,GAAO1B,EAAG5tB,GAKnB,MAAMosB,EAAQ,CACZxlB,KAAM,KAAU+R,EAAIlU,KAAO,KAO7B,OAJkB,OAAdkU,EAAIgD,YAAgC3X,IAAd2U,EAAIgD,QAC5ByQ,EAAMzQ,MAAQhD,EAAIgD,OAGbiS,EAAE5tB,EAAM,IAAKosB,EAAO,GAAIwB,EAAG5tB,GACpC,EZKEmlB,KaxBK,SAAcyI,EAAG5tB,GAEtB,MAAMosB,EAAQ,CACZxlB,KAAM,KAAU5G,EAAKyE,MAOvB,OAJmB,OAAfzE,EAAK2b,YAAiC3X,IAAfhE,EAAK2b,QAC9ByQ,EAAMzQ,MAAQ3b,EAAK2b,OAGdiS,EAAE5tB,EAAM,IAAKosB,EAAO,GAAIwB,EAAG5tB,GACpC,EbcEumB,SFrBK,SAAkBqH,EAAG5tB,EAAMkrB,GAChC,MAAMroB,EAAS,GAAI+qB,EAAG5tB,GAChB2uB,EAAQzD,EA8DhB,SAAmBlrB,GACjB,IAAI2uB,EAAQ3uB,EAAKurB,OACjB,MAAM9d,EAAWzN,EAAKyN,SACtB,IAAI/J,GAAS,EAEb,MAAQirB,KAAWjrB,EAAQ+J,EAASlP,QAClCowB,EAAQe,GAAcjiB,EAAS/J,IAGjC,OAAO0J,QAAQuhB,EACjB,CAxEyB6B,CAAUtF,GAAUwE,GAAc1vB,GAGnDosB,EAAQ,CAAC,EAGTqE,EAAU,GAEhB,GAA4B,kBAAjBzwB,EAAKwrB,QAAuB,CAErC,IAAI3O,EAEAha,EAAO,IAAyB,YAAnBA,EAAO,GAAGnB,MAA4C,MAAtBmB,EAAO,GAAG4a,QACzDZ,EAAYha,EAAO,IAEnBga,EAAY+Q,EAAE,KAAM,IAAK,IACzB/qB,EAAOmL,QAAQ6O,IAGbA,EAAUpP,SAASlP,OAAS,GAC9Bse,EAAUpP,SAASO,QAAQme,GAAE,OAAQ,MAGvCtP,EAAUpP,SAASO,QAAQ4f,EAAE,KAAM,QAAS,CAC1ClsB,KAAM,WACN8pB,QAASxrB,EAAKwrB,QACdkF,UAAU,KAIZtE,EAAM2D,UAAY,CAAC,iBACrB,CAEA,IAAIrsB,GAAS,EAEb,OAASA,EAAQb,EAAOtE,QAAQ,CAC9B,MAAMoyB,EAAQ9tB,EAAOa,IAEjBirB,GAAmB,IAAVjrB,GAA8B,YAAfitB,EAAMjvB,MAAwC,MAAlBivB,EAAMlT,UAC5DgT,EAAQ1vB,KAAKorB,GAAE,OAAQ,OAGN,YAAfwE,EAAMjvB,MAAwC,MAAlBivB,EAAMlT,SAAoBkR,EAGxD8B,EAAQ1vB,KAAK4vB,GAFbF,EAAQ1vB,QAAQ4vB,EAAMljB,SAI1B,CAEA,MAAM4H,EAAOxS,EAAOA,EAAOtE,OAAS,GAMpC,OAJI8W,IAASsZ,GAAW,YAAatZ,GAA0B,MAAjBA,EAAKoI,SACjDgT,EAAQ1vB,KAAKorB,GAAE,OAAQ,OAGlByB,EAAE5tB,EAAM,KAAMosB,EAAOqE,EAC9B,EEpCE9iB,KcxBK,SAAcigB,EAAG5tB,GAEtB,MAAMosB,EAAQ,CAAC,EACT7uB,EAAOyC,EAAKsrB,QAAU,KAAO,KAC7Bzd,EAAQ,GAAI+f,EAAG5tB,GACrB,IAAI0D,GAAS,EAOb,IAL0B,iBAAf1D,EAAKF,OAAqC,IAAfE,EAAKF,QACzCssB,EAAMtsB,MAAQE,EAAKF,SAIZ4D,EAAQmK,EAAMtP,QAAQ,CAC7B,MAAM2S,EAAOrD,EAAMnK,GAEnB,GAAkB,YAAdwN,EAAKxP,MAAuC,OAAjBwP,EAAKuM,SAAoBvM,EAAK0f,YAAch0B,MAAMF,QAAQwU,EAAK0f,WAAWb,YAAc7e,EAAK0f,WAAWb,UAAUnoB,SAAS,kBAAmB,CAC3KwkB,EAAM2D,UAAY,CAAC,sBACnB,KACF,CACF,CAEA,OAAOnC,EAAE5tB,EAAMzC,EAAM6uB,EAAO,GAAKve,GAAO,GAC1C,EdGEgP,Ue7BK,SAAmB+Q,EAAG5tB,GAC3B,OAAO4tB,EAAE5tB,EAAM,IAAK,GAAI4tB,EAAG5tB,GAC7B,Ef4BE6wB,KgB5BK,SAAcjD,EAAG5tB,GAEtB,OAAO4tB,EAAEC,QAAQ7tB,EAAMmsB,GAAE,OAAQ,GAAK,GAAIyB,EAAG5tB,KAC/C,EhB0BEmnB,OiB/BK,SAAgByG,EAAG5tB,GACxB,OAAO4tB,EAAE5tB,EAAM,SAAU,GAAI4tB,EAAG5tB,GAClC,EjB8BE8wB,MkB3BK,SAAelD,EAAG5tB,GACvB,MAAM+wB,EAAO/wB,EAAKyN,SAClB,IAAI/J,GAAS,EACb,MAAMstB,EAAQhxB,EAAKgxB,OAAS,GAGtBnuB,EAAS,GAEf,OAASa,EAAQqtB,EAAKxyB,QAAQ,CAC5B,MAAM0yB,EAAMF,EAAKrtB,GAAO+J,SAClBlQ,EAAiB,IAAVmG,EAAc,KAAO,KAG5BwtB,EAAM,GACZ,IAAIC,GAAa,EACjB,MAAM5yB,EAASyB,EAAKgxB,MAAQA,EAAMzyB,OAAS0yB,EAAI1yB,OAE/C,OAAS4yB,EAAY5yB,GAAQ,CAC3B,MAAM6yB,EAAOH,EAAIE,GACjBD,EAAInwB,KAAK6sB,EAAEwD,EAAM7zB,EAAM,CACrByzB,MAAOA,EAAMG,IACZC,EAAO,GAAIxD,EAAGwD,GAAQ,IAC3B,CAEAvuB,EAAOa,GAASkqB,EAAEmD,EAAKrtB,GAAQ,KAAM,GAAKwtB,GAAK,GACjD,CAEA,OAAOtD,EAAE5tB,EAAM,QAAS,GAAK,CAAC4tB,EAAE/qB,EAAO,GAAGhD,SAAU,QAAS,GAAK,CAACgD,EAAO,KAAK,KAAQ8oB,OAAO9oB,EAAO,GAAK+qB,EAAE,CAC1G9tB,MAAO0tB,GAAW3qB,EAAO,IACzBzC,IAAKqtB,GAAS5qB,EAAOA,EAAOtE,OAAS,KACpC,QAAS,GAAKsE,EAAO1B,MAAM,IAAI,IAAS,KAAK,GAClD,ElBHE4U,KmBhCK,SAAc6X,EAAG5tB,GACtB,OAAO4tB,EAAEC,QAAQ7tB,EAAMmsB,GAAE,OpBIpB,SAAmBzuB,GACxB,MAAM2C,EAAS2C,OAAOtF,GAChBwmB,EAAS,YACf,IAAIvkB,EAAQukB,EAAOhjB,KAAKb,GACpBgxB,EAAO,EAGX,MAAM3xB,EAAQ,GAEd,KAAOC,GACLD,EAAMqB,KAAK4uB,GAAStvB,EAAOc,MAAMkwB,EAAM1xB,EAAM+D,OAAQ2tB,EAAO,GAAG,GAAO1xB,EAAM,IAC5E0xB,EAAO1xB,EAAM+D,MAAQ/D,EAAM,GAAGpB,OAC9BoB,EAAQukB,EAAOhjB,KAAKb,GAItB,OADAX,EAAMqB,KAAK4uB,GAAStvB,EAAOc,MAAMkwB,GAAOA,EAAO,GAAG,IAC3C3xB,EAAM8F,KAAK,GACpB,CoBrBmC8rB,CAAUtuB,OAAOhD,EAAKtC,SACzD,EnB+BE4b,coBjCK,SAAuBsU,EAAG5tB,GAC/B,OAAO4tB,EAAE5tB,EAAM,KACjB,EpBgCEuxB,KAAMC,GACNC,KAAMD,GACNxV,WAAYwV,GACZE,mBAAoBF,IAGtB,SAASA,KACP,OAAO,IACT,CqBuDA,MAAM,GAAM,CAAC,EAAEp1B,eAQf,SAAS8wB,GAAQvgB,EAAMrP,GACrB,MAAMiO,EAAWjO,GAAW,CAAC,EACvB8yB,EAAY7kB,EAASomB,qBAAsB,EAG3CzB,EAAe,CAAC,EAiCtB,OAhCAtC,EAAEwC,UAAYA,EACdxC,EAAEuB,mBAA2CnrB,IAA3BuH,EAAS4jB,eAA0D,OAA3B5jB,EAAS4jB,cAAyB,gBAAkB5jB,EAAS4jB,cACvHvB,EAAEgE,cAAgBrmB,EAASqmB,eAAiB,YAC5ChE,EAAEiE,qBAAuBtmB,EAASsmB,sBAAwB,KAC1DjE,EAAEkE,wBAA0BvmB,EAASumB,yBAA2B,CAC9DjD,GAAI,iBACJkB,UAAW,CAAC,YAEdnC,EAAEmE,kBAAoBxmB,EAASwmB,mBAAqB,kBACpDnE,EAAE5R,W9BrHG,SAAqBhc,GAE1B,MAAM4C,EAAQ1G,OAAOkd,OAAO,MAE5B,IAAKpZ,IAASA,EAAK0B,KACjB,MAAM,IAAIf,MAAM,wCAUlB,OAPAysB,GAAMptB,EAAM,cAAcgc,IACxB,MAAM6S,EAAKnB,GAAM1R,EAAWC,YAExB4S,IAAO,GAAIhyB,KAAK+F,EAAOisB,KACzBjsB,EAAMisB,GAAM7S,EACd,IAUF,SAAoBC,GAClB,MAAM4S,EAAKnB,GAAMzR,GACjB,OAAO4S,GAAM,GAAIhyB,KAAK+F,EAAOisB,GAAMjsB,EAAMisB,GAAM,IACjD,CACF,C8B0FiBmD,CAAYrlB,GAC3BihB,EAAEsC,aAAeA,EAGjBtC,EAAEmB,cAAgB,GAGlBnB,EAAEqB,eAAiB,CAAC,EACpBrB,EAAEC,QAAUA,EACZD,EAAEE,SAAW,IAAKA,MACbviB,EAASuiB,UAEdF,EAAEK,eAAiB1iB,EAAS0iB,eAC5BL,EAAEG,YAAcxiB,EAASwiB,YACzBX,GAAMzgB,EAAM,sBAAsBqP,IAChC,MAAM6S,EAAK7rB,OAAOgZ,EAAWC,YAAY9Y,cAGpC,GAAItG,KAAKqzB,EAAcrB,KAC1BqB,EAAarB,GAAM7S,EACrB,IAGK4R,EAQP,SAASC,EAAQtf,EAAMC,GAErB,GAAID,GAAQ,SAAUA,GAAQA,EAAKhH,KAAM,CAEvC,MAAMA,EAAOgH,EAAKhH,KAEdA,EAAK0qB,QACY,YAAfzjB,EAAM9M,OACR8M,EAAQ,CACN9M,KAAM,UACN+b,QAAS,GACTmT,WAAY,CAAC,EACbnjB,SAAU,KAIde,EAAMiP,QAAUlW,EAAK0qB,OAGJ,YAAfzjB,EAAM9M,MAAsB6F,EAAK2qB,cACnC1jB,EAAMoiB,WAAa,IAAKpiB,EAAMoiB,cACzBrpB,EAAK2qB,cAIR,aAAc1jB,GAASA,EAAMf,UAAYlG,EAAK4qB,YAChD3jB,EAAMf,SAAWlG,EAAK4qB,UAE1B,CAEA,GAAI5jB,EAAM,CACR,MAAM6jB,EAAM,SAAU7jB,EAAOA,EAAO,CAClC1O,SAAU0O,IC9KQvO,EDiLLoyB,IChLFpyB,EAAKH,UAAaG,EAAKH,SAASC,OAAUE,EAAKH,SAASC,MAAMC,MAASC,EAAKH,SAASC,MAAMN,QAAWQ,EAAKH,SAASO,KAAQJ,EAAKH,SAASO,IAAIL,MAASC,EAAKH,SAASO,IAAIZ,SDkLpLgP,EAAM3O,SAAW,CACfC,MAAO0tB,GAAW4E,GAClBhyB,IAAKqtB,GAAS2E,IAGpB,CCxLG,IAAmBpyB,ED0LtB,OAAOwO,CACT,CAQA,SAASof,EAAE5tB,EAAMyd,EAAS2O,EAAO3e,GAO/B,OANI7Q,MAAMF,QAAQ0vB,KAChB3e,EAAW2e,EACXA,EAAQ,CAAC,GAIJyB,EAAQ7tB,EAAM,CACnB0B,KAAM,UACN+b,UACAmT,WAAYxE,GAAS,CAAC,EACtB3e,SAAUA,GAAY,IAE1B,CACF,CAUO,SAAS4kB,GAAO1lB,EAAMrP,GAC3B,MAAMswB,EAAIV,GAAQvgB,EAAMrP,GAClB0C,EAAO,GAAI4tB,EAAGjhB,EAAM,MACpB2lB,EElOD,SAAgB1E,GACrB,IAAIlqB,GAAS,EAGb,MAAM6uB,EAAY,GAElB,OAAS7uB,EAAQkqB,EAAEmB,cAAcxwB,QAAQ,CACvC,MAAMoa,EAAMiV,EAAEsC,aAAatC,EAAEmB,cAAcrrB,GAAOP,eAElD,IAAKwV,EACH,SAGF,MAAMrY,EAAU,GAAIstB,EAAGjV,GACjBkW,EAAK7rB,OAAO2V,EAAIsD,YAChB6S,EAASV,GAAYS,EAAG9S,eAC9B,IAAIyW,EAAiB,EAGrB,MAAMC,EAAiB,GAEvB,OAASD,GAAkB5E,EAAEqB,eAAeJ,IAAK,CAE/C,MAAM6D,EAAgB,CACpBhxB,KAAM,UACN+b,QAAS,IACTmT,WAAY,CACVhqB,KAAM,IAAMgnB,EAAEuB,cAAgB,SAAWL,GAAU0D,EAAiB,EAAI,IAAMA,EAAiB,IAC/FG,qBAAqB,EACrB5C,UAAW,CAAC,yBACZ6C,UAAWhF,EAAEmE,mBAEftkB,SAAU,CAAC,CACT/L,KAAM,OACNhE,MAAO,OAIP80B,EAAiB,GACnBE,EAAcjlB,SAAS1M,KAAK,CAC1BW,KAAM,UACN+b,QAAS,MACThQ,SAAU,CAAC,CACT/L,KAAM,OACNhE,MAAOsF,OAAOwvB,OAKhBC,EAAel0B,OAAS,GAC1Bk0B,EAAe1xB,KAAK,CAClBW,KAAM,OACNhE,MAAO,MAIX+0B,EAAe1xB,KAAK2xB,EACtB,CAEA,MAAMrd,EAAO/U,EAAQA,EAAQ/B,OAAS,GAEtC,GAAI8W,GAAsB,YAAdA,EAAK3T,MAAuC,MAAjB2T,EAAKoI,QAAiB,CAC3D,MAAMoV,EAAWxd,EAAK5H,SAAS4H,EAAK5H,SAASlP,OAAS,GAElDs0B,GAA8B,SAAlBA,EAASnxB,KACvBmxB,EAASn1B,OAAS,IAElB2X,EAAK5H,SAAS1M,KAAK,CACjBW,KAAM,OACNhE,MAAO,MAIX2X,EAAK5H,SAAS1M,QAAQ0xB,EACxB,MACEnyB,EAAQS,QAAQ0xB,GAKlB,MAAMlM,EAAW,CACf7kB,KAAM,UACN+b,QAAS,KACTmT,WAAY,CACV/B,GAAIjB,EAAEuB,cAAgB,MAAQL,GAEhCrhB,SAAU,GAAKnN,GAAS,IAGtBqY,EAAI9Y,WACN0mB,EAAS1mB,SAAW8Y,EAAI9Y,UAG1B0yB,EAAUxxB,KAAKwlB,EACjB,CAEA,OAAyB,IAArBgM,EAAUh0B,OACL,KAGF,CACLmD,KAAM,UACN+b,QAAS,UACTmT,WAAY,CACVkC,eAAe,EACf/C,UAAW,CAAC,cAEdtiB,SAAU,CAAC,CACT/L,KAAM,UACN+b,QAASmQ,EAAEiE,qBACXjB,WAAYtqB,KAAK0F,MAAM1F,KAAKC,UAAUqnB,EAAEkE,0BACxCrkB,SAAU,CAAC0e,GAAE,OAAQyB,EAAEgE,iBACtB,CACDlwB,KAAM,OACNhE,MAAO,MACN,CACDgE,KAAM,UACN+b,QAAS,KACTmT,WAAY,CAAC,EACbnjB,SAAU,GAAK8kB,GAAW,IACzB,CACD7wB,KAAM,OACNhE,MAAO,OAGb,CFqGeq1B,CAAOnF,GASpB,OAPI0E,GAIFtyB,EAAKyN,SAAS1M,KAAKorB,GAAE,OAAQ,MAAOmG,GAG/B11B,MAAMF,QAAQsD,GAAQ,CAC3B0B,KAAM,OACN+L,SAAUzN,GACRA,CACN,CGxNA,OAJA,SAAUiN,EAAa3P,GACrB,OAAO2P,GAAe,QAASA,EAWjC,SAAgBA,EAAa3P,GAC3B,MAAO,CAAC0C,EAAMwE,EAAM0F,KAClB+C,EAAYnD,IAAIuoB,GAAOryB,EAAM1C,GAAUkH,GAAMhE,IAC3C0J,EAAK1J,EAAM,GACX,CAEN,CAjB+CwyB,CAAO/lB,EAAa3P,GA0BnE,SAAgBA,GAEd,OAAO0C,GAAQqyB,GAAOryB,EAAM1C,EAC9B,CA7B8E21B,CAAOhmB,GAAe3P,EACpG,6BChCO,MAAM41B,GAOX/1B,YAAY4E,EAAUoxB,EAAQC,GAC5BjzB,KAAK4B,SAAWA,EAChB5B,KAAKgzB,OAASA,EAEVC,IACFjzB,KAAKizB,MAAQA,EAEjB,ECRK,SAASC,GAAMrB,EAAaoB,GAEjC,MAAMrxB,EAAW,CAAC,EAGZoxB,EAAS,CAAC,EAChB,IAAIzvB,GAAS,EAEb,OAASA,EAAQsuB,EAAYzzB,QAC3BrC,OAAOyP,OAAO5J,EAAUiwB,EAAYtuB,GAAO3B,UAC3C7F,OAAOyP,OAAOwnB,EAAQnB,EAAYtuB,GAAOyvB,QAG3C,OAAO,IAAID,GAAOnxB,EAAUoxB,EAAQC,EACtC,CCrBO,SAAS,GAAU11B,GACxB,OAAOA,EAAMqe,aACf,CFkBAmX,GAAO/2B,UAAU4F,SAAW,CAAC,EAG7BmxB,GAAO/2B,UAAUg3B,OAAS,CAAC,EAG3BD,GAAO/2B,UAAUi3B,MAAQ,KG9BlB,MAAME,GAMXn2B,YAAY4E,EAAUwxB,GAEpBpzB,KAAK4B,SAAWA,EAGhB5B,KAAKozB,UAAYA,CACnB,EAKFD,GAAKn3B,UAAUi3B,MAAQ,KACvBE,GAAKn3B,UAAUq3B,SAAU,EACzBF,GAAKn3B,UAAUs3B,YAAa,EAC5BH,GAAKn3B,UAAUu3B,mBAAoB,EACnCJ,GAAKn3B,UAAUw3B,QAAS,EACxBL,GAAKn3B,UAAUy3B,gBAAiB,EAChCN,GAAKn3B,UAAU03B,gBAAiB,EAChCP,GAAKn3B,UAAU23B,uBAAwB,EACvCR,GAAKn3B,UAAU43B,iBAAkB,EACjCT,GAAKn3B,UAAUigB,SAAU,EC1BzB,IAAI4X,GAAS,EACN,MAAM,GAAUC,KACVR,GAAaQ,KACbP,GAAoBO,KACpBN,GAASM,KACTJ,GAAiBI,KACjBL,GAAiBK,KACjBH,GAAwBG,KAErC,SAASA,KACP,OAAO,KAAOD,EAChB,CCNA,MAAMvH,GAASvwB,OAAOgR,KAAK,GACpB,MAAMgnB,WAAoBZ,GAQ/Bn2B,YAAY4E,EAAUwxB,EAAWY,EAAMf,GACrC,IAAI1vB,GAAS,EAIb,GAHAK,MAAMhC,EAAUwxB,GAChBa,GAAKj0B,KAAM,QAASizB,GAEA,iBAATe,EACT,OAASzwB,EAAQ+oB,GAAOluB,QAAQ,CAC9B,MAAM4T,EAAQsa,GAAO/oB,GACrB0wB,GAAKj0B,KAAMssB,GAAO/oB,IAASywB,EAAO,EAAMhiB,MAAY,EAAMA,GAC5D,CAEJ,EAUF,SAASiiB,GAAKrqB,EAAQ/M,EAAKU,GACrBA,IAEFqM,EAAO/M,GAAOU,EAElB,CAZAw2B,GAAY/3B,UAAUigB,SAAU,ECZhC,MAAM,GAAM,CAAC,EAAEhgB,eAMR,SAASgd,GAAO4C,GAErB,MAAMja,EAAW,CAAC,EAGZoxB,EAAS,CAAC,EAGhB,IAAIvxB,EAEJ,IAAKA,KAAQoa,EAAW4U,WACtB,GAAI,GAAI/zB,KAAKmf,EAAW4U,WAAYhvB,GAAO,CACzC,MAAMlE,EAAQse,EAAW4U,WAAWhvB,GAC9BqG,EAAO,IAAIisB,GAAYtyB,EAAMoa,EAAWqY,UAAUrY,EAAWsY,YAAc,CAAC,EAAG1yB,GAAOlE,EAAOse,EAAWoX,OAE1GpX,EAAW+X,iBAAmB/X,EAAW+X,gBAAgBnsB,SAAShG,KACpEqG,EAAK8rB,iBAAkB,GAGzBhyB,EAASH,GAAQqG,EACjBkrB,EAAO,GAAUvxB,IAASA,EAC1BuxB,EAAO,GAAUlrB,EAAKsrB,YAAc3xB,CACtC,CAGF,OAAO,IAAIsxB,GAAOnxB,EAAUoxB,EAAQnX,EAAWoX,MACjD,CC/CO,MAAMmB,GAAQnb,GAAO,CAC1Bga,MAAO,QAEPiB,UAAUlc,EAAGvW,GACX,MAAO,SAAWA,EAAKT,MAAM,GAAG4a,aAClC,EAEA6U,WAAY,CACV4D,aAAc,KACdC,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,UAAW,QCdFC,GAAM3b,GAAO,CACxBga,MAAO,MAEPiB,UAAUlc,EAAGvW,GACX,MAAO,OAASA,EAAKT,MAAM,GAAG4a,aAChC,EAEA6U,WAAY,CACVoE,QAAS,KACTC,QAAS,KACTC,SAAU,QCNP,SAASC,GAAuBb,EAAYf,GACjD,OAAOA,KAAae,EAAaA,EAAWf,GAAaA,CAC3D,CCAO,SAAS6B,GAAyBd,EAAYvyB,GACnD,OAAOozB,GAAuBb,EAAYvyB,EAASga,cACrD,CCPO,MAAMsZ,GAAQjc,GAAO,CAC1Bga,MAAO,QACPkB,WAAY,CACVgB,WAAY,eAEdjB,UAAWe,GACXxE,WAAY,CACVyE,MAAO,KACPE,WAAY,QCRHC,GAAOpc,GAAO,CACzBib,UAAUlc,EAAGvW,GACX,MAAgB,SAATA,EAAkBA,EAAO,QAAUA,EAAKT,MAAM,GAAG4a,aAC1D,EAEA6U,WAAY,CACV6E,qBAAsB,KACtBC,WAAYjC,GACZkC,iBAAkB,KAClBC,SAAUnC,GACVoC,YAAapC,GACbqC,aAAcnC,GACdoC,aAAcpC,GACdqC,YAAarC,GACbsC,aAAcpC,GACdqC,YAAa,KACb7G,gBAAiBwE,GACjBsC,YAAa,KACbC,aAAc3C,GACd4C,eAAgBxC,GAChByC,iBAAkB,KAClBC,aAAc9C,GACd+C,WAAY3C,GACZ4C,YAAahD,GACbiD,aAAc,KACdC,WAAYlD,GACZmD,YAAa,KACbC,iBAAkB,KAClBjE,UAAW,KACXkE,eAAgBjD,GAChBkD,UAAWpD,GACXqD,SAAU,KACVC,UAAWxD,GACXyD,cAAezD,GACf0D,oBAAqB1D,GACrB2D,gBAAiB,KACjBC,SAAUxD,GACVyD,gBAAiB,KACjBC,aAAc5D,GACd6D,YAAa/D,GACbgE,aAAchE,GACdiE,aAAc,KACdC,aAAclE,GACdmE,oBAAqB/D,GACrBgE,aAAclE,GACdmE,aAAcnE,GACdoE,YAAapE,GACbqE,aAAcvE,GACdwE,YAAatE,GACbuE,SAAU,KACVC,aAAcxE,GACdyE,aAAczE,GACd0E,aAAc1E,GACd2E,cAAe,KACfC,KAAM,QCrDG,GAAOnf,GAAO,CACzBga,MAAO,OACPkB,WAAY,CACVkE,cAAe,iBACfC,UAAW,QACXC,QAAS,MACTC,UAAW,cAEbtE,UAAWe,GACXrB,gBAAiB,CAAC,UAAW,WAAY,QAAS,YAClDnD,WAAY,CAEVgI,KAAM,KACNC,OAAQjF,GACRkF,cAAejF,GACfkF,UAAWlF,GACXmF,OAAQ,KACRC,MAAO,KACPC,gBAAiB,GACjBC,oBAAqB,GACrBC,eAAgB,GAChB5rB,IAAK,KACL6rB,GAAI,KACJC,MAAO,GACPC,eAAgB,KAChBC,aAAc3F,GACd4F,UAAW,GACXC,SAAU,GACVC,QAAS,GACTC,QAAS,KACTpO,QAAS,GACTqO,KAAM,KACN9J,UAAW8D,GACXiG,KAAMnG,GACNoG,QAAS,KACTz5B,QAAS,KACT05B,gBAAiBvG,GACjBwG,SAAU,GACVC,aAAcrG,GACdsG,OAAQxG,GAASC,GACjBwG,YAAa,KACb7yB,KAAM,KACN8yB,SAAU,KACVC,SAAU,KACVC,QAAS,GACTC,MAAO,GACPC,IAAK,KACLC,QAAS,KACThK,SAAU,GACViK,SAAUjH,GACVkH,UAAWnH,GACXoH,QAAS,KACTC,aAAc,KACdC,KAAM,KACNC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,eAAgB,GAChBC,WAAY,KACZC,QAASxH,GACTyH,OAAQ3H,GACR4H,OAAQ,GACRC,KAAM7H,GACN/sB,KAAM,KACN60B,SAAU,KACVC,QAAS7H,GACT8H,UAAW9H,GACXhF,GAAI,KACJ+M,WAAY,KACZC,YAAa,KACbC,UAAW,KACXC,UAAW,KACX/O,GAAI,KACJgP,MAAO,GACPC,OAAQ,KACRC,SAAUrI,GACVsI,QAAStI,GACTuI,UAAW,GACXC,SAAUxI,GACVna,KAAM,KACN4B,MAAO,KACP0P,KAAM,KACNsR,SAAU,KACV3uB,KAAM,KACN4uB,QAAS,KACTC,KAAM,GACNC,IAAK9I,GACL+I,SAAU,KACV7sB,IAAK,KACL8sB,UAAWhJ,GACX7S,MAAO,KACP8b,OAAQ,KACRC,IAAK,KACLC,UAAWnJ,GACXoJ,SAAU,GACVC,MAAO,GACPz/B,KAAM,KACN0/B,MAAO,KACPC,SAAU,GACVC,WAAY,GACZC,QAAS,KACTC,aAAc,KACdC,WAAY,KACZC,cAAe,KACfC,eAAgB,KAChBC,OAAQ,KACRC,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClBC,SAAU,KACVC,QAAS,KACTC,QAAS,KACTC,cAAe,KACfC,cAAe,KACfC,kBAAmB,KACnBC,OAAQ,KACRC,YAAa,KACbC,MAAO,KACPC,WAAY,KACZC,OAAQ,KACRC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,OAAQ,KACRC,iBAAkB,KAClBC,UAAW,KACXC,QAAS,KACTC,QAAS,KACTC,QAAS,KACTC,WAAY,KACZC,aAAc,KACdC,QAAS,KACTC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,QAAS,KACTC,iBAAkB,KAClBC,OAAQ,KACRC,aAAc,KACdC,iBAAkB,KAClBC,UAAW,KACXC,YAAa,KACbC,UAAW,KACXC,eAAgB,KAChBC,YAAa,KACbC,aAAc,KACdC,aAAc,KACdC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,WAAY,KACZC,WAAY,KACZC,QAAS,KACTC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,WAAY,KACZC,WAAY,KACZC,aAAc,KACdC,mBAAoB,KACpBC,QAAS,KACTC,SAAU,KACVC,SAAU,KACVC,0BAA2B,KAC3BC,SAAU,KACVC,UAAW,KACXC,SAAU,KACVC,aAAc,KACdC,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACdC,SAAU,KACVC,qBAAsB,KACtBC,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACXC,QAAS,KACTjoB,KAAM,GACNkoB,QAAS9O,GACT+O,QAAS,KACTC,KAAM9O,GACN+O,YAAa,KACbC,YAAa,GACbC,OAAQ,KACRC,QAAS,KACTC,SAAU,GACVC,eAAgB,KAChBC,IAAKrP,GACLsP,SAAU,GACVC,SAAU,GACVrS,KAAM4C,GACN0P,QAAS1P,GACT2P,QAASzP,GACT0P,MAAO,KACPC,OAAQ,GACRC,SAAU,GACVC,SAAU,GACVC,MAAO,KACP5zB,KAAM4jB,GACNiQ,MAAO,KACPC,KAAM,KACNC,KAAMnQ,GACNoQ,WAAYtQ,GACZx1B,IAAK,KACL+lC,OAAQ,KACRC,QAAS,KACTC,OAAQ,KACRpkC,MAAO6zB,GACP1G,KAAM,KACN5tB,MAAO,KACP8kC,SAAUxQ,GACVt2B,OAAQ,KACRse,MAAO,KACPyoB,UAAW,KACX1iC,KAAM,KACN2iC,cAAe,GACfC,OAAQ,KACR5mC,MAAO+1B,GACP8Q,MAAO5Q,GACPlrB,KAAM,KAGNuoB,MAAO,KAEPwT,MAAO,KAEPC,QAAS5Q,GAET6Q,KAAM,KAENC,WAAY,KAEZC,QAAS,KAETC,OAAQlR,GAERmR,YAAa,KAEbC,aAAcpR,GAEdqR,YAAa,KAEbC,YAAa,KAEbllB,KAAM,KAENmlB,QAAS,KAETC,QAAS,KAETC,MAAO,KAEP1iC,KAAM,KAEN2iC,SAAU,KAEVC,SAAU,KAEVC,MAAO,KAEPC,QAAS,GAETC,QAAS,GAET5xB,MAAO,KAEP6xB,KAAM,KAENC,MAAO,KAEPC,YAAa,KAEbC,OAAQlS,GAERmS,WAAYnS,GAEZxO,KAAM,KAEN4gB,SAAU,KAEVC,OAAQ,KAERC,aAActS,GAEduS,YAAavS,GAEbwS,SAAU,GAEVC,OAAQ,GAERC,QAAS,GAETC,OAAQ,GAERC,OAAQ,KAERC,QAAS,KAETC,OAAQ,KAERC,IAAK,KAELC,YAAahT,GAEbtyB,MAAO,KAEPulC,OAAQ,KAERC,UAAWpT,GAEXqT,QAAS,KAETC,QAAS,KAEThxB,KAAM,KAENixB,UAAWrT,GAEXsT,UAAW,KAEXC,QAAS,KAETC,OAAQ,KAERC,MAAO,KAEPC,OAAQ1T,GAGR2T,kBAAmB,KACnBC,YAAa,KACbC,SAAU,KACVC,wBAAyB,GACzBC,sBAAuB,GACvBz3B,OAAQ,KACRlO,SAAU,KACV4lC,QAAShU,GACTiU,SAAU,KACVC,aAAc,QC1VLC,GAAM1uB,GAAO,CACxBga,MAAO,MACPkB,WAAY,CACVyT,aAAc,gBACdC,kBAAmB,qBACnBC,WAAY,cACZC,cAAe,iBACfC,UAAW,aACXpY,UAAW,QACXqY,SAAU,YACVC,SAAU,YACVC,mBAAoB,sBACpBC,0BAA2B,8BAC3BC,aAAc,gBACdC,eAAgB,kBAChBrO,YAAa,cACbsO,SAAU,WACVC,iBAAkB,oBAClBC,iBAAkB,oBAClBC,YAAa,eACbC,SAAU,YACVC,WAAY,cACZC,aAAc,gBACdC,WAAY,cACZC,SAAU,YACVC,eAAgB,mBAChBC,YAAa,eACbC,UAAW,aACXC,YAAa,eACbC,WAAY,cACZC,UAAW,aACXC,2BAA4B,+BAC5BC,yBAA0B,6BAC1BjO,SAAU,WACVkO,UAAW,cACXC,aAAc,iBACdC,aAAc,iBACdC,eAAgB,kBAChBC,cAAe,iBACfC,cAAe,iBACfC,UAAW,aACXC,UAAW,aACXC,YAAa,eACbC,QAAS,WACTC,YAAa,gBACbC,aAAc,iBACdC,QAAS,WACTC,QAAS,WACTC,QAAS,WACTC,SAAU,YACVC,MAAO,SACPC,UAAW,cACXC,WAAY,eACZzN,QAAS,UACT0N,WAAY,aACZzN,aAAc,eACdE,cAAe,gBACfwN,QAAS,UACTrN,SAAU,WACVC,UAAW,YACXC,iBAAkB,mBAClBC,SAAU,WACVC,QAAS,UACTC,QAAS,UACTI,OAAQ,SACRC,YAAa,cACbC,MAAO,QACPC,WAAY,aACZC,OAAQ,SACRC,UAAW,YACXC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,OAAQ,SACRC,iBAAkB,mBAClBC,UAAW,YACXgM,MAAO,QACP/L,QAAS,UACTC,QAAS,UACTC,QAAS,UACT8L,UAAW,YACXC,WAAY,aACZ7L,aAAc,eACdC,QAAS,UACTC,UAAW,YACXC,UAAW,YACXC,WAAY,aACZC,QAAS,UACTE,OAAQ,SACRC,aAAc,eACdC,iBAAkB,mBAClBE,YAAa,cACbC,UAAW,YACXE,YAAa,cACbC,aAAc,eACdC,aAAc,eACdC,YAAa,cACbC,WAAY,aACZC,YAAa,cACbC,UAAW,YACX0K,aAAc,eACdzK,UAAW,YACXC,SAAU,WACVC,WAAY,aACZC,WAAY,aACZC,QAAS,UACTC,QAAS,UACTC,OAAQ,SACRC,UAAW,YACXC,WAAY,aACZC,WAAY,aACZC,aAAc,eACdgK,SAAU,WACV9J,QAAS,UACTC,SAAU,WACVC,SAAU,WACVE,SAAU,WACVC,UAAW,YACXC,SAAU,WACVyJ,OAAQ,SACRvJ,UAAW,YACXC,UAAW,YACXC,SAAU,WACVC,UAAW,YACXC,aAAc,eACdC,SAAU,WACVE,SAAU,WACVC,eAAgB,iBAChBC,UAAW,YACX+I,OAAQ,SACRC,iBAAkB,oBAClBC,kBAAmB,qBACnBC,WAAY,cACZC,QAAS,WACTC,cAAe,iBACf1I,eAAgB,iBAChB2I,gBAAiB,mBACjBC,eAAgB,kBAChBC,UAAW,aACXC,YAAa,eACbC,sBAAuB,yBACvBC,uBAAwB,0BACxBC,gBAAiB,mBACjBC,iBAAkB,oBAClBC,cAAe,iBACfC,eAAgB,kBAChBC,iBAAkB,oBAClBC,cAAe,iBACfC,YAAa,eACbrI,SAAU,WACVsI,WAAY,cACZC,eAAgB,kBAChBC,cAAe,iBACfC,OAAQ,SACRC,kBAAmB,qBACnBC,mBAAoB,sBACpBC,YAAa,eACbC,aAAc,gBACdC,WAAY,eACZC,YAAa,eACbC,SAAU,YACVC,aAAc,gBACdC,cAAe,iBACfC,aAAc,gBACdC,SAAU,aACVC,YAAa,gBACbC,YAAa,gBACbC,YAAa,eACbC,YAAa,eACbC,QAAS,WAETC,cAAe,gBACfC,cAAe,iBAEjBzZ,UAAWc,GACXvE,WAAY,CACVmd,MAAOja,GACPiU,aAAcpU,GACdqa,WAAY,KACZC,SAAU,KACVjG,kBAAmB,KACnBkG,WAAYva,GACZwa,UAAWxa,GACXsU,WAAY,KACZmG,OAAQza,GACR0a,cAAe,KACfC,cAAe,KACfC,QAAS5a,GACT6a,UAAW,KACXtG,cAAe,KACfuG,cAAe,KACfC,YAAa,KACbC,KAAM,KACNC,MAAO,KACPC,KAAMlb,GACNmb,GAAI,KACJC,SAAU,KACV5G,UAAWxU,GACX5D,UAAW8D,GACXmb,KAAM,KACN5G,SAAU,KACV6G,cAAe,KACf5G,SAAU,KACV9C,MAAO,KACP+C,mBAAoB,KACpBC,0BAA2B,KAC3BC,aAAc,KACdC,eAAgB,KAChBnoC,QAAS,KACT4uC,kBAAmB,KACnBC,iBAAkB,KAClB/U,YAAa,KACbgV,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJ1kB,EAAG,KACH8d,SAAU,KACV6G,cAAe,KACfC,QAAS7b,GACT8b,gBAAiB9b,GACjB+b,UAAW,KACXC,QAAS,KACTC,IAAK,KACLC,QAASlc,GACTgV,iBAAkB,KAClBhO,SAAU,GACVmV,GAAI,KACJC,GAAI,KACJC,SAAU,KACVC,SAAU,KACVC,UAAWvc,GACXiV,iBAAkB,KAClBxoC,IAAK,KACLyT,MAAO,KACPs8B,SAAUxc,GACVyc,0BAA2B,KAC3BC,KAAM,KACNxH,YAAalV,GACbmV,SAAU,KACVwH,OAAQ,KACRC,UAAW,KACXC,YAAa,KACbzH,WAAY,KACZC,aAAc,KACdyH,UAAW,KACXC,eAAgB,KAChBzH,WAAY,KACZC,SAAU,KACVC,eAAgB,KAChBC,YAAa,KACbC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZoH,OAAQ,KACRC,GAAI,KACJ7iC,KAAM,KACN8iC,GAAI,KACJC,GAAI,KACJC,GAAInd,GACJod,GAAIpd,GACJ4V,UAAW5V,GACX6V,2BAA4B,KAC5BC,yBAA0B,KAC1BuH,SAAU,KACVC,kBAAmB,KACnBC,cAAe,KACf/mB,QAAS,KACTgnB,QAASzd,GACT0d,kBAAmB,KACnBC,WAAY,KACZhW,OAAQ,KACR10B,KAAM,KACN60B,SAAU,KACVkO,UAAWhW,GACXiW,aAAcjW,GACdkW,aAAclW,GACd9E,GAAI,KACJ0iB,YAAa5d,GACbmW,eAAgB,KAChB0H,kBAAmB,KACnBC,GAAI,KACJC,IAAK,KACLC,UAAWhe,GACXie,EAAGje,GACHke,GAAIle,GACJme,GAAIne,GACJoe,GAAIpe,GACJqe,GAAIre,GACJse,aAAcne,GACdoe,iBAAkB,KAClBC,UAAW,KAEXC,WAAY,KAEZC,SAAU,KAEVC,QAAS,KACTtnB,KAAM,KACNunB,aAAc,KACdxI,cAAe,KACfC,cAAe,KACfwI,kBAAmB7e,GACnB8e,MAAO,KACPxI,UAAW,KACXC,UAAW,KACXC,YAAa,KACbuI,aAAc,KACdC,YAAa,KACbC,YAAa,KACbze,KAAM,KACN0e,iBAAkB,KAClBC,UAAW,KACXC,aAAc,KACdljC,IAAK,KACLiR,MAAO,KACPkyB,uBAAwB,KACxBC,sBAAuB,KACvBC,UAAWvf,GACXwf,UAAW,KACXvW,OAAQ,KACRC,IAAK,KACLuW,KAAM,KACN71C,KAAM,KACN6sC,QAAS,KACTC,YAAa,KACbC,aAAc,KACdC,QAAS,KACTC,QAAS,KACTC,QAAS,KACTC,SAAU,KACVC,MAAO,KACPC,UAAW,KACXC,WAAY,KACZwI,WAAY,KACZC,SAAU,KACV7gC,OAAQ,KACR2qB,QAAS,KACT0N,WAAY,KACZzN,aAAc,KACdE,cAAe,KACfwN,QAAS,KACTrN,SAAU,KACVC,UAAW,KACXC,iBAAkB,KAClBC,SAAU,KACVC,QAAS,KACTC,QAAS,KACTI,OAAQ,KACRC,YAAa,KACbC,MAAO,KACPC,WAAY,KACZC,OAAQ,KACRC,UAAW,KACXC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,OAAQ,KACRC,iBAAkB,KAClBC,UAAW,KACXgM,MAAO,KACP/L,QAAS,KACTC,QAAS,KACTC,QAAS,KACT8L,UAAW,KACXC,WAAY,KACZ7L,aAAc,KACdC,QAAS,KACTC,UAAW,KACXC,UAAW,KACXC,WAAY,KACZC,QAAS,KACTE,OAAQ,KACRC,aAAc,KACdC,iBAAkB,KAClBE,YAAa,KACbC,UAAW,KACXE,YAAa,KACbC,aAAc,KACdC,aAAc,KACdC,YAAa,KACbC,WAAY,KACZC,YAAa,KACbC,UAAW,KACX0K,aAAc,KACdzK,UAAW,KACXC,SAAU,KACVC,WAAY,KACZC,WAAY,KACZC,QAAS,KACTC,QAAS,KACTC,OAAQ,KACRC,UAAW,KACXC,WAAY,KACZC,WAAY,KACZC,aAAc,KACdgK,SAAU,KACV9J,QAAS,KACTC,SAAU,KACVC,SAAU,KACVE,SAAU,KACVC,UAAW,KACXC,SAAU,KACVyJ,OAAQ,KACRvJ,UAAW,KACXC,UAAW,KACXC,SAAU,KACVC,UAAW,KACXC,aAAc,KACdC,SAAU,KACVE,SAAU,KACVC,eAAgB,KAChBC,UAAW,KACX+I,OAAQ,KACRiI,QAAS,KACTC,SAAU,KACVnsC,MAAO,KACPosC,OAAQ,KACRC,YAAa,KACb7vC,OAAQ,KACR8vC,SAAU,KACVC,QAAS,KACTrI,iBAAkB5X,GAClB6X,kBAAmB7X,GACnB8X,WAAY,KACZC,QAAS,KACT/mC,KAAM,KACNkvC,WAAYlgB,GACZmgB,oBAAqB,KACrBC,iBAAkB,KAClBC,aAAc,KACdC,MAAO,KACPtR,KAAM9O,GACNqgB,MAAO,KACPrG,cAAe,KACflC,cAAe,KACfwI,OAAQ,KACRC,UAAWzgB,GACX0gB,UAAW1gB,GACX2gB,UAAW3gB,GACX4gB,cAAe,KACfC,oBAAqB,KACrBC,eAAgB,KAChBC,UAAW,KACX3yC,SAAU+xB,GACV6gB,EAAG,KACHC,OAAQ,KACR3R,eAAgB,KAChB4R,KAAM,KACNC,KAAM,KACN5R,IAAKpP,GACL4S,IAAK5S,GACL8X,gBAAiB,KACjBmJ,YAAa,KACbC,UAAW,KACXC,mBAAoBnhB,GACpBohB,iBAAkBphB,GAClBqhB,cAAerhB,GACfshB,gBAAiBthB,GACjBxK,SAAU,KACV+rB,QAAS,KACTxyC,OAAQ,KACRyyC,OAAQ,KACRC,GAAI,KACJC,GAAI,KACJC,MAAO,KACPC,KAAM,KACN7J,eAAgB,KAChB8J,KAAM,KACNC,MAAO,KACPC,aAAc,KACdC,iBAAkBniB,GAClBoiB,iBAAkBpiB,GAClBqiB,aAAc,KACdC,QAAS,KACTC,YAAa,KACbC,aAAc,KACdC,MAAO,KACPC,MAAO,KACPC,YAAa,KACbxK,UAAW,KACXC,YAAa,KACbC,sBAAuBrY,GACvBsY,uBAAwBtY,GACxBrxB,OAAQ,KACRi0C,OAAQ,KACRrK,gBAAiBpY,GACjBqY,iBAAkB,KAClBC,cAAe,KACfC,eAAgB,KAChBC,iBAAkB3Y,GAClB4Y,cAAe5Y,GACf6Y,YAAa,KACbntC,MAAO,KACPm3C,aAAc7iB,GACd8iB,aAAc,KACdC,oBAAqB,KACrBC,WAAY,KACZC,cAAe,KACfC,qBAAsB,KACtBC,eAAgBhjB,GAChBqQ,SAAUxQ,GACVojB,YAAa,KACb15C,OAAQ,KACR25C,QAASrjB,GACTsjB,QAAStjB,GACT8Y,WAAY,KACZC,eAAgB,KAChBC,cAAe,KACfuK,WAAY,KACZpJ,cAAe,KACfnyB,MAAO,KACPw7B,kBAAmB,KACnBz1C,KAAM,KACNkrC,OAAQ9Y,GACRsjB,GAAI,KACJ/iB,UAAW,KACXgjB,GAAI,KACJC,GAAI,KACJzK,kBAAmBlZ,GACnBmZ,mBAAoBnZ,GACpB4jB,QAAS,KACTxK,YAAa,KACbC,aAAc,KACdC,WAAYtZ,GACZ5pB,OAAQ,KACRmjC,YAAavZ,GACb0Z,cAAe1Z,GACf2Z,aAAc,KACdH,SAAUxZ,GACVyZ,aAAczZ,GACduT,QAAS,KACTqG,SAAU5Z,GACV6Z,YAAa7Z,GACb8Z,YAAa9Z,GACb6jB,QAAS,KACTC,WAAY,KACZC,WAAY,KACZnT,MAAO,KACPoT,OAAQ,KACRjK,YAAa,KACbC,YAAa,KACbiK,EAAG,KACHC,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClBnK,QAASja,GACTqkB,EAAG,KACHC,GAAI,KACJC,GAAI,KACJC,iBAAkB,KAClBC,EAAG,KACHC,WAAY,QChiBH,GAAOhlB,GAAM,CAAC0B,GAAKR,GAAOc,GAAOG,GAAM,IAAW,QAClD,GAAMnC,GAAM,CAAC0B,GAAKR,GAAOc,GAAOG,GAAMsS,IAAU,OCgFhD,GAkBb,SAAU5kC,GACR,GAAIA,QACF,OAAO,GAGT,GAAoB,iBAATA,EACT,OAqFJ,SAAqBiP,GACnB,OAAO,GAAYzQ,GAKnB,SAASA,EAAK1B,GACZ,OAAOA,GAAQA,EAAK0B,OAASyQ,CAC/B,CACF,CA9FW,CAAYjP,GAGrB,GAAoB,iBAATA,EACT,OAAOtG,MAAMF,QAAQwG,GAczB,SAAoBspB,GAElB,MAAMC,EAAS,GACf,IAAI/oB,GAAS,EAEb,OAASA,EAAQ8oB,EAAMjuB,QACrBkuB,EAAO/oB,GAAS,GAAQ8oB,EAAM9oB,IAGhC,OAAO,GAAYgpB,GAOnB,SAASA,IACP,IAAIhpB,GAAS,EAEb,IAAK,IAAIgC,EAAOrH,UAAUE,OAAQuK,EAAa,IAAIlM,MAAM8I,GAAOE,EAAO,EAAGA,EAAOF,EAAME,IACrFkD,EAAWlD,GAAQvH,UAAUuH,GAG/B,OAASlC,EAAQ+oB,EAAOluB,QACtB,GAAIkuB,EAAO/oB,GAAO7G,KAAKsD,QAAS2I,GAAa,OAAO,EAGtD,OAAO,CACT,CACF,CA3CiC,CAAW5F,GAqD5C,SAAsBiP,GACpB,OAAO,GAAYhE,GAMnB,SAASA,EAAInO,GAEX,IAAIhD,EAEJ,IAAKA,KAAOmV,EAEV,GAAInS,EAAKhD,KAASmV,EAAMnV,GAAM,OAAO,EAGvC,OAAO,CACT,CACF,CAvEoD,CAAakG,GAG/D,GAAoB,mBAATA,EACT,OAAO,GAAYA,GAGrB,MAAM,IAAIvC,MAAM,+CAClB,EA2FA,SAAS,GAAYwR,GACnB,OAOA,WACE,IAAK,IAAI/H,EAAQ/L,UAAUE,OAAQuK,EAAa,IAAIlM,MAAMwN,GAAQC,EAAQ,EAAGA,EAAQD,EAAOC,IAC1FvB,EAAWuB,GAAShM,UAAUgM,GAIhC,OAAO+C,QAAQ+E,EAAMtV,KAAKsD,QAAS2I,GACrC,CACF,CAGA,SAAS,KACP,OAAO,CACT,CCnOO,MAoBM,GAcb,SAAU6D,EAAMzJ,EAAM4pB,EAASC,GACT,mBAAT7pB,GAA0C,mBAAZ4pB,IACvCC,EAAUD,EAEVA,EAAU5pB,EACVA,EAAO,MAGT,MAAM8pB,EAAK,GAAQ9pB,GACb+pB,EAAOF,GAAW,EAAI,GAQ5B,SAASG,EAAQltB,EAAM0D,EAAOypB,GAG5B,MAAMzvB,EAAwB,iBAATsC,GAA8B,OAATA,EAAgBA,EAAO,CAAC,EAGlE,IAAIzC,EAEsB,iBAAfG,EAAMgE,OACfnE,EAAgC,iBAAlBG,EAAM+f,QAAuB/f,EAAM+f,QAAgC,iBAAf/f,EAAMH,KAAoBG,EAAMH,UAAOyG,EACzG9H,OAAOK,eAAe6wB,EAAO,OAAQ,CACnC1vB,MAAO,SAAiBA,EAAMgE,MAAQnE,EAAO,IAAMA,EAAO,IAAM,IAAO,OAI3E,OAAO6vB,EAEP,SAASA,IAEP,IAGIC,EAGA5a,EAGA6a,EATAzqB,EAAS,GAWb,KAAKK,GAAQ8pB,EAAGhtB,EAAM0D,EAAOypB,EAAQA,EAAQ5uB,OAAS,IAAM,SAC1DsE,EAmCR,SAAkBnF,GAChB,GAAId,MAAMF,QAAQgB,GAChB,OAAOA,EAGT,GAAqB,iBAAVA,EACT,MAAO,CA3Ha,KA2HFA,GAGpB,MAAO,CAACA,EACV,CA7CiB,CAASovB,EAAQ9sB,EAAMmtB,IAxEpB,QA0ERtqB,EAAO,IACT,OAAOA,EAKX,GAAI7C,EAAKyN,UArFK,SAqFO5K,EAAO,GAM1B,IAJA4P,GAAUsa,EAAU/sB,EAAKyN,SAASlP,QAAU,GAAK0uB,EAEjDK,EAAeH,EAAQxB,OAAO3rB,GAEvByS,GAAU,GAAKA,EAASzS,EAAKyN,SAASlP,QAAQ,CAInD,GAFA8uB,EAAYH,EAAQltB,EAAKyN,SAASgF,GAASA,EAAQ6a,EAAvCJ,GAxFF,QA0FNG,EAAU,GACZ,OAAOA,EAGT5a,EAAiC,iBAAjB4a,EAAU,GAAkBA,EAAU,GAAK5a,EAASwa,CACtE,CAGF,OAAOpqB,CACT,CACF,CAlEAqqB,CAAQvgB,EAAM,KAAM,GAApBugB,EAmEF,ECxGe,SAASorB,GAAah7C,GACnC,GAAIA,EAAQi7C,iBAAmBj7C,EAAQk7C,mBACrC,MAAM,IAAIl5C,UAAU,4EAGtB,GAAIhC,EAAQi7C,iBAAmBj7C,EAAQk7C,oBAAsBl7C,EAAQm7C,aACnE,OAAO9rC,KCGX,SAAUA,EAAMzJ,EAAM4pB,EAASC,GACT,mBAAT7pB,GAA0C,mBAAZ4pB,IACvCC,EAAUD,EACVA,EAAU5pB,EACVA,EAAO,MAGT,GAAayJ,EAAMzJ,GAMnB,SAAkBlD,EAAMmtB,GACtB,MAAMjC,EAASiC,EAAQA,EAAQ5uB,OAAS,GACxC,OAAOuuB,EAAQ9sB,EAAMkrB,EAASA,EAAOzd,SAASxJ,QAAQjE,GAAQ,KAAMkrB,EACtE,GATmC6B,EAUrC,CDnBM,CAAMpgB,EAAM,WAAW,CAAC3M,EAAM0D,EAAOg1C,KACnC,MAAMxtB,EAENwtB,EAGA,IAAI9qC,EAYJ,GAVItQ,EAAQi7C,gBACV3qC,GAAUtQ,EAAQi7C,gBAAgB3wC,SAAS5H,EAAKyd,SACvCngB,EAAQk7C,qBACjB5qC,EAAStQ,EAAQk7C,mBAAmB5wC,SAAS5H,EAAKyd,WAG/C7P,GAAUtQ,EAAQm7C,cAAiC,iBAAV/0C,IAC5CkK,GAAUtQ,EAAQm7C,aAAaz4C,EAAM0D,EAAOwnB,IAG1Ctd,GAA2B,iBAAVlK,EAOnB,OANIpG,EAAQq7C,kBAAoB34C,EAAKyN,SACnCyd,EAAOzd,SAASC,OAAOhK,EAAO,KAAM1D,EAAKyN,UAEzCyd,EAAOzd,SAASC,OAAOhK,EAAO,GAGzBA,CAGO,GAChB,CAGR,CE9DA,MAAMk1C,GAAY,CAAC,OAAQ,QAAS,SAAU,uBCM9C,MAAMC,GAAQ,kBACRC,GAAO,UACPC,GAAM,SA+CZ,SAASC,GAAMx0B,GACb,MAAO,IAAMA,EAAGzI,aAClB,CAOA,SAASk9B,GAAUz0B,GACjB,OAAOA,EAAG/iB,OAAO,GAAG0B,aACtB,CClEO,MAAM+1C,GAAc,CACzB/T,QAAS,UACTuD,SAAU,WACVzM,OAAQ,SACRiQ,gBAAiB,kBACjBC,iBAAkB,mBAClBC,cAAe,gBACfC,eAAgB,iBAChBC,iBAAkB,mBAClBM,OAAQ,SACRpY,aAAc,eACdC,aAAc,eACdC,UAAW,YACXC,UAAW,YACXC,UAAW,YACXC,WAAY,aACZC,UAAW,YACXS,WAAY,yCCyFd,MAAM,GAAM,CAAC,EAAEn5B,eAGT+8C,GAAgB,IAAIC,IAAI,CAAC,QAAS,QAAS,QAAS,QAAS,OAM5D,SAASC,GAAgB9kC,EAASvU,GAEvC,MAAMyN,EAAW,GACjB,IAGIkjB,EAHA2oB,GAAc,EAKlB,OAASA,EAAat5C,EAAKyN,SAASlP,QAClCoyB,EAAQ3wB,EAAKyN,SAAS6rC,GAEH,YAAf3oB,EAAMjvB,KACR+L,EAAS1M,KAAKw4C,GAAQhlC,EAASoc,EAAO2oB,EAAYt5C,IAC1B,SAAf2wB,EAAMjvB,KAQG,YAAd1B,EAAK0B,MAAuBy3C,GAAcK,IAAIx5C,EAAKyd,WClIvD/f,SAKoB,iBALpBA,GAFqB+7C,EDoI0D9oB,ICjIzD,iBAAV8oB,GAAqC,SAAfA,EAAM/3C,KAC5C+3C,EAAM/7C,OAAS,GAAK+7C,IAGsD,KAAtC/7C,EAAM0B,QAAQ,eAAgB,MD8H5DqO,EAAS1M,KAAK4vB,EAAMjzB,OAEE,QAAfizB,EAAMjvB,MAAmB6S,EAAQjX,QAAQo8C,UAElDjsC,EAAS1M,KAAK4vB,EAAMjzB,OCzInB,IAAoB+7C,EAErB/7C,ED2IJ,OAAO+P,CACT,CAQA,SAAS8rC,GAAQhlC,EAASvU,EAAM0D,EAAOwnB,GACrC,MAAM5tB,EAAUiX,EAAQjX,QAClBq8C,EAAeplC,EAAQqlC,OAIvBr8C,EAAOyC,EAAKyd,QAGZmT,EAAa,CAAC,EACpB,IAGI7uB,EAHA63C,EAASD,EAUb,GAL2B,SAAvBA,EAAavmB,OAA6B,QAAT71B,IACnCq8C,EAAS,GACTrlC,EAAQqlC,OAASA,GAGf55C,EAAK4wB,WACP,IAAK7uB,KAAY/B,EAAK4wB,WAChB,GAAI/zB,KAAKmD,EAAK4wB,WAAY7uB,IAC5B83C,GAAYjpB,EAAY7uB,EAAU/B,EAAK4wB,WAAW7uB,GAAWwS,GAKtD,OAAThX,GAA0B,OAATA,GACnBgX,EAAQulC,YAGV,MAAMrsC,EAAW4rC,GAAgB9kC,EAASvU,GAE7B,OAATzC,GAA0B,OAATA,GACnBgX,EAAQulC,YAIVvlC,EAAQqlC,OAASD,EAGjB,MAAM95C,EAAWG,EAAKH,UAAY,CAChCC,MAAO,CACLC,KAAM,KACNP,OAAQ,KACRiT,OAAQ,MAEVrS,IAAK,CACHL,KAAM,KACNP,OAAQ,KACRiT,OAAQ,OAGNsnC,EAAYz8C,EAAQ08C,YAAc,GAAIn9C,KAAKS,EAAQ08C,WAAYz8C,GAAQD,EAAQ08C,WAAWz8C,GAAQA,EAClG08C,EAA6B,iBAAdF,GAA0BA,IAAc,WAE7D,IAAK,sBAA2BA,GAC9B,MAAM,IAAIz6C,UAAU,uBAAuBqsB,OAAOpuB,EAAM,uCAyB1D,GAtBAqzB,EAAW5zB,IAAM,CAACO,EAAMsC,EAASC,MAAMC,KAAMF,EAASC,MAAMN,OAAQkE,GAAO8B,KAAK,KAEnE,MAATjI,GAAgBD,EAAQ48C,aAC1BtpB,EAAWvzB,OAAuC,mBAAvBC,EAAQ48C,WAA4B58C,EAAQ48C,WAAWl3C,OAAO4tB,EAAWhqB,MAAQ,IAAK5G,EAAKyN,SAAsC,iBAArBmjB,EAAWjV,MAAqBiV,EAAWjV,MAAQ,MAAQre,EAAQ48C,YAG/L,MAAT38C,GAAgBD,EAAQ68C,mBAC1BvpB,EAAWhqB,KAAOtJ,EAAQ68C,iBAAiBn3C,OAAO4tB,EAAWhqB,MAAQ,IAAK5G,EAAKyN,SAAsC,iBAArBmjB,EAAWjV,MAAqBiV,EAAWjV,MAAQ,OAGhJs+B,GAAkB,SAAT18C,GAAmC,YAAhB2tB,EAAOxpB,MAAyC,QAAnBwpB,EAAOzN,UACnEmT,EAAWwpB,QAAS,GAGjBH,GAAmB,OAAT18C,GAA0B,OAATA,GAA0B,OAATA,GAA0B,OAATA,GAA0B,OAATA,GAA0B,OAATA,IAClGqzB,EAAWypB,MAAQhvC,OAAO+Y,SAAS7mB,EAAKkE,OAAO,GAAI,KAGxC,QAATlE,GAAkBD,EAAQg9C,oBAC5B1pB,EAAW3yB,IAAMX,EAAQg9C,kBAAkBt3C,OAAO4tB,EAAW3yB,KAAO,IAAK+E,OAAO4tB,EAAWpjB,KAAO,IAAiC,iBAArBojB,EAAWjV,MAAqBiV,EAAWjV,MAAQ,QAG9Js+B,GAAkB,OAAT18C,GAAiC,YAAhB2tB,EAAOxpB,KAAoB,CACxD,MAAM64C,EAwDV,SAAyBv6C,GACvB,IAAI0D,GAAS,EAEb,OAASA,EAAQ1D,EAAKyN,SAASlP,QAAQ,CACrC,MAAMoyB,EAAQ3wB,EAAKyN,SAAS/J,GAE5B,GAAmB,YAAfitB,EAAMjvB,MAAwC,UAAlBivB,EAAMlT,QACpC,OAAOkT,CAEX,CAEA,OAAO,IACT,CApEkB6pB,CAAgBx6C,GAC9B4wB,EAAWpF,QAAU+uB,GAASA,EAAM3pB,WAAaxjB,QAAQmtC,EAAM3pB,WAAWpF,SAAW,KACrFoF,EAAWltB,MAAQ+2C,GAAuBvvB,EAAQlrB,GAClD4wB,EAAWtF,QAA6B,OAAnBJ,EAAOzN,OAC9B,CA6JF,IAAyBjc,EAjHvB,OA1CKy4C,GAAmB,OAAT18C,GAA0B,OAATA,IAC9BqzB,EAAWtF,QAAmB,OAAT/tB,EACrBqzB,EAAW3F,MAAQ1W,EAAQulC,WAGhB,OAATv8C,GAA0B,OAATA,IACfqzB,EAAWI,QACRJ,EAAWvxB,QAAOuxB,EAAWvxB,MAAQ,CAAC,GAE3CuxB,EAAWvxB,MAAMq7C,UAAY9pB,EAAWI,aACjCJ,EAAWI,OAGfipB,IACHrpB,EAAW+pB,SAAoB,OAATp9C,IAIrB08C,GAAkB,OAAT18C,GAAiC,YAAhB2tB,EAAOxpB,OACpCkvB,EAAW+pB,SAAWvtC,QAA2B,UAAnB8d,EAAOzN,UAInCngB,EAAQs9C,YACVhqB,EAAW,kBAoIN,EADgBpvB,EAnI0B3B,GAoIrCC,MAAMC,KAAM,IAAKyB,EAAI1B,MAAMN,OAAQ,IAAKgC,EAAIpB,IAAIL,KAAM,IAAKyB,EAAIpB,IAAIZ,QAAQmI,KAAIijB,GAAK5nB,OAAO4nB,KAAIplB,KAAK,MAjI3Gy0C,GAAS38C,EAAQu9C,eACpBjqB,EAAWkqB,eAAiB96C,EAAKH,WAI9Bo6C,GAAS38C,EAAQy9C,sBACpBnqB,EAAWltB,MAAQ+2C,GAAuBvvB,EAAQlrB,GAClD4wB,EAAWoqB,aAAeP,GAAuBvvB,IAG9C+uB,IACHrpB,EAAW5wB,KAAOA,GAIbyN,EAASlP,OAAS,EAAI,gBAAoBw7C,EAAWnpB,EAAYnjB,GAAY,gBAAoBssC,EAAWnpB,EACrH,CA2BA,SAAS6pB,GAAuBvvB,EAAQlrB,GACtC,IAAI0D,GAAS,EACTu3C,EAAQ,EAEZ,OAASv3C,EAAQwnB,EAAOzd,SAASlP,QAC3B2sB,EAAOzd,SAAS/J,KAAW1D,GACK,YAAhCkrB,EAAOzd,SAAS/J,GAAOhC,MAAoBu5C,IAGjD,OAAOA,CACT,CASA,SAASpB,GAAYztB,EAAOxqB,EAAMlE,EAAO00B,GACvC,MAAMnqB,EF/TD,SAAc2xC,EAAQl8C,GAC3B,MAAMy1B,EAAS,GAAUz1B,GACzB,IAAIkE,EAAOlE,EACPw9C,EAAO5nB,GAEX,GAAIH,KAAUymB,EAAOzmB,OACnB,OAAOymB,EAAO73C,SAAS63C,EAAOzmB,OAAOA,IAGvC,GAAIA,EAAO50B,OAAS,GAA4B,SAAvB40B,EAAOhyB,MAAM,EAAG,IAAiB03C,GAAM31C,KAAKxF,GAAQ,CAE3E,GAAwB,MAApBA,EAAM+D,OAAO,GAAY,CAE3B,MAAM05C,EAAOz9C,EAAMyD,MAAM,GAAG/B,QAAQ05C,GAAMG,IAC1Cr3C,EAAO,OAASu5C,EAAK15C,OAAO,GAAG0B,cAAgBg4C,EAAKh6C,MAAM,EAC5D,KAAO,CAEL,MAAMg6C,EAAOz9C,EAAMyD,MAAM,GAEzB,IAAK23C,GAAK51C,KAAKi4C,GAAO,CACpB,IAAIC,EAASD,EAAK/7C,QAAQ25C,GAAKC,IAEN,MAArBoC,EAAO35C,OAAO,KAChB25C,EAAS,IAAMA,GAGjB19C,EAAQ,OAAS09C,CACnB,CACF,CAEAF,EAAOhnB,EACT,CAEA,OAAO,IAAIgnB,EAAKt5C,EAAMlE,EACxB,CE6Re29C,CAAKjpB,EAAIwnB,OAAQh4C,GAC9B,IAAIiB,EAASnF,EE5RR,IAAmBqM,EAAQzM,EAC5BiO,EF8RA1I,SAA2CA,GAAWA,IAMtDjG,MAAMF,QAAQmG,KAChBA,EAASoF,EAAK2rB,gBErSZroB,EAAWjO,GAAW,CAAC,EAEO,MAHVyM,EFsSgBlH,GEnS7BkH,EAAOxL,OAAS,KACzBwL,EAASA,EAAO4hB,OAAO,KAGlB5hB,EAAOvE,MAAM+F,EAAS+vC,SAAW,IAAM,IAAM,MAA4B,IAArB/vC,EAASgwC,QAAoB,GAAK,MAAMr8C,QCzC9F,SAAmB6K,GACxB,OAAOA,EAAOvE,KAAK,KAAKtG,MAC1B,CHsUoD,CAAO2D,IAGnC,UAAlBoF,EAAKlG,UAA0C,iBAAXc,IACtCA,EAeJ,SAAoBnF,GAElB,MAAMmF,EAAS,CAAC,EAEhB,IACE,KAAMnF,EAAO8K,EAEf,CADE,MACF,CAEA,OAAO3F,EAMP,SAAS2F,EAASjL,EAAMi+C,GACtB,MAAM5J,EAAyB,SAArBr0C,EAAK4D,MAAM,EAAG,GAAgB,MAAMwqB,OAAOpuB,EAAK4D,MAAM,IAAM5D,EACtEsF,EAAO+uC,EAAExyC,QAAQ,YAAaq8C,KAAkBD,CAClD,CACF,CAlCaE,CAAW74C,IAGlBoF,EAAKmrB,OAASnrB,EAAKlG,SACrBqqB,EAAM,GAAIvvB,KAAKq8C,GAAajxC,EAAKlG,UAAYm3C,GAAYjxC,EAAKlG,UAAYkG,EAAKlG,UAAYc,EAClFoF,EAAKsrB,YACdnH,EAAMnkB,EAAKsrB,WAAa1wB,GAE5B,CAiCA,SAAS44C,GAActjC,EAAGsM,GACxB,OAAOA,EAAGthB,aACZ,CIrWA,MAAM,GAAM,CAAC,EAAE/G,eAITu/C,GAAa,CACjB7vC,QAAS,CACPsrC,GAAI,UACJvoB,GAAI,mCAEN+sB,UAAW,CACTxE,GAAI,aACJvoB,GAAI,kCAENgtB,WAAY,CACVhtB,GAAI,wCAEN8C,mBAAoB,CAClB9C,GAAI,wCAENitB,WAAY,CACVjtB,GAAI,wCAENxuB,OAAQ,CACN+2C,GAAI,WACJvoB,GAAI,6BAENktB,UAAW,CACT3E,GAAI,eACJvoB,GAAI,sDAENmtB,aAAc,CACZ5E,GAAI,kBACJvoB,GAAI,sDAENotB,gBAAiB,CACf7E,GAAI,qBACJvoB,GAAI,sDAENqtB,iBAAkB,CAChB9E,GAAI,sBACJvoB,GAAI,mDAUD,SAASstB,GAAc7+C,GAC5B,IAAK,MAAMN,KAAO2+C,GAChB,GAAI,GAAI9+C,KAAK8+C,GAAY3+C,IAAQ,GAAIH,KAAKS,EAASN,GAAM,CACvD,MAAMo/C,EAAcT,GAAW3+C,GAC/Bq/C,QAAQC,KAAK,oCAAoC3wB,OAAOywB,EAAYhF,GAAK,QAAQzrB,OAAOywB,EAAYhF,GAAI,gBAAkB,SAAU,MAAMzrB,OAAO3uB,EAAK,YAAY2uB,OArDtJ,oEAqDwK,KAAKA,OAAOywB,EAAYvtB,GAAI,4BACzM8sB,GAAW3+C,EACpB,CAGF,MAAM6N,EAAYpB,IAAUa,IAAI,IAAaA,IAAIhN,EAAQi/C,eAAiB,IAAIjyC,IAAI,GAAc,IAAKhN,EAAQk/C,oBAC3G7qB,oBAAoB,IACnBrnB,IAAIhN,EAAQm/C,eAAiB,IAAInyC,IAAIguC,GAAch7C,GAChDkH,EAAO,IAAI8C,EAEe,iBAArBhK,EAAQmQ,SACjBjJ,EAAK9G,MAAQJ,EAAQmQ,cACSzJ,IAArB1G,EAAQmQ,UAA+C,OAArBnQ,EAAQmQ,UACnD4uC,QAAQC,KAAK,uEAAuE3wB,OAAOruB,EAAQmQ,SAAU,OAG/G,MAAMivC,EAAW7xC,EAAU+B,QAAQ/B,EAAUmB,MAAMxH,GAAOA,GAE1D,GAAsB,SAAlBk4C,EAASh7C,KACX,MAAM,IAAIpC,UAAU,0BAKtB,IAAIuD,EAAS,gBAAoB,WAAgB,CAAC,EAAGw2C,GAAgB,CACnE/7C,UACAs8C,OAAQ,GACRE,UAAW,GACV4C,IAQH,OANIp/C,EAAQyyB,YACVltB,EAAS,gBAAoB,MAAO,CAClCktB,UAAWzyB,EAAQyyB,WAClBltB,IAGEA,CACT,CACAs5C,GAAcQ,aAAe,CAC3BxC,iBP1HK,SAAwByC,GAC7B,MAAMn4C,GAAOm4C,GAAO,IAAI19C,OAClB29C,EAAQp4C,EAAIhD,OAAO,GAEzB,GAAc,MAAVo7C,GAA2B,MAAVA,EACnB,OAAOp4C,EAGT,MAAM8pB,EAAQ9pB,EAAIR,QAAQ,KAE1B,IAAe,IAAXsqB,EACF,OAAO9pB,EAGT,IAAIf,GAAS,EAEb,OAASA,EAAQk1C,GAAUr6C,QAAQ,CACjC,MAAMwI,EAAW6xC,GAAUl1C,GAE3B,GAAI6qB,IAAUxnB,EAASxI,QAAUkG,EAAItD,MAAM,EAAG4F,EAASxI,QAAQwd,gBAAkBhV,EAC/E,OAAOtC,CAEX,CAIA,OAFAf,EAAQe,EAAIR,QAAQ,MAEL,IAAXP,GAAgB6qB,EAAQ7qB,EACnBe,GAGTf,EAAQe,EAAIR,QAAQ,MAEL,IAAXP,GAAgB6qB,EAAQ7qB,EACnBe,EAIF,qBACT,GOsFA03C,GAAcW,UAAY,CAExBrvC,SAAU,YAEVsiB,UAAW,YAEX0oB,aAAc,UACdF,gBAAiB,aAAkB,aACnCC,mBAAoB,aAAkB,aACtCG,iBAAkB,UAElB4D,cAAe,aAAkB,eAAoB,CAAC,YAAkB,UAAgB,aAAkB,eAAoB,CAAC,UAAgB,YAAkB,YAAkB,UAAgB,aAEnM,gBACAE,cAAe,aAAkB,eAAoB,CAAC,YAAkB,UAAgB,aAAkB,eAAoB,CAAC,UAAgB,YAAkB,YAAkB,UAAgB,aAEnM,gBAEA7B,UAAW,UACXC,aAAc,UACdnB,SAAU,UACVqB,oBAAqB,UACrBZ,iBAAkB,eAAoB,CAAC,UAAgB,YACvDD,WAAY,eAAoB,CAAC,UAAgB,cACjDI,kBAAmB,UACnBN,WAAY,+CChJd,IAcI7tB,EAdA4wB,EAAIz0C,OAAO00C,IAAI,iBACf17C,EAAIgH,OAAO00C,IAAI,gBACfpyB,EAAItiB,OAAO00C,IAAI,kBACfC,EAAI30C,OAAO00C,IAAI,qBACfE,EAAI50C,OAAO00C,IAAI,kBACfG,EAAI70C,OAAO00C,IAAI,kBACfpvB,EAAItlB,OAAO00C,IAAI,iBACfpL,EAAItpC,OAAO00C,IAAI,wBACfv6C,EAAI6F,OAAO00C,IAAI,qBACf/7C,EAAIqH,OAAO00C,IAAI,kBACfI,EAAI90C,OAAO00C,IAAI,uBACfK,EAAI/0C,OAAO00C,IAAI,cACfM,EAAIh1C,OAAO00C,IAAI,cACfO,EAAIj1C,OAAO00C,IAAI,mBAInB,SAASxB,EAAEgC,GACT,GAAI,iBAAoBA,GAAK,OAASA,EAAG,CACvC,IAAI7I,EAAI6I,EAAEC,SAEV,OAAQ9I,GACN,KAAKoI,EACH,OAAQS,EAAIA,EAAE97C,MACZ,KAAKkpB,EACL,KAAKsyB,EACL,KAAKD,EACL,KAAKh8C,EACL,KAAKm8C,EACH,OAAOI,EAET,QACE,OAAQA,EAAIA,GAAKA,EAAEC,UACjB,KAAK7L,EACL,KAAKhkB,EACL,KAAKnrB,EACL,KAAK66C,EACL,KAAKD,EACL,KAAKF,EACH,OAAOK,EAET,QACE,OAAO7I,GAKjB,KAAKrzC,EACH,OAAOqzC,EAEb,CACF,CApCAxoB,EAAI7jB,OAAO00C,IAAI,0BAsCfj/C,EAAQ2/C,gBAAkB9vB,EAC1B7vB,EAAQ4/C,gBAAkBR,EAC1Bp/C,EAAQ6/C,QAAUb,EAClBh/C,EAAQ8/C,WAAap7C,EACrB1E,EAAQ+/C,SAAWlzB,EACnB7sB,EAAQggD,KAAOT,EACfv/C,EAAQigD,KAAOX,EACft/C,EAAQkgD,OAAS38C,EACjBvD,EAAQmgD,SAAWhB,EACnBn/C,EAAQogD,WAAalB,EACrBl/C,EAAQqgD,SAAWn9C,EACnBlD,EAAQsgD,aAAejB,EAEvBr/C,EAAQugD,YAAc,WACpB,OAAO,CACT,EAEAvgD,EAAQwgD,iBAAmB,WACzB,OAAO,CACT,EAEAxgD,EAAQygD,kBAAoB,SAAUhB,GACpC,OAAOhC,EAAEgC,KAAO5vB,CAClB,EAEA7vB,EAAQ0gD,kBAAoB,SAAUjB,GACpC,OAAOhC,EAAEgC,KAAOL,CAClB,EAEAp/C,EAAQ2gD,UAAY,SAAUlB,GAC5B,MAAO,iBAAoBA,GAAK,OAASA,GAAKA,EAAEC,WAAaV,CAC/D,EAEAh/C,EAAQ4gD,aAAe,SAAUnB,GAC/B,OAAOhC,EAAEgC,KAAO/6C,CAClB,EAEA1E,EAAQ6gD,WAAa,SAAUpB,GAC7B,OAAOhC,EAAEgC,KAAO5yB,CAClB,EAEA7sB,EAAQ8gD,OAAS,SAAUrB,GACzB,OAAOhC,EAAEgC,KAAOF,CAClB,EAEAv/C,EAAQ+gD,OAAS,SAAUtB,GACzB,OAAOhC,EAAEgC,KAAOH,CAClB,EAEAt/C,EAAQghD,SAAW,SAAUvB,GAC3B,OAAOhC,EAAEgC,KAAOl8C,CAClB,EAEAvD,EAAQihD,WAAa,SAAUxB,GAC7B,OAAOhC,EAAEgC,KAAON,CAClB,EAEAn/C,EAAQkhD,aAAe,SAAUzB,GAC/B,OAAOhC,EAAEgC,KAAOP,CAClB,EAEAl/C,EAAQmhD,WAAa,SAAU1B,GAC7B,OAAOhC,EAAEgC,KAAOv8C,CAClB,EAEAlD,EAAQohD,eAAiB,SAAU3B,GACjC,OAAOhC,EAAEgC,KAAOJ,CAClB,EAEAr/C,EAAQqhD,mBAAqB,SAAU5B,GACrC,MAAO,iBAAoBA,GAAK,mBAAsBA,GAAKA,IAAM5yB,GAAK4yB,IAAMN,GAAKM,IAAMP,GAAKO,IAAMv8C,GAAKu8C,IAAMJ,GAAKI,IAAMD,GAAK,iBAAoBC,GAAK,OAASA,IAAMA,EAAEC,WAAaH,GAAKE,EAAEC,WAAaJ,GAAKG,EAAEC,WAAaN,GAAKK,EAAEC,WAAa7vB,GAAK4vB,EAAEC,WAAah7C,GAAK+6C,EAAEC,WAAatxB,QAAK,IAAWqxB,EAAE6B,YAC5S,EAEAthD,EAAQ6uC,OAAS4O,sCCtIf19C,EAAOC,QAAU,EAAjB,8BCHF,IAAIiO,EAAQ,EAAQ,OA2CpBlO,EAAOC,QA7BP,SAAuBsB,EAAOmJ,GAC5B,IAMI7G,EANA4H,EAAS,KAEb,IAAKlK,GAA0B,iBAAVA,EACnB,OAAOkK,EAST,IALA,IAEIxH,EACArE,EAHAwE,EAAe8J,EAAM3M,GACrBigD,EAAkC,mBAAb92C,EAIhBlK,EAAI,EAAGihD,EAAMr9C,EAAa3D,OAAQD,EAAIihD,EAAKjhD,IAElDyD,GADAJ,EAAcO,EAAa5D,IACJyD,SACvBrE,EAAQiE,EAAYjE,MAEhB4hD,EACF92C,EAASzG,EAAUrE,EAAOiE,GACjBjE,IACT6L,IAAWA,EAAS,CAAC,GACrBA,EAAOxH,GAAYrE,GAIvB,OAAO6L,CACT","sources":["webpack://waxcarvers-fe/./node_modules/extend/index.js","webpack://waxcarvers-fe/./node_modules/inline-style-parser/index.js","webpack://waxcarvers-fe/./node_modules/is-buffer/index.js","webpack://waxcarvers-fe/./node_modules/mdurl/encode.js","webpack://waxcarvers-fe/./node_modules/unist-util-stringify-position/index.js","webpack://waxcarvers-fe/./node_modules/vfile-message/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/vfile/lib/minpath.browser.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/vfile/lib/minproc.browser.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/vfile/lib/minurl.shared.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/vfile/lib/minurl.browser.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/vfile/lib/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/bail/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/is-plain-obj/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/trough/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/unified/lib/index.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/mdast-util-to-string/index.js","webpack://waxcarvers-fe/./node_modules/micromark-util-chunked/index.js","webpack://waxcarvers-fe/./node_modules/micromark-util-combine-extensions/index.js","webpack://waxcarvers-fe/./node_modules/micromark-util-character/lib/unicode-punctuation-regex.js","webpack://waxcarvers-fe/./node_modules/micromark-util-character/index.js","webpack://waxcarvers-fe/./node_modules/micromark-factory-space/index.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/initialize/content.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/initialize/document.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/blank-line.js","webpack://waxcarvers-fe/./node_modules/micromark-util-subtokenize/index.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/content.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/initialize/flow.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/initialize/text.js","webpack://waxcarvers-fe/./node_modules/micromark-util-resolve-all/index.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/create-tokenizer.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/thematic-break.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/list.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/block-quote.js","webpack://waxcarvers-fe/./node_modules/micromark-factory-destination/index.js","webpack://waxcarvers-fe/./node_modules/micromark-factory-label/index.js","webpack://waxcarvers-fe/./node_modules/micromark-factory-title/index.js","webpack://waxcarvers-fe/./node_modules/micromark-factory-whitespace/index.js","webpack://waxcarvers-fe/./node_modules/micromark-util-normalize-identifier/index.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/definition.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/code-indented.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/heading-atx.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/setext-underline.js","webpack://waxcarvers-fe/./node_modules/micromark-util-html-tag-name/index.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/html-flow.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/code-fenced.js","webpack://waxcarvers-fe/./node_modules/decode-named-character-reference/index.dom.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/character-reference.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/character-escape.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/line-ending.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/label-end.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/label-start-image.js","webpack://waxcarvers-fe/./node_modules/micromark-util-classify-character/index.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/attention.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/autolink.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/html-text.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/label-start-link.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/hard-break-escape.js","webpack://waxcarvers-fe/./node_modules/micromark-core-commonmark/lib/code-text.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/constructs.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/preprocess.js","webpack://waxcarvers-fe/./node_modules/micromark-util-decode-numeric-character-reference/index.js","webpack://waxcarvers-fe/./node_modules/micromark-util-decode-string/index.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/lib/index.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/postprocess.js","webpack://waxcarvers-fe/./node_modules/mdast-util-from-markdown/node_modules/micromark/lib/parse.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/remark-parse/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/remark-parse/lib/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/unist-builder/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/unist-util-is/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/unist-util-visit-parents/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/unist-util-visit/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/unist-util-position/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-definitions/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/traverse.js","webpack://waxcarvers-fe/./node_modules/micromark-util-encode/index.js","webpack://waxcarvers-fe/./node_modules/micromark-util-sanitize-uri/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/wrap.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/footnote-reference.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/revert.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/list-item.js","webpack://waxcarvers-fe/./node_modules/trim-lines/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/blockquote.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/break.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/code.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/delete.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/emphasis.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/footnote.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/heading.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/html.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/image-reference.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/image.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/inline-code.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/link-reference.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/link.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/list.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/paragraph.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/root.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/strong.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/table.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/text.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/handlers/thematic-break.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/unist-util-generated/index.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/node_modules/mdast-util-to-hast/lib/footer.js","webpack://waxcarvers-fe/./node_modules/remark-rehype/lib/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/schema.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/merge.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/normalize.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/info.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/types.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/defined-info.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/create.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/xlink.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/xml.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/case-sensitive-transform.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/util/case-insensitive-transform.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/xmlns.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/aria.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/html.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/svg.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/unist-util-is/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/unist-util-visit-parents/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/lib/rehype-filter.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/unist-util-visit/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/lib/uri-transformer.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/find.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/property-information/lib/hast-to-react.js","webpack://waxcarvers-fe/./node_modules/react-markdown/lib/ast-to-react.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/hast-util-whitespace/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/comma-separated-tokens/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/space-separated-tokens/index.js","webpack://waxcarvers-fe/./node_modules/react-markdown/lib/react-markdown.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/react-is/cjs/react-is.production.min.js","webpack://waxcarvers-fe/./node_modules/react-markdown/node_modules/react-is/index.js","webpack://waxcarvers-fe/./node_modules/style-to-object/index.js"],"sourcesContent":["'use strict';\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar toStr = Object.prototype.toString;\nvar defineProperty = Object.defineProperty;\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nvar isArray = function isArray(arr) {\n  if (typeof Array.isArray === 'function') {\n    return Array.isArray(arr);\n  }\n\n  return toStr.call(arr) === '[object Array]';\n};\n\nvar isPlainObject = function isPlainObject(obj) {\n  if (!obj || toStr.call(obj) !== '[object Object]') {\n    return false;\n  }\n\n  var hasOwnConstructor = hasOwn.call(obj, 'constructor');\n  var hasIsPrototypeOf = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); // Not own constructor property must be Object\n\n  if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {\n    return false;\n  } // Own properties are enumerated firstly, so to speed up,\n  // if last one is own, then all properties are own.\n\n\n  var key;\n\n  for (key in obj) {\n    /**/\n  }\n\n  return typeof key === 'undefined' || hasOwn.call(obj, key);\n}; // If name is '__proto__', and Object.defineProperty is available, define __proto__ as an own property on target\n\n\nvar setProperty = function setProperty(target, options) {\n  if (defineProperty && options.name === '__proto__') {\n    defineProperty(target, options.name, {\n      enumerable: true,\n      configurable: true,\n      value: options.newValue,\n      writable: true\n    });\n  } else {\n    target[options.name] = options.newValue;\n  }\n}; // Return undefined instead of __proto__ if '__proto__' is not an own property\n\n\nvar getProperty = function getProperty(obj, name) {\n  if (name === '__proto__') {\n    if (!hasOwn.call(obj, name)) {\n      return void 0;\n    } else if (gOPD) {\n      // In early versions of node, obj['__proto__'] is buggy when obj has\n      // __proto__ as an own property. Object.getOwnPropertyDescriptor() works.\n      return gOPD(obj, name).value;\n    }\n  }\n\n  return obj[name];\n};\n\nmodule.exports = function extend() {\n  var options, name, src, copy, copyIsArray, clone;\n  var target = arguments[0];\n  var i = 1;\n  var length = arguments.length;\n  var deep = false; // Handle a deep copy situation\n\n  if (typeof target === 'boolean') {\n    deep = target;\n    target = arguments[1] || {}; // skip the boolean and the target\n\n    i = 2;\n  }\n\n  if (target == null || typeof target !== 'object' && typeof target !== 'function') {\n    target = {};\n  }\n\n  for (; i < length; ++i) {\n    options = arguments[i]; // Only deal with non-null/undefined values\n\n    if (options != null) {\n      // Extend the base object\n      for (name in options) {\n        src = getProperty(target, name);\n        copy = getProperty(options, name); // Prevent never-ending loop\n\n        if (target !== copy) {\n          // Recurse if we're merging plain objects or arrays\n          if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {\n            if (copyIsArray) {\n              copyIsArray = false;\n              clone = src && isArray(src) ? src : [];\n            } else {\n              clone = src && isPlainObject(src) ? src : {};\n            } // Never move original objects, clone them\n\n\n            setProperty(target, {\n              name: name,\n              newValue: extend(deep, clone, copy)\n            }); // Don't bring in undefined values\n          } else if (typeof copy !== 'undefined') {\n            setProperty(target, {\n              name: name,\n              newValue: copy\n            });\n          }\n        }\n      }\n    }\n  } // Return the modified object\n\n\n  return target;\n};","// http://www.w3.org/TR/CSS21/grammar.html\n// https://github.com/visionmedia/css-parse/pull/49#issuecomment-30088027\nvar COMMENT_REGEX = /\\/\\*[^*]*\\*+([^/*][^*]*\\*+)*\\//g;\nvar NEWLINE_REGEX = /\\n/g;\nvar WHITESPACE_REGEX = /^\\s*/; // declaration\n\nvar PROPERTY_REGEX = /^(\\*?[-#/*\\\\\\w]+(\\[[0-9a-z_-]+\\])?)\\s*/;\nvar COLON_REGEX = /^:\\s*/;\nvar VALUE_REGEX = /^((?:'(?:\\\\'|.)*?'|\"(?:\\\\\"|.)*?\"|\\([^)]*?\\)|[^};])+)/;\nvar SEMICOLON_REGEX = /^[;\\s]*/; // https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/String/Trim#Polyfill\n\nvar TRIM_REGEX = /^\\s+|\\s+$/g; // strings\n\nvar NEWLINE = '\\n';\nvar FORWARD_SLASH = '/';\nvar ASTERISK = '*';\nvar EMPTY_STRING = ''; // types\n\nvar TYPE_COMMENT = 'comment';\nvar TYPE_DECLARATION = 'declaration';\n/**\n * @param {String} style\n * @param {Object} [options]\n * @return {Object[]}\n * @throws {TypeError}\n * @throws {Error}\n */\n\nmodule.exports = function (style, options) {\n  if (typeof style !== 'string') {\n    throw new TypeError('First argument must be a string');\n  }\n\n  if (!style) return [];\n  options = options || {};\n  /**\n   * Positional.\n   */\n\n  var lineno = 1;\n  var column = 1;\n  /**\n   * Update lineno and column based on `str`.\n   *\n   * @param {String} str\n   */\n\n  function updatePosition(str) {\n    var lines = str.match(NEWLINE_REGEX);\n    if (lines) lineno += lines.length;\n    var i = str.lastIndexOf(NEWLINE);\n    column = ~i ? str.length - i : column + str.length;\n  }\n  /**\n   * Mark position and patch `node.position`.\n   *\n   * @return {Function}\n   */\n\n\n  function position() {\n    var start = {\n      line: lineno,\n      column: column\n    };\n    return function (node) {\n      node.position = new Position(start);\n      whitespace();\n      return node;\n    };\n  }\n  /**\n   * Store position information for a node.\n   *\n   * @constructor\n   * @property {Object} start\n   * @property {Object} end\n   * @property {undefined|String} source\n   */\n\n\n  function Position(start) {\n    this.start = start;\n    this.end = {\n      line: lineno,\n      column: column\n    };\n    this.source = options.source;\n  }\n  /**\n   * Non-enumerable source string.\n   */\n\n\n  Position.prototype.content = style;\n  var errorsList = [];\n  /**\n   * Error `msg`.\n   *\n   * @param {String} msg\n   * @throws {Error}\n   */\n\n  function error(msg) {\n    var err = new Error(options.source + ':' + lineno + ':' + column + ': ' + msg);\n    err.reason = msg;\n    err.filename = options.source;\n    err.line = lineno;\n    err.column = column;\n    err.source = style;\n\n    if (options.silent) {\n      errorsList.push(err);\n    } else {\n      throw err;\n    }\n  }\n  /**\n   * Match `re` and return captures.\n   *\n   * @param {RegExp} re\n   * @return {undefined|Array}\n   */\n\n\n  function match(re) {\n    var m = re.exec(style);\n    if (!m) return;\n    var str = m[0];\n    updatePosition(str);\n    style = style.slice(str.length);\n    return m;\n  }\n  /**\n   * Parse whitespace.\n   */\n\n\n  function whitespace() {\n    match(WHITESPACE_REGEX);\n  }\n  /**\n   * Parse comments.\n   *\n   * @param {Object[]} [rules]\n   * @return {Object[]}\n   */\n\n\n  function comments(rules) {\n    var c;\n    rules = rules || [];\n\n    while (c = comment()) {\n      if (c !== false) {\n        rules.push(c);\n      }\n    }\n\n    return rules;\n  }\n  /**\n   * Parse comment.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n\n\n  function comment() {\n    var pos = position();\n    if (FORWARD_SLASH != style.charAt(0) || ASTERISK != style.charAt(1)) return;\n    var i = 2;\n\n    while (EMPTY_STRING != style.charAt(i) && (ASTERISK != style.charAt(i) || FORWARD_SLASH != style.charAt(i + 1))) {\n      ++i;\n    }\n\n    i += 2;\n\n    if (EMPTY_STRING === style.charAt(i - 1)) {\n      return error('End of comment missing');\n    }\n\n    var str = style.slice(2, i - 2);\n    column += 2;\n    updatePosition(str);\n    style = style.slice(i);\n    column += 2;\n    return pos({\n      type: TYPE_COMMENT,\n      comment: str\n    });\n  }\n  /**\n   * Parse declaration.\n   *\n   * @return {Object}\n   * @throws {Error}\n   */\n\n\n  function declaration() {\n    var pos = position(); // prop\n\n    var prop = match(PROPERTY_REGEX);\n    if (!prop) return;\n    comment(); // :\n\n    if (!match(COLON_REGEX)) return error(\"property missing ':'\"); // val\n\n    var val = match(VALUE_REGEX);\n    var ret = pos({\n      type: TYPE_DECLARATION,\n      property: trim(prop[0].replace(COMMENT_REGEX, EMPTY_STRING)),\n      value: val ? trim(val[0].replace(COMMENT_REGEX, EMPTY_STRING)) : EMPTY_STRING\n    }); // ;\n\n    match(SEMICOLON_REGEX);\n    return ret;\n  }\n  /**\n   * Parse declarations.\n   *\n   * @return {Object[]}\n   */\n\n\n  function declarations() {\n    var decls = [];\n    comments(decls); // declarations\n\n    var decl;\n\n    while (decl = declaration()) {\n      if (decl !== false) {\n        decls.push(decl);\n        comments(decls);\n      }\n    }\n\n    return decls;\n  }\n\n  whitespace();\n  return declarations();\n};\n/**\n * Trim `str`.\n *\n * @param {String} str\n * @return {String}\n */\n\n\nfunction trim(str) {\n  return str ? str.replace(TRIM_REGEX, EMPTY_STRING) : EMPTY_STRING;\n}","/*!\n * Determine if an object is a Buffer\n *\n * @author   Feross Aboukhadijeh <https://feross.org>\n * @license  MIT\n */\nmodule.exports = function isBuffer(obj) {\n  return obj != null && obj.constructor != null && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj);\n};","'use strict';\n\nvar encodeCache = {}; // Create a lookup array where anything but characters in `chars` string\n// and alphanumeric chars is percent-encoded.\n//\n\nfunction getEncodeCache(exclude) {\n  var i,\n      ch,\n      cache = encodeCache[exclude];\n\n  if (cache) {\n    return cache;\n  }\n\n  cache = encodeCache[exclude] = [];\n\n  for (i = 0; i < 128; i++) {\n    ch = String.fromCharCode(i);\n\n    if (/^[0-9a-z]$/i.test(ch)) {\n      // always allow unencoded alphanumeric characters\n      cache.push(ch);\n    } else {\n      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2));\n    }\n  }\n\n  for (i = 0; i < exclude.length; i++) {\n    cache[exclude.charCodeAt(i)] = exclude[i];\n  }\n\n  return cache;\n} // Encode unsafe characters with percent-encoding, skipping already\n// encoded sequences.\n//\n//  - string       - string to encode\n//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)\n//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)\n//\n\n\nfunction encode(string, exclude, keepEscaped) {\n  var i,\n      l,\n      code,\n      nextCode,\n      cache,\n      result = '';\n\n  if (typeof exclude !== 'string') {\n    // encode(string, keepEscaped)\n    keepEscaped = exclude;\n    exclude = encode.defaultChars;\n  }\n\n  if (typeof keepEscaped === 'undefined') {\n    keepEscaped = true;\n  }\n\n  cache = getEncodeCache(exclude);\n\n  for (i = 0, l = string.length; i < l; i++) {\n    code = string.charCodeAt(i);\n\n    if (keepEscaped && code === 0x25\n    /* % */\n    && i + 2 < l) {\n      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {\n        result += string.slice(i, i + 3);\n        i += 2;\n        continue;\n      }\n    }\n\n    if (code < 128) {\n      result += cache[code];\n      continue;\n    }\n\n    if (code >= 0xD800 && code <= 0xDFFF) {\n      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {\n        nextCode = string.charCodeAt(i + 1);\n\n        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {\n          result += encodeURIComponent(string[i] + string[i + 1]);\n          i++;\n          continue;\n        }\n      }\n\n      result += '%EF%BF%BD';\n      continue;\n    }\n\n    result += encodeURIComponent(string[i]);\n  }\n\n  return result;\n}\n\nencode.defaultChars = \";/?:@&=+$,-_.!~*'()#\";\nencode.componentChars = \"-_.!~*'()\";\nmodule.exports = encode;","/**\n * @typedef {import('unist').Point} Point\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\n\n/**\n * Stringify one point, a position (start and end points), or a node’s\n * positional information.\n *\n * @param {Node|NodeLike|Position|Point|null} [value]\n * @returns {string}\n */\nexport function stringifyPosition(value) {\n  // Nothing.\n  if (!value || typeof value !== 'object') {\n    return '';\n  } // Node.\n\n\n  if ('position' in value || 'type' in value) {\n    return position(value.position);\n  } // Position.\n\n\n  if ('start' in value || 'end' in value) {\n    return position(value);\n  } // Point.\n\n\n  if ('line' in value || 'column' in value) {\n    return point(value);\n  } // ?\n\n\n  return '';\n}\n/**\n * @param {Point|undefined} point\n * @returns {string}\n */\n\nfunction point(point) {\n  return index(point && point.line) + ':' + index(point && point.column);\n}\n/**\n * @param {Position|undefined} pos\n * @returns {string}\n */\n\n\nfunction position(pos) {\n  return point(pos && pos.start) + '-' + point(pos && pos.end);\n}\n/**\n * @param {number|undefined} value\n * @returns {number}\n */\n\n\nfunction index(value) {\n  return value && typeof value === 'number' ? value : 1;\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {object & {type: string, position?: Position|undefined}} NodeLike\n */\nimport { stringifyPosition } from 'unist-util-stringify-position';\nexport class VFileMessage extends Error {\n  /**\n   * Constructor of a message for `reason` at `place` from `origin`.\n   * When an error is passed in as `reason`, copies the `stack`.\n   *\n   * @param {string|Error} reason Reason for message (`string` or `Error`). Uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place] Place at which the message occurred in a file (`Node`, `Position`, or `Point`, optional).\n   * @param {string} [origin] Place in code the message originates from (`string`, optional).\n   */\n  constructor(reason, place, origin) {\n    /** @type {[string|null, string|null]} */\n    const parts = [null, null];\n    /** @type {Position} */\n\n    let position = {\n      // @ts-expect-error: we always follows the structure of `position`.\n      start: {\n        line: null,\n        column: null\n      },\n      // @ts-expect-error: \"\n      end: {\n        line: null,\n        column: null\n      }\n    };\n    super();\n\n    if (typeof place === 'string') {\n      origin = place;\n      place = undefined;\n    }\n\n    if (typeof origin === 'string') {\n      const index = origin.indexOf(':');\n\n      if (index === -1) {\n        parts[1] = origin;\n      } else {\n        parts[0] = origin.slice(0, index);\n        parts[1] = origin.slice(index + 1);\n      }\n    }\n\n    if (place) {\n      // Node.\n      if ('type' in place || 'position' in place) {\n        if (place.position) {\n          position = place.position;\n        }\n      } // Position.\n      else if ('start' in place || 'end' in place) {\n        position = place;\n      } // Point.\n      else if ('line' in place || 'column' in place) {\n        position.start = place;\n      }\n    } // Fields from `Error`\n\n\n    this.name = stringifyPosition(place) || '1:1';\n    this.message = typeof reason === 'object' ? reason.message : reason;\n    this.stack = typeof reason === 'object' ? reason.stack : '';\n    /**\n     * Reason for message.\n     * @type {string}\n     */\n\n    this.reason = this.message;\n    /**\n     * If true, marks associated file as no longer processable.\n     * @type {boolean?}\n     */\n    // eslint-disable-next-line no-unused-expressions\n\n    this.fatal;\n    /**\n     * Starting line of error.\n     * @type {number?}\n     */\n\n    this.line = position.start.line;\n    /**\n     * Starting column of error.\n     * @type {number?}\n     */\n\n    this.column = position.start.column;\n    /**\n     * Namespace of warning.\n     * @type {string?}\n     */\n\n    this.source = parts[0];\n    /**\n     * Category of message.\n     * @type {string?}\n     */\n\n    this.ruleId = parts[1];\n    /**\n     * Full range information, when available.\n     * Has start and end properties, both set to an object with line and column, set to number?.\n     * @type {Position?}\n     */\n\n    this.position = position; // The following fields are “well known”.\n    // Not standard.\n    // Feel free to add other non-standard fields to your messages.\n\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * You can use this to specify the source value that’s being reported, which\n     * is deemed incorrect.\n     * @type {string?}\n     */\n\n    this.actual;\n    /**\n     * You can use this to suggest values that should be used instead of\n     * `actual`, one or more values that are deemed as acceptable.\n     * @type {Array<string>?}\n     */\n\n    this.expected;\n    /**\n     * You may add a file property with a path of a file (used throughout the VFile ecosystem).\n     * @type {string?}\n     */\n\n    this.file;\n    /**\n     * You may add a url property with a link to documentation for the message.\n     * @type {string?}\n     */\n\n    this.url;\n    /**\n     * You may add a note property with a long form description of the message (supported by vfile-reporter).\n     * @type {string?}\n     */\n\n    this.note;\n    /* eslint-enable no-unused-expressions */\n  }\n\n}\nVFileMessage.prototype.file = '';\nVFileMessage.prototype.name = '';\nVFileMessage.prototype.reason = '';\nVFileMessage.prototype.message = '';\nVFileMessage.prototype.stack = '';\nVFileMessage.prototype.fatal = null;\nVFileMessage.prototype.column = null;\nVFileMessage.prototype.line = null;\nVFileMessage.prototype.source = null;\nVFileMessage.prototype.ruleId = null;\nVFileMessage.prototype.position = null;","// A derivative work based on:\n// <https://github.com/browserify/path-browserify>.\n// Which is licensed:\n//\n// MIT License\n//\n// Copyright (c) 2013 James Halliday\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy of\n// this software and associated documentation files (the \"Software\"), to deal in\n// the Software without restriction, including without limitation the rights to\n// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\n// the Software, and to permit persons to whom the Software is furnished to do so,\n// subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\n// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\n// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\n// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A derivative work based on:\n//\n// Parts of that are extracted from Node’s internal `path` module:\n// <https://github.com/nodejs/node/blob/master/lib/path.js>.\n// Which is licensed:\n//\n// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\nexport const path = {\n  basename,\n  dirname,\n  extname,\n  join,\n  sep: '/'\n};\n/* eslint-disable max-depth, complexity */\n\n/**\n * @param {string} path\n * @param {string} [ext]\n * @returns {string}\n */\n\nfunction basename(path, ext) {\n  if (ext !== undefined && typeof ext !== 'string') {\n    throw new TypeError('\"ext\" argument must be a string');\n  }\n\n  assertPath(path);\n  let start = 0;\n  let end = -1;\n  let index = path.length;\n  /** @type {boolean|undefined} */\n\n  let seenNonSlash;\n\n  if (ext === undefined || ext.length === 0 || ext.length > path.length) {\n    while (index--) {\n      if (path.charCodeAt(index) === 47\n      /* `/` */\n      ) {\n        // If we reached a path separator that was not part of a set of path\n        // separators at the end of the string, stop now.\n        if (seenNonSlash) {\n          start = index + 1;\n          break;\n        }\n      } else if (end < 0) {\n        // We saw the first non-path separator, mark this as the end of our\n        // path component.\n        seenNonSlash = true;\n        end = index + 1;\n      }\n    }\n\n    return end < 0 ? '' : path.slice(start, end);\n  }\n\n  if (ext === path) {\n    return '';\n  }\n\n  let firstNonSlashEnd = -1;\n  let extIndex = ext.length - 1;\n\n  while (index--) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (seenNonSlash) {\n        start = index + 1;\n        break;\n      }\n    } else {\n      if (firstNonSlashEnd < 0) {\n        // We saw the first non-path separator, remember this index in case\n        // we need it if the extension ends up not matching.\n        seenNonSlash = true;\n        firstNonSlashEnd = index + 1;\n      }\n\n      if (extIndex > -1) {\n        // Try to match the explicit extension.\n        if (path.charCodeAt(index) === ext.charCodeAt(extIndex--)) {\n          if (extIndex < 0) {\n            // We matched the extension, so mark this as the end of our path\n            // component\n            end = index;\n          }\n        } else {\n          // Extension does not match, so our result is the entire path\n          // component\n          extIndex = -1;\n          end = firstNonSlashEnd;\n        }\n      }\n    }\n  }\n\n  if (start === end) {\n    end = firstNonSlashEnd;\n  } else if (end < 0) {\n    end = path.length;\n  }\n\n  return path.slice(start, end);\n}\n/**\n * @param {string} path\n * @returns {string}\n */\n\n\nfunction dirname(path) {\n  assertPath(path);\n\n  if (path.length === 0) {\n    return '.';\n  }\n\n  let end = -1;\n  let index = path.length;\n  /** @type {boolean|undefined} */\n\n  let unmatchedSlash; // Prefix `--` is important to not run on `0`.\n\n  while (--index) {\n    if (path.charCodeAt(index) === 47\n    /* `/` */\n    ) {\n      if (unmatchedSlash) {\n        end = index;\n        break;\n      }\n    } else if (!unmatchedSlash) {\n      // We saw the first non-path separator\n      unmatchedSlash = true;\n    }\n  }\n\n  return end < 0 ? path.charCodeAt(0) === 47\n  /* `/` */\n  ? '/' : '.' : end === 1 && path.charCodeAt(0) === 47\n  /* `/` */\n  ? '//' : path.slice(0, end);\n}\n/**\n * @param {string} path\n * @returns {string}\n */\n\n\nfunction extname(path) {\n  assertPath(path);\n  let index = path.length;\n  let end = -1;\n  let startPart = 0;\n  let startDot = -1; // Track the state of characters (if any) we see before our first dot and\n  // after any path separator we find.\n\n  let preDotState = 0;\n  /** @type {boolean|undefined} */\n\n  let unmatchedSlash;\n\n  while (index--) {\n    const code = path.charCodeAt(index);\n\n    if (code === 47\n    /* `/` */\n    ) {\n      // If we reached a path separator that was not part of a set of path\n      // separators at the end of the string, stop now.\n      if (unmatchedSlash) {\n        startPart = index + 1;\n        break;\n      }\n\n      continue;\n    }\n\n    if (end < 0) {\n      // We saw the first non-path separator, mark this as the end of our\n      // extension.\n      unmatchedSlash = true;\n      end = index + 1;\n    }\n\n    if (code === 46\n    /* `.` */\n    ) {\n      // If this is our first dot, mark it as the start of our extension.\n      if (startDot < 0) {\n        startDot = index;\n      } else if (preDotState !== 1) {\n        preDotState = 1;\n      }\n    } else if (startDot > -1) {\n      // We saw a non-dot and non-path separator before our dot, so we should\n      // have a good chance at having a non-empty extension.\n      preDotState = -1;\n    }\n  }\n\n  if (startDot < 0 || end < 0 || // We saw a non-dot character immediately before the dot.\n  preDotState === 0 || // The (right-most) trimmed path component is exactly `..`.\n  preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {\n    return '';\n  }\n\n  return path.slice(startDot, end);\n}\n/**\n * @param {Array<string>} segments\n * @returns {string}\n */\n\n\nfunction join() {\n  let index = -1;\n  /** @type {string|undefined} */\n\n  let joined;\n\n  for (var _len = arguments.length, segments = new Array(_len), _key = 0; _key < _len; _key++) {\n    segments[_key] = arguments[_key];\n  }\n\n  while (++index < segments.length) {\n    assertPath(segments[index]);\n\n    if (segments[index]) {\n      joined = joined === undefined ? segments[index] : joined + '/' + segments[index];\n    }\n  }\n\n  return joined === undefined ? '.' : normalize(joined);\n}\n/**\n * Note: `normalize` is not exposed as `path.normalize`, so some code is\n * manually removed from it.\n *\n * @param {string} path\n * @returns {string}\n */\n\n\nfunction normalize(path) {\n  assertPath(path);\n  const absolute = path.charCodeAt(0) === 47;\n  /* `/` */\n  // Normalize the path according to POSIX rules.\n\n  let value = normalizeString(path, !absolute);\n\n  if (value.length === 0 && !absolute) {\n    value = '.';\n  }\n\n  if (value.length > 0 && path.charCodeAt(path.length - 1) === 47\n  /* / */\n  ) {\n    value += '/';\n  }\n\n  return absolute ? '/' + value : value;\n}\n/**\n * Resolve `.` and `..` elements in a path with directory names.\n *\n * @param {string} path\n * @param {boolean} allowAboveRoot\n * @returns {string}\n */\n\n\nfunction normalizeString(path, allowAboveRoot) {\n  let result = '';\n  let lastSegmentLength = 0;\n  let lastSlash = -1;\n  let dots = 0;\n  let index = -1;\n  /** @type {number|undefined} */\n\n  let code;\n  /** @type {number} */\n\n  let lastSlashIndex;\n\n  while (++index <= path.length) {\n    if (index < path.length) {\n      code = path.charCodeAt(index);\n    } else if (code === 47\n    /* `/` */\n    ) {\n      break;\n    } else {\n      code = 47;\n      /* `/` */\n    }\n\n    if (code === 47\n    /* `/` */\n    ) {\n      if (lastSlash === index - 1 || dots === 1) {// Empty.\n      } else if (lastSlash !== index - 1 && dots === 2) {\n        if (result.length < 2 || lastSegmentLength !== 2 || result.charCodeAt(result.length - 1) !== 46\n        /* `.` */\n        || result.charCodeAt(result.length - 2) !== 46\n        /* `.` */\n        ) {\n          if (result.length > 2) {\n            lastSlashIndex = result.lastIndexOf('/');\n\n            if (lastSlashIndex !== result.length - 1) {\n              if (lastSlashIndex < 0) {\n                result = '';\n                lastSegmentLength = 0;\n              } else {\n                result = result.slice(0, lastSlashIndex);\n                lastSegmentLength = result.length - 1 - result.lastIndexOf('/');\n              }\n\n              lastSlash = index;\n              dots = 0;\n              continue;\n            }\n          } else if (result.length > 0) {\n            result = '';\n            lastSegmentLength = 0;\n            lastSlash = index;\n            dots = 0;\n            continue;\n          }\n        }\n\n        if (allowAboveRoot) {\n          result = result.length > 0 ? result + '/..' : '..';\n          lastSegmentLength = 2;\n        }\n      } else {\n        if (result.length > 0) {\n          result += '/' + path.slice(lastSlash + 1, index);\n        } else {\n          result = path.slice(lastSlash + 1, index);\n        }\n\n        lastSegmentLength = index - lastSlash - 1;\n      }\n\n      lastSlash = index;\n      dots = 0;\n    } else if (code === 46\n    /* `.` */\n    && dots > -1) {\n      dots++;\n    } else {\n      dots = -1;\n    }\n  }\n\n  return result;\n}\n/**\n * @param {string} path\n */\n\n\nfunction assertPath(path) {\n  if (typeof path !== 'string') {\n    throw new TypeError('Path must be a string. Received ' + JSON.stringify(path));\n  }\n}\n/* eslint-enable max-depth, complexity */","// Somewhat based on:\n// <https://github.com/defunctzombie/node-process/blob/master/browser.js>.\n// But I don’t think one tiny line of code can be copyrighted. 😅\nexport const proc = {\n  cwd\n};\n\nfunction cwd() {\n  return '/';\n}","/**\n * @typedef URL\n * @property {string} hash\n * @property {string} host\n * @property {string} hostname\n * @property {string} href\n * @property {string} origin\n * @property {string} password\n * @property {string} pathname\n * @property {string} port\n * @property {string} protocol\n * @property {string} search\n * @property {any} searchParams\n * @property {string} username\n * @property {() => string} toString\n * @property {() => string} toJSON\n */\n\n/**\n * @param {unknown} fileURLOrPath\n * @returns {fileURLOrPath is URL}\n */\n// From: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js#L1501>\nexport function isUrl(fileURLOrPath) {\n  return fileURLOrPath !== null && typeof fileURLOrPath === 'object' && // @ts-expect-error: indexable.\n  fileURLOrPath.href && // @ts-expect-error: indexable.\n  fileURLOrPath.origin;\n}","/// <reference lib=\"dom\" />\nimport { isUrl } from './minurl.shared.js'; // See: <https://github.com/nodejs/node/blob/fcf8ba4/lib/internal/url.js>\n\n/**\n * @param {string|URL} path\n */\n\nexport function urlToPath(path) {\n  if (typeof path === 'string') {\n    path = new URL(path);\n  } else if (!isUrl(path)) {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The \"path\" argument must be of type string or an instance of URL. Received `' + path + '`');\n    error.code = 'ERR_INVALID_ARG_TYPE';\n    throw error;\n  }\n\n  if (path.protocol !== 'file:') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('The URL must be of scheme file');\n    error.code = 'ERR_INVALID_URL_SCHEME';\n    throw error;\n  }\n\n  return getPathFromURLPosix(path);\n}\n/**\n * @param {URL} url\n */\n\nfunction getPathFromURLPosix(url) {\n  if (url.hostname !== '') {\n    /** @type {NodeJS.ErrnoException} */\n    const error = new TypeError('File URL host must be \"localhost\" or empty on darwin');\n    error.code = 'ERR_INVALID_FILE_URL_HOST';\n    throw error;\n  }\n\n  const pathname = url.pathname;\n  let index = -1;\n\n  while (++index < pathname.length) {\n    if (pathname.charCodeAt(index) === 37\n    /* `%` */\n    && pathname.charCodeAt(index + 1) === 50\n    /* `2` */\n    ) {\n      const third = pathname.charCodeAt(index + 2);\n\n      if (third === 70\n      /* `F` */\n      || third === 102\n      /* `f` */\n      ) {\n        /** @type {NodeJS.ErrnoException} */\n        const error = new TypeError('File URL path must not include encoded / characters');\n        error.code = 'ERR_INVALID_FILE_URL_PATH';\n        throw error;\n      }\n    }\n  }\n\n  return decodeURIComponent(pathname);\n}\n\nexport { isUrl } from './minurl.shared.js';","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Point} Point\n * @typedef {Record<string, unknown> & {type: string, position?: Position|undefined}} NodeLike\n * @typedef {import('./minurl.shared.js').URL} URL\n * @typedef {import('../index.js').Data} Data\n * @typedef {import('../index.js').Value} Value\n *\n * @typedef {'ascii'|'utf8'|'utf-8'|'utf16le'|'ucs2'|'ucs-2'|'base64'|'base64url'|'latin1'|'binary'|'hex'} BufferEncoding\n *   Encodings supported by the buffer class.\n *   This is a copy of the typing from Node, copied to prevent Node globals from\n *   being needed.\n *   Copied from: <https://github.com/DefinitelyTyped/DefinitelyTyped/blob/90a4ec8/types/node/buffer.d.ts#L170>\n *\n * @typedef {Value|Options|VFile|URL} Compatible\n *   Things that can be passed to the constructor.\n *\n * @typedef VFileCoreOptions\n * @property {Value} [value]\n * @property {string} [cwd]\n * @property {Array<string>} [history]\n * @property {string|URL} [path]\n * @property {string} [basename]\n * @property {string} [stem]\n * @property {string} [extname]\n * @property {string} [dirname]\n * @property {Data} [data]\n *\n * @typedef Map\n *   Raw source map, see:\n *   <https://github.com/mozilla/source-map/blob/58819f0/source-map.d.ts#L15-L23>.\n * @property {number} version\n * @property {Array<string>} sources\n * @property {Array<string>} names\n * @property {string|undefined} [sourceRoot]\n * @property {Array<string>|undefined} [sourcesContent]\n * @property {string} mappings\n * @property {string} file\n *\n * @typedef {{[key: string]: unknown} & VFileCoreOptions} Options\n *   Configuration: a bunch of keys that will be shallow copied over to the new\n *   file.\n *\n * @typedef {Record<string, unknown>} ReporterSettings\n * @typedef {<T = ReporterSettings>(files: Array<VFile>, options: T) => string} Reporter\n */\nimport buffer from 'is-buffer';\nimport { VFileMessage } from 'vfile-message';\nimport { path } from './minpath.js';\nimport { proc } from './minproc.js';\nimport { urlToPath, isUrl } from './minurl.js'; // Order of setting (least specific to most), we need this because otherwise\n// `{stem: 'a', path: '~/b.js'}` would throw, as a path is needed before a\n// stem can be set.\n\nconst order = ['history', 'path', 'basename', 'stem', 'extname', 'dirname'];\nexport class VFile {\n  /**\n   * Create a new virtual file.\n   *\n   * If `options` is `string` or `Buffer`, it’s treated as `{value: options}`.\n   * If `options` is a `URL`, it’s treated as `{path: options}`.\n   * If `options` is a `VFile`, shallow copies its data over to the new file.\n   * All fields in `options` are set on the newly created `VFile`.\n   *\n   * Path related fields are set in the following order (least specific to\n   * most specific): `history`, `path`, `basename`, `stem`, `extname`,\n   * `dirname`.\n   *\n   * It’s not possible to set either `dirname` or `extname` without setting\n   * either `history`, `path`, `basename`, or `stem` as well.\n   *\n   * @param {Compatible} [value]\n   */\n  constructor(value) {\n    /** @type {Options} */\n    let options;\n\n    if (!value) {\n      options = {};\n    } else if (typeof value === 'string' || buffer(value)) {\n      // @ts-expect-error Looks like a buffer.\n      options = {\n        value\n      };\n    } else if (isUrl(value)) {\n      options = {\n        path: value\n      };\n    } else {\n      // @ts-expect-error Looks like file or options.\n      options = value;\n    }\n    /**\n     * Place to store custom information (default: `{}`).\n     * It’s OK to store custom data directly on the file but moving it to\n     * `data` is recommended.\n     * @type {Data}\n     */\n\n\n    this.data = {};\n    /**\n     * List of messages associated with the file.\n     * @type {Array<VFileMessage>}\n     */\n\n    this.messages = [];\n    /**\n     * List of filepaths the file moved between.\n     * The first is the original path and the last is the current path.\n     * @type {Array<string>}\n     */\n\n    this.history = [];\n    /**\n     * Base of `path` (default: `process.cwd()` or `'/'` in browsers).\n     * @type {string}\n     */\n\n    this.cwd = proc.cwd();\n    /* eslint-disable no-unused-expressions */\n\n    /**\n     * Raw value.\n     * @type {Value}\n     */\n\n    this.value; // The below are non-standard, they are “well-known”.\n    // As in, used in several tools.\n\n    /**\n     * Whether a file was saved to disk.\n     * This is used by vfile reporters.\n     * @type {boolean}\n     */\n\n    this.stored;\n    /**\n     * Sometimes files have a non-string, compiled, representation.\n     * This can be stored in the `result` field.\n     * One example is when turning markdown into React nodes.\n     * This is used by unified to store non-string results.\n     * @type {unknown}\n     */\n\n    this.result;\n    /**\n     * Sometimes files have a source map associated with them.\n     * This can be stored in the `map` field.\n     * This should be a `Map` type, which is equivalent to the `RawSourceMap`\n     * type from the `source-map` module.\n     * @type {Map|undefined}\n     */\n\n    this.map;\n    /* eslint-enable no-unused-expressions */\n    // Set path related properties in the correct order.\n\n    let index = -1;\n\n    while (++index < order.length) {\n      const prop = order[index]; // Note: we specifically use `in` instead of `hasOwnProperty` to accept\n      // `vfile`s too.\n\n      if (prop in options && options[prop] !== undefined) {\n        // @ts-expect-error: TS is confused by the different types for `history`.\n        this[prop] = prop === 'history' ? [...options[prop]] : options[prop];\n      }\n    }\n    /** @type {string} */\n\n\n    let prop; // Set non-path related properties.\n\n    for (prop in options) {\n      // @ts-expect-error: fine to set other things.\n      if (!order.includes(prop)) this[prop] = options[prop];\n    }\n  }\n  /**\n   * Get the full path (example: `'~/index.min.js'`).\n   * @returns {string}\n   */\n\n\n  get path() {\n    return this.history[this.history.length - 1];\n  }\n  /**\n   * Set the full path (example: `'~/index.min.js'`).\n   * Cannot be nullified.\n   * You can set a file URL (a `URL` object with a `file:` protocol) which will\n   * be turned into a path with `url.fileURLToPath`.\n   * @param {string|URL} path\n   */\n\n\n  set path(path) {\n    if (isUrl(path)) {\n      path = urlToPath(path);\n    }\n\n    assertNonEmpty(path, 'path');\n\n    if (this.path !== path) {\n      this.history.push(path);\n    }\n  }\n  /**\n   * Get the parent path (example: `'~'`).\n   */\n\n\n  get dirname() {\n    return typeof this.path === 'string' ? path.dirname(this.path) : undefined;\n  }\n  /**\n   * Set the parent path (example: `'~'`).\n   * Cannot be set if there’s no `path` yet.\n   */\n\n\n  set dirname(dirname) {\n    assertPath(this.basename, 'dirname');\n    this.path = path.join(dirname || '', this.basename);\n  }\n  /**\n   * Get the basename (including extname) (example: `'index.min.js'`).\n   */\n\n\n  get basename() {\n    return typeof this.path === 'string' ? path.basename(this.path) : undefined;\n  }\n  /**\n   * Set basename (including extname) (`'index.min.js'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n\n\n  set basename(basename) {\n    assertNonEmpty(basename, 'basename');\n    assertPart(basename, 'basename');\n    this.path = path.join(this.dirname || '', basename);\n  }\n  /**\n   * Get the extname (including dot) (example: `'.js'`).\n   */\n\n\n  get extname() {\n    return typeof this.path === 'string' ? path.extname(this.path) : undefined;\n  }\n  /**\n   * Set the extname (including dot) (example: `'.js'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be set if there’s no `path` yet.\n   */\n\n\n  set extname(extname) {\n    assertPart(extname, 'extname');\n    assertPath(this.dirname, 'extname');\n\n    if (extname) {\n      if (extname.charCodeAt(0) !== 46\n      /* `.` */\n      ) {\n        throw new Error('`extname` must start with `.`');\n      }\n\n      if (extname.includes('.', 1)) {\n        throw new Error('`extname` cannot contain multiple dots');\n      }\n    }\n\n    this.path = path.join(this.dirname, this.stem + (extname || ''));\n  }\n  /**\n   * Get the stem (basename w/o extname) (example: `'index.min'`).\n   */\n\n\n  get stem() {\n    return typeof this.path === 'string' ? path.basename(this.path, this.extname) : undefined;\n  }\n  /**\n   * Set the stem (basename w/o extname) (example: `'index.min'`).\n   * Cannot contain path separators (`'/'` on unix, macOS, and browsers, `'\\'`\n   * on windows).\n   * Cannot be nullified (use `file.path = file.dirname` instead).\n   */\n\n\n  set stem(stem) {\n    assertNonEmpty(stem, 'stem');\n    assertPart(stem, 'stem');\n    this.path = path.join(this.dirname || '', stem + (this.extname || ''));\n  }\n  /**\n   * Serialize the file.\n   *\n   * @param {BufferEncoding} [encoding='utf8']\n   *   When `value` is a `Buffer`, `encoding` is a character encoding to\n   *   understand it as (default: `'utf8'`).\n   * @returns {string}\n   *   Serialized file.\n   */\n\n\n  toString(encoding) {\n    return (this.value || '').toString(encoding);\n  }\n  /**\n   * Constructs a new `VFileMessage`, where `fatal` is set to `false`, and\n   * associates it with the file by adding it to `vfile.messages` and setting\n   * `message.file` to the current filepath.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n\n\n  message(reason, place, origin) {\n    const message = new VFileMessage(reason, place, origin);\n\n    if (this.path) {\n      message.name = this.path + ':' + message.name;\n      message.file = this.path;\n    }\n\n    message.fatal = false;\n    this.messages.push(message);\n    return message;\n  }\n  /**\n   * Like `VFile#message()`, but associates an informational message where\n   * `fatal` is set to `null`.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {VFileMessage}\n   *   Message.\n   */\n\n\n  info(reason, place, origin) {\n    const message = this.message(reason, place, origin);\n    message.fatal = null;\n    return message;\n  }\n  /**\n   * Like `VFile#message()`, but associates a fatal message where `fatal` is\n   * set to `true`, and then immediately throws it.\n   *\n   * > 👉 **Note**: a fatal error means that a file is no longer processable.\n   *\n   * @param {string|Error} reason\n   *   Human readable reason for the message, uses the stack and message of the error if given.\n   * @param {Node|NodeLike|Position|Point} [place]\n   *   Place where the message occurred in the file.\n   * @param {string} [origin]\n   *   Computer readable reason for the message\n   * @returns {never}\n   *   Message.\n   */\n\n\n  fail(reason, place, origin) {\n    const message = this.message(reason, place, origin);\n    message.fatal = true;\n    throw message;\n  }\n\n}\n/**\n * Assert that `part` is not a path (as in, does not contain `path.sep`).\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {void}\n */\n\nfunction assertPart(part, name) {\n  if (part && part.includes(path.sep)) {\n    throw new Error('`' + name + '` cannot be a path: did not expect `' + path.sep + '`');\n  }\n}\n/**\n * Assert that `part` is not empty.\n *\n * @param {string|undefined} part\n * @param {string} name\n * @returns {asserts part is string}\n */\n\n\nfunction assertNonEmpty(part, name) {\n  if (!part) {\n    throw new Error('`' + name + '` cannot be empty');\n  }\n}\n/**\n * Assert `path` exists.\n *\n * @param {string|undefined} path\n * @param {string} name\n * @returns {asserts path is string}\n */\n\n\nfunction assertPath(path, name) {\n  if (!path) {\n    throw new Error('Setting `' + name + '` requires `path` to be set too');\n  }\n}","/**\n * Throw a given error.\n *\n * @param {Error|null|undefined} [error]\n *   Maybe error.\n * @returns {asserts error is null|undefined}\n */\nexport function bail(error) {\n  if (error) {\n    throw error;\n  }\n}","export default function isPlainObject(value) {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n\n  const prototype = Object.getPrototypeOf(value);\n  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);\n}","/**\n * @typedef {(error?: Error|null|undefined, ...output: Array<any>) => void} Callback\n * @typedef {(...input: Array<any>) => any} Middleware\n *\n * @typedef {(...input: Array<any>) => void} Run\n *   Call all middleware.\n * @typedef {(fn: Middleware) => Pipeline} Use\n *   Add `fn` (middleware) to the list.\n * @typedef {{run: Run, use: Use}} Pipeline\n *   Middleware.\n */\n\n/**\n * Create new middleware.\n *\n * @returns {Pipeline}\n */\nexport function trough() {\n  /** @type {Array<Middleware>} */\n  const fns = [];\n  /** @type {Pipeline} */\n\n  const pipeline = {\n    run,\n    use\n  };\n  return pipeline;\n  /** @type {Run} */\n\n  function run() {\n    for (var _len = arguments.length, values = new Array(_len), _key = 0; _key < _len; _key++) {\n      values[_key] = arguments[_key];\n    }\n\n    let middlewareIndex = -1;\n    /** @type {Callback} */\n\n    const callback = values.pop();\n\n    if (typeof callback !== 'function') {\n      throw new TypeError('Expected function as last argument, not ' + callback);\n    }\n\n    next(null, ...values);\n    /**\n     * Run the next `fn`, or we’re done.\n     *\n     * @param {Error|null|undefined} error\n     * @param {Array<any>} output\n     */\n\n    function next(error) {\n      const fn = fns[++middlewareIndex];\n      let index = -1;\n\n      if (error) {\n        callback(error);\n        return;\n      } // Copy non-nullish input into values.\n\n\n      for (var _len2 = arguments.length, output = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n        output[_key2 - 1] = arguments[_key2];\n      }\n\n      while (++index < values.length) {\n        if (output[index] === null || output[index] === undefined) {\n          output[index] = values[index];\n        }\n      } // Save the newly created `output` for the next call.\n\n\n      values = output; // Next or done.\n\n      if (fn) {\n        wrap(fn, next)(...output);\n      } else {\n        callback(null, ...output);\n      }\n    }\n  }\n  /** @type {Use} */\n\n\n  function use(middelware) {\n    if (typeof middelware !== 'function') {\n      throw new TypeError('Expected `middelware` to be a function, not ' + middelware);\n    }\n\n    fns.push(middelware);\n    return pipeline;\n  }\n}\n/**\n * Wrap `middleware`.\n * Can be sync or async; return a promise, receive a callback, or return new\n * values and errors.\n *\n * @param {Middleware} middleware\n * @param {Callback} callback\n */\n\nexport function wrap(middleware, callback) {\n  /** @type {boolean} */\n  let called;\n  return wrapped;\n  /**\n   * Call `middleware`.\n   * @this {any}\n   * @param {Array<any>} parameters\n   * @returns {void}\n   */\n\n  function wrapped() {\n    for (var _len3 = arguments.length, parameters = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {\n      parameters[_key3] = arguments[_key3];\n    }\n\n    const fnExpectsCallback = middleware.length > parameters.length;\n    /** @type {any} */\n\n    let result;\n\n    if (fnExpectsCallback) {\n      parameters.push(done);\n    }\n\n    try {\n      result = middleware.apply(this, parameters);\n    } catch (error) {\n      const exception =\n      /** @type {Error} */\n      error; // Well, this is quite the pickle.\n      // `middleware` received a callback and called it synchronously, but that\n      // threw an error.\n      // The only thing left to do is to throw the thing instead.\n\n      if (fnExpectsCallback && called) {\n        throw exception;\n      }\n\n      return done(exception);\n    }\n\n    if (!fnExpectsCallback) {\n      if (result instanceof Promise) {\n        result.then(then, done);\n      } else if (result instanceof Error) {\n        done(result);\n      } else {\n        then(result);\n      }\n    }\n  }\n  /**\n   * Call `callback`, only once.\n   * @type {Callback}\n   */\n\n\n  function done(error) {\n    if (!called) {\n      called = true;\n\n      for (var _len4 = arguments.length, output = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n        output[_key4 - 1] = arguments[_key4];\n      }\n\n      callback(error, ...output);\n    }\n  }\n  /**\n   * Call `done` with one value.\n   *\n   * @param {any} [value]\n   */\n\n\n  function then(value) {\n    done(null, value);\n  }\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('vfile').VFileCompatible} VFileCompatible\n * @typedef {import('vfile').VFileValue} VFileValue\n * @typedef {import('..').Processor} Processor\n * @typedef {import('..').Plugin} Plugin\n * @typedef {import('..').Preset} Preset\n * @typedef {import('..').Pluggable} Pluggable\n * @typedef {import('..').PluggableList} PluggableList\n * @typedef {import('..').Transformer} Transformer\n * @typedef {import('..').Parser} Parser\n * @typedef {import('..').Compiler} Compiler\n * @typedef {import('..').RunCallback} RunCallback\n * @typedef {import('..').ProcessCallback} ProcessCallback\n *\n * @typedef Context\n * @property {Node} tree\n * @property {VFile} file\n */\nimport { bail } from 'bail';\nimport isBuffer from 'is-buffer';\nimport extend from 'extend';\nimport isPlainObj from 'is-plain-obj';\nimport { trough } from 'trough';\nimport { VFile } from 'vfile'; // Expose a frozen processor.\n\nexport const unified = base().freeze();\nconst own = {}.hasOwnProperty; // Function to create the first processor.\n\n/**\n * @returns {Processor}\n */\n\nfunction base() {\n  const transformers = trough();\n  /** @type {Processor['attachers']} */\n\n  const attachers = [];\n  /** @type {Record<string, unknown>} */\n\n  let namespace = {};\n  /** @type {boolean|undefined} */\n\n  let frozen;\n  let freezeIndex = -1; // Data management.\n  // @ts-expect-error: overloads are handled.\n\n  processor.data = data;\n  processor.Parser = undefined;\n  processor.Compiler = undefined; // Lock.\n\n  processor.freeze = freeze; // Plugins.\n\n  processor.attachers = attachers; // @ts-expect-error: overloads are handled.\n\n  processor.use = use; // API.\n\n  processor.parse = parse;\n  processor.stringify = stringify; // @ts-expect-error: overloads are handled.\n\n  processor.run = run;\n  processor.runSync = runSync; // @ts-expect-error: overloads are handled.\n\n  processor.process = process;\n  processor.processSync = processSync; // Expose.\n\n  return processor; // Create a new processor based on the processor in the current scope.\n\n  /** @type {Processor} */\n\n  function processor() {\n    const destination = base();\n    let index = -1;\n\n    while (++index < attachers.length) {\n      destination.use(...attachers[index]);\n    }\n\n    destination.data(extend(true, {}, namespace));\n    return destination;\n  }\n  /**\n   * @param {string|Record<string, unknown>} [key]\n   * @param {unknown} [value]\n   * @returns {unknown}\n   */\n\n\n  function data(key, value) {\n    if (typeof key === 'string') {\n      // Set `key`.\n      if (arguments.length === 2) {\n        assertUnfrozen('data', frozen);\n        namespace[key] = value;\n        return processor;\n      } // Get `key`.\n\n\n      return own.call(namespace, key) && namespace[key] || null;\n    } // Set space.\n\n\n    if (key) {\n      assertUnfrozen('data', frozen);\n      namespace = key;\n      return processor;\n    } // Get space.\n\n\n    return namespace;\n  }\n  /** @type {Processor['freeze']} */\n\n\n  function freeze() {\n    if (frozen) {\n      return processor;\n    }\n\n    while (++freezeIndex < attachers.length) {\n      const [attacher, ...options] = attachers[freezeIndex];\n\n      if (options[0] === false) {\n        continue;\n      }\n\n      if (options[0] === true) {\n        options[0] = undefined;\n      }\n      /** @type {Transformer|void} */\n\n\n      const transformer = attacher.call(processor, ...options);\n\n      if (typeof transformer === 'function') {\n        transformers.use(transformer);\n      }\n    }\n\n    frozen = true;\n    freezeIndex = Number.POSITIVE_INFINITY;\n    return processor;\n  }\n  /**\n   * @param {Pluggable|null|undefined} [value]\n   * @param {...unknown} options\n   * @returns {Processor}\n   */\n\n\n  function use(value) {\n    for (var _len = arguments.length, options = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      options[_key - 1] = arguments[_key];\n    }\n\n    /** @type {Record<string, unknown>|undefined} */\n    let settings;\n    assertUnfrozen('use', frozen);\n\n    if (value === null || value === undefined) {// Empty.\n    } else if (typeof value === 'function') {\n      addPlugin(value, ...options);\n    } else if (typeof value === 'object') {\n      if (Array.isArray(value)) {\n        addList(value);\n      } else {\n        addPreset(value);\n      }\n    } else {\n      throw new TypeError('Expected usable value, not `' + value + '`');\n    }\n\n    if (settings) {\n      namespace.settings = Object.assign(namespace.settings || {}, settings);\n    }\n\n    return processor;\n    /**\n     * @param {import('..').Pluggable<unknown[]>} value\n     * @returns {void}\n     */\n\n    function add(value) {\n      if (typeof value === 'function') {\n        addPlugin(value);\n      } else if (typeof value === 'object') {\n        if (Array.isArray(value)) {\n          const [plugin, ...options] = value;\n          addPlugin(plugin, ...options);\n        } else {\n          addPreset(value);\n        }\n      } else {\n        throw new TypeError('Expected usable value, not `' + value + '`');\n      }\n    }\n    /**\n     * @param {Preset} result\n     * @returns {void}\n     */\n\n\n    function addPreset(result) {\n      addList(result.plugins);\n\n      if (result.settings) {\n        settings = Object.assign(settings || {}, result.settings);\n      }\n    }\n    /**\n     * @param {PluggableList|null|undefined} [plugins]\n     * @returns {void}\n     */\n\n\n    function addList(plugins) {\n      let index = -1;\n\n      if (plugins === null || plugins === undefined) {// Empty.\n      } else if (Array.isArray(plugins)) {\n        while (++index < plugins.length) {\n          const thing = plugins[index];\n          add(thing);\n        }\n      } else {\n        throw new TypeError('Expected a list of plugins, not `' + plugins + '`');\n      }\n    }\n    /**\n     * @param {Plugin} plugin\n     * @param {...unknown} [value]\n     * @returns {void}\n     */\n\n\n    function addPlugin(plugin, value) {\n      let index = -1;\n      /** @type {Processor['attachers'][number]|undefined} */\n\n      let entry;\n\n      while (++index < attachers.length) {\n        if (attachers[index][0] === plugin) {\n          entry = attachers[index];\n          break;\n        }\n      }\n\n      if (entry) {\n        if (isPlainObj(entry[1]) && isPlainObj(value)) {\n          value = extend(true, entry[1], value);\n        }\n\n        entry[1] = value;\n      } else {\n        // @ts-expect-error: fine.\n        attachers.push([...arguments]);\n      }\n    }\n  }\n  /** @type {Processor['parse']} */\n\n\n  function parse(doc) {\n    processor.freeze();\n    const file = vfile(doc);\n    const Parser = processor.Parser;\n    assertParser('parse', Parser);\n\n    if (newable(Parser, 'parse')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Parser(String(file), file).parse();\n    } // @ts-expect-error: `newable` checks this.\n\n\n    return Parser(String(file), file); // eslint-disable-line new-cap\n  }\n  /** @type {Processor['stringify']} */\n\n\n  function stringify(node, doc) {\n    processor.freeze();\n    const file = vfile(doc);\n    const Compiler = processor.Compiler;\n    assertCompiler('stringify', Compiler);\n    assertNode(node);\n\n    if (newable(Compiler, 'compile')) {\n      // @ts-expect-error: `newable` checks this.\n      return new Compiler(node, file).compile();\n    } // @ts-expect-error: `newable` checks this.\n\n\n    return Compiler(node, file); // eslint-disable-line new-cap\n  }\n  /**\n   * @param {Node} node\n   * @param {VFileCompatible|RunCallback} [doc]\n   * @param {RunCallback} [callback]\n   * @returns {Promise<Node>|void}\n   */\n\n\n  function run(node, doc, callback) {\n    assertNode(node);\n    processor.freeze();\n\n    if (!callback && typeof doc === 'function') {\n      callback = doc;\n      doc = undefined;\n    }\n\n    if (!callback) {\n      return new Promise(executor);\n    }\n\n    executor(null, callback);\n    /**\n     * @param {null|((node: Node) => void)} resolve\n     * @param {(error: Error) => void} reject\n     * @returns {void}\n     */\n\n    function executor(resolve, reject) {\n      // @ts-expect-error: `doc` can’t be a callback anymore, we checked.\n      transformers.run(node, vfile(doc), done);\n      /**\n       * @param {Error|null} error\n       * @param {Node} tree\n       * @param {VFile} file\n       * @returns {void}\n       */\n\n      function done(error, tree, file) {\n        tree = tree || node;\n\n        if (error) {\n          reject(error);\n        } else if (resolve) {\n          resolve(tree);\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, tree, file);\n        }\n      }\n    }\n  }\n  /** @type {Processor['runSync']} */\n\n\n  function runSync(node, file) {\n    /** @type {Node|undefined} */\n    let result;\n    /** @type {boolean|undefined} */\n\n    let complete;\n    processor.run(node, file, done);\n    assertDone('runSync', 'run', complete); // @ts-expect-error: we either bailed on an error or have a tree.\n\n    return result;\n    /**\n     * @param {Error|null} [error]\n     * @param {Node} [tree]\n     * @returns {void}\n     */\n\n    function done(error, tree) {\n      bail(error);\n      result = tree;\n      complete = true;\n    }\n  }\n  /**\n   * @param {VFileCompatible} doc\n   * @param {ProcessCallback} [callback]\n   * @returns {Promise<VFile>|undefined}\n   */\n\n\n  function process(doc, callback) {\n    processor.freeze();\n    assertParser('process', processor.Parser);\n    assertCompiler('process', processor.Compiler);\n\n    if (!callback) {\n      return new Promise(executor);\n    }\n\n    executor(null, callback);\n    /**\n     * @param {null|((file: VFile) => void)} resolve\n     * @param {(error?: Error|null|undefined) => void} reject\n     * @returns {void}\n     */\n\n    function executor(resolve, reject) {\n      const file = vfile(doc);\n      processor.run(processor.parse(file), file, (error, tree, file) => {\n        if (error || !tree || !file) {\n          done(error);\n        } else {\n          /** @type {unknown} */\n          const result = processor.stringify(tree, file);\n\n          if (result === undefined || result === null) {// Empty.\n          } else if (looksLikeAVFileValue(result)) {\n            file.value = result;\n          } else {\n            file.result = result;\n          }\n\n          done(error, file);\n        }\n      });\n      /**\n       * @param {Error|null|undefined} [error]\n       * @param {VFile|undefined} [file]\n       * @returns {void}\n       */\n\n      function done(error, file) {\n        if (error || !file) {\n          reject(error);\n        } else if (resolve) {\n          resolve(file);\n        } else {\n          // @ts-expect-error: `callback` is defined if `resolve` is not.\n          callback(null, file);\n        }\n      }\n    }\n  }\n  /** @type {Processor['processSync']} */\n\n\n  function processSync(doc) {\n    /** @type {boolean|undefined} */\n    let complete;\n    processor.freeze();\n    assertParser('processSync', processor.Parser);\n    assertCompiler('processSync', processor.Compiler);\n    const file = vfile(doc);\n    processor.process(file, done);\n    assertDone('processSync', 'process', complete);\n    return file;\n    /**\n     * @param {Error|null|undefined} [error]\n     * @returns {void}\n     */\n\n    function done(error) {\n      complete = true;\n      bail(error);\n    }\n  }\n}\n/**\n * Check if `value` is a constructor.\n *\n * @param {unknown} value\n * @param {string} name\n * @returns {boolean}\n */\n\n\nfunction newable(value, name) {\n  return typeof value === 'function' && // Prototypes do exist.\n  // type-coverage:ignore-next-line\n  value.prototype && ( // A function with keys in its prototype is probably a constructor.\n  // Classes’ prototype methods are not enumerable, so we check if some value\n  // exists in the prototype.\n  // type-coverage:ignore-next-line\n  keys(value.prototype) || name in value.prototype);\n}\n/**\n * Check if `value` is an object with keys.\n *\n * @param {Record<string, unknown>} value\n * @returns {boolean}\n */\n\n\nfunction keys(value) {\n  /** @type {string} */\n  let key;\n\n  for (key in value) {\n    if (own.call(value, key)) {\n      return true;\n    }\n  }\n\n  return false;\n}\n/**\n * Assert a parser is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Parser}\n */\n\n\nfunction assertParser(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Parser`');\n  }\n}\n/**\n * Assert a compiler is available.\n *\n * @param {string} name\n * @param {unknown} value\n * @returns {asserts value is Compiler}\n */\n\n\nfunction assertCompiler(name, value) {\n  if (typeof value !== 'function') {\n    throw new TypeError('Cannot `' + name + '` without `Compiler`');\n  }\n}\n/**\n * Assert the processor is not frozen.\n *\n * @param {string} name\n * @param {unknown} frozen\n * @returns {asserts frozen is false}\n */\n\n\nfunction assertUnfrozen(name, frozen) {\n  if (frozen) {\n    throw new Error('Cannot call `' + name + '` on a frozen processor.\\nCreate a new processor first, by calling it: use `processor()` instead of `processor`.');\n  }\n}\n/**\n * Assert `node` is a unist node.\n *\n * @param {unknown} node\n * @returns {asserts node is Node}\n */\n\n\nfunction assertNode(node) {\n  // `isPlainObj` unfortunately uses `any` instead of `unknown`.\n  // type-coverage:ignore-next-line\n  if (!isPlainObj(node) || typeof node.type !== 'string') {\n    throw new TypeError('Expected node, got `' + node + '`'); // Fine.\n  }\n}\n/**\n * Assert that `complete` is `true`.\n *\n * @param {string} name\n * @param {string} asyncName\n * @param {unknown} complete\n * @returns {asserts complete is true}\n */\n\n\nfunction assertDone(name, asyncName, complete) {\n  if (!complete) {\n    throw new Error('`' + name + '` finished async. Use `' + asyncName + '` instead');\n  }\n}\n/**\n * @param {VFileCompatible} [value]\n * @returns {VFile}\n */\n\n\nfunction vfile(value) {\n  return looksLikeAVFile(value) ? value : new VFile(value);\n}\n/**\n * @param {VFileCompatible} [value]\n * @returns {value is VFile}\n */\n\n\nfunction looksLikeAVFile(value) {\n  return Boolean(value && typeof value === 'object' && 'message' in value && 'messages' in value);\n}\n/**\n * @param {unknown} [value]\n * @returns {value is VFileValue}\n */\n\n\nfunction looksLikeAVFileValue(value) {\n  return typeof value === 'string' || isBuffer(value);\n}","/**\n * @typedef Options\n * @property {boolean} [includeImageAlt=true]\n */\n\n/**\n * Get the text content of a node.\n * Prefer the node’s plain-text fields, otherwise serialize its children,\n * and if the given value is an array, serialize the nodes in it.\n *\n * @param {unknown} node\n * @param {Options} [options]\n * @returns {string}\n */\nexport function toString(node, options) {\n  var {\n    includeImageAlt = true\n  } = options || {};\n  return one(node, includeImageAlt);\n}\n/**\n * @param {unknown} node\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\n\nfunction one(node, includeImageAlt) {\n  return node && typeof node === 'object' && ( // @ts-ignore looks like a literal.\n  node.value || ( // @ts-ignore looks like an image.\n  includeImageAlt ? node.alt : '') || // @ts-ignore looks like a parent.\n  'children' in node && all(node.children, includeImageAlt) || Array.isArray(node) && all(node, includeImageAlt)) || '';\n}\n/**\n * @param {Array.<unknown>} values\n * @param {boolean} includeImageAlt\n * @returns {string}\n */\n\n\nfunction all(values, includeImageAlt) {\n  /** @type {Array.<string>} */\n  var result = [];\n  var index = -1;\n\n  while (++index < values.length) {\n    result[index] = one(values[index], includeImageAlt);\n  }\n\n  return result.join('');\n}","/**\n * Like `Array#splice`, but smarter for giant arrays.\n *\n * `Array#splice` takes all items to be inserted as individual argument which\n * causes a stack overflow in V8 when trying to insert 100k items for instance.\n *\n * Otherwise, this does not return the removed items, and takes `items` as an\n * array instead of rest parameters.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {number} start\n * @param {number} remove\n * @param {T[]} items\n * @returns {void}\n */\nexport function splice(list, start, remove, items) {\n  const end = list.length;\n  let chunkStart = 0;\n  /** @type {unknown[]} */\n\n  let parameters; // Make start between zero and `end` (included).\n\n  if (start < 0) {\n    start = -start > end ? 0 : end + start;\n  } else {\n    start = start > end ? end : start;\n  }\n\n  remove = remove > 0 ? remove : 0; // No need to chunk the items if there’s only a couple (10k) items.\n\n  if (items.length < 10000) {\n    parameters = Array.from(items);\n    parameters.unshift(start, remove) // @ts-expect-error Hush, it’s fine.\n    ;\n    [].splice.apply(list, parameters);\n  } else {\n    // Delete `remove` items starting from `start`\n    if (remove) [].splice.apply(list, [start, remove]); // Insert the items in chunks to not cause stack overflows.\n\n    while (chunkStart < items.length) {\n      parameters = items.slice(chunkStart, chunkStart + 10000);\n      parameters.unshift(start, 0) // @ts-expect-error Hush, it’s fine.\n      ;\n      [].splice.apply(list, parameters);\n      chunkStart += 10000;\n      start += 10000;\n    }\n  }\n}\n/**\n * Append `items` (an array) at the end of `list` (another array).\n * When `list` was empty, returns `items` instead.\n *\n * This prevents a potentially expensive operation when `list` is empty,\n * and adds items in batches to prevent V8 from hanging.\n *\n * @template {unknown} T\n * @param {T[]} list\n * @param {T[]} items\n * @returns {T[]}\n */\n\nexport function push(list, items) {\n  if (list.length > 0) {\n    splice(list, list.length, 0, items);\n    return list;\n  }\n\n  return items;\n}","/**\n * @typedef {import('micromark-util-types').NormalizedExtension} NormalizedExtension\n * @typedef {import('micromark-util-types').Extension} Extension\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension\n */\nimport { splice } from 'micromark-util-chunked';\nconst hasOwnProperty = {}.hasOwnProperty;\n/**\n * Combine several syntax extensions into one.\n *\n * @param {Extension[]} extensions List of syntax extensions.\n * @returns {NormalizedExtension} A single combined extension.\n */\n\nexport function combineExtensions(extensions) {\n  /** @type {NormalizedExtension} */\n  const all = {};\n  let index = -1;\n\n  while (++index < extensions.length) {\n    syntaxExtension(all, extensions[index]);\n  }\n\n  return all;\n}\n/**\n * Merge `extension` into `all`.\n *\n * @param {NormalizedExtension} all Extension to merge into.\n * @param {Extension} extension Extension to merge.\n * @returns {void}\n */\n\nfunction syntaxExtension(all, extension) {\n  /** @type {string} */\n  let hook;\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;\n    const left = maybe || (all[hook] = {});\n    const right = extension[hook];\n    /** @type {string} */\n\n    let code;\n\n    for (code in right) {\n      if (!hasOwnProperty.call(left, code)) left[code] = [];\n      const value = right[code];\n      constructs( // @ts-expect-error Looks like a list.\n      left[code], Array.isArray(value) ? value : value ? [value] : []);\n    }\n  }\n}\n/**\n * Merge `list` into `existing` (both lists of constructs).\n * Mutates `existing`.\n *\n * @param {unknown[]} existing\n * @param {unknown[]} list\n * @returns {void}\n */\n\n\nfunction constructs(existing, list) {\n  let index = -1;\n  /** @type {unknown[]} */\n\n  const before = [];\n\n  while (++index < list.length) {\n    // @ts-expect-error Looks like an object.\n    ;\n    (list[index].add === 'after' ? existing : before).push(list[index]);\n  }\n\n  splice(existing, 0, 0, before);\n}\n/**\n * Combine several HTML extensions into one.\n *\n * @param {HtmlExtension[]} htmlExtensions List of HTML extensions.\n * @returns {HtmlExtension} A single combined extension.\n */\n\n\nexport function combineHtmlExtensions(htmlExtensions) {\n  /** @type {HtmlExtension} */\n  const handlers = {};\n  let index = -1;\n\n  while (++index < htmlExtensions.length) {\n    htmlExtension(handlers, htmlExtensions[index]);\n  }\n\n  return handlers;\n}\n/**\n * Merge `extension` into `all`.\n *\n * @param {HtmlExtension} all Extension to merge into.\n * @param {HtmlExtension} extension Extension to merge.\n * @returns {void}\n */\n\nfunction htmlExtension(all, extension) {\n  /** @type {string} */\n  let hook;\n\n  for (hook in extension) {\n    const maybe = hasOwnProperty.call(all, hook) ? all[hook] : undefined;\n    const left = maybe || (all[hook] = {});\n    const right = extension[hook];\n    /** @type {string} */\n\n    let type;\n\n    if (right) {\n      for (type in right) {\n        left[type] = right[type];\n      }\n    }\n  }\n}","// This module is generated by `script/`.\n//\n// CommonMark handles attention (emphasis, strong) markers based on what comes\n// before or after them.\n// One such difference is if those characters are Unicode punctuation.\n// This script is generated from the Unicode data.\nexport const unicodePunctuationRegex = /[!-/:-@[-`{-~\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u09FD\\u0A76\\u0AF0\\u0C77\\u0C84\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2308-\\u230B\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E4F\\u2E52\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA8FC\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/;","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { unicodePunctuationRegex } from './lib/unicode-punctuation-regex.js';\n/**\n * Check whether the character code represents an ASCII alpha (`a` through `z`,\n * case insensitive).\n *\n * An **ASCII alpha** is an ASCII upper alpha or ASCII lower alpha.\n *\n * An **ASCII upper alpha** is a character in the inclusive range U+0041 (`A`)\n * to U+005A (`Z`).\n *\n * An **ASCII lower alpha** is a character in the inclusive range U+0061 (`a`)\n * to U+007A (`z`).\n */\n\nexport const asciiAlpha = regexCheck(/[A-Za-z]/);\n/**\n * Check whether the character code represents an ASCII digit (`0` through `9`).\n *\n * An **ASCII digit** is a character in the inclusive range U+0030 (`0`) to\n * U+0039 (`9`).\n */\n\nexport const asciiDigit = regexCheck(/\\d/);\n/**\n * Check whether the character code represents an ASCII hex digit (`a` through\n * `f`, case insensitive, or `0` through `9`).\n *\n * An **ASCII hex digit** is an ASCII digit (see `asciiDigit`), ASCII upper hex\n * digit, or an ASCII lower hex digit.\n *\n * An **ASCII upper hex digit** is a character in the inclusive range U+0041\n * (`A`) to U+0046 (`F`).\n *\n * An **ASCII lower hex digit** is a character in the inclusive range U+0061\n * (`a`) to U+0066 (`f`).\n */\n\nexport const asciiHexDigit = regexCheck(/[\\dA-Fa-f]/);\n/**\n * Check whether the character code represents an ASCII alphanumeric (`a`\n * through `z`, case insensitive, or `0` through `9`).\n *\n * An **ASCII alphanumeric** is an ASCII digit (see `asciiDigit`) or ASCII alpha\n * (see `asciiAlpha`).\n */\n\nexport const asciiAlphanumeric = regexCheck(/[\\dA-Za-z]/);\n/**\n * Check whether the character code represents ASCII punctuation.\n *\n * An **ASCII punctuation** is a character in the inclusive ranges U+0021\n * EXCLAMATION MARK (`!`) to U+002F SLASH (`/`), U+003A COLON (`:`) to U+0040 AT\n * SIGN (`@`), U+005B LEFT SQUARE BRACKET (`[`) to U+0060 GRAVE ACCENT\n * (`` ` ``), or U+007B LEFT CURLY BRACE (`{`) to U+007E TILDE (`~`).\n */\n\nexport const asciiPunctuation = regexCheck(/[!-/:-@[-`{-~]/);\n/**\n * Check whether the character code represents an ASCII atext.\n *\n * atext is an ASCII alphanumeric (see `asciiAlphanumeric`), or a character in\n * the inclusive ranges U+0023 NUMBER SIGN (`#`) to U+0027 APOSTROPHE (`'`),\n * U+002A ASTERISK (`*`), U+002B PLUS SIGN (`+`), U+002D DASH (`-`), U+002F\n * SLASH (`/`), U+003D EQUALS TO (`=`), U+003F QUESTION MARK (`?`), U+005E\n * CARET (`^`) to U+0060 GRAVE ACCENT (`` ` ``), or U+007B LEFT CURLY BRACE\n * (`{`) to U+007E TILDE (`~`).\n *\n * See:\n * **\\[RFC5322]**:\n * [Internet Message Format](https://tools.ietf.org/html/rfc5322).\n * P. Resnick.\n * IETF.\n */\n\nexport const asciiAtext = regexCheck(/[#-'*+\\--9=?A-Z^-~]/);\n/**\n * Check whether a character code is an ASCII control character.\n *\n * An **ASCII control** is a character in the inclusive range U+0000 NULL (NUL)\n * to U+001F (US), or U+007F (DEL).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function asciiControl(code) {\n  return (// Special whitespace codes (which have negative values), C0 and Control\n    // character DEL\n    code !== null && (code < 32 || code === 127)\n  );\n}\n/**\n * Check whether a character code is a markdown line ending (see\n * `markdownLineEnding`) or markdown space (see `markdownSpace`).\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEndingOrSpace(code) {\n  return code !== null && (code < 0 || code === 32);\n}\n/**\n * Check whether a character code is a markdown line ending.\n *\n * A **markdown line ending** is the virtual characters M-0003 CARRIAGE RETURN\n * LINE FEED (CRLF), M-0004 LINE FEED (LF) and M-0005 CARRIAGE RETURN (CR).\n *\n * In micromark, the actual character U+000A LINE FEED (LF) and U+000D CARRIAGE\n * RETURN (CR) are replaced by these virtual characters depending on whether\n * they occurred together.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownLineEnding(code) {\n  return code !== null && code < -2;\n}\n/**\n * Check whether a character code is a markdown space.\n *\n * A **markdown space** is the concrete character U+0020 SPACE (SP) and the\n * virtual characters M-0001 VIRTUAL SPACE (VS) and M-0002 HORIZONTAL TAB (HT).\n *\n * In micromark, the actual character U+0009 CHARACTER TABULATION (HT) is\n * replaced by one M-0002 HORIZONTAL TAB (HT) and between 0 and 3 M-0001 VIRTUAL\n * SPACE (VS) characters, depending on the column at which the tab occurred.\n *\n * @param {Code} code\n * @returns {code is number}\n */\n\nexport function markdownSpace(code) {\n  return code === -2 || code === -1 || code === 32;\n}\n/**\n * Check whether the character code represents Unicode whitespace.\n *\n * Note that this does handle micromark specific markdown whitespace characters.\n * See `markdownLineEndingOrSpace` to check that.\n *\n * A **Unicode whitespace** is a character in the Unicode `Zs` (Separator,\n * Space) category, or U+0009 CHARACTER TABULATION (HT), U+000A LINE FEED (LF),\n * U+000C (FF), or U+000D CARRIAGE RETURN (CR) (**\\[UNICODE]**).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n\nexport const unicodeWhitespace = regexCheck(/\\s/);\n/**\n * Check whether the character code represents Unicode punctuation.\n *\n * A **Unicode punctuation** is a character in the Unicode `Pc` (Punctuation,\n * Connector), `Pd` (Punctuation, Dash), `Pe` (Punctuation, Close), `Pf`\n * (Punctuation, Final quote), `Pi` (Punctuation, Initial quote), `Po`\n * (Punctuation, Other), or `Ps` (Punctuation, Open) categories, or an ASCII\n * punctuation (see `asciiPunctuation`).\n *\n * See:\n * **\\[UNICODE]**:\n * [The Unicode Standard](https://www.unicode.org/versions/).\n * Unicode Consortium.\n */\n// Size note: removing ASCII from the regex and using `asciiPunctuation` here\n// In fact adds to the bundle size.\n\nexport const unicodePunctuation = regexCheck(unicodePunctuationRegex);\n/**\n * Create a code check from a regex.\n *\n * @param {RegExp} regex\n * @returns {(code: Code) => code is number}\n */\n\nfunction regexCheck(regex) {\n  return check;\n  /**\n   * Check whether a code matches the bound regex.\n   *\n   * @param {Code} code Character code\n   * @returns {code is number} Whether the character code matches the bound regex\n   */\n\n  function check(code) {\n    return code !== null && regex.test(String.fromCharCode(code));\n  }\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport { markdownSpace } from 'micromark-util-character';\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {string} type\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n\nexport function factorySpace(effects, ok, type, max) {\n  const limit = max ? max - 1 : Number.POSITIVE_INFINITY;\n  let size = 0;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownSpace(code)) {\n      effects.enter(type);\n      return prefix(code);\n    }\n\n    return ok(code);\n  }\n  /** @type {State} */\n\n\n  function prefix(code) {\n    if (markdownSpace(code) && size++ < limit) {\n      effects.consume(code);\n      return prefix;\n    }\n\n    effects.exit(type);\n    return ok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\n\nexport const content = {\n  tokenize: initializeContent\n};\n/** @type {Initializer} */\n\nfunction initializeContent(effects) {\n  const contentStart = effects.attempt(this.parser.constructs.contentInitial, afterContentStartConstruct, paragraphInitial);\n  /** @type {Token} */\n\n  let previous;\n  return contentStart;\n  /** @type {State} */\n\n  function afterContentStartConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, contentStart, 'linePrefix');\n  }\n  /** @type {State} */\n\n\n  function paragraphInitial(code) {\n    effects.enter('paragraph');\n    return lineStart(code);\n  }\n  /** @type {State} */\n\n\n  function lineStart(code) {\n    const token = effects.enter('chunkText', {\n      contentType: 'text',\n      previous\n    });\n\n    if (previous) {\n      previous.next = token;\n    }\n\n    previous = token;\n    return data(code);\n  }\n  /** @type {State} */\n\n\n  function data(code) {\n    if (code === null) {\n      effects.exit('chunkText');\n      effects.exit('paragraph');\n      effects.consume(code);\n      return;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      effects.exit('chunkText');\n      return lineStart;\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Point} Point\n */\n\n/**\n * @typedef {Record<string, unknown>} StackState\n * @typedef {[Construct, StackState]} StackItem\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {InitialConstruct} */\n\nexport const document = {\n  tokenize: initializeDocument\n};\n/** @type {Construct} */\n\nconst containerConstruct = {\n  tokenize: tokenizeContainer\n};\n/** @type {Initializer} */\n\nfunction initializeDocument(effects) {\n  const self = this;\n  /** @type {StackItem[]} */\n\n  const stack = [];\n  let continued = 0;\n  /** @type {TokenizeContext|undefined} */\n\n  let childFlow;\n  /** @type {Token|undefined} */\n\n  let childToken;\n  /** @type {number} */\n\n  let lineStartOffset;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    // First we iterate through the open blocks, starting with the root\n    // document, and descending through last children down to the last open\n    // block.\n    // Each block imposes a condition that the line must satisfy if the block is\n    // to remain open.\n    // For example, a block quote requires a `>` character.\n    // A paragraph requires a non-blank line.\n    // In this phase we may match all or just some of the open blocks.\n    // But we cannot close unmatched blocks yet, because we may have a lazy\n    // continuation line.\n    if (continued < stack.length) {\n      const item = stack[continued];\n      self.containerState = item[1];\n      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);\n    } // Done.\n\n\n    return checkNewContainers(code);\n  }\n  /** @type {State} */\n\n\n  function documentContinue(code) {\n    continued++; // Note: this field is called `_closeFlow` but it also closes containers.\n    // Perhaps a good idea to rename it but it’s already used in the wild by\n    // extensions.\n\n    if (self.containerState._closeFlow) {\n      self.containerState._closeFlow = undefined;\n\n      if (childFlow) {\n        closeFlow();\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when dealing with lazy lines in `writeToChild`.\n\n\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {Point|undefined} */\n\n      let point; // Find the flow chunk.\n\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === 'chunkFlow') {\n          point = self.events[indexBeforeFlow][1].end;\n          break;\n        }\n      }\n\n      exitContainers(continued); // Fix positions.\n\n      let index = indexBeforeExits;\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point);\n        index++;\n      } // Inject the exits earlier (they’re still also at the end).\n\n\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits)); // Discard the duplicate exits.\n\n      self.events.length = index;\n      return checkNewContainers(code);\n    }\n\n    return start(code);\n  }\n  /** @type {State} */\n\n\n  function checkNewContainers(code) {\n    // Next, after consuming the continuation markers for existing blocks, we\n    // look for new block starts (e.g. `>` for a block quote).\n    // If we encounter a new block start, we close any blocks unmatched in\n    // step 1 before creating the new block as a child of the last matched\n    // block.\n    if (continued === stack.length) {\n      // No need to `check` whether there’s a container, of `exitContainers`\n      // would be moot.\n      // We can instead immediately `attempt` to parse one.\n      if (!childFlow) {\n        return documentContinued(code);\n      } // If we have concrete content, such as block HTML or fenced code,\n      // we can’t have containers “pierce” into them, so we can immediately\n      // start.\n\n\n      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {\n        return flowStart(code);\n      } // If we do have flow, it could still be a blank line,\n      // but we’d be interrupting it w/ a new container if there’s a current\n      // construct.\n\n\n      self.interrupt = Boolean(childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack);\n    } // Check if there is a new container.\n\n\n    self.containerState = {};\n    return effects.check(containerConstruct, thereIsANewContainer, thereIsNoNewContainer)(code);\n  }\n  /** @type {State} */\n\n\n  function thereIsANewContainer(code) {\n    if (childFlow) closeFlow();\n    exitContainers(continued);\n    return documentContinued(code);\n  }\n  /** @type {State} */\n\n\n  function thereIsNoNewContainer(code) {\n    self.parser.lazy[self.now().line] = continued !== stack.length;\n    lineStartOffset = self.now().offset;\n    return flowStart(code);\n  }\n  /** @type {State} */\n\n\n  function documentContinued(code) {\n    // Try new containers.\n    self.containerState = {};\n    return effects.attempt(containerConstruct, containerContinue, flowStart)(code);\n  }\n  /** @type {State} */\n\n\n  function containerContinue(code) {\n    continued++;\n    stack.push([self.currentConstruct, self.containerState]); // Try another.\n\n    return documentContinued(code);\n  }\n  /** @type {State} */\n\n\n  function flowStart(code) {\n    if (code === null) {\n      if (childFlow) closeFlow();\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n\n    childFlow = childFlow || self.parser.flow(self.now());\n    effects.enter('chunkFlow', {\n      contentType: 'flow',\n      previous: childToken,\n      _tokenizer: childFlow\n    });\n    return flowContinue(code);\n  }\n  /** @type {State} */\n\n\n  function flowContinue(code) {\n    if (code === null) {\n      writeToChild(effects.exit('chunkFlow'), true);\n      exitContainers(0);\n      effects.consume(code);\n      return;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.consume(code);\n      writeToChild(effects.exit('chunkFlow')); // Get ready for the next line.\n\n      continued = 0;\n      self.interrupt = undefined;\n      return start;\n    }\n\n    effects.consume(code);\n    return flowContinue;\n  }\n  /**\n   * @param {Token} token\n   * @param {boolean} [eof]\n   * @returns {void}\n   */\n\n\n  function writeToChild(token, eof) {\n    const stream = self.sliceStream(token);\n    if (eof) stream.push(null);\n    token.previous = childToken;\n    if (childToken) childToken.next = token;\n    childToken = token;\n    childFlow.defineSkip(token.start);\n    childFlow.write(stream); // Alright, so we just added a lazy line:\n    //\n    // ```markdown\n    // > a\n    // b.\n    //\n    // Or:\n    //\n    // > ~~~c\n    // d\n    //\n    // Or:\n    //\n    // > | e |\n    // f\n    // ```\n    //\n    // The construct in the second example (fenced code) does not accept lazy\n    // lines, so it marked itself as done at the end of its first line, and\n    // then the content construct parses `d`.\n    // Most constructs in markdown match on the first line: if the first line\n    // forms a construct, a non-lazy line can’t “unmake” it.\n    //\n    // The construct in the third example is potentially a GFM table, and\n    // those are *weird*.\n    // It *could* be a table, from the first line, if the following line\n    // matches a condition.\n    // In this case, that second line is lazy, which “unmakes” the first line\n    // and turns the whole into one content block.\n    //\n    // We’ve now parsed the non-lazy and the lazy line, and can figure out\n    // whether the lazy line started a new flow block.\n    // If it did, we exit the current containers between the two flow blocks.\n\n    if (self.parser.lazy[token.start.line]) {\n      let index = childFlow.events.length;\n\n      while (index--) {\n        if ( // The token starts before the line ending…\n        childFlow.events[index][1].start.offset < lineStartOffset && ( // …and either is not ended yet…\n        !childFlow.events[index][1].end || // …or ends after it.\n        childFlow.events[index][1].end.offset > lineStartOffset)) {\n          // Exit: there’s still something open, which means it’s a lazy line\n          // part of something.\n          return;\n        }\n      } // Note: this algorithm for moving events around is similar to the\n      // algorithm when closing flow in `documentContinue`.\n\n\n      const indexBeforeExits = self.events.length;\n      let indexBeforeFlow = indexBeforeExits;\n      /** @type {boolean|undefined} */\n\n      let seen;\n      /** @type {Point|undefined} */\n\n      let point; // Find the previous chunk (the one before the lazy line).\n\n      while (indexBeforeFlow--) {\n        if (self.events[indexBeforeFlow][0] === 'exit' && self.events[indexBeforeFlow][1].type === 'chunkFlow') {\n          if (seen) {\n            point = self.events[indexBeforeFlow][1].end;\n            break;\n          }\n\n          seen = true;\n        }\n      }\n\n      exitContainers(continued); // Fix positions.\n\n      index = indexBeforeExits;\n\n      while (index < self.events.length) {\n        self.events[index][1].end = Object.assign({}, point);\n        index++;\n      } // Inject the exits earlier (they’re still also at the end).\n\n\n      splice(self.events, indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits)); // Discard the duplicate exits.\n\n      self.events.length = index;\n    }\n  }\n  /**\n   * @param {number} size\n   * @returns {void}\n   */\n\n\n  function exitContainers(size) {\n    let index = stack.length; // Exit open containers.\n\n    while (index-- > size) {\n      const entry = stack[index];\n      self.containerState = entry[1];\n      entry[0].exit.call(self, effects);\n    }\n\n    stack.length = size;\n  }\n\n  function closeFlow() {\n    childFlow.write([null]);\n    childToken = undefined;\n    childFlow = undefined;\n    self.containerState._closeFlow = undefined;\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeContainer(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), 'linePrefix', this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const blankLine = {\n  tokenize: tokenizeBlankLine,\n  partial: true\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeBlankLine(effects, ok, nok) {\n  return factorySpace(effects, afterWhitespace, 'linePrefix');\n  /** @type {State} */\n\n  function afterWhitespace(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport { splice } from 'micromark-util-chunked';\n/**\n * Tokenize subcontent.\n *\n * @param {Event[]} events\n * @returns {boolean}\n */\n\nexport function subtokenize(events) {\n  /** @type {Record<string, number>} */\n  const jumps = {};\n  let index = -1;\n  /** @type {Event} */\n\n  let event;\n  /** @type {number|undefined} */\n\n  let lineIndex;\n  /** @type {number} */\n\n  let otherIndex;\n  /** @type {Event} */\n\n  let otherEvent;\n  /** @type {Event[]} */\n\n  let parameters;\n  /** @type {Event[]} */\n\n  let subevents;\n  /** @type {boolean|undefined} */\n\n  let more;\n\n  while (++index < events.length) {\n    while (index in jumps) {\n      index = jumps[index];\n    }\n\n    event = events[index]; // Add a hook for the GFM tasklist extension, which needs to know if text\n    // is in the first content of a list item.\n\n    if (index && event[1].type === 'chunkFlow' && events[index - 1][1].type === 'listItemPrefix') {\n      subevents = event[1]._tokenizer.events;\n      otherIndex = 0;\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'lineEndingBlank') {\n        otherIndex += 2;\n      }\n\n      if (otherIndex < subevents.length && subevents[otherIndex][1].type === 'content') {\n        while (++otherIndex < subevents.length) {\n          if (subevents[otherIndex][1].type === 'content') {\n            break;\n          }\n\n          if (subevents[otherIndex][1].type === 'chunkText') {\n            subevents[otherIndex][1]._isInFirstContentOfListItem = true;\n            otherIndex++;\n          }\n        }\n      }\n    } // Enter.\n\n\n    if (event[0] === 'enter') {\n      if (event[1].contentType) {\n        Object.assign(jumps, subcontent(events, index));\n        index = jumps[index];\n        more = true;\n      }\n    } // Exit.\n    else if (event[1]._container) {\n      otherIndex = index;\n      lineIndex = undefined;\n\n      while (otherIndex--) {\n        otherEvent = events[otherIndex];\n\n        if (otherEvent[1].type === 'lineEnding' || otherEvent[1].type === 'lineEndingBlank') {\n          if (otherEvent[0] === 'enter') {\n            if (lineIndex) {\n              events[lineIndex][1].type = 'lineEndingBlank';\n            }\n\n            otherEvent[1].type = 'lineEnding';\n            lineIndex = otherIndex;\n          }\n        } else {\n          break;\n        }\n      }\n\n      if (lineIndex) {\n        // Fix position.\n        event[1].end = Object.assign({}, events[lineIndex][1].start); // Switch container exit w/ line endings.\n\n        parameters = events.slice(lineIndex, index);\n        parameters.unshift(event);\n        splice(events, lineIndex, index - lineIndex + 1, parameters);\n      }\n    }\n  }\n\n  return !more;\n}\n/**\n * Tokenize embedded tokens.\n *\n * @param {Event[]} events\n * @param {number} eventIndex\n * @returns {Record<string, number>}\n */\n\nfunction subcontent(events, eventIndex) {\n  const token = events[eventIndex][1];\n  const context = events[eventIndex][2];\n  let startPosition = eventIndex - 1;\n  /** @type {number[]} */\n\n  const startPositions = [];\n  const tokenizer = token._tokenizer || context.parser[token.contentType](token.start);\n  const childEvents = tokenizer.events;\n  /** @type {[number, number][]} */\n\n  const jumps = [];\n  /** @type {Record<string, number>} */\n\n  const gaps = {};\n  /** @type {Chunk[]} */\n\n  let stream;\n  /** @type {Token|undefined} */\n\n  let previous;\n  let index = -1;\n  /** @type {Token|undefined} */\n\n  let current = token;\n  let adjust = 0;\n  let start = 0;\n  const breaks = [start]; // Loop forward through the linked tokens to pass them in order to the\n  // subtokenizer.\n\n  while (current) {\n    // Find the position of the event for this token.\n    while (events[++startPosition][1] !== current) {// Empty.\n    }\n\n    startPositions.push(startPosition);\n\n    if (!current._tokenizer) {\n      stream = context.sliceStream(current);\n\n      if (!current.next) {\n        stream.push(null);\n      }\n\n      if (previous) {\n        tokenizer.defineSkip(current.start);\n      }\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = true;\n      }\n\n      tokenizer.write(stream);\n\n      if (current._isInFirstContentOfListItem) {\n        tokenizer._gfmTasklistFirstContentOfListItem = undefined;\n      }\n    } // Unravel the next token.\n\n\n    previous = current;\n    current = current.next;\n  } // Now, loop back through all events (and linked tokens), to figure out which\n  // parts belong where.\n\n\n  current = token;\n\n  while (++index < childEvents.length) {\n    if ( // Find a void token that includes a break.\n    childEvents[index][0] === 'exit' && childEvents[index - 1][0] === 'enter' && childEvents[index][1].type === childEvents[index - 1][1].type && childEvents[index][1].start.line !== childEvents[index][1].end.line) {\n      start = index + 1;\n      breaks.push(start); // Help GC.\n\n      current._tokenizer = undefined;\n      current.previous = undefined;\n      current = current.next;\n    }\n  } // Help GC.\n\n\n  tokenizer.events = []; // If there’s one more token (which is the cases for lines that end in an\n  // EOF), that’s perfect: the last point we found starts it.\n  // If there isn’t then make sure any remaining content is added to it.\n\n  if (current) {\n    // Help GC.\n    current._tokenizer = undefined;\n    current.previous = undefined;\n  } else {\n    breaks.pop();\n  } // Now splice the events from the subtokenizer into the current events,\n  // moving back to front so that splice indices aren’t affected.\n\n\n  index = breaks.length;\n\n  while (index--) {\n    const slice = childEvents.slice(breaks[index], breaks[index + 1]);\n    const start = startPositions.pop();\n    jumps.unshift([start, start + slice.length - 1]);\n    splice(events, start, 2, slice);\n  }\n\n  index = -1;\n\n  while (++index < jumps.length) {\n    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1];\n    adjust += jumps[index][1] - jumps[index][0] - 1;\n  }\n\n  return gaps;\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * No name because it must not be turned off.\n * @type {Construct}\n */\n\nexport const content = {\n  tokenize: tokenizeContent,\n  resolve: resolveContent\n};\n/** @type {Construct} */\n\nconst continuationConstruct = {\n  tokenize: tokenizeContinuation,\n  partial: true\n};\n/**\n * Content is transparent: it’s parsed right now. That way, definitions are also\n * parsed right now: before text in paragraphs (specifically, media) are parsed.\n *\n * @type {Resolver}\n */\n\nfunction resolveContent(events) {\n  subtokenize(events);\n  return events;\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeContent(effects, ok) {\n  /** @type {Token} */\n  let previous;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('content');\n    previous = effects.enter('chunkContent', {\n      contentType: 'content'\n    });\n    return data(code);\n  }\n  /** @type {State} */\n\n\n  function data(code) {\n    if (code === null) {\n      return contentEnd(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.check(continuationConstruct, contentContinue, contentEnd)(code);\n    } // Data.\n\n\n    effects.consume(code);\n    return data;\n  }\n  /** @type {State} */\n\n\n  function contentEnd(code) {\n    effects.exit('chunkContent');\n    effects.exit('content');\n    return ok(code);\n  }\n  /** @type {State} */\n\n\n  function contentContinue(code) {\n    effects.consume(code);\n    effects.exit('chunkContent');\n    previous.next = effects.enter('chunkContent', {\n      contentType: 'content',\n      previous\n    });\n    previous = previous.next;\n    return data;\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeContinuation(effects, ok, nok) {\n  const self = this;\n  return startLookahead;\n  /** @type {State} */\n\n  function startLookahead(code) {\n    effects.exit('chunkContent');\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, prefixed, 'linePrefix');\n  }\n  /** @type {State} */\n\n\n  function prefixed(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    const tail = self.events[self.events.length - 1];\n\n    if (!self.parser.constructs.disable.null.includes('codeIndented') && tail && tail[1].type === 'linePrefix' && tail[2].sliceSerialize(tail[1], true).length >= 4) {\n      return ok(code);\n    }\n\n    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { blankLine, content } from 'micromark-core-commonmark';\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {InitialConstruct} */\n\nexport const flow = {\n  tokenize: initializeFlow\n};\n/** @type {Initializer} */\n\nfunction initializeFlow(effects) {\n  const self = this;\n  const initial = effects.attempt( // Try to parse a blank line.\n  blankLine, atBlankEnding, // Try to parse initial flow (essentially, only code).\n  effects.attempt(this.parser.constructs.flowInitial, afterConstruct, factorySpace(effects, effects.attempt(this.parser.constructs.flow, afterConstruct, effects.attempt(content, afterConstruct)), 'linePrefix')));\n  return initial;\n  /** @type {State} */\n\n  function atBlankEnding(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n  /** @type {State} */\n\n\n  function afterConstruct(code) {\n    if (code === null) {\n      effects.consume(code);\n      return;\n    }\n\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    self.currentConstruct = undefined;\n    return initial;\n  }\n}","/**\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Initializer} Initializer\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nexport const resolver = {\n  resolveAll: createResolver()\n};\nexport const string = initializeFactory('string');\nexport const text = initializeFactory('text');\n/**\n * @param {'string'|'text'} field\n * @returns {InitialConstruct}\n */\n\nfunction initializeFactory(field) {\n  return {\n    tokenize: initializeText,\n    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined)\n  };\n  /** @type {Initializer} */\n\n  function initializeText(effects) {\n    const self = this;\n    const constructs = this.parser.constructs[field];\n    const text = effects.attempt(constructs, start, notText);\n    return start;\n    /** @type {State} */\n\n    function start(code) {\n      return atBreak(code) ? text(code) : notText(code);\n    }\n    /** @type {State} */\n\n\n    function notText(code) {\n      if (code === null) {\n        effects.consume(code);\n        return;\n      }\n\n      effects.enter('data');\n      effects.consume(code);\n      return data;\n    }\n    /** @type {State} */\n\n\n    function data(code) {\n      if (atBreak(code)) {\n        effects.exit('data');\n        return text(code);\n      } // Data.\n\n\n      effects.consume(code);\n      return data;\n    }\n    /**\n     * @param {Code} code\n     * @returns {boolean}\n     */\n\n\n    function atBreak(code) {\n      if (code === null) {\n        return true;\n      }\n\n      const list = constructs[code];\n      let index = -1;\n\n      if (list) {\n        while (++index < list.length) {\n          const item = list[index];\n\n          if (!item.previous || item.previous.call(self, self.previous)) {\n            return true;\n          }\n        }\n      }\n\n      return false;\n    }\n  }\n}\n/**\n * @param {Resolver} [extraResolver]\n * @returns {Resolver}\n */\n\n\nfunction createResolver(extraResolver) {\n  return resolveAllText;\n  /** @type {Resolver} */\n\n  function resolveAllText(events, context) {\n    let index = -1;\n    /** @type {number|undefined} */\n\n    let enter; // A rather boring computation (to merge adjacent `data` events) which\n    // improves mm performance by 29%.\n\n    while (++index <= events.length) {\n      if (enter === undefined) {\n        if (events[index] && events[index][1].type === 'data') {\n          enter = index;\n          index++;\n        }\n      } else if (!events[index] || events[index][1].type !== 'data') {\n        // Don’t do anything if there is one data token.\n        if (index !== enter + 2) {\n          events[enter][1].end = events[index - 1][1].end;\n          events.splice(enter + 2, index - enter - 2);\n          index = enter + 2;\n        }\n\n        enter = undefined;\n      }\n    }\n\n    return extraResolver ? extraResolver(events, context) : events;\n  }\n}\n/**\n * A rather ugly set of instructions which again looks at chunks in the input\n * stream.\n * The reason to do this here is that it is *much* faster to parse in reverse.\n * And that we can’t hook into `null` to split the line suffix before an EOF.\n * To do: figure out if we can make this into a clean utility, or even in core.\n * As it will be useful for GFMs literal autolink extension (and maybe even\n * tables?)\n *\n * @type {Resolver}\n */\n\n\nfunction resolveAllLineSuffixes(events, context) {\n  let eventIndex = 0; // Skip first.\n\n  while (++eventIndex <= events.length) {\n    if ((eventIndex === events.length || events[eventIndex][1].type === 'lineEnding') && events[eventIndex - 1][1].type === 'data') {\n      const data = events[eventIndex - 1][1];\n      const chunks = context.sliceStream(data);\n      let index = chunks.length;\n      let bufferIndex = -1;\n      let size = 0;\n      /** @type {boolean|undefined} */\n\n      let tabs;\n\n      while (index--) {\n        const chunk = chunks[index];\n\n        if (typeof chunk === 'string') {\n          bufferIndex = chunk.length;\n\n          while (chunk.charCodeAt(bufferIndex - 1) === 32) {\n            size++;\n            bufferIndex--;\n          }\n\n          if (bufferIndex) break;\n          bufferIndex = -1;\n        } // Number\n        else if (chunk === -2) {\n          tabs = true;\n          size++;\n        } else if (chunk === -1) {// Empty\n        } else {\n          // Replacement character, exit.\n          index++;\n          break;\n        }\n      }\n\n      if (size) {\n        const token = {\n          type: eventIndex === events.length || tabs || size < 2 ? 'lineSuffix' : 'hardBreakTrailing',\n          start: {\n            line: data.end.line,\n            column: data.end.column - size,\n            offset: data.end.offset - size,\n            _index: data.start._index + index,\n            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex\n          },\n          end: Object.assign({}, data.end)\n        };\n        data.end = Object.assign({}, token.start);\n\n        if (data.start.offset === data.end.offset) {\n          Object.assign(data, token);\n        } else {\n          events.splice(eventIndex, 0, ['enter', token, context], ['exit', token, context]);\n          eventIndex += 2;\n        }\n      }\n\n      eventIndex++;\n    }\n  }\n\n  return events;\n}","/**\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Resolver} Resolver\n */\n\n/**\n * Call all `resolveAll`s.\n *\n * @param {{resolveAll?: Resolver}[]} constructs\n * @param {Event[]} events\n * @param {TokenizeContext} context\n * @returns {Event[]}\n */\nexport function resolveAll(constructs, events, context) {\n  /** @type {Resolver[]} */\n  const called = [];\n  let index = -1;\n\n  while (++index < constructs.length) {\n    const resolve = constructs[index].resolveAll;\n\n    if (resolve && !called.includes(resolve)) {\n      events = resolve(events, context);\n      called.push(resolve);\n    }\n  }\n\n  return events;\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Point} Point\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').ConstructRecord} ConstructRecord\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n */\n\n/**\n * @typedef Info\n * @property {() => void} restore\n * @property {number} from\n *\n * @callback ReturnHandle\n *   Handle a successful run.\n * @param {Construct} construct\n * @param {Info} info\n * @returns {void}\n */\nimport { markdownLineEnding } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/**\n * Create a tokenizer.\n * Tokenizers deal with one type of data (e.g., containers, flow, text).\n * The parser is the object dealing with it all.\n * `initialize` works like other constructs, except that only its `tokenize`\n * function is used, in which case it doesn’t receive an `ok` or `nok`.\n * `from` can be given to set the point before the first character, although\n * when further lines are indented, they must be set with `defineSkip`.\n *\n * @param {ParseContext} parser\n * @param {InitialConstruct} initialize\n * @param {Omit<Point, '_index'|'_bufferIndex'>} [from]\n * @returns {TokenizeContext}\n */\n\nexport function createTokenizer(parser, initialize, from) {\n  /** @type {Point} */\n  let point = Object.assign(from ? Object.assign({}, from) : {\n    line: 1,\n    column: 1,\n    offset: 0\n  }, {\n    _index: 0,\n    _bufferIndex: -1\n  });\n  /** @type {Record<string, number>} */\n\n  const columnStart = {};\n  /** @type {Construct[]} */\n\n  const resolveAllConstructs = [];\n  /** @type {Chunk[]} */\n\n  let chunks = [];\n  /** @type {Token[]} */\n\n  let stack = [];\n  /** @type {boolean|undefined} */\n\n  let consumed = true;\n  /**\n   * Tools used for tokenizing.\n   *\n   * @type {Effects}\n   */\n\n  const effects = {\n    consume,\n    enter,\n    exit,\n    attempt: constructFactory(onsuccessfulconstruct),\n    check: constructFactory(onsuccessfulcheck),\n    interrupt: constructFactory(onsuccessfulcheck, {\n      interrupt: true\n    })\n  };\n  /**\n   * State and tools for resolving and serializing.\n   *\n   * @type {TokenizeContext}\n   */\n\n  const context = {\n    previous: null,\n    code: null,\n    containerState: {},\n    events: [],\n    parser,\n    sliceStream,\n    sliceSerialize,\n    now,\n    defineSkip,\n    write\n  };\n  /**\n   * The state function.\n   *\n   * @type {State|void}\n   */\n\n  let state = initialize.tokenize.call(context, effects);\n  /**\n   * Track which character we expect to be consumed, to catch bugs.\n   *\n   * @type {Code}\n   */\n\n  let expectedCode;\n\n  if (initialize.resolveAll) {\n    resolveAllConstructs.push(initialize);\n  }\n\n  return context;\n  /** @type {TokenizeContext['write']} */\n\n  function write(slice) {\n    chunks = push(chunks, slice);\n    main(); // Exit if we’re not done, resolve might change stuff.\n\n    if (chunks[chunks.length - 1] !== null) {\n      return [];\n    }\n\n    addResult(initialize, 0); // Otherwise, resolve, and exit.\n\n    context.events = resolveAll(resolveAllConstructs, context.events, context);\n    return context.events;\n  } //\n  // Tools.\n  //\n\n  /** @type {TokenizeContext['sliceSerialize']} */\n\n\n  function sliceSerialize(token, expandTabs) {\n    return serializeChunks(sliceStream(token), expandTabs);\n  }\n  /** @type {TokenizeContext['sliceStream']} */\n\n\n  function sliceStream(token) {\n    return sliceChunks(chunks, token);\n  }\n  /** @type {TokenizeContext['now']} */\n\n\n  function now() {\n    return Object.assign({}, point);\n  }\n  /** @type {TokenizeContext['defineSkip']} */\n\n\n  function defineSkip(value) {\n    columnStart[value.line] = value.column;\n    accountForPotentialSkip();\n  } //\n  // State management.\n  //\n\n  /**\n   * Main loop (note that `_index` and `_bufferIndex` in `point` are modified by\n   * `consume`).\n   * Here is where we walk through the chunks, which either include strings of\n   * several characters, or numerical character codes.\n   * The reason to do this in a loop instead of a call is so the stack can\n   * drain.\n   *\n   * @returns {void}\n   */\n\n\n  function main() {\n    /** @type {number} */\n    let chunkIndex;\n\n    while (point._index < chunks.length) {\n      const chunk = chunks[point._index]; // If we’re in a buffer chunk, loop through it.\n\n      if (typeof chunk === 'string') {\n        chunkIndex = point._index;\n\n        if (point._bufferIndex < 0) {\n          point._bufferIndex = 0;\n        }\n\n        while (point._index === chunkIndex && point._bufferIndex < chunk.length) {\n          go(chunk.charCodeAt(point._bufferIndex));\n        }\n      } else {\n        go(chunk);\n      }\n    }\n  }\n  /**\n   * Deal with one code.\n   *\n   * @param {Code} code\n   * @returns {void}\n   */\n\n\n  function go(code) {\n    consumed = undefined;\n    expectedCode = code;\n    state = state(code);\n  }\n  /** @type {Effects['consume']} */\n\n\n  function consume(code) {\n    if (markdownLineEnding(code)) {\n      point.line++;\n      point.column = 1;\n      point.offset += code === -3 ? 2 : 1;\n      accountForPotentialSkip();\n    } else if (code !== -1) {\n      point.column++;\n      point.offset++;\n    } // Not in a string chunk.\n\n\n    if (point._bufferIndex < 0) {\n      point._index++;\n    } else {\n      point._bufferIndex++; // At end of string chunk.\n      // @ts-expect-error Points w/ non-negative `_bufferIndex` reference\n      // strings.\n\n      if (point._bufferIndex === chunks[point._index].length) {\n        point._bufferIndex = -1;\n        point._index++;\n      }\n    } // Expose the previous character.\n\n\n    context.previous = code; // Mark as consumed.\n\n    consumed = true;\n  }\n  /** @type {Effects['enter']} */\n\n\n  function enter(type, fields) {\n    /** @type {Token} */\n    // @ts-expect-error Patch instead of assign required fields to help GC.\n    const token = fields || {};\n    token.type = type;\n    token.start = now();\n    context.events.push(['enter', token, context]);\n    stack.push(token);\n    return token;\n  }\n  /** @type {Effects['exit']} */\n\n\n  function exit(type) {\n    const token = stack.pop();\n    token.end = now();\n    context.events.push(['exit', token, context]);\n    return token;\n  }\n  /**\n   * Use results.\n   *\n   * @type {ReturnHandle}\n   */\n\n\n  function onsuccessfulconstruct(construct, info) {\n    addResult(construct, info.from);\n  }\n  /**\n   * Discard results.\n   *\n   * @type {ReturnHandle}\n   */\n\n\n  function onsuccessfulcheck(_, info) {\n    info.restore();\n  }\n  /**\n   * Factory to attempt/check/interrupt.\n   *\n   * @param {ReturnHandle} onreturn\n   * @param {Record<string, unknown>} [fields]\n   */\n\n\n  function constructFactory(onreturn, fields) {\n    return hook;\n    /**\n     * Handle either an object mapping codes to constructs, a list of\n     * constructs, or a single construct.\n     *\n     * @param {Construct|Construct[]|ConstructRecord} constructs\n     * @param {State} returnState\n     * @param {State} [bogusState]\n     * @returns {State}\n     */\n\n    function hook(constructs, returnState, bogusState) {\n      /** @type {Construct[]} */\n      let listOfConstructs;\n      /** @type {number} */\n\n      let constructIndex;\n      /** @type {Construct} */\n\n      let currentConstruct;\n      /** @type {Info} */\n\n      let info;\n      return Array.isArray(constructs) ?\n      /* c8 ignore next 1 */\n      handleListOfConstructs(constructs) : 'tokenize' in constructs // @ts-expect-error Looks like a construct.\n      ? handleListOfConstructs([constructs]) : handleMapOfConstructs(constructs);\n      /**\n       * Handle a list of construct.\n       *\n       * @param {ConstructRecord} map\n       * @returns {State}\n       */\n\n      function handleMapOfConstructs(map) {\n        return start;\n        /** @type {State} */\n\n        function start(code) {\n          const def = code !== null && map[code];\n          const all = code !== null && map.null;\n          const list = [// To do: add more extension tests.\n\n          /* c8 ignore next 2 */\n          ...(Array.isArray(def) ? def : def ? [def] : []), ...(Array.isArray(all) ? all : all ? [all] : [])];\n          return handleListOfConstructs(list)(code);\n        }\n      }\n      /**\n       * Handle a list of construct.\n       *\n       * @param {Construct[]} list\n       * @returns {State}\n       */\n\n\n      function handleListOfConstructs(list) {\n        listOfConstructs = list;\n        constructIndex = 0;\n\n        if (list.length === 0) {\n          return bogusState;\n        }\n\n        return handleConstruct(list[constructIndex]);\n      }\n      /**\n       * Handle a single construct.\n       *\n       * @param {Construct} construct\n       * @returns {State}\n       */\n\n\n      function handleConstruct(construct) {\n        return start;\n        /** @type {State} */\n\n        function start(code) {\n          // To do: not needed to store if there is no bogus state, probably?\n          // Currently doesn’t work because `inspect` in document does a check\n          // w/o a bogus, which doesn’t make sense. But it does seem to help perf\n          // by not storing.\n          info = store();\n          currentConstruct = construct;\n\n          if (!construct.partial) {\n            context.currentConstruct = construct;\n          }\n\n          if (construct.name && context.parser.constructs.disable.null.includes(construct.name)) {\n            return nok(code);\n          }\n\n          return construct.tokenize.call( // If we do have fields, create an object w/ `context` as its\n          // prototype.\n          // This allows a “live binding”, which is needed for `interrupt`.\n          fields ? Object.assign(Object.create(context), fields) : context, effects, ok, nok)(code);\n        }\n      }\n      /** @type {State} */\n\n\n      function ok(code) {\n        consumed = true;\n        onreturn(currentConstruct, info);\n        return returnState;\n      }\n      /** @type {State} */\n\n\n      function nok(code) {\n        consumed = true;\n        info.restore();\n\n        if (++constructIndex < listOfConstructs.length) {\n          return handleConstruct(listOfConstructs[constructIndex]);\n        }\n\n        return bogusState;\n      }\n    }\n  }\n  /**\n   * @param {Construct} construct\n   * @param {number} from\n   * @returns {void}\n   */\n\n\n  function addResult(construct, from) {\n    if (construct.resolveAll && !resolveAllConstructs.includes(construct)) {\n      resolveAllConstructs.push(construct);\n    }\n\n    if (construct.resolve) {\n      splice(context.events, from, context.events.length - from, construct.resolve(context.events.slice(from), context));\n    }\n\n    if (construct.resolveTo) {\n      context.events = construct.resolveTo(context.events, context);\n    }\n  }\n  /**\n   * Store state.\n   *\n   * @returns {Info}\n   */\n\n\n  function store() {\n    const startPoint = now();\n    const startPrevious = context.previous;\n    const startCurrentConstruct = context.currentConstruct;\n    const startEventsIndex = context.events.length;\n    const startStack = Array.from(stack);\n    return {\n      restore,\n      from: startEventsIndex\n    };\n    /**\n     * Restore state.\n     *\n     * @returns {void}\n     */\n\n    function restore() {\n      point = startPoint;\n      context.previous = startPrevious;\n      context.currentConstruct = startCurrentConstruct;\n      context.events.length = startEventsIndex;\n      stack = startStack;\n      accountForPotentialSkip();\n    }\n  }\n  /**\n   * Move the current point a bit forward in the line when it’s on a column\n   * skip.\n   *\n   * @returns {void}\n   */\n\n\n  function accountForPotentialSkip() {\n    if (point.line in columnStart && point.column < 2) {\n      point.column = columnStart[point.line];\n      point.offset += columnStart[point.line] - 1;\n    }\n  }\n}\n/**\n * Get the chunks from a slice of chunks in the range of a token.\n *\n * @param {Chunk[]} chunks\n * @param {Pick<Token, 'start'|'end'>} token\n * @returns {Chunk[]}\n */\n\nfunction sliceChunks(chunks, token) {\n  const startIndex = token.start._index;\n  const startBufferIndex = token.start._bufferIndex;\n  const endIndex = token.end._index;\n  const endBufferIndex = token.end._bufferIndex;\n  /** @type {Chunk[]} */\n\n  let view;\n\n  if (startIndex === endIndex) {\n    // @ts-expect-error `_bufferIndex` is used on string chunks.\n    view = [chunks[startIndex].slice(startBufferIndex, endBufferIndex)];\n  } else {\n    view = chunks.slice(startIndex, endIndex);\n\n    if (startBufferIndex > -1) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view[0] = view[0].slice(startBufferIndex);\n    }\n\n    if (endBufferIndex > 0) {\n      // @ts-expect-error `_bufferIndex` is used on string chunks.\n      view.push(chunks[endIndex].slice(0, endBufferIndex));\n    }\n  }\n\n  return view;\n}\n/**\n * Get the string value of a slice of chunks.\n *\n * @param {Chunk[]} chunks\n * @param {boolean} [expandTabs=false]\n * @returns {string}\n */\n\n\nfunction serializeChunks(chunks, expandTabs) {\n  let index = -1;\n  /** @type {string[]} */\n\n  const result = [];\n  /** @type {boolean|undefined} */\n\n  let atTab;\n\n  while (++index < chunks.length) {\n    const chunk = chunks[index];\n    /** @type {string} */\n\n    let value;\n\n    if (typeof chunk === 'string') {\n      value = chunk;\n    } else switch (chunk) {\n      case -5:\n        {\n          value = '\\r';\n          break;\n        }\n\n      case -4:\n        {\n          value = '\\n';\n          break;\n        }\n\n      case -3:\n        {\n          value = '\\r' + '\\n';\n          break;\n        }\n\n      case -2:\n        {\n          value = expandTabs ? ' ' : '\\t';\n          break;\n        }\n\n      case -1:\n        {\n          if (!expandTabs && atTab) continue;\n          value = ' ';\n          break;\n        }\n\n      default:\n        {\n          // Currently only replacement character.\n          value = String.fromCharCode(chunk);\n        }\n    }\n\n    atTab = chunk === -2;\n    result.push(value);\n  }\n\n  return result.join('');\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const thematicBreak = {\n  name: 'thematicBreak',\n  tokenize: tokenizeThematicBreak\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeThematicBreak(effects, ok, nok) {\n  let size = 0;\n  /** @type {NonNullable<Code>} */\n\n  let marker;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('thematicBreak');\n    marker = code;\n    return atBreak(code);\n  }\n  /** @type {State} */\n\n\n  function atBreak(code) {\n    if (code === marker) {\n      effects.enter('thematicBreakSequence');\n      return sequence(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, atBreak, 'whitespace')(code);\n    }\n\n    if (size < 3 || code !== null && !markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.exit('thematicBreak');\n    return ok(code);\n  }\n  /** @type {State} */\n\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      size++;\n      return sequence;\n    }\n\n    effects.exit('thematicBreakSequence');\n    return atBreak(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @typedef {Record<string, unknown> & {marker: Code, type: string, size: number}} ListContainerState\n * @typedef {TokenizeContext & {containerState: ListContainerState}} TokenizeContextWithState\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiDigit, markdownSpace } from 'micromark-util-character';\nimport { blankLine } from './blank-line.js';\nimport { thematicBreak } from './thematic-break.js';\n/** @type {Construct} */\n\nexport const list = {\n  name: 'list',\n  tokenize: tokenizeListStart,\n  continuation: {\n    tokenize: tokenizeListContinuation\n  },\n  exit: tokenizeListEnd\n};\n/** @type {Construct} */\n\nconst listItemPrefixWhitespaceConstruct = {\n  tokenize: tokenizeListItemPrefixWhitespace,\n  partial: true\n};\n/** @type {Construct} */\n\nconst indentConstruct = {\n  tokenize: tokenizeIndent,\n  partial: true\n};\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\nfunction tokenizeListStart(effects, ok, nok) {\n  const self = this;\n  const tail = self.events[self.events.length - 1];\n  let initialSize = tail && tail[1].type === 'linePrefix' ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let size = 0;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    const kind = self.containerState.type || (code === 42 || code === 43 || code === 45 ? 'listUnordered' : 'listOrdered');\n\n    if (kind === 'listUnordered' ? !self.containerState.marker || code === self.containerState.marker : asciiDigit(code)) {\n      if (!self.containerState.type) {\n        self.containerState.type = kind;\n        effects.enter(kind, {\n          _container: true\n        });\n      }\n\n      if (kind === 'listUnordered') {\n        effects.enter('listItemPrefix');\n        return code === 42 || code === 45 ? effects.check(thematicBreak, nok, atMarker)(code) : atMarker(code);\n      }\n\n      if (!self.interrupt || code === 49) {\n        effects.enter('listItemPrefix');\n        effects.enter('listItemValue');\n        return inside(code);\n      }\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function inside(code) {\n    if (asciiDigit(code) && ++size < 10) {\n      effects.consume(code);\n      return inside;\n    }\n\n    if ((!self.interrupt || size < 2) && (self.containerState.marker ? code === self.containerState.marker : code === 41 || code === 46)) {\n      effects.exit('listItemValue');\n      return atMarker(code);\n    }\n\n    return nok(code);\n  }\n  /**\n   * @type {State}\n   **/\n\n\n  function atMarker(code) {\n    effects.enter('listItemMarker');\n    effects.consume(code);\n    effects.exit('listItemMarker');\n    self.containerState.marker = self.containerState.marker || code;\n    return effects.check(blankLine, // Can’t be empty when interrupting.\n    self.interrupt ? nok : onBlank, effects.attempt(listItemPrefixWhitespaceConstruct, endOfPrefix, otherPrefix));\n  }\n  /** @type {State} */\n\n\n  function onBlank(code) {\n    self.containerState.initialBlankLine = true;\n    initialSize++;\n    return endOfPrefix(code);\n  }\n  /** @type {State} */\n\n\n  function otherPrefix(code) {\n    if (markdownSpace(code)) {\n      effects.enter('listItemPrefixWhitespace');\n      effects.consume(code);\n      effects.exit('listItemPrefixWhitespace');\n      return endOfPrefix;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function endOfPrefix(code) {\n    self.containerState.size = initialSize + self.sliceSerialize(effects.exit('listItemPrefix'), true).length;\n    return ok(code);\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\n\nfunction tokenizeListContinuation(effects, ok, nok) {\n  const self = this;\n  self.containerState._closeFlow = undefined;\n  return effects.check(blankLine, onBlank, notBlank);\n  /** @type {State} */\n\n  function onBlank(code) {\n    self.containerState.furtherBlankLines = self.containerState.furtherBlankLines || self.containerState.initialBlankLine; // We have a blank line.\n    // Still, try to consume at most the items size.\n\n    return factorySpace(effects, ok, 'listItemIndent', self.containerState.size + 1)(code);\n  }\n  /** @type {State} */\n\n\n  function notBlank(code) {\n    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {\n      self.containerState.furtherBlankLines = undefined;\n      self.containerState.initialBlankLine = undefined;\n      return notInCurrentItem(code);\n    }\n\n    self.containerState.furtherBlankLines = undefined;\n    self.containerState.initialBlankLine = undefined;\n    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code);\n  }\n  /** @type {State} */\n\n\n  function notInCurrentItem(code) {\n    // While we do continue, we signal that the flow should be closed.\n    self.containerState._closeFlow = true; // As we’re closing flow, we’re no longer interrupting.\n\n    self.interrupt = undefined;\n    return factorySpace(effects, effects.attempt(list, ok, nok), 'linePrefix', self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code);\n  }\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\n\nfunction tokenizeIndent(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, 'listItemIndent', self.containerState.size + 1);\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'listItemIndent' && tail[2].sliceSerialize(tail[1], true).length === self.containerState.size ? ok(code) : nok(code);\n  }\n}\n/**\n * @type {Exiter}\n * @this {TokenizeContextWithState}\n */\n\n\nfunction tokenizeListEnd(effects) {\n  effects.exit(this.containerState.type);\n}\n/**\n * @type {Tokenizer}\n * @this {TokenizeContextWithState}\n */\n\n\nfunction tokenizeListItemPrefixWhitespace(effects, ok, nok) {\n  const self = this;\n  return factorySpace(effects, afterPrefix, 'listItemPrefixWhitespace', self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4 + 1);\n  /** @type {State} */\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return !markdownSpace(code) && tail && tail[1].type === 'listItemPrefixWhitespace' ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Exiter} Exiter\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const blockQuote = {\n  name: 'blockQuote',\n  tokenize: tokenizeBlockQuoteStart,\n  continuation: {\n    tokenize: tokenizeBlockQuoteContinuation\n  },\n  exit\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeBlockQuoteStart(effects, ok, nok) {\n  const self = this;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 62) {\n      const state = self.containerState;\n\n      if (!state.open) {\n        effects.enter('blockQuote', {\n          _container: true\n        });\n        state.open = true;\n      }\n\n      effects.enter('blockQuotePrefix');\n      effects.enter('blockQuoteMarker');\n      effects.consume(code);\n      effects.exit('blockQuoteMarker');\n      return after;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function after(code) {\n    if (markdownSpace(code)) {\n      effects.enter('blockQuotePrefixWhitespace');\n      effects.consume(code);\n      effects.exit('blockQuotePrefixWhitespace');\n      effects.exit('blockQuotePrefix');\n      return ok;\n    }\n\n    effects.exit('blockQuotePrefix');\n    return ok(code);\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeBlockQuoteContinuation(effects, ok, nok) {\n  return factorySpace(effects, effects.attempt(blockQuote, ok, nok), 'linePrefix', this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n}\n/** @type {Exiter} */\n\n\nfunction exit(effects) {\n  effects.exit('blockQuote');\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport { asciiControl, markdownLineEndingOrSpace, markdownLineEnding } from 'micromark-util-character';\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} literalType\n * @param {string} literalMarkerType\n * @param {string} rawType\n * @param {string} stringType\n * @param {number} [max=Infinity]\n * @returns {State}\n */\n// eslint-disable-next-line max-params\n\nexport function factoryDestination(effects, ok, nok, type, literalType, literalMarkerType, rawType, stringType, max) {\n  const limit = max || Number.POSITIVE_INFINITY;\n  let balance = 0;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    if (code === 60) {\n      effects.enter(type);\n      effects.enter(literalType);\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      return destinationEnclosedBefore;\n    }\n\n    if (code === null || code === 41 || asciiControl(code)) {\n      return nok(code);\n    }\n\n    effects.enter(type);\n    effects.enter(rawType);\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationRaw(code);\n  }\n  /** @type {State} */\n\n\n  function destinationEnclosedBefore(code) {\n    if (code === 62) {\n      effects.enter(literalMarkerType);\n      effects.consume(code);\n      effects.exit(literalMarkerType);\n      effects.exit(literalType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return destinationEnclosed(code);\n  }\n  /** @type {State} */\n\n\n  function destinationEnclosed(code) {\n    if (code === 62) {\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      return destinationEnclosedBefore(code);\n    }\n\n    if (code === null || code === 60 || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? destinationEnclosedEscape : destinationEnclosed;\n  }\n  /** @type {State} */\n\n\n  function destinationEnclosedEscape(code) {\n    if (code === 60 || code === 62 || code === 92) {\n      effects.consume(code);\n      return destinationEnclosed;\n    }\n\n    return destinationEnclosed(code);\n  }\n  /** @type {State} */\n\n\n  function destinationRaw(code) {\n    if (code === 40) {\n      if (++balance > limit) return nok(code);\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === 41) {\n      if (!balance--) {\n        effects.exit('chunkString');\n        effects.exit(stringType);\n        effects.exit(rawType);\n        effects.exit(type);\n        return ok(code);\n      }\n\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      if (balance) return nok(code);\n      effects.exit('chunkString');\n      effects.exit(stringType);\n      effects.exit(rawType);\n      effects.exit(type);\n      return ok(code);\n    }\n\n    if (asciiControl(code)) return nok(code);\n    effects.consume(code);\n    return code === 92 ? destinationRawEscape : destinationRaw;\n  }\n  /** @type {State} */\n\n\n  function destinationRawEscape(code) {\n    if (code === 40 || code === 41 || code === 92) {\n      effects.consume(code);\n      return destinationRaw;\n    }\n\n    return destinationRaw(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').State} State\n */\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * @this {TokenizeContext}\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\n\nexport function factoryLabel(effects, ok, nok, type, markerType, stringType) {\n  const self = this;\n  let size = 0;\n  /** @type {boolean} */\n\n  let data;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    effects.enter(stringType);\n    return atBreak;\n  }\n  /** @type {State} */\n\n\n  function atBreak(code) {\n    if (code === null || code === 91 || code === 93 && !data ||\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook */\n\n    /* c8 ignore next 3 */\n    code === 94 && !size && '_hiddenFootnoteSupport' in self.parser.constructs || size > 999) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.exit(stringType);\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return atBreak;\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return label(code);\n  }\n  /** @type {State} */\n\n\n  function label(code) {\n    if (code === null || code === 91 || code === 93 || markdownLineEnding(code) || size++ > 999) {\n      effects.exit('chunkString');\n      return atBreak(code);\n    }\n\n    effects.consume(code);\n    data = data || !markdownSpace(code);\n    return code === 92 ? labelEscape : label;\n  }\n  /** @type {State} */\n\n\n  function labelEscape(code) {\n    if (code === 91 || code === 92 || code === 93) {\n      effects.consume(code);\n      size++;\n      return label;\n    }\n\n    return label(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/**\n * @param {Effects} effects\n * @param {State} ok\n * @param {State} nok\n * @param {string} type\n * @param {string} markerType\n * @param {string} stringType\n * @returns {State}\n */\n// eslint-disable-next-line max-params\n\nexport function factoryTitle(effects, ok, nok, type, markerType, stringType) {\n  /** @type {NonNullable<Code>} */\n  let marker;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter(type);\n    effects.enter(markerType);\n    effects.consume(code);\n    effects.exit(markerType);\n    marker = code === 40 ? 41 : code;\n    return atFirstTitleBreak;\n  }\n  /** @type {State} */\n\n\n  function atFirstTitleBreak(code) {\n    if (code === marker) {\n      effects.enter(markerType);\n      effects.consume(code);\n      effects.exit(markerType);\n      effects.exit(type);\n      return ok;\n    }\n\n    effects.enter(stringType);\n    return atTitleBreak(code);\n  }\n  /** @type {State} */\n\n\n  function atTitleBreak(code) {\n    if (code === marker) {\n      effects.exit(stringType);\n      return atFirstTitleBreak(marker);\n    }\n\n    if (code === null) {\n      return nok(code);\n    } // Note: blank lines can’t exist in content.\n\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return factorySpace(effects, atTitleBreak, 'linePrefix');\n    }\n\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return title(code);\n  }\n  /** @type {State} */\n\n\n  function title(code) {\n    if (code === marker || code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      return atTitleBreak(code);\n    }\n\n    effects.consume(code);\n    return code === 92 ? titleEscape : title;\n  }\n  /** @type {State} */\n\n\n  function titleEscape(code) {\n    if (code === marker || code === 92) {\n      effects.consume(code);\n      return title;\n    }\n\n    return title(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Effects} Effects\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownSpace } from 'micromark-util-character';\n/**\n * @param {Effects} effects\n * @param {State} ok\n */\n\nexport function factoryWhitespace(effects, ok) {\n  /** @type {boolean} */\n  let seen;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      seen = true;\n      return start;\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, start, seen ? 'linePrefix' : 'lineSuffix')(code);\n    }\n\n    return ok(code);\n  }\n}","/**\n * Normalize an identifier (such as used in definitions).\n *\n * @param {string} value\n * @returns {string}\n */\nexport function normalizeIdentifier(value) {\n  return value // Collapse Markdown whitespace.\n  .replace(/[\\t\\n\\r ]+/g, ' ') // Trim.\n  .replace(/^ | $/g, '') // Some characters are considered “uppercase”, but if their lowercase\n  // counterpart is uppercased will result in a different uppercase\n  // character.\n  // Hence, to get that form, we perform both lower- and uppercase.\n  // Upper case makes sure keys will not interact with default prototypal\n  // methods: no method is uppercase.\n  .toLowerCase().toUpperCase();\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factorySpace } from 'micromark-factory-space';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { markdownLineEnding, markdownLineEndingOrSpace } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const definition = {\n  name: 'definition',\n  tokenize: tokenizeDefinition\n};\n/** @type {Construct} */\n\nconst titleConstruct = {\n  tokenize: tokenizeTitle,\n  partial: true\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeDefinition(effects, ok, nok) {\n  const self = this;\n  /** @type {string} */\n\n  let identifier;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('definition');\n    return factoryLabel.call(self, effects, labelAfter, nok, 'definitionLabel', 'definitionLabelMarker', 'definitionLabelString')(code);\n  }\n  /** @type {State} */\n\n\n  function labelAfter(code) {\n    identifier = normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1));\n\n    if (code === 58) {\n      effects.enter('definitionMarker');\n      effects.consume(code);\n      effects.exit('definitionMarker'); // Note: blank lines can’t exist in content.\n\n      return factoryWhitespace(effects, factoryDestination(effects, effects.attempt(titleConstruct, factorySpace(effects, after, 'whitespace'), factorySpace(effects, after, 'whitespace')), nok, 'definitionDestination', 'definitionDestinationLiteral', 'definitionDestinationLiteralMarker', 'definitionDestinationRaw', 'definitionDestinationString'));\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function after(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('definition');\n\n      if (!self.parser.defined.includes(identifier)) {\n        self.parser.defined.push(identifier);\n      }\n\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeTitle(effects, ok, nok) {\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, before)(code) : nok(code);\n  }\n  /** @type {State} */\n\n\n  function before(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factorySpace(effects, after, 'whitespace'), nok, 'definitionTitle', 'definitionTitleMarker', 'definitionTitleString')(code);\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function after(code) {\n    return code === null || markdownLineEnding(code) ? ok(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const codeIndented = {\n  name: 'codeIndented',\n  tokenize: tokenizeCodeIndented\n};\n/** @type {Construct} */\n\nconst indentedContent = {\n  tokenize: tokenizeIndentedContent,\n  partial: true\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeIndented(effects, ok, nok) {\n  const self = this;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeIndented');\n    return factorySpace(effects, afterStartPrefix, 'linePrefix', 4 + 1)(code);\n  }\n  /** @type {State} */\n\n\n  function afterStartPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'linePrefix' && tail[2].sliceSerialize(tail[1], true).length >= 4 ? afterPrefix(code) : nok(code);\n  }\n  /** @type {State} */\n\n\n  function afterPrefix(code) {\n    if (code === null) {\n      return after(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(indentedContent, afterPrefix, after)(code);\n    }\n\n    effects.enter('codeFlowValue');\n    return content(code);\n  }\n  /** @type {State} */\n\n\n  function content(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return afterPrefix(code);\n    }\n\n    effects.consume(code);\n    return content;\n  }\n  /** @type {State} */\n\n\n  function after(code) {\n    effects.exit('codeIndented');\n    return ok(code);\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeIndentedContent(effects, ok, nok) {\n  const self = this;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    // If this is a lazy line, it can’t be code.\n    if (self.parser.lazy[self.now().line]) {\n      return nok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return start;\n    }\n\n    return factorySpace(effects, afterPrefix, 'linePrefix', 4 + 1)(code);\n  }\n  /** @type {State} */\n\n\n  function afterPrefix(code) {\n    const tail = self.events[self.events.length - 1];\n    return tail && tail[1].type === 'linePrefix' && tail[2].sliceSerialize(tail[1], true).length >= 4 ? ok(code) : markdownLineEnding(code) ? start(code) : nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { splice } from 'micromark-util-chunked';\n/** @type {Construct} */\n\nexport const headingAtx = {\n  name: 'headingAtx',\n  tokenize: tokenizeHeadingAtx,\n  resolve: resolveHeadingAtx\n};\n/** @type {Resolver} */\n\nfunction resolveHeadingAtx(events, context) {\n  let contentEnd = events.length - 2;\n  let contentStart = 3;\n  /** @type {Token} */\n\n  let content;\n  /** @type {Token} */\n\n  let text; // Prefix whitespace, part of the opening.\n\n  if (events[contentStart][1].type === 'whitespace') {\n    contentStart += 2;\n  } // Suffix whitespace, part of the closing.\n\n\n  if (contentEnd - 2 > contentStart && events[contentEnd][1].type === 'whitespace') {\n    contentEnd -= 2;\n  }\n\n  if (events[contentEnd][1].type === 'atxHeadingSequence' && (contentStart === contentEnd - 1 || contentEnd - 4 > contentStart && events[contentEnd - 2][1].type === 'whitespace')) {\n    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4;\n  }\n\n  if (contentEnd > contentStart) {\n    content = {\n      type: 'atxHeadingText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end\n    };\n    text = {\n      type: 'chunkText',\n      start: events[contentStart][1].start,\n      end: events[contentEnd][1].end,\n      // @ts-expect-error Constants are fine to assign.\n      contentType: 'text'\n    };\n    splice(events, contentStart, contentEnd - contentStart + 1, [['enter', content, context], ['enter', text, context], ['exit', text, context], ['exit', content, context]]);\n  }\n\n  return events;\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeHeadingAtx(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('atxHeading');\n    effects.enter('atxHeadingSequence');\n    return fenceOpenInside(code);\n  }\n  /** @type {State} */\n\n\n  function fenceOpenInside(code) {\n    if (code === 35 && size++ < 6) {\n      effects.consume(code);\n      return fenceOpenInside;\n    }\n\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingSequence');\n      return self.interrupt ? ok(code) : headingBreak(code);\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function headingBreak(code) {\n    if (code === 35) {\n      effects.enter('atxHeadingSequence');\n      return sequence(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('atxHeading');\n      return ok(code);\n    }\n\n    if (markdownSpace(code)) {\n      return factorySpace(effects, headingBreak, 'whitespace')(code);\n    }\n\n    effects.enter('atxHeadingText');\n    return data(code);\n  }\n  /** @type {State} */\n\n\n  function sequence(code) {\n    if (code === 35) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    effects.exit('atxHeadingSequence');\n    return headingBreak(code);\n  }\n  /** @type {State} */\n\n\n  function data(code) {\n    if (code === null || code === 35 || markdownLineEndingOrSpace(code)) {\n      effects.exit('atxHeadingText');\n      return headingBreak(code);\n    }\n\n    effects.consume(code);\n    return data;\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const setextUnderline = {\n  name: 'setextUnderline',\n  tokenize: tokenizeSetextUnderline,\n  resolveTo: resolveToSetextUnderline\n};\n/** @type {Resolver} */\n\nfunction resolveToSetextUnderline(events, context) {\n  let index = events.length;\n  /** @type {number|undefined} */\n\n  let content;\n  /** @type {number|undefined} */\n\n  let text;\n  /** @type {number|undefined} */\n\n  let definition; // Find the opening of the content.\n  // It’ll always exist: we don’t tokenize if it isn’t there.\n\n  while (index--) {\n    if (events[index][0] === 'enter') {\n      if (events[index][1].type === 'content') {\n        content = index;\n        break;\n      }\n\n      if (events[index][1].type === 'paragraph') {\n        text = index;\n      }\n    } // Exit\n    else {\n      if (events[index][1].type === 'content') {\n        // Remove the content end (if needed we’ll add it later)\n        events.splice(index, 1);\n      }\n\n      if (!definition && events[index][1].type === 'definition') {\n        definition = index;\n      }\n    }\n  }\n\n  const heading = {\n    type: 'setextHeading',\n    start: Object.assign({}, events[text][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  }; // Change the paragraph to setext heading text.\n\n  events[text][1].type = 'setextHeadingText'; // If we have definitions in the content, we’ll keep on having content,\n  // but we need move it.\n\n  if (definition) {\n    events.splice(text, 0, ['enter', heading, context]);\n    events.splice(definition + 1, 0, ['exit', events[content][1], context]);\n    events[content][1].end = Object.assign({}, events[definition][1].end);\n  } else {\n    events[content][1] = heading;\n  } // Add the heading exit at the end.\n\n\n  events.push(['exit', heading, context]);\n  return events;\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeSetextUnderline(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {NonNullable<Code>} */\n\n  let marker;\n  /** @type {boolean} */\n\n  let paragraph; // Find an opening.\n\n  while (index--) {\n    // Skip enter/exit of line ending, line prefix, and content.\n    // We can now either have a definition or a paragraph.\n    if (self.events[index][1].type !== 'lineEnding' && self.events[index][1].type !== 'linePrefix' && self.events[index][1].type !== 'content') {\n      paragraph = self.events[index][1].type === 'paragraph';\n      break;\n    }\n  }\n\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    if (!self.parser.lazy[self.now().line] && (self.interrupt || paragraph)) {\n      effects.enter('setextHeadingLine');\n      effects.enter('setextHeadingLineSequence');\n      marker = code;\n      return closingSequence(code);\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function closingSequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return closingSequence;\n    }\n\n    effects.exit('setextHeadingLineSequence');\n    return factorySpace(effects, closingSequenceEnd, 'lineSuffix')(code);\n  }\n  /** @type {State} */\n\n\n  function closingSequenceEnd(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('setextHeadingLine');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}","/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result\n * in more relaxed rules (condition 6): because they are known blocks, the\n * HTML-like syntax doesn’t have to be strictly parsed.\n * For tag names not in this list, a more strict algorithm (condition 7) is used\n * to detect whether the HTML-like syntax is seen as HTML (flow) or not.\n *\n * This is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n */\nexport const htmlBlockNames = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul'];\n/**\n * List of lowercase HTML tag names which when parsing HTML (flow), result in\n * HTML that can include lines w/o exiting, until a closing tag also in this\n * list is found (condition 1).\n *\n * This module is copied from:\n * <https://spec.commonmark.org/0.30/#html-blocks>.\n *\n * Note that `textarea` was added in `CommonMark@0.30`.\n */\n\nexport const htmlRawNames = ['pre', 'script', 'style', 'textarea'];","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\nimport { htmlBlockNames, htmlRawNames } from 'micromark-util-html-tag-name';\nimport { blankLine } from './blank-line.js';\n/** @type {Construct} */\n\nexport const htmlFlow = {\n  name: 'htmlFlow',\n  tokenize: tokenizeHtmlFlow,\n  resolveTo: resolveToHtmlFlow,\n  concrete: true\n};\n/** @type {Construct} */\n\nconst nextBlankConstruct = {\n  tokenize: tokenizeNextBlank,\n  partial: true\n};\n/** @type {Resolver} */\n\nfunction resolveToHtmlFlow(events) {\n  let index = events.length;\n\n  while (index--) {\n    if (events[index][0] === 'enter' && events[index][1].type === 'htmlFlow') {\n      break;\n    }\n  }\n\n  if (index > 1 && events[index - 2][1].type === 'linePrefix') {\n    // Add the prefix start to the HTML token.\n    events[index][1].start = events[index - 2][1].start; // Add the prefix start to the HTML line token.\n\n    events[index + 1][1].start = events[index - 2][1].start; // Remove the line prefix.\n\n    events.splice(index - 2, 2);\n  }\n\n  return events;\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeHtmlFlow(effects, ok, nok) {\n  const self = this;\n  /** @type {number} */\n\n  let kind;\n  /** @type {boolean} */\n\n  let startTag;\n  /** @type {string} */\n\n  let buffer;\n  /** @type {number} */\n\n  let index;\n  /** @type {Code} */\n\n  let marker;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlFlow');\n    effects.enter('htmlFlowData');\n    effects.consume(code);\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationStart;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      kind = 3; // While we’re in an instruction instead of a declaration, we’re on a `?`\n      // right now, so we do need to search for `>`, similar to declarations.\n\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      startTag = true;\n      return tagName;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function declarationStart(code) {\n    if (code === 45) {\n      effects.consume(code);\n      kind = 2;\n      return commentOpenInside;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      kind = 5;\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpenInside;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      kind = 4;\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function commentOpenInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuationDeclarationInside;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function cdataOpenInside(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? self.interrupt ? ok : continuation : cdataOpenInside;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      buffer = String.fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function tagName(code) {\n    if (code === null || code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      if (code !== 47 && startTag && htmlRawNames.includes(buffer.toLowerCase())) {\n        kind = 1;\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      if (htmlBlockNames.includes(buffer.toLowerCase())) {\n        kind = 6;\n\n        if (code === 47) {\n          effects.consume(code);\n          return basicSelfClosing;\n        }\n\n        return self.interrupt ? ok(code) : continuation(code);\n      }\n\n      kind = 7; // Do not support complete HTML when interrupting\n\n      return self.interrupt && !self.parser.lazy[self.now().line] ? nok(code) : startTag ? completeAttributeNameBefore(code) : completeClosingTagAfter(code);\n    }\n\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return tagName;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function basicSelfClosing(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return self.interrupt ? ok : continuation;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function completeClosingTagAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeClosingTagAfter;\n    }\n\n    return completeEnd(code);\n  }\n  /** @type {State} */\n\n\n  function completeAttributeNameBefore(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return completeEnd;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameBefore;\n    }\n\n    return completeEnd(code);\n  }\n  /** @type {State} */\n\n\n  function completeAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return completeAttributeName;\n    }\n\n    return completeAttributeNameAfter(code);\n  }\n  /** @type {State} */\n\n\n  function completeAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeNameAfter;\n    }\n\n    return completeAttributeNameBefore(code);\n  }\n  /** @type {State} */\n\n\n  function completeAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return completeAttributeValueQuoted;\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAttributeValueBefore;\n    }\n\n    marker = null;\n    return completeAttributeValueUnquoted(code);\n  }\n  /** @type {State} */\n\n\n  function completeAttributeValueQuoted(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return nok(code);\n    }\n\n    if (code === marker) {\n      effects.consume(code);\n      return completeAttributeValueQuotedAfter;\n    }\n\n    effects.consume(code);\n    return completeAttributeValueQuoted;\n  }\n  /** @type {State} */\n\n\n  function completeAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 62 || code === 96 || markdownLineEndingOrSpace(code)) {\n      return completeAttributeNameAfter(code);\n    }\n\n    effects.consume(code);\n    return completeAttributeValueUnquoted;\n  }\n  /** @type {State} */\n\n\n  function completeAttributeValueQuotedAfter(code) {\n    if (code === 47 || code === 62 || markdownSpace(code)) {\n      return completeAttributeNameBefore(code);\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function completeEnd(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function completeAfter(code) {\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return completeAfter;\n    }\n\n    return code === null || markdownLineEnding(code) ? continuation(code) : nok(code);\n  }\n  /** @type {State} */\n\n\n  function continuation(code) {\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationCommentInside;\n    }\n\n    if (code === 60 && kind === 1) {\n      effects.consume(code);\n      return continuationRawTagOpen;\n    }\n\n    if (code === 62 && kind === 4) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (code === 63 && kind === 3) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    if (code === 93 && kind === 5) {\n      effects.consume(code);\n      return continuationCharacterDataInside;\n    }\n\n    if (markdownLineEnding(code) && (kind === 6 || kind === 7)) {\n      return effects.check(nextBlankConstruct, continuationClose, continuationAtLineEnding)(code);\n    }\n\n    if (code === null || markdownLineEnding(code)) {\n      return continuationAtLineEnding(code);\n    }\n\n    effects.consume(code);\n    return continuation;\n  }\n  /** @type {State} */\n\n\n  function continuationAtLineEnding(code) {\n    effects.exit('htmlFlowData');\n    return htmlContinueStart(code);\n  }\n  /** @type {State} */\n\n\n  function htmlContinueStart(code) {\n    if (code === null) {\n      return done(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt({\n        tokenize: htmlLineEnd,\n        partial: true\n      }, htmlContinueStart, done)(code);\n    }\n\n    effects.enter('htmlFlowData');\n    return continuation(code);\n  }\n  /** @type {Tokenizer} */\n\n\n  function htmlLineEnd(effects, ok, nok) {\n    return start;\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return lineStart;\n    }\n    /** @type {State} */\n\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n    }\n  }\n  /** @type {State} */\n\n\n  function continuationCommentInside(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n  /** @type {State} */\n\n\n  function continuationRawTagOpen(code) {\n    if (code === 47) {\n      effects.consume(code);\n      buffer = '';\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n  /** @type {State} */\n\n\n  function continuationRawEndTag(code) {\n    if (code === 62 && htmlRawNames.includes(buffer.toLowerCase())) {\n      effects.consume(code);\n      return continuationClose;\n    }\n\n    if (asciiAlpha(code) && buffer.length < 8) {\n      effects.consume(code);\n      buffer += String.fromCharCode(code);\n      return continuationRawEndTag;\n    }\n\n    return continuation(code);\n  }\n  /** @type {State} */\n\n\n  function continuationCharacterDataInside(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n  /** @type {State} */\n\n\n  function continuationDeclarationInside(code) {\n    if (code === 62) {\n      effects.consume(code);\n      return continuationClose;\n    } // More dashes.\n\n\n    if (code === 45 && kind === 2) {\n      effects.consume(code);\n      return continuationDeclarationInside;\n    }\n\n    return continuation(code);\n  }\n  /** @type {State} */\n\n\n  function continuationClose(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('htmlFlowData');\n      return done(code);\n    }\n\n    effects.consume(code);\n    return continuationClose;\n  }\n  /** @type {State} */\n\n\n  function done(code) {\n    effects.exit('htmlFlow');\n    return ok(code);\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeNextBlank(effects, ok, nok) {\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.exit('htmlFlowData');\n    effects.enter('lineEndingBlank');\n    effects.consume(code);\n    effects.exit('lineEndingBlank');\n    return effects.attempt(blankLine, ok, nok);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding, markdownLineEndingOrSpace } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const codeFenced = {\n  name: 'codeFenced',\n  tokenize: tokenizeCodeFenced,\n  concrete: true\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeCodeFenced(effects, ok, nok) {\n  const self = this;\n  /** @type {Construct} */\n\n  const closingFenceConstruct = {\n    tokenize: tokenizeClosingFence,\n    partial: true\n  };\n  /** @type {Construct} */\n\n  const nonLazyLine = {\n    tokenize: tokenizeNonLazyLine,\n    partial: true\n  };\n  const tail = this.events[this.events.length - 1];\n  const initialPrefix = tail && tail[1].type === 'linePrefix' ? tail[2].sliceSerialize(tail[1], true).length : 0;\n  let sizeOpen = 0;\n  /** @type {NonNullable<Code>} */\n\n  let marker;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeFenced');\n    effects.enter('codeFencedFence');\n    effects.enter('codeFencedFenceSequence');\n    marker = code;\n    return sequenceOpen(code);\n  }\n  /** @type {State} */\n\n\n  function sequenceOpen(code) {\n    if (code === marker) {\n      effects.consume(code);\n      sizeOpen++;\n      return sequenceOpen;\n    }\n\n    effects.exit('codeFencedFenceSequence');\n    return sizeOpen < 3 ? nok(code) : factorySpace(effects, infoOpen, 'whitespace')(code);\n  }\n  /** @type {State} */\n\n\n  function infoOpen(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceInfo');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return info(code);\n  }\n  /** @type {State} */\n\n\n  function info(code) {\n    if (code === null || markdownLineEndingOrSpace(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceInfo');\n      return factorySpace(effects, infoAfter, 'whitespace')(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return info;\n  }\n  /** @type {State} */\n\n\n  function infoAfter(code) {\n    if (code === null || markdownLineEnding(code)) {\n      return openAfter(code);\n    }\n\n    effects.enter('codeFencedFenceMeta');\n    effects.enter('chunkString', {\n      contentType: 'string'\n    });\n    return meta(code);\n  }\n  /** @type {State} */\n\n\n  function meta(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('chunkString');\n      effects.exit('codeFencedFenceMeta');\n      return openAfter(code);\n    }\n\n    if (code === 96 && code === marker) return nok(code);\n    effects.consume(code);\n    return meta;\n  }\n  /** @type {State} */\n\n\n  function openAfter(code) {\n    effects.exit('codeFencedFence');\n    return self.interrupt ? ok(code) : contentStart(code);\n  }\n  /** @type {State} */\n\n\n  function contentStart(code) {\n    if (code === null) {\n      return after(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      return effects.attempt(nonLazyLine, effects.attempt(closingFenceConstruct, after, initialPrefix ? factorySpace(effects, contentStart, 'linePrefix', initialPrefix + 1) : contentStart), after)(code);\n    }\n\n    effects.enter('codeFlowValue');\n    return contentContinue(code);\n  }\n  /** @type {State} */\n\n\n  function contentContinue(code) {\n    if (code === null || markdownLineEnding(code)) {\n      effects.exit('codeFlowValue');\n      return contentStart(code);\n    }\n\n    effects.consume(code);\n    return contentContinue;\n  }\n  /** @type {State} */\n\n\n  function after(code) {\n    effects.exit('codeFenced');\n    return ok(code);\n  }\n  /** @type {Tokenizer} */\n\n\n  function tokenizeNonLazyLine(effects, ok, nok) {\n    const self = this;\n    return start;\n    /** @type {State} */\n\n    function start(code) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return lineStart;\n    }\n    /** @type {State} */\n\n\n    function lineStart(code) {\n      return self.parser.lazy[self.now().line] ? nok(code) : ok(code);\n    }\n  }\n  /** @type {Tokenizer} */\n\n\n  function tokenizeClosingFence(effects, ok, nok) {\n    let size = 0;\n    return factorySpace(effects, closingSequenceStart, 'linePrefix', this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n    /** @type {State} */\n\n    function closingSequenceStart(code) {\n      effects.enter('codeFencedFence');\n      effects.enter('codeFencedFenceSequence');\n      return closingSequence(code);\n    }\n    /** @type {State} */\n\n\n    function closingSequence(code) {\n      if (code === marker) {\n        effects.consume(code);\n        size++;\n        return closingSequence;\n      }\n\n      if (size < sizeOpen) return nok(code);\n      effects.exit('codeFencedFenceSequence');\n      return factorySpace(effects, closingSequenceEnd, 'whitespace')(code);\n    }\n    /** @type {State} */\n\n\n    function closingSequenceEnd(code) {\n      if (code === null || markdownLineEnding(code)) {\n        effects.exit('codeFencedFence');\n        return ok(code);\n      }\n\n      return nok(code);\n    }\n  }\n}","/// <reference lib=\"dom\" />\n\n/* eslint-env browser */\nconst element = document.createElement('i');\n/**\n * @param {string} value\n * @returns {string|false}\n */\n\nexport function decodeNamedCharacterReference(value) {\n  const characterReference = '&' + value + ';';\n  element.innerHTML = characterReference;\n  const char = element.textContent; // Some named character references do not require the closing semicolon\n  // (`&not`, for instance), which leads to situations where parsing the assumed\n  // named reference of `&notit;` will result in the string `¬it;`.\n  // When we encounter a trailing semicolon after parsing, and the character\n  // reference to decode was not a semicolon (`&semi;`), we can assume that the\n  // matching was not complete.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n\n  if (char.charCodeAt(char.length - 1) === 59\n  /* `;` */\n  && value !== 'semi') {\n    return false;\n  } // If the decoded string is equal to the input, the character reference was\n  // not valid.\n  // @ts-expect-error: TypeScript is wrong that `textContent` on elements can\n  // yield `null`.\n\n\n  return char === characterReference ? false : char;\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { asciiAlphanumeric, asciiDigit, asciiHexDigit } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const characterReference = {\n  name: 'characterReference',\n  tokenize: tokenizeCharacterReference\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterReference(effects, ok, nok) {\n  const self = this;\n  let size = 0;\n  /** @type {number} */\n\n  let max;\n  /** @type {(code: Code) => code is number} */\n\n  let test;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterReference');\n    effects.enter('characterReferenceMarker');\n    effects.consume(code);\n    effects.exit('characterReferenceMarker');\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (code === 35) {\n      effects.enter('characterReferenceMarkerNumeric');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerNumeric');\n      return numeric;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 31;\n    test = asciiAlphanumeric;\n    return value(code);\n  }\n  /** @type {State} */\n\n\n  function numeric(code) {\n    if (code === 88 || code === 120) {\n      effects.enter('characterReferenceMarkerHexadecimal');\n      effects.consume(code);\n      effects.exit('characterReferenceMarkerHexadecimal');\n      effects.enter('characterReferenceValue');\n      max = 6;\n      test = asciiHexDigit;\n      return value;\n    }\n\n    effects.enter('characterReferenceValue');\n    max = 7;\n    test = asciiDigit;\n    return value(code);\n  }\n  /** @type {State} */\n\n\n  function value(code) {\n    /** @type {Token} */\n    let token;\n\n    if (code === 59 && size) {\n      token = effects.exit('characterReferenceValue');\n\n      if (test === asciiAlphanumeric && !decodeNamedCharacterReference(self.sliceSerialize(token))) {\n        return nok(code);\n      }\n\n      effects.enter('characterReferenceMarker');\n      effects.consume(code);\n      effects.exit('characterReferenceMarker');\n      effects.exit('characterReference');\n      return ok;\n    }\n\n    if (test(code) && size++ < max) {\n      effects.consume(code);\n      return value;\n    }\n\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { asciiPunctuation } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const characterEscape = {\n  name: 'characterEscape',\n  tokenize: tokenizeCharacterEscape\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeCharacterEscape(effects, ok, nok) {\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('characterEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    effects.exit('escapeMarker');\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (asciiPunctuation(code)) {\n      effects.enter('characterEscapeValue');\n      effects.consume(code);\n      effects.exit('characterEscapeValue');\n      effects.exit('characterEscape');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const lineEnding = {\n  name: 'lineEnding',\n  tokenize: tokenizeLineEnding\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeLineEnding(effects, ok) {\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, ok, 'linePrefix');\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { factoryDestination } from 'micromark-factory-destination';\nimport { factoryLabel } from 'micromark-factory-label';\nimport { factoryTitle } from 'micromark-factory-title';\nimport { factoryWhitespace } from 'micromark-factory-whitespace';\nimport { markdownLineEndingOrSpace } from 'micromark-util-character';\nimport { push, splice } from 'micromark-util-chunked';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\n\nexport const labelEnd = {\n  name: 'labelEnd',\n  tokenize: tokenizeLabelEnd,\n  resolveTo: resolveToLabelEnd,\n  resolveAll: resolveAllLabelEnd\n};\n/** @type {Construct} */\n\nconst resourceConstruct = {\n  tokenize: tokenizeResource\n};\n/** @type {Construct} */\n\nconst fullReferenceConstruct = {\n  tokenize: tokenizeFullReference\n};\n/** @type {Construct} */\n\nconst collapsedReferenceConstruct = {\n  tokenize: tokenizeCollapsedReference\n};\n/** @type {Resolver} */\n\nfunction resolveAllLabelEnd(events) {\n  let index = -1;\n  /** @type {Token} */\n\n  let token;\n\n  while (++index < events.length) {\n    token = events[index][1];\n\n    if (token.type === 'labelImage' || token.type === 'labelLink' || token.type === 'labelEnd') {\n      // Remove the marker.\n      events.splice(index + 1, token.type === 'labelImage' ? 4 : 2);\n      token.type = 'data';\n      index++;\n    }\n  }\n\n  return events;\n}\n/** @type {Resolver} */\n\n\nfunction resolveToLabelEnd(events, context) {\n  let index = events.length;\n  let offset = 0;\n  /** @type {Token} */\n\n  let token;\n  /** @type {number|undefined} */\n\n  let open;\n  /** @type {number|undefined} */\n\n  let close;\n  /** @type {Event[]} */\n\n  let media; // Find an opening.\n\n  while (index--) {\n    token = events[index][1];\n\n    if (open) {\n      // If we see another link, or inactive link label, we’ve been here before.\n      if (token.type === 'link' || token.type === 'labelLink' && token._inactive) {\n        break;\n      } // Mark other link openings as inactive, as we can’t have links in\n      // links.\n\n\n      if (events[index][0] === 'enter' && token.type === 'labelLink') {\n        token._inactive = true;\n      }\n    } else if (close) {\n      if (events[index][0] === 'enter' && (token.type === 'labelImage' || token.type === 'labelLink') && !token._balanced) {\n        open = index;\n\n        if (token.type !== 'labelLink') {\n          offset = 2;\n          break;\n        }\n      }\n    } else if (token.type === 'labelEnd') {\n      close = index;\n    }\n  }\n\n  const group = {\n    type: events[open][1].type === 'labelLink' ? 'link' : 'image',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[events.length - 1][1].end)\n  };\n  const label = {\n    type: 'label',\n    start: Object.assign({}, events[open][1].start),\n    end: Object.assign({}, events[close][1].end)\n  };\n  const text = {\n    type: 'labelText',\n    start: Object.assign({}, events[open + offset + 2][1].end),\n    end: Object.assign({}, events[close - 2][1].start)\n  };\n  media = [['enter', group, context], ['enter', label, context]]; // Opening marker.\n\n  media = push(media, events.slice(open + 1, open + offset + 3)); // Text open.\n\n  media = push(media, [['enter', text, context]]); // Between.\n\n  media = push(media, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + offset + 4, close - 3), context)); // Text close, marker close, label close.\n\n  media = push(media, [['exit', text, context], events[close - 2], events[close - 1], ['exit', label, context]]); // Reference, resource, or so.\n\n  media = push(media, events.slice(close + 1)); // Media close.\n\n  media = push(media, [['exit', group, context]]);\n  splice(events, open, events.length, media);\n  return events;\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeLabelEnd(effects, ok, nok) {\n  const self = this;\n  let index = self.events.length;\n  /** @type {Token} */\n\n  let labelStart;\n  /** @type {boolean} */\n\n  let defined; // Find an opening.\n\n  while (index--) {\n    if ((self.events[index][1].type === 'labelImage' || self.events[index][1].type === 'labelLink') && !self.events[index][1]._balanced) {\n      labelStart = self.events[index][1];\n      break;\n    }\n  }\n\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    if (!labelStart) {\n      return nok(code);\n    } // It’s a balanced bracket, but contains a link.\n\n\n    if (labelStart._inactive) return balanced(code);\n    defined = self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize({\n      start: labelStart.end,\n      end: self.now()\n    })));\n    effects.enter('labelEnd');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelEnd');\n    return afterLabelEnd;\n  }\n  /** @type {State} */\n\n\n  function afterLabelEnd(code) {\n    // Resource: `[asd](fgh)`.\n    if (code === 40) {\n      return effects.attempt(resourceConstruct, ok, defined ? ok : balanced)(code);\n    } // Collapsed (`[asd][]`) or full (`[asd][fgh]`) reference?\n\n\n    if (code === 91) {\n      return effects.attempt(fullReferenceConstruct, ok, defined ? effects.attempt(collapsedReferenceConstruct, ok, balanced) : balanced)(code);\n    } // Shortcut reference: `[asd]`?\n\n\n    return defined ? ok(code) : balanced(code);\n  }\n  /** @type {State} */\n\n\n  function balanced(code) {\n    labelStart._balanced = true;\n    return nok(code);\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeResource(effects, ok, nok) {\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('resource');\n    effects.enter('resourceMarker');\n    effects.consume(code);\n    effects.exit('resourceMarker');\n    return factoryWhitespace(effects, open);\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (code === 41) {\n      return end(code);\n    }\n\n    return factoryDestination(effects, destinationAfter, nok, 'resourceDestination', 'resourceDestinationLiteral', 'resourceDestinationLiteralMarker', 'resourceDestinationRaw', 'resourceDestinationString', 32)(code);\n  }\n  /** @type {State} */\n\n\n  function destinationAfter(code) {\n    return markdownLineEndingOrSpace(code) ? factoryWhitespace(effects, between)(code) : end(code);\n  }\n  /** @type {State} */\n\n\n  function between(code) {\n    if (code === 34 || code === 39 || code === 40) {\n      return factoryTitle(effects, factoryWhitespace(effects, end), nok, 'resourceTitle', 'resourceTitleMarker', 'resourceTitleString')(code);\n    }\n\n    return end(code);\n  }\n  /** @type {State} */\n\n\n  function end(code) {\n    if (code === 41) {\n      effects.enter('resourceMarker');\n      effects.consume(code);\n      effects.exit('resourceMarker');\n      effects.exit('resource');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeFullReference(effects, ok, nok) {\n  const self = this;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    return factoryLabel.call(self, effects, afterLabel, nok, 'reference', 'referenceMarker', 'referenceString')(code);\n  }\n  /** @type {State} */\n\n\n  function afterLabel(code) {\n    return self.parser.defined.includes(normalizeIdentifier(self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1))) ? ok(code) : nok(code);\n  }\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeCollapsedReference(effects, ok, nok) {\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('reference');\n    effects.enter('referenceMarker');\n    effects.consume(code);\n    effects.exit('referenceMarker');\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (code === 93) {\n      effects.enter('referenceMarker');\n      effects.consume(code);\n      effects.exit('referenceMarker');\n      effects.exit('reference');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { labelEnd } from './label-end.js';\n/** @type {Construct} */\n\nexport const labelStartImage = {\n  name: 'labelStartImage',\n  tokenize: tokenizeLabelStartImage,\n  resolveAll: labelEnd.resolveAll\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartImage(effects, ok, nok) {\n  const self = this;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelImage');\n    effects.enter('labelImageMarker');\n    effects.consume(code);\n    effects.exit('labelImageMarker');\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (code === 91) {\n      effects.enter('labelMarker');\n      effects.consume(code);\n      effects.exit('labelMarker');\n      effects.exit('labelImage');\n      return after;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { markdownLineEndingOrSpace, unicodePunctuation, unicodeWhitespace } from 'micromark-util-character';\n/**\n * Classify whether a character code represents whitespace, punctuation, or\n * something else.\n *\n * Used for attention (emphasis, strong), whose sequences can open or close\n * based on the class of surrounding characters.\n *\n * Note that eof (`null`) is seen as whitespace.\n *\n * @param {Code} code\n * @returns {number|undefined}\n */\n\nexport function classifyCharacter(code) {\n  if (code === null || markdownLineEndingOrSpace(code) || unicodeWhitespace(code)) {\n    return 1;\n  }\n\n  if (unicodePunctuation(code)) {\n    return 2;\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').Code} Code\n * @typedef {import('micromark-util-types').Point} Point\n */\nimport { push, splice } from 'micromark-util-chunked';\nimport { classifyCharacter } from 'micromark-util-classify-character';\nimport { resolveAll } from 'micromark-util-resolve-all';\n/** @type {Construct} */\n\nexport const attention = {\n  name: 'attention',\n  tokenize: tokenizeAttention,\n  resolveAll: resolveAllAttention\n};\n/**\n * Take all events and resolve attention to emphasis or strong.\n *\n * @type {Resolver}\n */\n\nfunction resolveAllAttention(events, context) {\n  let index = -1;\n  /** @type {number} */\n\n  let open;\n  /** @type {Token} */\n\n  let group;\n  /** @type {Token} */\n\n  let text;\n  /** @type {Token} */\n\n  let openingSequence;\n  /** @type {Token} */\n\n  let closingSequence;\n  /** @type {number} */\n\n  let use;\n  /** @type {Event[]} */\n\n  let nextEvents;\n  /** @type {number} */\n\n  let offset; // Walk through all events.\n  //\n  // Note: performance of this is fine on an mb of normal markdown, but it’s\n  // a bottleneck for malicious stuff.\n\n  while (++index < events.length) {\n    // Find a token that can close.\n    if (events[index][0] === 'enter' && events[index][1].type === 'attentionSequence' && events[index][1]._close) {\n      open = index; // Now walk back to find an opener.\n\n      while (open--) {\n        // Find a token that can open the closer.\n        if (events[open][0] === 'exit' && events[open][1].type === 'attentionSequence' && events[open][1]._open && // If the markers are the same:\n        context.sliceSerialize(events[open][1]).charCodeAt(0) === context.sliceSerialize(events[index][1]).charCodeAt(0)) {\n          // If the opening can close or the closing can open,\n          // and the close size *is not* a multiple of three,\n          // but the sum of the opening and closing size *is* multiple of three,\n          // then don’t match.\n          if ((events[open][1]._close || events[index][1]._open) && (events[index][1].end.offset - events[index][1].start.offset) % 3 && !((events[open][1].end.offset - events[open][1].start.offset + events[index][1].end.offset - events[index][1].start.offset) % 3)) {\n            continue;\n          } // Number of markers to use from the sequence.\n\n\n          use = events[open][1].end.offset - events[open][1].start.offset > 1 && events[index][1].end.offset - events[index][1].start.offset > 1 ? 2 : 1;\n          const start = Object.assign({}, events[open][1].end);\n          const end = Object.assign({}, events[index][1].start);\n          movePoint(start, -use);\n          movePoint(end, use);\n          openingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start,\n            end: Object.assign({}, events[open][1].end)\n          };\n          closingSequence = {\n            type: use > 1 ? 'strongSequence' : 'emphasisSequence',\n            start: Object.assign({}, events[index][1].start),\n            end\n          };\n          text = {\n            type: use > 1 ? 'strongText' : 'emphasisText',\n            start: Object.assign({}, events[open][1].end),\n            end: Object.assign({}, events[index][1].start)\n          };\n          group = {\n            type: use > 1 ? 'strong' : 'emphasis',\n            start: Object.assign({}, openingSequence.start),\n            end: Object.assign({}, closingSequence.end)\n          };\n          events[open][1].end = Object.assign({}, openingSequence.start);\n          events[index][1].start = Object.assign({}, closingSequence.end);\n          nextEvents = []; // If there are more markers in the opening, add them before.\n\n          if (events[open][1].end.offset - events[open][1].start.offset) {\n            nextEvents = push(nextEvents, [['enter', events[open][1], context], ['exit', events[open][1], context]]);\n          } // Opening.\n\n\n          nextEvents = push(nextEvents, [['enter', group, context], ['enter', openingSequence, context], ['exit', openingSequence, context], ['enter', text, context]]); // Between.\n\n          nextEvents = push(nextEvents, resolveAll(context.parser.constructs.insideSpan.null, events.slice(open + 1, index), context)); // Closing.\n\n          nextEvents = push(nextEvents, [['exit', text, context], ['enter', closingSequence, context], ['exit', closingSequence, context], ['exit', group, context]]); // If there are more markers in the closing, add them after.\n\n          if (events[index][1].end.offset - events[index][1].start.offset) {\n            offset = 2;\n            nextEvents = push(nextEvents, [['enter', events[index][1], context], ['exit', events[index][1], context]]);\n          } else {\n            offset = 0;\n          }\n\n          splice(events, open - 1, index - open + 3, nextEvents);\n          index = open + nextEvents.length - offset - 2;\n          break;\n        }\n      }\n    }\n  } // Remove remaining sequences.\n\n\n  index = -1;\n\n  while (++index < events.length) {\n    if (events[index][1].type === 'attentionSequence') {\n      events[index][1].type = 'data';\n    }\n  }\n\n  return events;\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeAttention(effects, ok) {\n  const attentionMarkers = this.parser.constructs.attentionMarkers.null;\n  const previous = this.previous;\n  const before = classifyCharacter(previous);\n  /** @type {NonNullable<Code>} */\n\n  let marker;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('attentionSequence');\n    marker = code;\n    return sequence(code);\n  }\n  /** @type {State} */\n\n\n  function sequence(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return sequence;\n    }\n\n    const token = effects.exit('attentionSequence');\n    const after = classifyCharacter(code);\n    const open = !after || after === 2 && before || attentionMarkers.includes(code);\n    const close = !before || before === 2 && after || attentionMarkers.includes(previous);\n    token._open = Boolean(marker === 42 ? open : open && (before || !close));\n    token._close = Boolean(marker === 42 ? close : close && (after || !open));\n    return ok(code);\n  }\n}\n/**\n * Move a point a bit.\n *\n * Note: `move` only works inside lines! It’s not possible to move past other\n * chunks (replacement characters, tabs, or line endings).\n *\n * @param {Point} point\n * @param {number} offset\n * @returns {void}\n */\n\n\nfunction movePoint(point, offset) {\n  point.column += offset;\n  point.offset += offset;\n  point._bufferIndex += offset;\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { asciiAlpha, asciiAlphanumeric, asciiAtext, asciiControl } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const autolink = {\n  name: 'autolink',\n  tokenize: tokenizeAutolink\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeAutolink(effects, ok, nok) {\n  let size = 1;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('autolink');\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.enter('autolinkProtocol');\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return schemeOrEmailAtext;\n    }\n\n    return asciiAtext(code) ? emailAtext(code) : nok(code);\n  }\n  /** @type {State} */\n\n\n  function schemeOrEmailAtext(code) {\n    return code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code) ? schemeInsideOrEmailAtext(code) : emailAtext(code);\n  }\n  /** @type {State} */\n\n\n  function schemeInsideOrEmailAtext(code) {\n    if (code === 58) {\n      effects.consume(code);\n      return urlInside;\n    }\n\n    if ((code === 43 || code === 45 || code === 46 || asciiAlphanumeric(code)) && size++ < 32) {\n      effects.consume(code);\n      return schemeInsideOrEmailAtext;\n    }\n\n    return emailAtext(code);\n  }\n  /** @type {State} */\n\n\n  function urlInside(code) {\n    if (code === 62) {\n      effects.exit('autolinkProtocol');\n      return end(code);\n    }\n\n    if (code === null || code === 32 || code === 60 || asciiControl(code)) {\n      return nok(code);\n    }\n\n    effects.consume(code);\n    return urlInside;\n  }\n  /** @type {State} */\n\n\n  function emailAtext(code) {\n    if (code === 64) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (asciiAtext(code)) {\n      effects.consume(code);\n      return emailAtext;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function emailAtSignOrDot(code) {\n    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code);\n  }\n  /** @type {State} */\n\n\n  function emailLabel(code) {\n    if (code === 46) {\n      effects.consume(code);\n      size = 0;\n      return emailAtSignOrDot;\n    }\n\n    if (code === 62) {\n      // Exit, then change the type.\n      effects.exit('autolinkProtocol').type = 'autolinkEmail';\n      return end(code);\n    }\n\n    return emailValue(code);\n  }\n  /** @type {State} */\n\n\n  function emailValue(code) {\n    if ((code === 45 || asciiAlphanumeric(code)) && size++ < 63) {\n      effects.consume(code);\n      return code === 45 ? emailValue : emailLabel;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function end(code) {\n    effects.enter('autolinkMarker');\n    effects.consume(code);\n    effects.exit('autolinkMarker');\n    effects.exit('autolink');\n    return ok;\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n * @typedef {import('micromark-util-types').Code} Code\n */\nimport { factorySpace } from 'micromark-factory-space';\nimport { asciiAlpha, asciiAlphanumeric, markdownLineEnding, markdownLineEndingOrSpace, markdownSpace } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const htmlText = {\n  name: 'htmlText',\n  tokenize: tokenizeHtmlText\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeHtmlText(effects, ok, nok) {\n  const self = this;\n  /** @type {NonNullable<Code>|undefined} */\n\n  let marker;\n  /** @type {string} */\n\n  let buffer;\n  /** @type {number} */\n\n  let index;\n  /** @type {State} */\n\n  let returnState;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('htmlText');\n    effects.enter('htmlTextData');\n    effects.consume(code);\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (code === 33) {\n      effects.consume(code);\n      return declarationOpen;\n    }\n\n    if (code === 47) {\n      effects.consume(code);\n      return tagCloseStart;\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instruction;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function declarationOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentOpen;\n    }\n\n    if (code === 91) {\n      effects.consume(code);\n      buffer = 'CDATA[';\n      index = 0;\n      return cdataOpen;\n    }\n\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return declaration;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function commentOpen(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return commentStart;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function commentStart(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentStartDash;\n    }\n\n    return comment(code);\n  }\n  /** @type {State} */\n\n\n  function commentStartDash(code) {\n    if (code === null || code === 62) {\n      return nok(code);\n    }\n\n    return comment(code);\n  }\n  /** @type {State} */\n\n\n  function comment(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 45) {\n      effects.consume(code);\n      return commentClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = comment;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return comment;\n  }\n  /** @type {State} */\n\n\n  function commentClose(code) {\n    if (code === 45) {\n      effects.consume(code);\n      return end;\n    }\n\n    return comment(code);\n  }\n  /** @type {State} */\n\n\n  function cdataOpen(code) {\n    if (code === buffer.charCodeAt(index++)) {\n      effects.consume(code);\n      return index === buffer.length ? cdata : cdataOpen;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function cdata(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = cdata;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return cdata;\n  }\n  /** @type {State} */\n\n\n  function cdataClose(code) {\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n  /** @type {State} */\n\n\n  function cdataEnd(code) {\n    if (code === 62) {\n      return end(code);\n    }\n\n    if (code === 93) {\n      effects.consume(code);\n      return cdataEnd;\n    }\n\n    return cdata(code);\n  }\n  /** @type {State} */\n\n\n  function declaration(code) {\n    if (code === null || code === 62) {\n      return end(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = declaration;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return declaration;\n  }\n  /** @type {State} */\n\n\n  function instruction(code) {\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (code === 63) {\n      effects.consume(code);\n      return instructionClose;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = instruction;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return instruction;\n  }\n  /** @type {State} */\n\n\n  function instructionClose(code) {\n    return code === 62 ? end(code) : instruction(code);\n  }\n  /** @type {State} */\n\n\n  function tagCloseStart(code) {\n    if (asciiAlpha(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function tagClose(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagClose;\n    }\n\n    return tagCloseBetween(code);\n  }\n  /** @type {State} */\n\n\n  function tagCloseBetween(code) {\n    if (markdownLineEnding(code)) {\n      returnState = tagCloseBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagCloseBetween;\n    }\n\n    return end(code);\n  }\n  /** @type {State} */\n\n\n  function tagOpen(code) {\n    if (code === 45 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpen;\n    }\n\n    if (code === 47 || code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function tagOpenBetween(code) {\n    if (code === 47) {\n      effects.consume(code);\n      return end;\n    }\n\n    if (code === 58 || code === 95 || asciiAlpha(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenBetween;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenBetween;\n    }\n\n    return end(code);\n  }\n  /** @type {State} */\n\n\n  function tagOpenAttributeName(code) {\n    if (code === 45 || code === 46 || code === 58 || code === 95 || asciiAlphanumeric(code)) {\n      effects.consume(code);\n      return tagOpenAttributeName;\n    }\n\n    return tagOpenAttributeNameAfter(code);\n  }\n  /** @type {State} */\n\n\n  function tagOpenAttributeNameAfter(code) {\n    if (code === 61) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeNameAfter;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeNameAfter;\n    }\n\n    return tagOpenBetween(code);\n  }\n  /** @type {State} */\n\n\n  function tagOpenAttributeValueBefore(code) {\n    if (code === null || code === 60 || code === 61 || code === 62 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 34 || code === 39) {\n      effects.consume(code);\n      marker = code;\n      return tagOpenAttributeValueQuoted;\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueBefore;\n      return atLineEnding(code);\n    }\n\n    if (markdownSpace(code)) {\n      effects.consume(code);\n      return tagOpenAttributeValueBefore;\n    }\n\n    effects.consume(code);\n    marker = undefined;\n    return tagOpenAttributeValueUnquoted;\n  }\n  /** @type {State} */\n\n\n  function tagOpenAttributeValueQuoted(code) {\n    if (code === marker) {\n      effects.consume(code);\n      return tagOpenAttributeValueQuotedAfter;\n    }\n\n    if (code === null) {\n      return nok(code);\n    }\n\n    if (markdownLineEnding(code)) {\n      returnState = tagOpenAttributeValueQuoted;\n      return atLineEnding(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueQuoted;\n  }\n  /** @type {State} */\n\n\n  function tagOpenAttributeValueQuotedAfter(code) {\n    if (code === 62 || code === 47 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    return nok(code);\n  }\n  /** @type {State} */\n\n\n  function tagOpenAttributeValueUnquoted(code) {\n    if (code === null || code === 34 || code === 39 || code === 60 || code === 61 || code === 96) {\n      return nok(code);\n    }\n\n    if (code === 62 || markdownLineEndingOrSpace(code)) {\n      return tagOpenBetween(code);\n    }\n\n    effects.consume(code);\n    return tagOpenAttributeValueUnquoted;\n  } // We can’t have blank lines in content, so no need to worry about empty\n  // tokens.\n\n  /** @type {State} */\n\n\n  function atLineEnding(code) {\n    effects.exit('htmlTextData');\n    effects.enter('lineEnding');\n    effects.consume(code);\n    effects.exit('lineEnding');\n    return factorySpace(effects, afterPrefix, 'linePrefix', self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);\n  }\n  /** @type {State} */\n\n\n  function afterPrefix(code) {\n    effects.enter('htmlTextData');\n    return returnState(code);\n  }\n  /** @type {State} */\n\n\n  function end(code) {\n    if (code === 62) {\n      effects.consume(code);\n      effects.exit('htmlTextData');\n      effects.exit('htmlText');\n      return ok;\n    }\n\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { labelEnd } from './label-end.js';\n/** @type {Construct} */\n\nexport const labelStartLink = {\n  name: 'labelStartLink',\n  tokenize: tokenizeLabelStartLink,\n  resolveAll: labelEnd.resolveAll\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeLabelStartLink(effects, ok, nok) {\n  const self = this;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('labelLink');\n    effects.enter('labelMarker');\n    effects.consume(code);\n    effects.exit('labelMarker');\n    effects.exit('labelLink');\n    return after;\n  }\n  /** @type {State} */\n\n\n  function after(code) {\n    /* To do: remove in the future once we’ve switched from\n     * `micromark-extension-footnote` to `micromark-extension-gfm-footnote`,\n     * which doesn’t need this */\n\n    /* Hidden footnotes hook. */\n\n    /* c8 ignore next 3 */\n    return code === 94 && '_hiddenFootnoteSupport' in self.parser.constructs ? nok(code) : ok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').State} State\n */\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const hardBreakEscape = {\n  name: 'hardBreakEscape',\n  tokenize: tokenizeHardBreakEscape\n};\n/** @type {Tokenizer} */\n\nfunction tokenizeHardBreakEscape(effects, ok, nok) {\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('hardBreakEscape');\n    effects.enter('escapeMarker');\n    effects.consume(code);\n    return open;\n  }\n  /** @type {State} */\n\n\n  function open(code) {\n    if (markdownLineEnding(code)) {\n      effects.exit('escapeMarker');\n      effects.exit('hardBreakEscape');\n      return ok(code);\n    }\n\n    return nok(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Construct} Construct\n * @typedef {import('micromark-util-types').Resolver} Resolver\n * @typedef {import('micromark-util-types').Tokenizer} Tokenizer\n * @typedef {import('micromark-util-types').Previous} Previous\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').State} State\n */\nimport { markdownLineEnding } from 'micromark-util-character';\n/** @type {Construct} */\n\nexport const codeText = {\n  name: 'codeText',\n  tokenize: tokenizeCodeText,\n  resolve: resolveCodeText,\n  previous\n};\n/** @type {Resolver} */\n\nfunction resolveCodeText(events) {\n  let tailExitIndex = events.length - 4;\n  let headEnterIndex = 3;\n  /** @type {number} */\n\n  let index;\n  /** @type {number|undefined} */\n\n  let enter; // If we start and end with an EOL or a space.\n\n  if ((events[headEnterIndex][1].type === 'lineEnding' || events[headEnterIndex][1].type === 'space') && (events[tailExitIndex][1].type === 'lineEnding' || events[tailExitIndex][1].type === 'space')) {\n    index = headEnterIndex; // And we have data.\n\n    while (++index < tailExitIndex) {\n      if (events[index][1].type === 'codeTextData') {\n        // Then we have padding.\n        events[headEnterIndex][1].type = 'codeTextPadding';\n        events[tailExitIndex][1].type = 'codeTextPadding';\n        headEnterIndex += 2;\n        tailExitIndex -= 2;\n        break;\n      }\n    }\n  } // Merge adjacent spaces and data.\n\n\n  index = headEnterIndex - 1;\n  tailExitIndex++;\n\n  while (++index <= tailExitIndex) {\n    if (enter === undefined) {\n      if (index !== tailExitIndex && events[index][1].type !== 'lineEnding') {\n        enter = index;\n      }\n    } else if (index === tailExitIndex || events[index][1].type === 'lineEnding') {\n      events[enter][1].type = 'codeTextData';\n\n      if (index !== enter + 2) {\n        events[enter][1].end = events[index - 1][1].end;\n        events.splice(enter + 2, index - enter - 2);\n        tailExitIndex -= index - enter - 2;\n        index = enter + 2;\n      }\n\n      enter = undefined;\n    }\n  }\n\n  return events;\n}\n/** @type {Previous} */\n\n\nfunction previous(code) {\n  // If there is a previous code, there will always be a tail.\n  return code !== 96 || this.events[this.events.length - 1][1].type === 'characterEscape';\n}\n/** @type {Tokenizer} */\n\n\nfunction tokenizeCodeText(effects, ok, nok) {\n  const self = this;\n  let sizeOpen = 0;\n  /** @type {number} */\n\n  let size;\n  /** @type {Token} */\n\n  let token;\n  return start;\n  /** @type {State} */\n\n  function start(code) {\n    effects.enter('codeText');\n    effects.enter('codeTextSequence');\n    return openingSequence(code);\n  }\n  /** @type {State} */\n\n\n  function openingSequence(code) {\n    if (code === 96) {\n      effects.consume(code);\n      sizeOpen++;\n      return openingSequence;\n    }\n\n    effects.exit('codeTextSequence');\n    return gap(code);\n  }\n  /** @type {State} */\n\n\n  function gap(code) {\n    // EOF.\n    if (code === null) {\n      return nok(code);\n    } // Closing fence?\n    // Could also be data.\n\n\n    if (code === 96) {\n      token = effects.enter('codeTextSequence');\n      size = 0;\n      return closingSequence(code);\n    } // Tabs don’t work, and virtual spaces don’t make sense.\n\n\n    if (code === 32) {\n      effects.enter('space');\n      effects.consume(code);\n      effects.exit('space');\n      return gap;\n    }\n\n    if (markdownLineEnding(code)) {\n      effects.enter('lineEnding');\n      effects.consume(code);\n      effects.exit('lineEnding');\n      return gap;\n    } // Data.\n\n\n    effects.enter('codeTextData');\n    return data(code);\n  } // In code.\n\n  /** @type {State} */\n\n\n  function data(code) {\n    if (code === null || code === 32 || code === 96 || markdownLineEnding(code)) {\n      effects.exit('codeTextData');\n      return gap(code);\n    }\n\n    effects.consume(code);\n    return data;\n  } // Closing fence.\n\n  /** @type {State} */\n\n\n  function closingSequence(code) {\n    // More.\n    if (code === 96) {\n      effects.consume(code);\n      size++;\n      return closingSequence;\n    } // Done!\n\n\n    if (size === sizeOpen) {\n      effects.exit('codeTextSequence');\n      effects.exit('codeText');\n      return ok(code);\n    } // More or less accents: mark as data.\n\n\n    token.type = 'codeTextData';\n    return data(code);\n  }\n}","/**\n * @typedef {import('micromark-util-types').Extension} Extension\n */\nimport { attention, autolink, blockQuote, characterEscape, characterReference, codeFenced, codeIndented, codeText, definition, hardBreakEscape, headingAtx, htmlFlow, htmlText, labelEnd, labelStartImage, labelStartLink, lineEnding, list, setextUnderline, thematicBreak } from 'micromark-core-commonmark';\nimport { resolver as resolveText } from './initialize/text.js';\n/** @type {Extension['document']} */\n\nexport const document = {\n  [42]: list,\n  [43]: list,\n  [45]: list,\n  [48]: list,\n  [49]: list,\n  [50]: list,\n  [51]: list,\n  [52]: list,\n  [53]: list,\n  [54]: list,\n  [55]: list,\n  [56]: list,\n  [57]: list,\n  [62]: blockQuote\n};\n/** @type {Extension['contentInitial']} */\n\nexport const contentInitial = {\n  [91]: definition\n};\n/** @type {Extension['flowInitial']} */\n\nexport const flowInitial = {\n  [-2]: codeIndented,\n  [-1]: codeIndented,\n  [32]: codeIndented\n};\n/** @type {Extension['flow']} */\n\nexport const flow = {\n  [35]: headingAtx,\n  [42]: thematicBreak,\n  [45]: [setextUnderline, thematicBreak],\n  [60]: htmlFlow,\n  [61]: setextUnderline,\n  [95]: thematicBreak,\n  [96]: codeFenced,\n  [126]: codeFenced\n};\n/** @type {Extension['string']} */\n\nexport const string = {\n  [38]: characterReference,\n  [92]: characterEscape\n};\n/** @type {Extension['text']} */\n\nexport const text = {\n  [-5]: lineEnding,\n  [-4]: lineEnding,\n  [-3]: lineEnding,\n  [33]: labelStartImage,\n  [38]: characterReference,\n  [42]: attention,\n  [60]: [autolink, htmlText],\n  [91]: labelStartLink,\n  [92]: [hardBreakEscape, characterEscape],\n  [93]: labelEnd,\n  [95]: attention,\n  [96]: codeText\n};\n/** @type {Extension['insideSpan']} */\n\nexport const insideSpan = {\n  null: [attention, resolveText]\n};\n/** @type {Extension['attentionMarkers']} */\n\nexport const attentionMarkers = {\n  null: [42, 95]\n};\n/** @type {Extension['disable']} */\n\nexport const disable = {\n  null: []\n};","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('micromark-util-types').Chunk} Chunk\n * @typedef {import('micromark-util-types').Code} Code\n */\n\n/**\n * @callback Preprocessor\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {boolean} [end=false]\n * @returns {Chunk[]}\n */\nconst search = /[\\0\\t\\n\\r]/g;\n/**\n * @returns {Preprocessor}\n */\n\nexport function preprocess() {\n  let column = 1;\n  let buffer = '';\n  /** @type {boolean|undefined} */\n\n  let start = true;\n  /** @type {boolean|undefined} */\n\n  let atCarriageReturn;\n  return preprocessor;\n  /** @type {Preprocessor} */\n\n  function preprocessor(value, encoding, end) {\n    /** @type {Chunk[]} */\n    const chunks = [];\n    /** @type {RegExpMatchArray|null} */\n\n    let match;\n    /** @type {number} */\n\n    let next;\n    /** @type {number} */\n\n    let startPosition;\n    /** @type {number} */\n\n    let endPosition;\n    /** @type {Code} */\n\n    let code; // @ts-expect-error `Buffer` does allow an encoding.\n\n    value = buffer + value.toString(encoding);\n    startPosition = 0;\n    buffer = '';\n\n    if (start) {\n      if (value.charCodeAt(0) === 65279) {\n        startPosition++;\n      }\n\n      start = undefined;\n    }\n\n    while (startPosition < value.length) {\n      search.lastIndex = startPosition;\n      match = search.exec(value);\n      endPosition = match && match.index !== undefined ? match.index : value.length;\n      code = value.charCodeAt(endPosition);\n\n      if (!match) {\n        buffer = value.slice(startPosition);\n        break;\n      }\n\n      if (code === 10 && startPosition === endPosition && atCarriageReturn) {\n        chunks.push(-3);\n        atCarriageReturn = undefined;\n      } else {\n        if (atCarriageReturn) {\n          chunks.push(-5);\n          atCarriageReturn = undefined;\n        }\n\n        if (startPosition < endPosition) {\n          chunks.push(value.slice(startPosition, endPosition));\n          column += endPosition - startPosition;\n        }\n\n        switch (code) {\n          case 0:\n            {\n              chunks.push(65533);\n              column++;\n              break;\n            }\n\n          case 9:\n            {\n              next = Math.ceil(column / 4) * 4;\n              chunks.push(-2);\n\n              while (column++ < next) chunks.push(-1);\n\n              break;\n            }\n\n          case 10:\n            {\n              chunks.push(-4);\n              column = 1;\n              break;\n            }\n\n          default:\n            {\n              atCarriageReturn = true;\n              column = 1;\n            }\n        }\n      }\n\n      startPosition = endPosition + 1;\n    }\n\n    if (end) {\n      if (atCarriageReturn) chunks.push(-5);\n      if (buffer) chunks.push(buffer);\n      chunks.push(null);\n    }\n\n    return chunks;\n  }\n}","/**\n * Turn the number (in string form as either hexa- or plain decimal) coming from\n * a numeric character reference into a character.\n *\n * @param {string} value\n *   Value to decode.\n * @param {number} base\n *   Numeric base.\n * @returns {string}\n */\nexport function decodeNumericCharacterReference(value, base) {\n  const code = Number.parseInt(value, base);\n\n  if ( // C0 except for HT, LF, FF, CR, space\n  code < 9 || code === 11 || code > 13 && code < 32 || // Control character (DEL) of the basic block and C1 controls.\n  code > 126 && code < 160 || // Lone high surrogates and low surrogates.\n  code > 55295 && code < 57344 || // Noncharacters.\n  code > 64975 && code < 65008 || (code & 65535) === 65535 || (code & 65535) === 65534 || // Out of range\n  code > 1114111) {\n    return '\\uFFFD';\n  }\n\n  return String.fromCharCode(code);\n}","import { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nconst characterEscapeOrReference = /\\\\([!-/:-@[-`{-~])|&(#(?:\\d{1,7}|x[\\da-f]{1,6})|[\\da-z]{1,31});/gi;\n/**\n * Utility to decode markdown strings (which occur in places such as fenced\n * code info strings, destinations, labels, and titles).\n * The “string” content type allows character escapes and -references.\n * This decodes those.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function decodeString(value) {\n  return value.replace(characterEscapeOrReference, decode);\n}\n/**\n * @param {string} $0\n * @param {string} $1\n * @param {string} $2\n * @returns {string}\n */\n\nfunction decode($0, $1, $2) {\n  if ($1) {\n    // Escape.\n    return $1;\n  } // Reference.\n\n\n  const head = $2.charCodeAt(0);\n\n  if (head === 35) {\n    const head = $2.charCodeAt(1);\n    const hex = head === 120 || head === 88;\n    return decodeNumericCharacterReference($2.slice(hex ? 2 : 1), hex ? 16 : 10);\n  }\n\n  return decodeNamedCharacterReference($2) || $0;\n}","/**\n * @typedef {import('micromark-util-types').Encoding} Encoding\n * @typedef {import('micromark-util-types').Event} Event\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').Token} Token\n * @typedef {import('micromark-util-types').TokenizeContext} TokenizeContext\n * @typedef {import('micromark-util-types').Value} Value\n * @typedef {import('unist').Parent} UnistParent\n * @typedef {import('unist').Point} Point\n * @typedef {import('mdast').PhrasingContent} PhrasingContent\n * @typedef {import('mdast').Content} Content\n * @typedef {Root|Content} Node\n * @typedef {Extract<Node, UnistParent>} Parent\n * @typedef {import('mdast').Break} Break\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('mdast').Code} Code\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('mdast').Image} Image\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('mdast').Link} Link\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').List} List\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('mdast').Text} Text\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n *\n * @typedef {UnistParent & {type: 'fragment', children: Array<PhrasingContent>}} Fragment\n */\n\n/**\n * @typedef _CompileDataFields\n * @property {boolean|undefined} expectingFirstListItemValue\n * @property {boolean|undefined} flowCodeInside\n * @property {boolean|undefined} setextHeadingSlurpLineEnding\n * @property {boolean|undefined} atHardBreak\n * @property {'collapsed'|'full'} referenceType\n * @property {boolean|undefined} inReference\n * @property {'characterReferenceMarkerHexadecimal'|'characterReferenceMarkerNumeric'} characterReferenceType\n *\n * @typedef {Record<string, unknown> & Partial<_CompileDataFields>} CompileData\n *\n * @typedef {(tree: Root) => Root|void} Transform\n * @typedef {(this: CompileContext, token: Token) => void} Handle\n * @typedef {Record<string, Handle>} Handles\n *   Token types mapping to handles\n * @typedef {Record<string, Record<string, unknown>|Array<unknown>> & {canContainEols: Array<string>, transforms: Array<Transform>, enter: Handles, exit: Handles}} NormalizedExtension\n * @typedef {Partial<NormalizedExtension>} Extension\n *   An mdast extension changes how markdown tokens are turned into mdast.\n *\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token|undefined, right: Token) => void} OnEnterError\n * @typedef {(this: Omit<CompileContext, 'sliceSerialize'>, left: Token, right: Token) => void} OnExitError\n *\n * @typedef CompileContext\n *   mdast compiler context\n * @property {Array<Node | Fragment>} stack\n * @property {Array<[Token, OnEnterError|undefined]>} tokenStack\n * @property {(key: string, value?: unknown) => void} setData\n *   Set data into the key-value store.\n * @property {<K extends string>(key: K) => CompileData[K]} getData\n *   Get data from the key-value store.\n * @property {(this: CompileContext) => void} buffer\n *   Capture some of the output data.\n * @property {(this: CompileContext) => string} resume\n *   Stop capturing and access the output data.\n * @property {<N extends Node>(this: CompileContext, node: N, token: Token, onError?: OnEnterError) => N} enter\n *   Enter a token.\n * @property {(this: CompileContext, token: Token, onError?: OnExitError) => Node} exit\n *   Exit a token.\n * @property {TokenizeContext['sliceSerialize']} sliceSerialize\n *   Get the string value of a token.\n * @property {NormalizedExtension} config\n *   Configuration.\n *\n * @typedef {{mdastExtensions?: Array<Extension|Array<Extension>>}} FromMarkdownOptions\n * @typedef {ParseOptions & FromMarkdownOptions} Options\n */\nimport { toString } from 'mdast-util-to-string';\nimport { parse } from 'micromark/lib/parse.js';\nimport { preprocess } from 'micromark/lib/preprocess.js';\nimport { postprocess } from 'micromark/lib/postprocess.js';\nimport { decodeNumericCharacterReference } from 'micromark-util-decode-numeric-character-reference';\nimport { decodeString } from 'micromark-util-decode-string';\nimport { normalizeIdentifier } from 'micromark-util-normalize-identifier';\nimport { decodeNamedCharacterReference } from 'decode-named-character-reference';\nimport { stringifyPosition } from 'unist-util-stringify-position';\nconst own = {}.hasOwnProperty;\n/**\n * @param value Markdown to parse (`string` or `Buffer`).\n * @param [encoding] Character encoding to understand `value` as when it’s a `Buffer` (`string`, default: `'utf8'`).\n * @param [options] Configuration\n */\n\nexport const fromMarkdown =\n/**\n * @type {(\n *   ((value: Value, encoding: Encoding, options?: Options) => Root) &\n *   ((value: Value, options?: Options) => Root)\n * )}\n */\n\n/**\n * @param {Value} value\n * @param {Encoding} [encoding]\n * @param {Options} [options]\n * @returns {Root}\n */\nfunction (value, encoding, options) {\n  if (typeof encoding !== 'string') {\n    options = encoding;\n    encoding = undefined;\n  }\n\n  return compiler(options)(postprocess(parse(options).document().write(preprocess()(value, encoding, true))));\n};\n/**\n * Note this compiler only understand complete buffering, not streaming.\n *\n * @param {Options} [options]\n */\n\nfunction compiler() {\n  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n  /** @type {NormalizedExtension} */\n  // @ts-expect-error: our base has all required fields, so the result will too.\n  const config = configure({\n    transforms: [],\n    canContainEols: ['emphasis', 'fragment', 'heading', 'paragraph', 'strong'],\n    enter: {\n      autolink: opener(link),\n      autolinkProtocol: onenterdata,\n      autolinkEmail: onenterdata,\n      atxHeading: opener(heading),\n      blockQuote: opener(blockQuote),\n      characterEscape: onenterdata,\n      characterReference: onenterdata,\n      codeFenced: opener(codeFlow),\n      codeFencedFenceInfo: buffer,\n      codeFencedFenceMeta: buffer,\n      codeIndented: opener(codeFlow, buffer),\n      codeText: opener(codeText, buffer),\n      codeTextData: onenterdata,\n      data: onenterdata,\n      codeFlowValue: onenterdata,\n      definition: opener(definition),\n      definitionDestinationString: buffer,\n      definitionLabelString: buffer,\n      definitionTitleString: buffer,\n      emphasis: opener(emphasis),\n      hardBreakEscape: opener(hardBreak),\n      hardBreakTrailing: opener(hardBreak),\n      htmlFlow: opener(html, buffer),\n      htmlFlowData: onenterdata,\n      htmlText: opener(html, buffer),\n      htmlTextData: onenterdata,\n      image: opener(image),\n      label: buffer,\n      link: opener(link),\n      listItem: opener(listItem),\n      listItemValue: onenterlistitemvalue,\n      listOrdered: opener(list, onenterlistordered),\n      listUnordered: opener(list),\n      paragraph: opener(paragraph),\n      reference: onenterreference,\n      referenceString: buffer,\n      resourceDestinationString: buffer,\n      resourceTitleString: buffer,\n      setextHeading: opener(heading),\n      strong: opener(strong),\n      thematicBreak: opener(thematicBreak)\n    },\n    exit: {\n      atxHeading: closer(),\n      atxHeadingSequence: onexitatxheadingsequence,\n      autolink: closer(),\n      autolinkEmail: onexitautolinkemail,\n      autolinkProtocol: onexitautolinkprotocol,\n      blockQuote: closer(),\n      characterEscapeValue: onexitdata,\n      characterReferenceMarkerHexadecimal: onexitcharacterreferencemarker,\n      characterReferenceMarkerNumeric: onexitcharacterreferencemarker,\n      characterReferenceValue: onexitcharacterreferencevalue,\n      codeFenced: closer(onexitcodefenced),\n      codeFencedFence: onexitcodefencedfence,\n      codeFencedFenceInfo: onexitcodefencedfenceinfo,\n      codeFencedFenceMeta: onexitcodefencedfencemeta,\n      codeFlowValue: onexitdata,\n      codeIndented: closer(onexitcodeindented),\n      codeText: closer(onexitcodetext),\n      codeTextData: onexitdata,\n      data: onexitdata,\n      definition: closer(),\n      definitionDestinationString: onexitdefinitiondestinationstring,\n      definitionLabelString: onexitdefinitionlabelstring,\n      definitionTitleString: onexitdefinitiontitlestring,\n      emphasis: closer(),\n      hardBreakEscape: closer(onexithardbreak),\n      hardBreakTrailing: closer(onexithardbreak),\n      htmlFlow: closer(onexithtmlflow),\n      htmlFlowData: onexitdata,\n      htmlText: closer(onexithtmltext),\n      htmlTextData: onexitdata,\n      image: closer(onexitimage),\n      label: onexitlabel,\n      labelText: onexitlabeltext,\n      lineEnding: onexitlineending,\n      link: closer(onexitlink),\n      listItem: closer(),\n      listOrdered: closer(),\n      listUnordered: closer(),\n      paragraph: closer(),\n      referenceString: onexitreferencestring,\n      resourceDestinationString: onexitresourcedestinationstring,\n      resourceTitleString: onexitresourcetitlestring,\n      resource: onexitresource,\n      setextHeading: closer(onexitsetextheading),\n      setextHeadingLineSequence: onexitsetextheadinglinesequence,\n      setextHeadingText: onexitsetextheadingtext,\n      strong: closer(),\n      thematicBreak: closer()\n    }\n  }, options.mdastExtensions || []);\n  /** @type {CompileData} */\n\n  const data = {};\n  return compile;\n  /**\n   * @param {Array<Event>} events\n   * @returns {Root}\n   */\n\n  function compile(events) {\n    /** @type {Root} */\n    let tree = {\n      type: 'root',\n      children: []\n    };\n    /** @type {CompileContext['stack']} */\n\n    const stack = [tree];\n    /** @type {CompileContext['tokenStack']} */\n\n    const tokenStack = [];\n    /** @type {Array<number>} */\n\n    const listStack = [];\n    /** @type {Omit<CompileContext, 'sliceSerialize'>} */\n\n    const context = {\n      stack,\n      tokenStack,\n      config,\n      enter,\n      exit,\n      buffer,\n      resume,\n      setData,\n      getData\n    };\n    let index = -1;\n\n    while (++index < events.length) {\n      // We preprocess lists to add `listItem` tokens, and to infer whether\n      // items the list itself are spread out.\n      if (events[index][1].type === 'listOrdered' || events[index][1].type === 'listUnordered') {\n        if (events[index][0] === 'enter') {\n          listStack.push(index);\n        } else {\n          const tail = listStack.pop();\n          index = prepareList(events, tail, index);\n        }\n      }\n    }\n\n    index = -1;\n\n    while (++index < events.length) {\n      const handler = config[events[index][0]];\n\n      if (own.call(handler, events[index][1].type)) {\n        handler[events[index][1].type].call(Object.assign({\n          sliceSerialize: events[index][2].sliceSerialize\n        }, context), events[index][1]);\n      }\n    }\n\n    if (tokenStack.length > 0) {\n      const tail = tokenStack[tokenStack.length - 1];\n      const handler = tail[1] || defaultOnError;\n      handler.call(context, undefined, tail[0]);\n    } // Figure out `root` position.\n\n\n    tree.position = {\n      start: point(events.length > 0 ? events[0][1].start : {\n        line: 1,\n        column: 1,\n        offset: 0\n      }),\n      end: point(events.length > 0 ? events[events.length - 2][1].end : {\n        line: 1,\n        column: 1,\n        offset: 0\n      })\n    };\n    index = -1;\n\n    while (++index < config.transforms.length) {\n      tree = config.transforms[index](tree) || tree;\n    }\n\n    return tree;\n  }\n  /**\n   * @param {Array<Event>} events\n   * @param {number} start\n   * @param {number} length\n   * @returns {number}\n   */\n\n\n  function prepareList(events, start, length) {\n    let index = start - 1;\n    let containerBalance = -1;\n    let listSpread = false;\n    /** @type {Token|undefined} */\n\n    let listItem;\n    /** @type {number|undefined} */\n\n    let lineIndex;\n    /** @type {number|undefined} */\n\n    let firstBlankLineIndex;\n    /** @type {boolean|undefined} */\n\n    let atMarker;\n\n    while (++index <= length) {\n      const event = events[index];\n\n      if (event[1].type === 'listUnordered' || event[1].type === 'listOrdered' || event[1].type === 'blockQuote') {\n        if (event[0] === 'enter') {\n          containerBalance++;\n        } else {\n          containerBalance--;\n        }\n\n        atMarker = undefined;\n      } else if (event[1].type === 'lineEndingBlank') {\n        if (event[0] === 'enter') {\n          if (listItem && !atMarker && !containerBalance && !firstBlankLineIndex) {\n            firstBlankLineIndex = index;\n          }\n\n          atMarker = undefined;\n        }\n      } else if (event[1].type === 'linePrefix' || event[1].type === 'listItemValue' || event[1].type === 'listItemMarker' || event[1].type === 'listItemPrefix' || event[1].type === 'listItemPrefixWhitespace') {// Empty.\n      } else {\n        atMarker = undefined;\n      }\n\n      if (!containerBalance && event[0] === 'enter' && event[1].type === 'listItemPrefix' || containerBalance === -1 && event[0] === 'exit' && (event[1].type === 'listUnordered' || event[1].type === 'listOrdered')) {\n        if (listItem) {\n          let tailIndex = index;\n          lineIndex = undefined;\n\n          while (tailIndex--) {\n            const tailEvent = events[tailIndex];\n\n            if (tailEvent[1].type === 'lineEnding' || tailEvent[1].type === 'lineEndingBlank') {\n              if (tailEvent[0] === 'exit') continue;\n\n              if (lineIndex) {\n                events[lineIndex][1].type = 'lineEndingBlank';\n                listSpread = true;\n              }\n\n              tailEvent[1].type = 'lineEnding';\n              lineIndex = tailIndex;\n            } else if (tailEvent[1].type === 'linePrefix' || tailEvent[1].type === 'blockQuotePrefix' || tailEvent[1].type === 'blockQuotePrefixWhitespace' || tailEvent[1].type === 'blockQuoteMarker' || tailEvent[1].type === 'listItemIndent') {// Empty\n            } else {\n              break;\n            }\n          }\n\n          if (firstBlankLineIndex && (!lineIndex || firstBlankLineIndex < lineIndex)) {\n            // @ts-expect-error Patched.\n            listItem._spread = true;\n          } // Fix position.\n\n\n          listItem.end = Object.assign({}, lineIndex ? events[lineIndex][1].start : event[1].end);\n          events.splice(lineIndex || index, 0, ['exit', listItem, event[2]]);\n          index++;\n          length++;\n        } // Create a new list item.\n\n\n        if (event[1].type === 'listItemPrefix') {\n          listItem = {\n            type: 'listItem',\n            // @ts-expect-error Patched\n            _spread: false,\n            start: Object.assign({}, event[1].start)\n          }; // @ts-expect-error: `listItem` is most definitely defined, TS...\n\n          events.splice(index, 0, ['enter', listItem, event[2]]);\n          index++;\n          length++;\n          firstBlankLineIndex = undefined;\n          atMarker = true;\n        }\n      }\n    } // @ts-expect-error Patched.\n\n\n    events[start][1]._spread = listSpread;\n    return length;\n  }\n  /**\n   * @type {CompileContext['setData']}\n   * @param [value]\n   */\n\n\n  function setData(key, value) {\n    data[key] = value;\n  }\n  /**\n   * @type {CompileContext['getData']}\n   * @template {string} K\n   * @param {K} key\n   * @returns {CompileData[K]}\n   */\n\n\n  function getData(key) {\n    return data[key];\n  }\n  /**\n   * @param {Point} d\n   * @returns {Point}\n   */\n\n\n  function point(d) {\n    return {\n      line: d.line,\n      column: d.column,\n      offset: d.offset\n    };\n  }\n  /**\n   * @param {(token: Token) => Node} create\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n\n  function opener(create, and) {\n    return open;\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function open(token) {\n      enter.call(this, create(token), token);\n      if (and) and.call(this, token);\n    }\n  }\n  /** @type {CompileContext['buffer']} */\n\n\n  function buffer() {\n    this.stack.push({\n      type: 'fragment',\n      children: []\n    });\n  }\n  /**\n   * @type {CompileContext['enter']}\n   * @template {Node} N\n   * @this {CompileContext}\n   * @param {N} node\n   * @param {Token} token\n   * @param {OnEnterError} [errorHandler]\n   * @returns {N}\n   */\n\n\n  function enter(node, token, errorHandler) {\n    const parent = this.stack[this.stack.length - 1]; // @ts-expect-error: Assume `Node` can exist as a child of `parent`.\n\n    parent.children.push(node);\n    this.stack.push(node);\n    this.tokenStack.push([token, errorHandler]); // @ts-expect-error: `end` will be patched later.\n\n    node.position = {\n      start: point(token.start)\n    };\n    return node;\n  }\n  /**\n   * @param {Handle} [and]\n   * @returns {Handle}\n   */\n\n\n  function closer(and) {\n    return close;\n    /**\n     * @this {CompileContext}\n     * @param {Token} token\n     * @returns {void}\n     */\n\n    function close(token) {\n      if (and) and.call(this, token);\n      exit.call(this, token);\n    }\n  }\n  /**\n   * @type {CompileContext['exit']}\n   * @this {CompileContext}\n   * @param {Token} token\n   * @param {OnExitError} [onExitError]\n   * @returns {Node}\n   */\n\n\n  function exit(token, onExitError) {\n    const node = this.stack.pop();\n    const open = this.tokenStack.pop();\n\n    if (!open) {\n      throw new Error('Cannot close `' + token.type + '` (' + stringifyPosition({\n        start: token.start,\n        end: token.end\n      }) + '): it’s not open');\n    } else if (open[0].type !== token.type) {\n      if (onExitError) {\n        onExitError.call(this, token, open[0]);\n      } else {\n        const handler = open[1] || defaultOnError;\n        handler.call(this, token, open[0]);\n      }\n    }\n\n    node.position.end = point(token.end);\n    return node;\n  }\n  /**\n   * @this {CompileContext}\n   * @returns {string}\n   */\n\n\n  function resume() {\n    return toString(this.stack.pop());\n  } //\n  // Handlers.\n  //\n\n  /** @type {Handle} */\n\n\n  function onenterlistordered() {\n    setData('expectingFirstListItemValue', true);\n  }\n  /** @type {Handle} */\n\n\n  function onenterlistitemvalue(token) {\n    if (getData('expectingFirstListItemValue')) {\n      const ancestor =\n      /** @type {List} */\n      this.stack[this.stack.length - 2];\n      ancestor.start = Number.parseInt(this.sliceSerialize(token), 10);\n      setData('expectingFirstListItemValue');\n    }\n  }\n  /** @type {Handle} */\n\n\n  function onexitcodefencedfenceinfo() {\n    const data = this.resume();\n    const node =\n    /** @type {Code} */\n    this.stack[this.stack.length - 1];\n    node.lang = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitcodefencedfencemeta() {\n    const data = this.resume();\n    const node =\n    /** @type {Code} */\n    this.stack[this.stack.length - 1];\n    node.meta = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitcodefencedfence() {\n    // Exit if this is the closing fence.\n    if (getData('flowCodeInside')) return;\n    this.buffer();\n    setData('flowCodeInside', true);\n  }\n  /** @type {Handle} */\n\n\n  function onexitcodefenced() {\n    const data = this.resume();\n    const node =\n    /** @type {Code} */\n    this.stack[this.stack.length - 1];\n    node.value = data.replace(/^(\\r?\\n|\\r)|(\\r?\\n|\\r)$/g, '');\n    setData('flowCodeInside');\n  }\n  /** @type {Handle} */\n\n\n  function onexitcodeindented() {\n    const data = this.resume();\n    const node =\n    /** @type {Code} */\n    this.stack[this.stack.length - 1];\n    node.value = data.replace(/(\\r?\\n|\\r)$/g, '');\n  }\n  /** @type {Handle} */\n\n\n  function onexitdefinitionlabelstring(token) {\n    // Discard label, use the source content instead.\n    const label = this.resume();\n    const node =\n    /** @type {Definition} */\n    this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n  }\n  /** @type {Handle} */\n\n\n  function onexitdefinitiontitlestring() {\n    const data = this.resume();\n    const node =\n    /** @type {Definition} */\n    this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitdefinitiondestinationstring() {\n    const data = this.resume();\n    const node =\n    /** @type {Definition} */\n    this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitatxheadingsequence(token) {\n    const node =\n    /** @type {Heading} */\n    this.stack[this.stack.length - 1];\n\n    if (!node.depth) {\n      const depth = this.sliceSerialize(token).length;\n      node.depth = depth;\n    }\n  }\n  /** @type {Handle} */\n\n\n  function onexitsetextheadingtext() {\n    setData('setextHeadingSlurpLineEnding', true);\n  }\n  /** @type {Handle} */\n\n\n  function onexitsetextheadinglinesequence(token) {\n    const node =\n    /** @type {Heading} */\n    this.stack[this.stack.length - 1];\n    node.depth = this.sliceSerialize(token).charCodeAt(0) === 61 ? 1 : 2;\n  }\n  /** @type {Handle} */\n\n\n  function onexitsetextheading() {\n    setData('setextHeadingSlurpLineEnding');\n  }\n  /** @type {Handle} */\n\n\n  function onenterdata(token) {\n    const parent =\n    /** @type {Parent} */\n    this.stack[this.stack.length - 1];\n    /** @type {Node} */\n\n    let tail = parent.children[parent.children.length - 1];\n\n    if (!tail || tail.type !== 'text') {\n      // Add a new text node.\n      tail = text(); // @ts-expect-error: we’ll add `end` later.\n\n      tail.position = {\n        start: point(token.start)\n      }; // @ts-expect-error: Assume `parent` accepts `text`.\n\n      parent.children.push(tail);\n    }\n\n    this.stack.push(tail);\n  }\n  /** @type {Handle} */\n\n\n  function onexitdata(token) {\n    const tail = this.stack.pop();\n    tail.value += this.sliceSerialize(token);\n    tail.position.end = point(token.end);\n  }\n  /** @type {Handle} */\n\n\n  function onexitlineending(token) {\n    const context = this.stack[this.stack.length - 1]; // If we’re at a hard break, include the line ending in there.\n\n    if (getData('atHardBreak')) {\n      const tail = context.children[context.children.length - 1];\n      tail.position.end = point(token.end);\n      setData('atHardBreak');\n      return;\n    }\n\n    if (!getData('setextHeadingSlurpLineEnding') && config.canContainEols.includes(context.type)) {\n      onenterdata.call(this, token);\n      onexitdata.call(this, token);\n    }\n  }\n  /** @type {Handle} */\n\n\n  function onexithardbreak() {\n    setData('atHardBreak', true);\n  }\n  /** @type {Handle} */\n\n\n  function onexithtmlflow() {\n    const data = this.resume();\n    const node =\n    /** @type {HTML} */\n    this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexithtmltext() {\n    const data = this.resume();\n    const node =\n    /** @type {HTML} */\n    this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitcodetext() {\n    const data = this.resume();\n    const node =\n    /** @type {InlineCode} */\n    this.stack[this.stack.length - 1];\n    node.value = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitlink() {\n    const context =\n    /** @type {Link & {identifier: string, label: string}} */\n    this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference'; // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut'; // @ts-expect-error: mutate.\n\n      delete context.url;\n      delete context.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier; // @ts-expect-error: mutate.\n\n      delete context.label;\n    }\n\n    setData('referenceType');\n  }\n  /** @type {Handle} */\n\n\n  function onexitimage() {\n    const context =\n    /** @type {Image & {identifier: string, label: string}} */\n    this.stack[this.stack.length - 1]; // To do: clean.\n\n    if (getData('inReference')) {\n      context.type += 'Reference'; // @ts-expect-error: mutate.\n\n      context.referenceType = getData('referenceType') || 'shortcut'; // @ts-expect-error: mutate.\n\n      delete context.url;\n      delete context.title;\n    } else {\n      // @ts-expect-error: mutate.\n      delete context.identifier; // @ts-expect-error: mutate.\n\n      delete context.label;\n    }\n\n    setData('referenceType');\n  }\n  /** @type {Handle} */\n\n\n  function onexitlabeltext(token) {\n    const ancestor =\n    /** @type {(Link|Image) & {identifier: string, label: string}} */\n    this.stack[this.stack.length - 2];\n    const string = this.sliceSerialize(token);\n    ancestor.label = decodeString(string);\n    ancestor.identifier = normalizeIdentifier(string).toLowerCase();\n  }\n  /** @type {Handle} */\n\n\n  function onexitlabel() {\n    const fragment =\n    /** @type {Fragment} */\n    this.stack[this.stack.length - 1];\n    const value = this.resume();\n    const node =\n    /** @type {(Link|Image) & {identifier: string, label: string}} */\n    this.stack[this.stack.length - 1]; // Assume a reference.\n\n    setData('inReference', true);\n\n    if (node.type === 'link') {\n      // @ts-expect-error: Assume static phrasing content.\n      node.children = fragment.children;\n    } else {\n      node.alt = value;\n    }\n  }\n  /** @type {Handle} */\n\n\n  function onexitresourcedestinationstring() {\n    const data = this.resume();\n    const node =\n    /** @type {Link|Image} */\n    this.stack[this.stack.length - 1];\n    node.url = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitresourcetitlestring() {\n    const data = this.resume();\n    const node =\n    /** @type {Link|Image} */\n    this.stack[this.stack.length - 1];\n    node.title = data;\n  }\n  /** @type {Handle} */\n\n\n  function onexitresource() {\n    setData('inReference');\n  }\n  /** @type {Handle} */\n\n\n  function onenterreference() {\n    setData('referenceType', 'collapsed');\n  }\n  /** @type {Handle} */\n\n\n  function onexitreferencestring(token) {\n    const label = this.resume();\n    const node =\n    /** @type {LinkReference|ImageReference} */\n    this.stack[this.stack.length - 1];\n    node.label = label;\n    node.identifier = normalizeIdentifier(this.sliceSerialize(token)).toLowerCase();\n    setData('referenceType', 'full');\n  }\n  /** @type {Handle} */\n\n\n  function onexitcharacterreferencemarker(token) {\n    setData('characterReferenceType', token.type);\n  }\n  /** @type {Handle} */\n\n\n  function onexitcharacterreferencevalue(token) {\n    const data = this.sliceSerialize(token);\n    const type = getData('characterReferenceType');\n    /** @type {string} */\n\n    let value;\n\n    if (type) {\n      value = decodeNumericCharacterReference(data, type === 'characterReferenceMarkerNumeric' ? 10 : 16);\n      setData('characterReferenceType');\n    } else {\n      // @ts-expect-error `decodeNamedCharacterReference` can return false for\n      // invalid named character references, but everything we’ve tokenized is\n      // valid.\n      value = decodeNamedCharacterReference(data);\n    }\n\n    const tail = this.stack.pop();\n    tail.value += value;\n    tail.position.end = point(token.end);\n  }\n  /** @type {Handle} */\n\n\n  function onexitautolinkprotocol(token) {\n    onexitdata.call(this, token);\n    const node =\n    /** @type {Link} */\n    this.stack[this.stack.length - 1];\n    node.url = this.sliceSerialize(token);\n  }\n  /** @type {Handle} */\n\n\n  function onexitautolinkemail(token) {\n    onexitdata.call(this, token);\n    const node =\n    /** @type {Link} */\n    this.stack[this.stack.length - 1];\n    node.url = 'mailto:' + this.sliceSerialize(token);\n  } //\n  // Creaters.\n  //\n\n  /** @returns {Blockquote} */\n\n\n  function blockQuote() {\n    return {\n      type: 'blockquote',\n      children: []\n    };\n  }\n  /** @returns {Code} */\n\n\n  function codeFlow() {\n    return {\n      type: 'code',\n      lang: null,\n      meta: null,\n      value: ''\n    };\n  }\n  /** @returns {InlineCode} */\n\n\n  function codeText() {\n    return {\n      type: 'inlineCode',\n      value: ''\n    };\n  }\n  /** @returns {Definition} */\n\n\n  function definition() {\n    return {\n      type: 'definition',\n      identifier: '',\n      label: null,\n      title: null,\n      url: ''\n    };\n  }\n  /** @returns {Emphasis} */\n\n\n  function emphasis() {\n    return {\n      type: 'emphasis',\n      children: []\n    };\n  }\n  /** @returns {Heading} */\n\n\n  function heading() {\n    // @ts-expect-error `depth` will be set later.\n    return {\n      type: 'heading',\n      depth: undefined,\n      children: []\n    };\n  }\n  /** @returns {Break} */\n\n\n  function hardBreak() {\n    return {\n      type: 'break'\n    };\n  }\n  /** @returns {HTML} */\n\n\n  function html() {\n    return {\n      type: 'html',\n      value: ''\n    };\n  }\n  /** @returns {Image} */\n\n\n  function image() {\n    return {\n      type: 'image',\n      title: null,\n      url: '',\n      alt: null\n    };\n  }\n  /** @returns {Link} */\n\n\n  function link() {\n    return {\n      type: 'link',\n      title: null,\n      url: '',\n      children: []\n    };\n  }\n  /**\n   * @param {Token} token\n   * @returns {List}\n   */\n\n\n  function list(token) {\n    return {\n      type: 'list',\n      ordered: token.type === 'listOrdered',\n      start: null,\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      children: []\n    };\n  }\n  /**\n   * @param {Token} token\n   * @returns {ListItem}\n   */\n\n\n  function listItem(token) {\n    return {\n      type: 'listItem',\n      // @ts-expect-error Patched.\n      spread: token._spread,\n      checked: null,\n      children: []\n    };\n  }\n  /** @returns {Paragraph} */\n\n\n  function paragraph() {\n    return {\n      type: 'paragraph',\n      children: []\n    };\n  }\n  /** @returns {Strong} */\n\n\n  function strong() {\n    return {\n      type: 'strong',\n      children: []\n    };\n  }\n  /** @returns {Text} */\n\n\n  function text() {\n    return {\n      type: 'text',\n      value: ''\n    };\n  }\n  /** @returns {ThematicBreak} */\n\n\n  function thematicBreak() {\n    return {\n      type: 'thematicBreak'\n    };\n  }\n}\n/**\n * @param {Extension} combined\n * @param {Array<Extension|Array<Extension>>} extensions\n * @returns {Extension}\n */\n\n\nfunction configure(combined, extensions) {\n  let index = -1;\n\n  while (++index < extensions.length) {\n    const value = extensions[index];\n\n    if (Array.isArray(value)) {\n      configure(combined, value);\n    } else {\n      extension(combined, value);\n    }\n  }\n\n  return combined;\n}\n/**\n * @param {Extension} combined\n * @param {Extension} extension\n * @returns {void}\n */\n\n\nfunction extension(combined, extension) {\n  /** @type {string} */\n  let key;\n\n  for (key in extension) {\n    if (own.call(extension, key)) {\n      const list = key === 'canContainEols' || key === 'transforms';\n      const maybe = own.call(combined, key) ? combined[key] : undefined;\n      /* c8 ignore next */\n\n      const left = maybe || (combined[key] = list ? [] : {});\n      const right = extension[key];\n\n      if (right) {\n        if (list) {\n          // @ts-expect-error: `left` is an array.\n          combined[key] = [...left, ...right];\n        } else {\n          Object.assign(left, right);\n        }\n      }\n    }\n  }\n}\n/** @type {OnEnterError} */\n\n\nfunction defaultOnError(left, right) {\n  if (left) {\n    throw new Error('Cannot close `' + left.type + '` (' + stringifyPosition({\n      start: left.start,\n      end: left.end\n    }) + '): a different token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is open');\n  } else {\n    throw new Error('Cannot close document, a token (`' + right.type + '`, ' + stringifyPosition({\n      start: right.start,\n      end: right.end\n    }) + ') is still open');\n  }\n}","/**\n * @typedef {import('micromark-util-types').Event} Event\n */\nimport { subtokenize } from 'micromark-util-subtokenize';\n/**\n * @param {Event[]} events\n * @returns {Event[]}\n */\n\nexport function postprocess(events) {\n  while (!subtokenize(events)) {// Empty\n  }\n\n  return events;\n}","/**\n * @typedef {import('micromark-util-types').InitialConstruct} InitialConstruct\n * @typedef {import('micromark-util-types').FullNormalizedExtension} FullNormalizedExtension\n * @typedef {import('micromark-util-types').ParseOptions} ParseOptions\n * @typedef {import('micromark-util-types').ParseContext} ParseContext\n * @typedef {import('micromark-util-types').Create} Create\n */\nimport { combineExtensions } from 'micromark-util-combine-extensions';\nimport { content } from './initialize/content.js';\nimport { document } from './initialize/document.js';\nimport { flow } from './initialize/flow.js';\nimport { text, string } from './initialize/text.js';\nimport { createTokenizer } from './create-tokenizer.js';\nimport * as defaultConstructs from './constructs.js';\n/**\n * @param {ParseOptions} [options]\n * @returns {ParseContext}\n */\n\nexport function parse() {\n  let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n  /** @type {FullNormalizedExtension} */\n  // @ts-expect-error `defaultConstructs` is full, so the result will be too.\n  const constructs = combineExtensions( // @ts-expect-error Same as above.\n  [defaultConstructs].concat(options.extensions || []));\n  /** @type {ParseContext} */\n\n  const parser = {\n    defined: [],\n    lazy: {},\n    constructs,\n    content: create(content),\n    document: create(document),\n    flow: create(flow),\n    string: create(string),\n    text: create(text)\n  };\n  return parser;\n  /**\n   * @param {InitialConstruct} initial\n   */\n\n  function create(initial) {\n    return creator;\n    /** @type {Create} */\n\n    function creator(from) {\n      return createTokenizer(parser, initial, from);\n    }\n  }\n}","import remarkParse from './lib/index.js';\nexport default remarkParse;","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('mdast-util-from-markdown').Options} Options\n */\nimport { fromMarkdown } from 'mdast-util-from-markdown';\n/** @type {import('unified').Plugin<[Options?] | void[], string, Root>} */\n\nexport default function remarkParse(options) {\n  /** @type {import('unified').ParserFunction<Root>} */\n  const parser = doc => {\n    // Assume options.\n    const settings =\n    /** @type {Options} */\n    this.data('settings');\n    return fromMarkdown(doc, Object.assign({}, settings, options, {\n      // Note: these options are not in the readme.\n      // The goal is for them to be set by plugins on `data` instead of being\n      // passed by users.\n      extensions: this.data('micromarkExtensions') || [],\n      mdastExtensions: this.data('fromMarkdownExtensions') || []\n    }));\n  };\n\n  Object.assign(this, {\n    Parser: parser\n  });\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist').Literal} Literal\n * @typedef {Object.<string, unknown>} Props\n * @typedef {Array.<Node>|string} ChildrenOrValue\n *\n * @typedef {(<T extends string, P extends Record<string, unknown>, C extends Node[]>(type: T, props: P, children: C) => {type: T, children: C} & P)} BuildParentWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P, value: string) => {type: T, value: string} & P)} BuildLiteralWithProps\n * @typedef {(<T extends string, P extends Record<string, unknown>>(type: T, props: P) => {type: T} & P)} BuildVoidWithProps\n * @typedef {(<T extends string, C extends Node[]>(type: T, children: C) => {type: T, children: C})} BuildParent\n * @typedef {(<T extends string>(type: T, value: string) => {type: T, value: string})} BuildLiteral\n * @typedef {(<T extends string>(type: T) => {type: T})} BuildVoid\n */\nexport var u =\n/**\n* @type {BuildVoid & BuildVoidWithProps & BuildLiteral & BuildLiteralWithProps & BuildParent & BuildParentWithProps}\n*/\n\n/**\n * @param {string} type Type of node\n * @param {Props|ChildrenOrValue} [props] Additional properties for node (or `children` or `value`)\n * @param {ChildrenOrValue} [value] `children` or `value` of node\n * @returns {Node}\n */\nfunction (type, props, value) {\n  /** @type {Node} */\n  var node = {\n    type: String(type)\n  };\n\n  if ((value === undefined || value === null) && (typeof props === 'string' || Array.isArray(props))) {\n    value = props;\n  } else {\n    Object.assign(node, props);\n  }\n\n  if (Array.isArray(value)) {\n    node.children = value;\n  } else if (value !== undefined && value !== null) {\n    node.value = String(value);\n  }\n\n  return node;\n};","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n *\n * @typedef {string} Type\n * @typedef {Object<string, unknown>} Props\n *\n * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test\n */\n\n/**\n * Check if a node passes a test\n *\n * @callback TestFunctionAnything\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} X\n * @callback TestFunctionPredicate\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is X}\n */\n\n/**\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\nexport const is =\n/**\n * Check if a node passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @type {(\n *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &\n *   ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)\n * )}\n */\n\n/**\n * Check if a node passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @param {unknown} [node] Node to check\n * @param {Test} [test]\n * When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * When `array`, checks any one of the subtests pass.\n * @param {number|null|undefined} [index] Position of `node` in `parent`\n * @param {Parent|null|undefined} [parent] Parent of `node`\n * @param {unknown} [context] Context object to invoke `test` with\n * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).\n */\n// eslint-disable-next-line max-params\nfunction is(node, test, index, parent, context) {\n  const check = convert(test);\n\n  if (index !== undefined && index !== null && (typeof index !== 'number' || index < 0 || index === Number.POSITIVE_INFINITY)) {\n    throw new Error('Expected positive finite index');\n  }\n\n  if (parent !== undefined && parent !== null && (!is(parent) || !parent.children)) {\n    throw new Error('Expected parent node');\n  }\n\n  if ((parent === undefined || parent === null) !== (index === undefined || index === null)) {\n    throw new Error('Expected both parent and index');\n  } // @ts-expect-error Looks like a node.\n\n\n  return node && node.type && typeof node.type === 'string' ? Boolean(check.call(context, node, index, parent)) : false;\n};\nexport const convert =\n/**\n * @type {(\n *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &\n *   ((test?: Test) => AssertAnything)\n * )}\n */\n\n/**\n * Generate an assertion from a check.\n * @param {Test} [test]\n * When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * When `array`, checks any one of the subtests pass.\n * @returns {AssertAnything}\n */\nfunction (test) {\n  if (test === undefined || test === null) {\n    return ok;\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n\n  if (typeof test === 'object') {\n    return Array.isArray(test) ? anyFactory(test) : propsFactory(test);\n  }\n\n  if (typeof test === 'function') {\n    return castFactory(test);\n  }\n\n  throw new Error('Expected function, string, or object as test');\n};\n/**\n * @param {Array.<Type|Props|TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\n\nfunction anyFactory(tests) {\n  /** @type {Array.<AssertAnything>} */\n  const checks = [];\n  let index = -1;\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n\n  return castFactory(any);\n  /**\n   * @this {unknown}\n   * @param {unknown[]} parameters\n   * @returns {boolean}\n   */\n\n  function any() {\n    let index = -1;\n\n    for (var _len = arguments.length, parameters = new Array(_len), _key = 0; _key < _len; _key++) {\n      parameters[_key] = arguments[_key];\n    }\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) return true;\n    }\n\n    return false;\n  }\n}\n/**\n * Utility to assert each property in `test` is represented in `node`, and each\n * values are strictly equal.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\n\n\nfunction propsFactory(check) {\n  return castFactory(all);\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n\n  function all(node) {\n    /** @type {string} */\n    let key;\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[key]) return false;\n    }\n\n    return true;\n  }\n}\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n *\n * @param {Type} check\n * @returns {AssertAnything}\n */\n\n\nfunction typeFactory(check) {\n  return castFactory(type);\n  /**\n   * @param {Node} node\n   */\n\n  function type(node) {\n    return node && node.type === check;\n  }\n}\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\n\n\nfunction castFactory(check) {\n  return assertion;\n  /**\n   * @this {unknown}\n   * @param {Array.<unknown>} parameters\n   * @returns {boolean}\n   */\n\n  function assertion() {\n    for (var _len2 = arguments.length, parameters = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      parameters[_key2] = arguments[_key2];\n    }\n\n    // @ts-expect-error: spreading is fine.\n    return Boolean(check.call(this, ...parameters));\n  }\n} // Utility to return true.\n\n\nfunction ok() {\n  return true;\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('./complex-types').Action} Action\n * @typedef {import('./complex-types').Index} Index\n * @typedef {import('./complex-types').ActionTuple} ActionTuple\n * @typedef {import('./complex-types').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\nimport { convert } from 'unist-util-is';\nimport { color } from './color.js';\n/**\n * Continue traversing as normal\n */\n\nexport const CONTINUE = true;\n/**\n * Do not traverse this node’s children\n */\n\nexport const SKIP = 'skip';\n/**\n * Stop traversing immediately\n */\n\nexport const EXIT = false;\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test node, optional\n * @param visitor Function to run for each node\n * @param reverse Visit the tree in reverse order, defaults to false\n */\n\nexport const visitParents =\n/**\n * @type {(\n *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types').BuildVisitor<Tree>, reverse?: boolean) => void)\n * )}\n */\n\n/**\n * @param {Node} tree\n * @param {Test} test\n * @param {import('./complex-types').Visitor<Node>} visitor\n * @param {boolean} [reverse]\n */\nfunction (tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor; // @ts-expect-error no visitor given, so `visitor` is test.\n\n    visitor = test;\n    test = null;\n  }\n\n  const is = convert(test);\n  const step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n  /**\n   * @param {Node} node\n   * @param {number?} index\n   * @param {Array.<Parent>} parents\n   */\n\n  function factory(node, index, parents) {\n    /** @type {Object.<string, unknown>} */\n    // @ts-expect-error: hush\n    const value = typeof node === 'object' && node !== null ? node : {};\n    /** @type {string|undefined} */\n\n    let name;\n\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      Object.defineProperty(visit, 'name', {\n        value: 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')'\n      });\n    }\n\n    return visit;\n\n    function visit() {\n      /** @type {ActionTuple} */\n      let result = [];\n      /** @type {ActionTuple} */\n\n      let subresult;\n      /** @type {number} */\n\n      let offset;\n      /** @type {Array.<Parent>} */\n\n      let grandparents;\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n\n        if (result[0] === EXIT) {\n          return result;\n        }\n      } // @ts-expect-error looks like a parent.\n\n\n      if (node.children && result[0] !== SKIP) {\n        // @ts-expect-error looks like a parent.\n        offset = (reverse ? node.children.length : -1) + step; // @ts-expect-error looks like a parent.\n\n        grandparents = parents.concat(node); // @ts-expect-error looks like a parent.\n\n        while (offset > -1 && offset < node.children.length) {\n          // @ts-expect-error looks like a parent.\n          subresult = factory(node.children[offset], offset, grandparents)();\n\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n\n      return result;\n    }\n  }\n};\n/**\n * @param {VisitorResult} value\n * @returns {ActionTuple}\n */\n\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n\n  return [value];\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\nimport { visitParents, CONTINUE, SKIP, EXIT } from 'unist-util-visit-parents';\nexport { CONTINUE, SKIP, EXIT };\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test, optional\n * @param visitor Function to run for each node\n * @param reverse Fisit the tree in reverse, defaults to false\n */\n\nexport const visit =\n/**\n * @type {(\n *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types').BuildVisitor<Tree>, reverse?: boolean) => void)\n * )}\n */\n\n/**\n * @param {Node} tree\n * @param {Test} test\n * @param {import('./complex-types').Visitor} visitor\n * @param {boolean} [reverse]\n */\nfunction (tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  visitParents(tree, test, overload, reverse);\n  /**\n   * @param {Node} node\n   * @param {Array.<Parent>} parents\n   */\n\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1];\n    return visitor(node, parent ? parent.children.indexOf(node) : null, parent);\n  }\n};","/**\n * @typedef {import('unist').Position} Position\n * @typedef {import('unist').Node} Node\n * @typedef {Record<string, unknown> & {type: string, position?: PositionLike|undefined}} NodeLike\n * @typedef {import('unist').Point} Point\n *\n * @typedef {Partial<Point>} PointLike\n *\n * @typedef PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n */\nexport const pointStart = point('start');\nexport const pointEnd = point('end');\n/**\n * Get the positional info of `node`.\n *\n * @param {NodeLike|Node} [node]\n * @returns {Position}\n */\n\nexport function position(node) {\n  return {\n    start: pointStart(node),\n    end: pointEnd(node)\n  };\n}\n/**\n * Get the positional info of `node`.\n *\n * @param {'start'|'end'} type\n */\n\nfunction point(type) {\n  return point;\n  /**\n   * Get the positional info of `node`.\n   *\n   * @param {NodeLike|Node} [node]\n   * @returns {Point}\n   */\n\n  function point(node) {\n    const point = node && node.position && node.position[type] || {};\n    return {\n      line: point.line || null,\n      column: point.column || null,\n      offset: point.offset > -1 ? point.offset : null\n    };\n  }\n}","/**\n * @typedef {import('mdast').Root|import('mdast').Content} Node\n * @typedef {import('mdast').Definition} Definition\n */\nimport { visit } from 'unist-util-visit';\nconst own = {}.hasOwnProperty;\n/**\n * Find definitions in `node`.\n * Uses CommonMark precedence, which means that earlier definitions are\n * preferred over duplicate later definitions.\n *\n * @param {Node} node\n */\n\nexport function definitions(node) {\n  /** @type {Record<string, Definition>} */\n  const cache = Object.create(null);\n\n  if (!node || !node.type) {\n    throw new Error('mdast-util-definitions expected node');\n  }\n\n  visit(node, 'definition', definition => {\n    const id = clean(definition.identifier);\n\n    if (id && !own.call(cache, id)) {\n      cache[id] = definition;\n    }\n  });\n  return definition;\n  /**\n   * Get a node from the bound definition cache.\n   *\n   * @param {string} identifier\n   * @returns {Definition|null}\n   */\n\n  function definition(identifier) {\n    const id = clean(identifier);\n    return id && own.call(cache, id) ? cache[id] : null;\n  }\n}\n/**\n * @param {string} [value]\n * @returns {string}\n */\n\nfunction clean(value) {\n  return String(value || '').toUpperCase();\n}","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('./index.js').H} H\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\nimport { u } from 'unist-builder';\nconst own = {}.hasOwnProperty;\n/**\n * Transform an unknown node.\n * @type {Handler}\n * @param {MdastNode} node\n */\n\nfunction unknown(h, node) {\n  const data = node.data || {};\n\n  if ('value' in node && !(own.call(data, 'hName') || own.call(data, 'hProperties') || own.call(data, 'hChildren'))) {\n    return h.augment(node, u('text', node.value));\n  }\n\n  return h(node, 'div', all(h, node));\n}\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\n\n\nexport function one(h, node, parent) {\n  const type = node && node.type;\n  /** @type {Handler} */\n\n  let fn; // Fail on non-nodes.\n\n  if (!type) {\n    throw new Error('Expected node, got `' + node + '`');\n  }\n\n  if (own.call(h.handlers, type)) {\n    fn = h.handlers[type];\n  } else if (h.passThrough && h.passThrough.includes(type)) {\n    fn = returnNode;\n  } else {\n    fn = h.unknownHandler;\n  }\n\n  return (typeof fn === 'function' ? fn : unknown)(h, node, parent);\n}\n/**\n * @type {Handler}\n * @param {MdastNode} node\n */\n\nfunction returnNode(h, node) {\n  // @ts-expect-error: Pass through custom node.\n  return 'children' in node ? { ...node,\n    children: all(h, node)\n  } : node;\n}\n/**\n * @param {H} h\n * @param {MdastNode} parent\n */\n\n\nexport function all(h, parent) {\n  /** @type {Array<Content>} */\n  const values = [];\n\n  if ('children' in parent) {\n    const nodes = parent.children;\n    let index = -1;\n\n    while (++index < nodes.length) {\n      const result = one(h, nodes[index], parent);\n\n      if (result) {\n        if (index && nodes[index - 1].type === 'break') {\n          if (!Array.isArray(result) && result.type === 'text') {\n            result.value = result.value.replace(/^\\s+/, '');\n          }\n\n          if (!Array.isArray(result) && result.type === 'element') {\n            const head = result.children[0];\n\n            if (head && head.type === 'text') {\n              head.value = head.value.replace(/^\\s+/, '');\n            }\n          }\n        }\n\n        if (Array.isArray(result)) {\n          values.push(...result);\n        } else {\n          values.push(result);\n        }\n      }\n    }\n  }\n\n  return values;\n}","const characterReferences = {\n  '\"': 'quot',\n  '&': 'amp',\n  '<': 'lt',\n  '>': 'gt'\n};\n/**\n * Encode only the dangerous HTML characters.\n *\n * This ensures that certain characters which have special meaning in HTML are\n * dealt with.\n * Technically, we can skip `>` and `\"` in many cases, but CM includes them.\n *\n * @param {string} value\n * @returns {string}\n */\n\nexport function encode(value) {\n  return value.replace(/[\"&<>]/g, replace);\n  /**\n   * @param {string} value\n   * @returns {string}\n   */\n\n  function replace(value) {\n    // @ts-expect-error Hush, it’s fine.\n    return '&' + characterReferences[value] + ';';\n  }\n}","import { asciiAlphanumeric } from 'micromark-util-character';\nimport { encode } from 'micromark-util-encode';\n/**\n * Make a value safe for injection as a URL.\n *\n * This encodes unsafe characters with percent-encoding and skips already\n * encoded sequences (see `normalizeUri` below).\n * Further unsafe characters are encoded as character references (see\n * `micromark-util-encode`).\n *\n * Then, a regex of allowed protocols can be given, in which case the URL is\n * sanitized.\n * For example, `/^(https?|ircs?|mailto|xmpp)$/i` can be used for `a[href]`,\n * or `/^https?$/i` for `img[src]`.\n * If the URL includes an unknown protocol (one not matched by `protocol`, such\n * as a dangerous example, `javascript:`), the value is ignored.\n *\n * @param {string|undefined} url\n * @param {RegExp} [protocol]\n * @returns {string}\n */\n\nexport function sanitizeUri(url, protocol) {\n  const value = encode(normalizeUri(url || ''));\n\n  if (!protocol) {\n    return value;\n  }\n\n  const colon = value.indexOf(':');\n  const questionMark = value.indexOf('?');\n  const numberSign = value.indexOf('#');\n  const slash = value.indexOf('/');\n\n  if ( // If there is no protocol, it’s relative.\n  colon < 0 || // If the first colon is after a `?`, `#`, or `/`, it’s not a protocol.\n  slash > -1 && colon > slash || questionMark > -1 && colon > questionMark || numberSign > -1 && colon > numberSign || // It is a protocol, it should be allowed.\n  protocol.test(value.slice(0, colon))) {\n    return value;\n  }\n\n  return '';\n}\n/**\n * Normalize a URL (such as used in definitions).\n *\n * Encode unsafe characters with percent-encoding, skipping already encoded\n * sequences.\n *\n * @param {string} value\n * @returns {string}\n */\n\nfunction normalizeUri(value) {\n  /** @type {string[]} */\n  const result = [];\n  let index = -1;\n  let start = 0;\n  let skip = 0;\n\n  while (++index < value.length) {\n    const code = value.charCodeAt(index);\n    /** @type {string} */\n\n    let replace = ''; // A correct percent encoded value.\n\n    if (code === 37 && asciiAlphanumeric(value.charCodeAt(index + 1)) && asciiAlphanumeric(value.charCodeAt(index + 2))) {\n      skip = 2;\n    } // ASCII.\n    else if (code < 128) {\n      if (!/[!#$&-;=?-Z_a-z~]/.test(String.fromCharCode(code))) {\n        replace = String.fromCharCode(code);\n      }\n    } // Astral.\n    else if (code > 55295 && code < 57344) {\n      const next = value.charCodeAt(index + 1); // A correct surrogate pair.\n\n      if (code < 56320 && next > 56319 && next < 57344) {\n        replace = String.fromCharCode(code, next);\n        skip = 1;\n      } // Lone surrogate.\n      else {\n        replace = '\\uFFFD';\n      }\n    } // Unicode.\n    else {\n      replace = String.fromCharCode(code);\n    }\n\n    if (replace) {\n      result.push(value.slice(start, index), encodeURIComponent(replace));\n      start = index + skip + 1;\n      replace = '';\n    }\n\n    if (skip) {\n      index += skip;\n      skip = 0;\n    }\n  }\n\n  return result.join('') + value.slice(start);\n}","/**\n * @typedef {import('./index.js').Content} Content\n */\nimport { u } from 'unist-builder';\n/**\n * Wrap `nodes` with line feeds between each entry.\n * Optionally adds line feeds at the start and end.\n *\n * @param {Array<Content>} nodes\n * @param {boolean} [loose=false]\n * @returns {Array<Content>}\n */\n\nexport function wrap(nodes, loose) {\n  /** @type {Array<Content>} */\n  const result = [];\n  let index = -1;\n\n  if (loose) {\n    result.push(u('text', '\\n'));\n  }\n\n  while (++index < nodes.length) {\n    if (index) result.push(u('text', '\\n'));\n    result.push(nodes[index]);\n  }\n\n  if (loose && nodes.length > 0) {\n    result.push(u('text', '\\n'));\n  }\n\n  return result;\n}","/**\n * @typedef {import('mdast').FootnoteReference} FootnoteReference\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { sanitizeUri } from 'micromark-util-sanitize-uri';\nimport { u } from 'unist-builder';\n/**\n * @type {Handler}\n * @param {FootnoteReference} node\n */\n\nexport function footnoteReference(h, node) {\n  const id = String(node.identifier);\n  const safeId = sanitizeUri(id.toLowerCase());\n  const index = h.footnoteOrder.indexOf(id);\n  /** @type {number} */\n\n  let counter;\n\n  if (index === -1) {\n    h.footnoteOrder.push(id);\n    h.footnoteCounts[id] = 1;\n    counter = h.footnoteOrder.length;\n  } else {\n    h.footnoteCounts[id]++;\n    counter = index + 1;\n  }\n\n  const reuseCounter = h.footnoteCounts[id];\n  return h(node, 'sup', [h(node.position, 'a', {\n    href: '#' + h.clobberPrefix + 'fn-' + safeId,\n    id: h.clobberPrefix + 'fnref-' + safeId + (reuseCounter > 1 ? '-' + reuseCounter : ''),\n    dataFootnoteRef: true,\n    ariaDescribedBy: 'footnote-label'\n  }, [u('text', String(counter))])]);\n}","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('./index.js').Handler} Handler\n * @typedef {import('./index.js').Content} Content\n */\nimport { u } from 'unist-builder';\nimport { all } from './traverse.js';\n/**\n * Return the content of a reference without definition as plain text.\n *\n * @type {Handler}\n * @param {ImageReference|LinkReference} node\n * @returns {Content|Array<Content>}\n */\n\nexport function revert(h, node) {\n  const subtype = node.referenceType;\n  let suffix = ']';\n\n  if (subtype === 'collapsed') {\n    suffix += '[]';\n  } else if (subtype === 'full') {\n    suffix += '[' + (node.label || node.identifier) + ']';\n  }\n\n  if (node.type === 'imageReference') {\n    return u('text', '![' + node.alt + suffix);\n  }\n\n  const contents = all(h, node);\n  const head = contents[0];\n\n  if (head && head.type === 'text') {\n    head.value = '[' + head.value;\n  } else {\n    contents.unshift(u('text', '['));\n  }\n\n  const tail = contents[contents.length - 1];\n\n  if (tail && tail.type === 'text') {\n    tail.value += suffix;\n  } else {\n    contents.push(u('text', suffix));\n  }\n\n  return contents;\n}","/**\n * @typedef {import('mdast').ListItem} ListItem\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\nimport { u } from 'unist-builder';\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {ListItem} node\n * @param {List} parent\n */\n\nexport function listItem(h, node, parent) {\n  const result = all(h, node);\n  const loose = parent ? listLoose(parent) : listItemLoose(node);\n  /** @type {Properties} */\n\n  const props = {};\n  /** @type {Array<Content>} */\n\n  const wrapped = [];\n\n  if (typeof node.checked === 'boolean') {\n    /** @type {Element} */\n    let paragraph;\n\n    if (result[0] && result[0].type === 'element' && result[0].tagName === 'p') {\n      paragraph = result[0];\n    } else {\n      paragraph = h(null, 'p', []);\n      result.unshift(paragraph);\n    }\n\n    if (paragraph.children.length > 0) {\n      paragraph.children.unshift(u('text', ' '));\n    }\n\n    paragraph.children.unshift(h(null, 'input', {\n      type: 'checkbox',\n      checked: node.checked,\n      disabled: true\n    })); // According to github-markdown-css, this class hides bullet.\n    // See: <https://github.com/sindresorhus/github-markdown-css>.\n\n    props.className = ['task-list-item'];\n  }\n\n  let index = -1;\n\n  while (++index < result.length) {\n    const child = result[index]; // Add eols before nodes, except if this is a loose, first paragraph.\n\n    if (loose || index !== 0 || child.type !== 'element' || child.tagName !== 'p') {\n      wrapped.push(u('text', '\\n'));\n    }\n\n    if (child.type === 'element' && child.tagName === 'p' && !loose) {\n      wrapped.push(...child.children);\n    } else {\n      wrapped.push(child);\n    }\n  }\n\n  const tail = result[result.length - 1]; // Add a final eol.\n\n  if (tail && (loose || !('tagName' in tail) || tail.tagName !== 'p')) {\n    wrapped.push(u('text', '\\n'));\n  }\n\n  return h(node, 'li', props, wrapped);\n}\n/**\n * @param {List} node\n * @return {Boolean}\n */\n\nfunction listLoose(node) {\n  let loose = node.spread;\n  const children = node.children;\n  let index = -1;\n\n  while (!loose && ++index < children.length) {\n    loose = listItemLoose(children[index]);\n  }\n\n  return Boolean(loose);\n}\n/**\n * @param {ListItem} node\n * @return {Boolean}\n */\n\n\nfunction listItemLoose(node) {\n  const spread = node.spread;\n  return spread === undefined || spread === null ? node.children.length > 1 : spread;\n}","const tab = 9;\n/* `\\t` */\n\nconst space = 32;\n/* ` ` */\n\n/**\n * Remove initial and final spaces and tabs at the line breaks in `value`.\n * Does not trim initial and final spaces and tabs of the value itself.\n *\n * @param {string} value\n *   Value to trim.\n * @returns {string}\n *   Trimmed value.\n */\n\nexport function trimLines(value) {\n  const source = String(value);\n  const search = /\\r?\\n|\\r/g;\n  let match = search.exec(source);\n  let last = 0;\n  /** @type {Array<string>} */\n\n  const lines = [];\n\n  while (match) {\n    lines.push(trimLine(source.slice(last, match.index), last > 0, true), match[0]);\n    last = match.index + match[0].length;\n    match = search.exec(source);\n  }\n\n  lines.push(trimLine(source.slice(last), last > 0, false));\n  return lines.join('');\n}\n/**\n * @param {string} value\n *   Line to trim.\n * @param {boolean} start\n *   Whether to trim the start of the line.\n * @param {boolean} end\n *   Whether to trim the end of the line.\n * @returns {string}\n *   Trimmed line.\n */\n\nfunction trimLine(value, start, end) {\n  let startIndex = 0;\n  let endIndex = value.length;\n\n  if (start) {\n    let code = value.codePointAt(startIndex);\n\n    while (code === tab || code === space) {\n      startIndex++;\n      code = value.codePointAt(startIndex);\n    }\n  }\n\n  if (end) {\n    let code = value.codePointAt(endIndex - 1);\n\n    while (code === tab || code === space) {\n      endIndex--;\n      code = value.codePointAt(endIndex - 1);\n    }\n  }\n\n  return endIndex > startIndex ? value.slice(startIndex, endIndex) : '';\n}","import { blockquote } from './blockquote.js';\nimport { hardBreak } from './break.js';\nimport { code } from './code.js';\nimport { strikethrough } from './delete.js';\nimport { emphasis } from './emphasis.js';\nimport { footnoteReference } from './footnote-reference.js';\nimport { footnote } from './footnote.js';\nimport { heading } from './heading.js';\nimport { html } from './html.js';\nimport { imageReference } from './image-reference.js';\nimport { image } from './image.js';\nimport { inlineCode } from './inline-code.js';\nimport { linkReference } from './link-reference.js';\nimport { link } from './link.js';\nimport { listItem } from './list-item.js';\nimport { list } from './list.js';\nimport { paragraph } from './paragraph.js';\nimport { root } from './root.js';\nimport { strong } from './strong.js';\nimport { table } from './table.js';\nimport { text } from './text.js';\nimport { thematicBreak } from './thematic-break.js';\nexport const handlers = {\n  blockquote,\n  break: hardBreak,\n  code,\n  delete: strikethrough,\n  emphasis,\n  footnoteReference,\n  footnote,\n  heading,\n  html,\n  imageReference,\n  image,\n  inlineCode,\n  linkReference,\n  link,\n  listItem,\n  list,\n  paragraph,\n  root,\n  strong,\n  table,\n  text,\n  thematicBreak,\n  toml: ignore,\n  yaml: ignore,\n  definition: ignore,\n  footnoteDefinition: ignore\n}; // Return nothing for nodes that are ignored.\n\nfunction ignore() {\n  return null;\n}","/**\n * @typedef {import('mdast').Blockquote} Blockquote\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { wrap } from '../wrap.js';\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Blockquote} node\n */\n\nexport function blockquote(h, node) {\n  return h(node, 'blockquote', wrap(all(h, node), true));\n}","/**\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Text} Text\n * @typedef {import('mdast').Break} Break\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { u } from 'unist-builder';\n/**\n * @type {Handler}\n * @param {Break} node\n * @returns {Array<Element|Text>}\n */\n\nexport function hardBreak(h, node) {\n  return [h(node, 'br'), u('text', '\\n')];\n}","/**\n * @typedef {import('mdast').Code} Code\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { u } from 'unist-builder';\n/**\n * @type {Handler}\n * @param {Code} node\n */\n\nexport function code(h, node) {\n  const value = node.value ? node.value + '\\n' : ''; // To do: next major, use `node.lang` w/o regex, the splitting’s been going\n  // on for years in remark now.\n\n  const lang = node.lang && node.lang.match(/^[^ \\t]+(?=[ \\t]|$)/);\n  /** @type {Properties} */\n\n  const props = {};\n\n  if (lang) {\n    props.className = ['language-' + lang];\n  }\n\n  const code = h(node, 'code', props, [u('text', value)]);\n\n  if (node.meta) {\n    code.data = {\n      meta: node.meta\n    };\n  }\n\n  return h(node.position, 'pre', [code]);\n}","/**\n * @typedef {import('mdast').Delete} Delete\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Delete} node\n */\n\nexport function strikethrough(h, node) {\n  return h(node, 'del', all(h, node));\n}","/**\n * @typedef {import('mdast').Emphasis} Emphasis\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Emphasis} node\n */\n\nexport function emphasis(h, node) {\n  return h(node, 'em', all(h, node));\n}","/**\n * @typedef {import('mdast').Footnote} Footnote\n * @typedef {import('../index.js').Handler} Handler\n *\n * @todo\n *   `footnote` (or “inline note”) are a pandoc footnotes feature (`^[a note]`)\n *   that does not exist in GFM.\n *   We still have support for it, so that things remain working with\n *   `micromark-extension-footnote` and `mdast-util-footnote`, but in the future\n *   we might be able to remove it?\n */\nimport { footnoteReference } from './footnote-reference.js';\n/**\n * @type {Handler}\n * @param {Footnote} node\n */\n\nexport function footnote(h, node) {\n  const footnoteById = h.footnoteById;\n  let no = 1;\n\n  while (no in footnoteById) no++;\n\n  const identifier = String(no);\n  footnoteById[identifier] = {\n    type: 'footnoteDefinition',\n    identifier,\n    children: [{\n      type: 'paragraph',\n      children: node.children\n    }],\n    position: node.position\n  };\n  return footnoteReference(h, {\n    type: 'footnoteReference',\n    identifier,\n    position: node.position\n  });\n}","/**\n * @typedef {import('mdast').Heading} Heading\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Heading} node\n */\n\nexport function heading(h, node) {\n  return h(node, 'h' + node.depth, all(h, node));\n}","/**\n * @typedef {import('mdast').HTML} HTML\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { u } from 'unist-builder';\n/**\n * Return either a `raw` node in dangerous mode, otherwise nothing.\n *\n * @type {Handler}\n * @param {HTML} node\n */\n\nexport function html(h, node) {\n  return h.dangerous ? h.augment(node, u('raw', node.value)) : null;\n}","/**\n * @typedef {import('mdast').ImageReference} ImageReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\nimport normalize from 'mdurl/encode.js';\nimport { revert } from '../revert.js';\n/**\n * @type {Handler}\n * @param {ImageReference} node\n */\n\nexport function imageReference(h, node) {\n  const def = h.definition(node.identifier);\n\n  if (!def) {\n    return revert(h, node);\n  }\n  /** @type {Properties} */\n\n\n  const props = {\n    src: normalize(def.url || ''),\n    alt: node.alt\n  };\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title;\n  }\n\n  return h(node, 'img', props);\n}","/**\n * @typedef {import('mdast').Image} Image\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\nimport normalize from 'mdurl/encode.js';\n/**\n * @type {Handler}\n * @param {Image} node\n */\n\nexport function image(h, node) {\n  /** @type {Properties} */\n  const props = {\n    src: normalize(node.url),\n    alt: node.alt\n  };\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title;\n  }\n\n  return h(node, 'img', props);\n}","/**\n * @typedef {import('mdast').InlineCode} InlineCode\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { u } from 'unist-builder';\n/**\n * @type {Handler}\n * @param {InlineCode} node\n */\n\nexport function inlineCode(h, node) {\n  return h(node, 'code', [u('text', node.value.replace(/\\r?\\n|\\r/g, ' '))]);\n}","/**\n * @typedef {import('mdast').LinkReference} LinkReference\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\nimport normalize from 'mdurl/encode.js';\nimport { revert } from '../revert.js';\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {LinkReference} node\n */\n\nexport function linkReference(h, node) {\n  const def = h.definition(node.identifier);\n\n  if (!def) {\n    return revert(h, node);\n  }\n  /** @type {Properties} */\n\n\n  const props = {\n    href: normalize(def.url || '')\n  };\n\n  if (def.title !== null && def.title !== undefined) {\n    props.title = def.title;\n  }\n\n  return h(node, 'a', props, all(h, node));\n}","/**\n * @typedef {import('mdast').Link} Link\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\nimport normalize from 'mdurl/encode.js';\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Link} node\n */\n\nexport function link(h, node) {\n  /** @type {Properties} */\n  const props = {\n    href: normalize(node.url)\n  };\n\n  if (node.title !== null && node.title !== undefined) {\n    props.title = node.title;\n  }\n\n  return h(node, 'a', props, all(h, node));\n}","/**\n * @typedef {import('mdast').List} List\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { wrap } from '../wrap.js';\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {List} node\n * @returns {Element}\n */\n\nexport function list(h, node) {\n  /** @type {Properties} */\n  const props = {};\n  const name = node.ordered ? 'ol' : 'ul';\n  const items = all(h, node);\n  let index = -1;\n\n  if (typeof node.start === 'number' && node.start !== 1) {\n    props.start = node.start;\n  } // Like GitHub, add a class for custom styling.\n\n\n  while (++index < items.length) {\n    const item = items[index];\n\n    if (item.type === 'element' && item.tagName === 'li' && item.properties && Array.isArray(item.properties.className) && item.properties.className.includes('task-list-item')) {\n      props.className = ['contains-task-list'];\n      break;\n    }\n  }\n\n  return h(node, name, props, wrap(items, true));\n}","/**\n * @typedef {import('mdast').Paragraph} Paragraph\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Paragraph} node\n */\n\nexport function paragraph(h, node) {\n  return h(node, 'p', all(h, node));\n}","/**\n * @typedef {import('mdast').Root} Root\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { u } from 'unist-builder';\nimport { all } from '../traverse.js';\nimport { wrap } from '../wrap.js';\n/**\n * @type {Handler}\n * @param {Root} node\n */\n\nexport function root(h, node) {\n  // @ts-expect-error `root`s are also fine.\n  return h.augment(node, u('root', wrap(all(h, node))));\n}","/**\n * @typedef {import('mdast').Strong} Strong\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Strong} node\n */\n\nexport function strong(h, node) {\n  return h(node, 'strong', all(h, node));\n}","/**\n * @typedef {import('mdast').Table} Table\n * @typedef {import('mdast').TableCell} TableCell\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n * @typedef {import('../index.js').Content} Content\n */\nimport { pointStart, pointEnd } from 'unist-util-position';\nimport { wrap } from '../wrap.js';\nimport { all } from '../traverse.js';\n/**\n * @type {Handler}\n * @param {Table} node\n */\n\nexport function table(h, node) {\n  const rows = node.children;\n  let index = -1;\n  const align = node.align || [];\n  /** @type {Array<Element>} */\n\n  const result = [];\n\n  while (++index < rows.length) {\n    const row = rows[index].children;\n    const name = index === 0 ? 'th' : 'td';\n    /** @type {Array<Content>} */\n\n    const out = [];\n    let cellIndex = -1;\n    const length = node.align ? align.length : row.length;\n\n    while (++cellIndex < length) {\n      const cell = row[cellIndex];\n      out.push(h(cell, name, {\n        align: align[cellIndex]\n      }, cell ? all(h, cell) : []));\n    }\n\n    result[index] = h(rows[index], 'tr', wrap(out, true));\n  }\n\n  return h(node, 'table', wrap([h(result[0].position, 'thead', wrap([result[0]], true))].concat(result[1] ? h({\n    start: pointStart(result[1]),\n    end: pointEnd(result[result.length - 1])\n  }, 'tbody', wrap(result.slice(1), true)) : []), true));\n}","/**\n * @typedef {import('mdast').Text} Text\n * @typedef {import('../index.js').Handler} Handler\n */\nimport { trimLines } from 'trim-lines';\nimport { u } from 'unist-builder';\n/**\n * @type {Handler}\n * @param {Text} node\n */\n\nexport function text(h, node) {\n  return h.augment(node, u('text', trimLines(String(node.value))));\n}","/**\n * @typedef {import('mdast').ThematicBreak} ThematicBreak\n * @typedef {import('hast').Element} Element\n * @typedef {import('../index.js').Handler} Handler\n */\n\n/**\n * @type {Handler}\n * @param {ThematicBreak} [node]\n * @returns {Element}\n */\nexport function thematicBreak(h, node) {\n  return h(node, 'hr');\n}","/**\n * @typedef {import('mdast').Root|import('mdast').Parent['children'][number]} MdastNode\n * @typedef {import('hast').Root|import('hast').Parent['children'][number]} HastNode\n * @typedef {import('mdast').Parent} Parent\n * @typedef {import('mdast').Definition} Definition\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Properties} Properties\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').ElementContent} Content\n * @typedef {import('unist-util-position').PositionLike} PositionLike\n *\n * @typedef EmbeddedHastFields\n * @property {string} [hName] Defines the tag name of an element\n * @property {Properties} [hProperties] Defines the properties of an element\n * @property {Array<Content>} [hChildren] Defines the (hast) children of an element\n *\n * @typedef {Record<string, unknown> & EmbeddedHastFields} Data unist data with embedded hast fields\n *\n * @typedef {MdastNode & {data?: Data}} NodeWithData unist node with embedded hast data\n *\n * @callback Handler\n * @param {H} h Handle context\n * @param {any} node mdast node to handle\n * @param {Parent|null} parent Parent of `node`\n * @returns {Content|Array<Content>|null|undefined} hast node\n *\n * @callback HFunctionProps\n * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position\n * @param {string} tagName HTML tag name\n * @param {Properties} props Properties\n * @param {Array<Content>?} [children] hast content\n * @returns {Element}\n *\n * @callback HFunctionNoProps\n * @param {MdastNode|PositionLike|null|undefined} node mdast node or unist position\n * @param {string} tagName HTML tag name\n * @param {Array<Content>?} [children] hast content\n * @returns {Element}\n *\n * @typedef HFields\n * @property {boolean} dangerous Whether HTML is allowed\n * @property {string} clobberPrefix Prefix to use to prevent DOM clobbering\n * @property {string} footnoteLabel Label to use to introduce the footnote section\n * @property {string} footnoteLabelTagName HTML used for the footnote label\n * @property {Properties} footnoteLabelProperties properties on the HTML tag used for the footnote label\n * @property {string} footnoteBackLabel Label to use to go back to a footnote call from the footnote section\n * @property {(identifier: string) => Definition|null} definition Definition cache\n * @property {Record<string, FootnoteDefinition>} footnoteById Footnote cache\n * @property {Array<string>} footnoteOrder Order in which footnotes occur\n * @property {Record<string, number>} footnoteCounts Counts the same footnote was used\n * @property {Handlers} handlers Applied handlers\n * @property {Handler} unknownHandler Handler for any none not in `passThrough` or otherwise handled\n * @property {(left: NodeWithData|PositionLike|null|undefined, right: Content) => Content} augment Like `h` but lower-level and usable on non-elements.\n * @property {Array<string>} passThrough List of node types to pass through untouched (except for their children).\n *\n * @typedef Options\n * @property {boolean} [allowDangerousHtml=false]\n *   Whether to allow `html` nodes and inject them as `raw` HTML\n * @property {string} [clobberPrefix='user-content-']\n *   Prefix to use before the `id` attribute to prevent it from *clobbering*.\n *   attributes.\n *   DOM clobbering is this:\n *\n *   ```html\n *   <p id=x></p>\n *   <script>alert(x)</script>\n *   ```\n *\n *   Elements by their ID are made available in browsers on the `window` object.\n *   Using a prefix prevents this from being a problem.\n * @property {string} [footnoteLabel='Footnotes']\n *   Label to use for the footnotes section.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {string} [footnoteLabelTagName='h2']\n *   HTML tag to use for the footnote label.\n *   Can be changed to match your document structure and play well with your choice of css.\n * @property {Properties} [footnoteLabelProperties={id: 'footnote-label', className: ['sr-only']}]\n *   Properties to use on the footnote label.\n *   A 'sr-only' class is added by default to hide this from sighted users.\n *   Change it to make the label visible, or add classes for other purposes.\n * @property {string} [footnoteBackLabel='Back to content']\n *   Label to use from backreferences back to their footnote call.\n *   Affects screen reader users.\n *   Change it if you’re authoring in a different language.\n * @property {Handlers} [handlers]\n *   Object mapping mdast nodes to functions handling them\n * @property {Array<string>} [passThrough]\n *   List of custom mdast node types to pass through (keep) in hast\n * @property {Handler} [unknownHandler]\n *   Handler for all unknown nodes.\n *\n * @typedef {Record<string, Handler>} Handlers\n *   Map of node types to handlers\n * @typedef {HFunctionProps & HFunctionNoProps & HFields} H\n *   Handle context\n */\nimport { u } from 'unist-builder';\nimport { visit } from 'unist-util-visit';\nimport { pointStart, pointEnd } from 'unist-util-position';\nimport { generated } from 'unist-util-generated';\nimport { definitions } from 'mdast-util-definitions';\nimport { one } from './traverse.js';\nimport { footer } from './footer.js';\nimport { handlers } from './handlers/index.js';\nconst own = {}.hasOwnProperty;\n/**\n * Factory to transform.\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {H} `h` function\n */\n\nfunction factory(tree, options) {\n  const settings = options || {};\n  const dangerous = settings.allowDangerousHtml || false;\n  /** @type {Record<string, FootnoteDefinition>} */\n\n  const footnoteById = {};\n  h.dangerous = dangerous;\n  h.clobberPrefix = settings.clobberPrefix === undefined || settings.clobberPrefix === null ? 'user-content-' : settings.clobberPrefix;\n  h.footnoteLabel = settings.footnoteLabel || 'Footnotes';\n  h.footnoteLabelTagName = settings.footnoteLabelTagName || 'h2';\n  h.footnoteLabelProperties = settings.footnoteLabelProperties || {\n    id: 'footnote-label',\n    className: ['sr-only']\n  };\n  h.footnoteBackLabel = settings.footnoteBackLabel || 'Back to content';\n  h.definition = definitions(tree);\n  h.footnoteById = footnoteById;\n  /** @type {Array<string>} */\n\n  h.footnoteOrder = [];\n  /** @type {Record<string, number>} */\n\n  h.footnoteCounts = {};\n  h.augment = augment;\n  h.handlers = { ...handlers,\n    ...settings.handlers\n  };\n  h.unknownHandler = settings.unknownHandler;\n  h.passThrough = settings.passThrough;\n  visit(tree, 'footnoteDefinition', definition => {\n    const id = String(definition.identifier).toUpperCase(); // Mimick CM behavior of link definitions.\n    // See: <https://github.com/syntax-tree/mdast-util-definitions/blob/8290999/index.js#L26>.\n\n    if (!own.call(footnoteById, id)) {\n      footnoteById[id] = definition;\n    }\n  }); // @ts-expect-error Hush, it’s fine!\n\n  return h;\n  /**\n   * Finalise the created `right`, a hast node, from `left`, an mdast node.\n   * @param {(NodeWithData|PositionLike)?} left\n   * @param {Content} right\n   * @returns {Content}\n   */\n\n  function augment(left, right) {\n    // Handle `data.hName`, `data.hProperties, `data.hChildren`.\n    if (left && 'data' in left && left.data) {\n      /** @type {Data} */\n      const data = left.data;\n\n      if (data.hName) {\n        if (right.type !== 'element') {\n          right = {\n            type: 'element',\n            tagName: '',\n            properties: {},\n            children: []\n          };\n        }\n\n        right.tagName = data.hName;\n      }\n\n      if (right.type === 'element' && data.hProperties) {\n        right.properties = { ...right.properties,\n          ...data.hProperties\n        };\n      }\n\n      if ('children' in right && right.children && data.hChildren) {\n        right.children = data.hChildren;\n      }\n    }\n\n    if (left) {\n      const ctx = 'type' in left ? left : {\n        position: left\n      };\n\n      if (!generated(ctx)) {\n        // @ts-expect-error: fine.\n        right.position = {\n          start: pointStart(ctx),\n          end: pointEnd(ctx)\n        };\n      }\n    }\n\n    return right;\n  }\n  /**\n   * Create an element for `node`.\n   *\n   * @type {HFunctionProps}\n   */\n\n\n  function h(node, tagName, props, children) {\n    if (Array.isArray(props)) {\n      children = props;\n      props = {};\n    } // @ts-expect-error augmenting an element yields an element.\n\n\n    return augment(node, {\n      type: 'element',\n      tagName,\n      properties: props || {},\n      children: children || []\n    });\n  }\n}\n/**\n * Transform `tree` (an mdast node) to a hast node.\n *\n * @param {MdastNode} tree mdast node\n * @param {Options} [options] Configuration\n * @returns {HastNode|null|undefined} hast node\n */\n\n\nexport function toHast(tree, options) {\n  const h = factory(tree, options);\n  const node = one(h, tree, null);\n  const foot = footer(h);\n\n  if (foot) {\n    // @ts-expect-error If there’s a footer, there were definitions, meaning block\n    // content.\n    // So assume `node` is a parent node.\n    node.children.push(u('text', '\\n'), foot);\n  }\n\n  return Array.isArray(node) ? {\n    type: 'root',\n    children: node\n  } : node;\n}\nexport { handlers as defaultHandlers } from './handlers/index.js';","/**\n * @typedef {Object} PointLike\n * @property {number} [line]\n * @property {number} [column]\n * @property {number} [offset]\n *\n * @typedef {Object} PositionLike\n * @property {PointLike} [start]\n * @property {PointLike} [end]\n *\n * @typedef {Object} NodeLike\n * @property {PositionLike} [position]\n */\n\n/**\n * Check if `node` is *generated*.\n *\n * @param {NodeLike} [node]\n * @returns {boolean}\n */\nexport function generated(node) {\n  return !node || !node.position || !node.position.start || !node.position.start.line || !node.position.start.column || !node.position.end || !node.position.end.line || !node.position.end.column;\n}","/**\n * @typedef {import('mdast').BlockContent} BlockContent\n * @typedef {import('mdast').FootnoteDefinition} FootnoteDefinition\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('./index.js').H} H\n */\nimport { sanitizeUri } from 'micromark-util-sanitize-uri';\nimport { u } from 'unist-builder';\nimport { all } from './traverse.js';\nimport { wrap } from './wrap.js';\n/**\n * @param {H} h\n * @returns {Element|null}\n */\n\nexport function footer(h) {\n  let index = -1;\n  /** @type {Array<ElementContent>} */\n\n  const listItems = [];\n\n  while (++index < h.footnoteOrder.length) {\n    const def = h.footnoteById[h.footnoteOrder[index].toUpperCase()];\n\n    if (!def) {\n      continue;\n    }\n\n    const content = all(h, def);\n    const id = String(def.identifier);\n    const safeId = sanitizeUri(id.toLowerCase());\n    let referenceIndex = 0;\n    /** @type {Array<ElementContent>} */\n\n    const backReferences = [];\n\n    while (++referenceIndex <= h.footnoteCounts[id]) {\n      /** @type {Element} */\n      const backReference = {\n        type: 'element',\n        tagName: 'a',\n        properties: {\n          href: '#' + h.clobberPrefix + 'fnref-' + safeId + (referenceIndex > 1 ? '-' + referenceIndex : ''),\n          dataFootnoteBackref: true,\n          className: ['data-footnote-backref'],\n          ariaLabel: h.footnoteBackLabel\n        },\n        children: [{\n          type: 'text',\n          value: '↩'\n        }]\n      };\n\n      if (referenceIndex > 1) {\n        backReference.children.push({\n          type: 'element',\n          tagName: 'sup',\n          children: [{\n            type: 'text',\n            value: String(referenceIndex)\n          }]\n        });\n      }\n\n      if (backReferences.length > 0) {\n        backReferences.push({\n          type: 'text',\n          value: ' '\n        });\n      }\n\n      backReferences.push(backReference);\n    }\n\n    const tail = content[content.length - 1];\n\n    if (tail && tail.type === 'element' && tail.tagName === 'p') {\n      const tailTail = tail.children[tail.children.length - 1];\n\n      if (tailTail && tailTail.type === 'text') {\n        tailTail.value += ' ';\n      } else {\n        tail.children.push({\n          type: 'text',\n          value: ' '\n        });\n      }\n\n      tail.children.push(...backReferences);\n    } else {\n      content.push(...backReferences);\n    }\n    /** @type {Element} */\n\n\n    const listItem = {\n      type: 'element',\n      tagName: 'li',\n      properties: {\n        id: h.clobberPrefix + 'fn-' + safeId\n      },\n      children: wrap(content, true)\n    };\n\n    if (def.position) {\n      listItem.position = def.position;\n    }\n\n    listItems.push(listItem);\n  }\n\n  if (listItems.length === 0) {\n    return null;\n  }\n\n  return {\n    type: 'element',\n    tagName: 'section',\n    properties: {\n      dataFootnotes: true,\n      className: ['footnotes']\n    },\n    children: [{\n      type: 'element',\n      tagName: h.footnoteLabelTagName,\n      properties: JSON.parse(JSON.stringify(h.footnoteLabelProperties)),\n      children: [u('text', h.footnoteLabel)]\n    }, {\n      type: 'text',\n      value: '\\n'\n    }, {\n      type: 'element',\n      tagName: 'ol',\n      properties: {},\n      children: wrap(listItems, true)\n    }, {\n      type: 'text',\n      value: '\\n'\n    }]\n  };\n}","/**\n * @typedef {import('hast').Root} HastRoot\n * @typedef {import('mdast').Root} MdastRoot\n * @typedef {import('mdast-util-to-hast').Options} Options\n * @typedef {import('unified').Processor<any, any, any, any>} Processor\n *\n * @typedef {import('mdast-util-to-hast')} DoNotTouchAsThisImportIncludesRawInTree\n */\nimport { toHast } from 'mdast-util-to-hast'; // Note: the `<MdastRoot, HastRoot>` overload doesn’t seem to work :'(\n\n/**\n * Plugin that turns markdown into HTML to support rehype.\n *\n * *   If a destination processor is given, that processor runs with a new HTML\n *     (hast) tree (bridge-mode).\n *     As the given processor runs with a hast tree, and rehype plugins support\n *     hast, that means rehype plugins can be used with the given processor.\n *     The hast tree is discarded in the end.\n *     It’s highly unlikely that you want to do this.\n * *   The common case is to not pass a destination processor, in which case the\n *     current processor continues running with a new HTML (hast) tree\n *     (mutate-mode).\n *     As the current processor continues with a hast tree, and rehype plugins\n *     support hast, that means rehype plugins can be used after\n *     `remark-rehype`.\n *     It’s likely that this is what you want to do.\n *\n * @param destination\n *   Optional unified processor.\n * @param options\n *   Options passed to `mdast-util-to-hast`.\n */\n\nconst remarkRehype =\n/** @type {(import('unified').Plugin<[Processor, Options?]|[null|undefined, Options?]|[Options]|[], MdastRoot>)} */\nfunction (destination, options) {\n  return destination && 'run' in destination ? bridge(destination, options) : mutate(destination || options);\n};\n\nexport default remarkRehype;\n/**\n * Bridge-mode.\n * Runs the destination with the new hast tree.\n *\n * @type {import('unified').Plugin<[Processor, Options?], MdastRoot>}\n */\n\nfunction bridge(destination, options) {\n  return (node, file, next) => {\n    destination.run(toHast(node, options), file, error => {\n      next(error);\n    });\n  };\n}\n/**\n * Mutate-mode.\n * Further plugins run on the hast tree.\n *\n * @type {import('unified').Plugin<[Options?]|void[], MdastRoot, HastRoot>}\n */\n\n\nfunction mutate(options) {\n  // @ts-expect-error: assume a corresponding node is returned by `toHast`.\n  return node => toHast(node, options);\n}","/**\n * @typedef {import('./info.js').Info} Info\n * @typedef {Record<string, Info>} Properties\n * @typedef {Record<string, string>} Normal\n */\nexport class Schema {\n  /**\n   * @constructor\n   * @param {Properties} property\n   * @param {Normal} normal\n   * @param {string} [space]\n   */\n  constructor(property, normal, space) {\n    this.property = property;\n    this.normal = normal;\n\n    if (space) {\n      this.space = space;\n    }\n  }\n\n}\n/** @type {Properties} */\n\nSchema.prototype.property = {};\n/** @type {Normal} */\n\nSchema.prototype.normal = {};\n/** @type {string|null} */\n\nSchema.prototype.space = null;","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n */\nimport { Schema } from './schema.js';\n/**\n * @param {Schema[]} definitions\n * @param {string} [space]\n * @returns {Schema}\n */\n\nexport function merge(definitions, space) {\n  /** @type {Properties} */\n  const property = {};\n  /** @type {Normal} */\n\n  const normal = {};\n  let index = -1;\n\n  while (++index < definitions.length) {\n    Object.assign(property, definitions[index].property);\n    Object.assign(normal, definitions[index].normal);\n  }\n\n  return new Schema(property, normal, space);\n}","/**\n * @param {string} value\n * @returns {string}\n */\nexport function normalize(value) {\n  return value.toLowerCase();\n}","export class Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   */\n  constructor(property, attribute) {\n    /** @type {string} */\n    this.property = property;\n    /** @type {string} */\n\n    this.attribute = attribute;\n  }\n\n}\n/** @type {string|null} */\n\nInfo.prototype.space = null;\nInfo.prototype.boolean = false;\nInfo.prototype.booleanish = false;\nInfo.prototype.overloadedBoolean = false;\nInfo.prototype.number = false;\nInfo.prototype.commaSeparated = false;\nInfo.prototype.spaceSeparated = false;\nInfo.prototype.commaOrSpaceSeparated = false;\nInfo.prototype.mustUseProperty = false;\nInfo.prototype.defined = false;","let powers = 0;\nexport const boolean = increment();\nexport const booleanish = increment();\nexport const overloadedBoolean = increment();\nexport const number = increment();\nexport const spaceSeparated = increment();\nexport const commaSeparated = increment();\nexport const commaOrSpaceSeparated = increment();\n\nfunction increment() {\n  return 2 ** ++powers;\n}","import { Info } from './info.js';\nimport * as types from './types.js';\n/** @type {Array<keyof types>} */\n// @ts-expect-error: hush.\n\nconst checks = Object.keys(types);\nexport class DefinedInfo extends Info {\n  /**\n   * @constructor\n   * @param {string} property\n   * @param {string} attribute\n   * @param {number|null} [mask]\n   * @param {string} [space]\n   */\n  constructor(property, attribute, mask, space) {\n    let index = -1;\n    super(property, attribute);\n    mark(this, 'space', space);\n\n    if (typeof mask === 'number') {\n      while (++index < checks.length) {\n        const check = checks[index];\n        mark(this, checks[index], (mask & types[check]) === types[check]);\n      }\n    }\n  }\n\n}\nDefinedInfo.prototype.defined = true;\n/**\n * @param {DefinedInfo} values\n * @param {string} key\n * @param {unknown} value\n */\n\nfunction mark(values, key, value) {\n  if (value) {\n    // @ts-expect-error: assume `value` matches the expected value of `key`.\n    values[key] = value;\n  }\n}","/**\n * @typedef {import('./schema.js').Properties} Properties\n * @typedef {import('./schema.js').Normal} Normal\n *\n * @typedef {Record<string, string>} Attributes\n *\n * @typedef {Object} Definition\n * @property {Record<string, number|null>} properties\n * @property {(attributes: Attributes, property: string) => string} transform\n * @property {string} [space]\n * @property {Attributes} [attributes]\n * @property {Array<string>} [mustUseProperty]\n */\nimport { normalize } from '../normalize.js';\nimport { Schema } from './schema.js';\nimport { DefinedInfo } from './defined-info.js';\nconst own = {}.hasOwnProperty;\n/**\n * @param {Definition} definition\n * @returns {Schema}\n */\n\nexport function create(definition) {\n  /** @type {Properties} */\n  const property = {};\n  /** @type {Normal} */\n\n  const normal = {};\n  /** @type {string} */\n\n  let prop;\n\n  for (prop in definition.properties) {\n    if (own.call(definition.properties, prop)) {\n      const value = definition.properties[prop];\n      const info = new DefinedInfo(prop, definition.transform(definition.attributes || {}, prop), value, definition.space);\n\n      if (definition.mustUseProperty && definition.mustUseProperty.includes(prop)) {\n        info.mustUseProperty = true;\n      }\n\n      property[prop] = info;\n      normal[normalize(prop)] = prop;\n      normal[normalize(info.attribute)] = prop;\n    }\n  }\n\n  return new Schema(property, normal, definition.space);\n}","import { create } from './util/create.js';\nexport const xlink = create({\n  space: 'xlink',\n\n  transform(_, prop) {\n    return 'xlink:' + prop.slice(5).toLowerCase();\n  },\n\n  properties: {\n    xLinkActuate: null,\n    xLinkArcRole: null,\n    xLinkHref: null,\n    xLinkRole: null,\n    xLinkShow: null,\n    xLinkTitle: null,\n    xLinkType: null\n  }\n});","import { create } from './util/create.js';\nexport const xml = create({\n  space: 'xml',\n\n  transform(_, prop) {\n    return 'xml:' + prop.slice(3).toLowerCase();\n  },\n\n  properties: {\n    xmlLang: null,\n    xmlBase: null,\n    xmlSpace: null\n  }\n});","/**\n * @param {Record<string, string>} attributes\n * @param {string} attribute\n * @returns {string}\n */\nexport function caseSensitiveTransform(attributes, attribute) {\n  return attribute in attributes ? attributes[attribute] : attribute;\n}","import { caseSensitiveTransform } from './case-sensitive-transform.js';\n/**\n * @param {Record<string, string>} attributes\n * @param {string} property\n * @returns {string}\n */\n\nexport function caseInsensitiveTransform(attributes, property) {\n  return caseSensitiveTransform(attributes, property.toLowerCase());\n}","import { create } from './util/create.js';\nimport { caseInsensitiveTransform } from './util/case-insensitive-transform.js';\nexport const xmlns = create({\n  space: 'xmlns',\n  attributes: {\n    xmlnsxlink: 'xmlns:xlink'\n  },\n  transform: caseInsensitiveTransform,\n  properties: {\n    xmlns: null,\n    xmlnsXLink: null\n  }\n});","import { booleanish, number, spaceSeparated } from './util/types.js';\nimport { create } from './util/create.js';\nexport const aria = create({\n  transform(_, prop) {\n    return prop === 'role' ? prop : 'aria-' + prop.slice(4).toLowerCase();\n  },\n\n  properties: {\n    ariaActiveDescendant: null,\n    ariaAtomic: booleanish,\n    ariaAutoComplete: null,\n    ariaBusy: booleanish,\n    ariaChecked: booleanish,\n    ariaColCount: number,\n    ariaColIndex: number,\n    ariaColSpan: number,\n    ariaControls: spaceSeparated,\n    ariaCurrent: null,\n    ariaDescribedBy: spaceSeparated,\n    ariaDetails: null,\n    ariaDisabled: booleanish,\n    ariaDropEffect: spaceSeparated,\n    ariaErrorMessage: null,\n    ariaExpanded: booleanish,\n    ariaFlowTo: spaceSeparated,\n    ariaGrabbed: booleanish,\n    ariaHasPopup: null,\n    ariaHidden: booleanish,\n    ariaInvalid: null,\n    ariaKeyShortcuts: null,\n    ariaLabel: null,\n    ariaLabelledBy: spaceSeparated,\n    ariaLevel: number,\n    ariaLive: null,\n    ariaModal: booleanish,\n    ariaMultiLine: booleanish,\n    ariaMultiSelectable: booleanish,\n    ariaOrientation: null,\n    ariaOwns: spaceSeparated,\n    ariaPlaceholder: null,\n    ariaPosInSet: number,\n    ariaPressed: booleanish,\n    ariaReadOnly: booleanish,\n    ariaRelevant: null,\n    ariaRequired: booleanish,\n    ariaRoleDescription: spaceSeparated,\n    ariaRowCount: number,\n    ariaRowIndex: number,\n    ariaRowSpan: number,\n    ariaSelected: booleanish,\n    ariaSetSize: number,\n    ariaSort: null,\n    ariaValueMax: number,\n    ariaValueMin: number,\n    ariaValueNow: number,\n    ariaValueText: null,\n    role: null\n  }\n});","import { boolean, overloadedBoolean, booleanish, number, spaceSeparated, commaSeparated } from './util/types.js';\nimport { create } from './util/create.js';\nimport { caseInsensitiveTransform } from './util/case-insensitive-transform.js';\nexport const html = create({\n  space: 'html',\n  attributes: {\n    acceptcharset: 'accept-charset',\n    classname: 'class',\n    htmlfor: 'for',\n    httpequiv: 'http-equiv'\n  },\n  transform: caseInsensitiveTransform,\n  mustUseProperty: ['checked', 'multiple', 'muted', 'selected'],\n  properties: {\n    // Standard Properties.\n    abbr: null,\n    accept: commaSeparated,\n    acceptCharset: spaceSeparated,\n    accessKey: spaceSeparated,\n    action: null,\n    allow: null,\n    allowFullScreen: boolean,\n    allowPaymentRequest: boolean,\n    allowUserMedia: boolean,\n    alt: null,\n    as: null,\n    async: boolean,\n    autoCapitalize: null,\n    autoComplete: spaceSeparated,\n    autoFocus: boolean,\n    autoPlay: boolean,\n    capture: boolean,\n    charSet: null,\n    checked: boolean,\n    cite: null,\n    className: spaceSeparated,\n    cols: number,\n    colSpan: null,\n    content: null,\n    contentEditable: booleanish,\n    controls: boolean,\n    controlsList: spaceSeparated,\n    coords: number | commaSeparated,\n    crossOrigin: null,\n    data: null,\n    dateTime: null,\n    decoding: null,\n    default: boolean,\n    defer: boolean,\n    dir: null,\n    dirName: null,\n    disabled: boolean,\n    download: overloadedBoolean,\n    draggable: booleanish,\n    encType: null,\n    enterKeyHint: null,\n    form: null,\n    formAction: null,\n    formEncType: null,\n    formMethod: null,\n    formNoValidate: boolean,\n    formTarget: null,\n    headers: spaceSeparated,\n    height: number,\n    hidden: boolean,\n    high: number,\n    href: null,\n    hrefLang: null,\n    htmlFor: spaceSeparated,\n    httpEquiv: spaceSeparated,\n    id: null,\n    imageSizes: null,\n    imageSrcSet: null,\n    inputMode: null,\n    integrity: null,\n    is: null,\n    isMap: boolean,\n    itemId: null,\n    itemProp: spaceSeparated,\n    itemRef: spaceSeparated,\n    itemScope: boolean,\n    itemType: spaceSeparated,\n    kind: null,\n    label: null,\n    lang: null,\n    language: null,\n    list: null,\n    loading: null,\n    loop: boolean,\n    low: number,\n    manifest: null,\n    max: null,\n    maxLength: number,\n    media: null,\n    method: null,\n    min: null,\n    minLength: number,\n    multiple: boolean,\n    muted: boolean,\n    name: null,\n    nonce: null,\n    noModule: boolean,\n    noValidate: boolean,\n    onAbort: null,\n    onAfterPrint: null,\n    onAuxClick: null,\n    onBeforePrint: null,\n    onBeforeUnload: null,\n    onBlur: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onContextLost: null,\n    onContextMenu: null,\n    onContextRestored: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFormData: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLanguageChange: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadEnd: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMessageError: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRejectionHandled: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSecurityPolicyViolation: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onSlotChange: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnhandledRejection: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onWheel: null,\n    open: boolean,\n    optimum: number,\n    pattern: null,\n    ping: spaceSeparated,\n    placeholder: null,\n    playsInline: boolean,\n    poster: null,\n    preload: null,\n    readOnly: boolean,\n    referrerPolicy: null,\n    rel: spaceSeparated,\n    required: boolean,\n    reversed: boolean,\n    rows: number,\n    rowSpan: number,\n    sandbox: spaceSeparated,\n    scope: null,\n    scoped: boolean,\n    seamless: boolean,\n    selected: boolean,\n    shape: null,\n    size: number,\n    sizes: null,\n    slot: null,\n    span: number,\n    spellCheck: booleanish,\n    src: null,\n    srcDoc: null,\n    srcLang: null,\n    srcSet: null,\n    start: number,\n    step: null,\n    style: null,\n    tabIndex: number,\n    target: null,\n    title: null,\n    translate: null,\n    type: null,\n    typeMustMatch: boolean,\n    useMap: null,\n    value: booleanish,\n    width: number,\n    wrap: null,\n    // Legacy.\n    // See: https://html.spec.whatwg.org/#other-elements,-attributes-and-apis\n    align: null,\n    // Several. Use CSS `text-align` instead,\n    aLink: null,\n    // `<body>`. Use CSS `a:active {color}` instead\n    archive: spaceSeparated,\n    // `<object>`. List of URIs to archives\n    axis: null,\n    // `<td>` and `<th>`. Use `scope` on `<th>`\n    background: null,\n    // `<body>`. Use CSS `background-image` instead\n    bgColor: null,\n    // `<body>` and table elements. Use CSS `background-color` instead\n    border: number,\n    // `<table>`. Use CSS `border-width` instead,\n    borderColor: null,\n    // `<table>`. Use CSS `border-color` instead,\n    bottomMargin: number,\n    // `<body>`\n    cellPadding: null,\n    // `<table>`\n    cellSpacing: null,\n    // `<table>`\n    char: null,\n    // Several table elements. When `align=char`, sets the character to align on\n    charOff: null,\n    // Several table elements. When `char`, offsets the alignment\n    classId: null,\n    // `<object>`\n    clear: null,\n    // `<br>`. Use CSS `clear` instead\n    code: null,\n    // `<object>`\n    codeBase: null,\n    // `<object>`\n    codeType: null,\n    // `<object>`\n    color: null,\n    // `<font>` and `<hr>`. Use CSS instead\n    compact: boolean,\n    // Lists. Use CSS to reduce space between items instead\n    declare: boolean,\n    // `<object>`\n    event: null,\n    // `<script>`\n    face: null,\n    // `<font>`. Use CSS instead\n    frame: null,\n    // `<table>`\n    frameBorder: null,\n    // `<iframe>`. Use CSS `border` instead\n    hSpace: number,\n    // `<img>` and `<object>`\n    leftMargin: number,\n    // `<body>`\n    link: null,\n    // `<body>`. Use CSS `a:link {color: *}` instead\n    longDesc: null,\n    // `<frame>`, `<iframe>`, and `<img>`. Use an `<a>`\n    lowSrc: null,\n    // `<img>`. Use a `<picture>`\n    marginHeight: number,\n    // `<body>`\n    marginWidth: number,\n    // `<body>`\n    noResize: boolean,\n    // `<frame>`\n    noHref: boolean,\n    // `<area>`. Use no href instead of an explicit `nohref`\n    noShade: boolean,\n    // `<hr>`. Use background-color and height instead of borders\n    noWrap: boolean,\n    // `<td>` and `<th>`\n    object: null,\n    // `<applet>`\n    profile: null,\n    // `<head>`\n    prompt: null,\n    // `<isindex>`\n    rev: null,\n    // `<link>`\n    rightMargin: number,\n    // `<body>`\n    rules: null,\n    // `<table>`\n    scheme: null,\n    // `<meta>`\n    scrolling: booleanish,\n    // `<frame>`. Use overflow in the child context\n    standby: null,\n    // `<object>`\n    summary: null,\n    // `<table>`\n    text: null,\n    // `<body>`. Use CSS `color` instead\n    topMargin: number,\n    // `<body>`\n    valueType: null,\n    // `<param>`\n    version: null,\n    // `<html>`. Use a doctype.\n    vAlign: null,\n    // Several. Use CSS `vertical-align` instead\n    vLink: null,\n    // `<body>`. Use CSS `a:visited {color}` instead\n    vSpace: number,\n    // `<img>` and `<object>`\n    // Non-standard Properties.\n    allowTransparency: null,\n    autoCorrect: null,\n    autoSave: null,\n    disablePictureInPicture: boolean,\n    disableRemotePlayback: boolean,\n    prefix: null,\n    property: null,\n    results: number,\n    security: null,\n    unselectable: null\n  }\n});","import { boolean, number, spaceSeparated, commaSeparated, commaOrSpaceSeparated } from './util/types.js';\nimport { create } from './util/create.js';\nimport { caseSensitiveTransform } from './util/case-sensitive-transform.js';\nexport const svg = create({\n  space: 'svg',\n  attributes: {\n    accentHeight: 'accent-height',\n    alignmentBaseline: 'alignment-baseline',\n    arabicForm: 'arabic-form',\n    baselineShift: 'baseline-shift',\n    capHeight: 'cap-height',\n    className: 'class',\n    clipPath: 'clip-path',\n    clipRule: 'clip-rule',\n    colorInterpolation: 'color-interpolation',\n    colorInterpolationFilters: 'color-interpolation-filters',\n    colorProfile: 'color-profile',\n    colorRendering: 'color-rendering',\n    crossOrigin: 'crossorigin',\n    dataType: 'datatype',\n    dominantBaseline: 'dominant-baseline',\n    enableBackground: 'enable-background',\n    fillOpacity: 'fill-opacity',\n    fillRule: 'fill-rule',\n    floodColor: 'flood-color',\n    floodOpacity: 'flood-opacity',\n    fontFamily: 'font-family',\n    fontSize: 'font-size',\n    fontSizeAdjust: 'font-size-adjust',\n    fontStretch: 'font-stretch',\n    fontStyle: 'font-style',\n    fontVariant: 'font-variant',\n    fontWeight: 'font-weight',\n    glyphName: 'glyph-name',\n    glyphOrientationHorizontal: 'glyph-orientation-horizontal',\n    glyphOrientationVertical: 'glyph-orientation-vertical',\n    hrefLang: 'hreflang',\n    horizAdvX: 'horiz-adv-x',\n    horizOriginX: 'horiz-origin-x',\n    horizOriginY: 'horiz-origin-y',\n    imageRendering: 'image-rendering',\n    letterSpacing: 'letter-spacing',\n    lightingColor: 'lighting-color',\n    markerEnd: 'marker-end',\n    markerMid: 'marker-mid',\n    markerStart: 'marker-start',\n    navDown: 'nav-down',\n    navDownLeft: 'nav-down-left',\n    navDownRight: 'nav-down-right',\n    navLeft: 'nav-left',\n    navNext: 'nav-next',\n    navPrev: 'nav-prev',\n    navRight: 'nav-right',\n    navUp: 'nav-up',\n    navUpLeft: 'nav-up-left',\n    navUpRight: 'nav-up-right',\n    onAbort: 'onabort',\n    onActivate: 'onactivate',\n    onAfterPrint: 'onafterprint',\n    onBeforePrint: 'onbeforeprint',\n    onBegin: 'onbegin',\n    onCancel: 'oncancel',\n    onCanPlay: 'oncanplay',\n    onCanPlayThrough: 'oncanplaythrough',\n    onChange: 'onchange',\n    onClick: 'onclick',\n    onClose: 'onclose',\n    onCopy: 'oncopy',\n    onCueChange: 'oncuechange',\n    onCut: 'oncut',\n    onDblClick: 'ondblclick',\n    onDrag: 'ondrag',\n    onDragEnd: 'ondragend',\n    onDragEnter: 'ondragenter',\n    onDragExit: 'ondragexit',\n    onDragLeave: 'ondragleave',\n    onDragOver: 'ondragover',\n    onDragStart: 'ondragstart',\n    onDrop: 'ondrop',\n    onDurationChange: 'ondurationchange',\n    onEmptied: 'onemptied',\n    onEnd: 'onend',\n    onEnded: 'onended',\n    onError: 'onerror',\n    onFocus: 'onfocus',\n    onFocusIn: 'onfocusin',\n    onFocusOut: 'onfocusout',\n    onHashChange: 'onhashchange',\n    onInput: 'oninput',\n    onInvalid: 'oninvalid',\n    onKeyDown: 'onkeydown',\n    onKeyPress: 'onkeypress',\n    onKeyUp: 'onkeyup',\n    onLoad: 'onload',\n    onLoadedData: 'onloadeddata',\n    onLoadedMetadata: 'onloadedmetadata',\n    onLoadStart: 'onloadstart',\n    onMessage: 'onmessage',\n    onMouseDown: 'onmousedown',\n    onMouseEnter: 'onmouseenter',\n    onMouseLeave: 'onmouseleave',\n    onMouseMove: 'onmousemove',\n    onMouseOut: 'onmouseout',\n    onMouseOver: 'onmouseover',\n    onMouseUp: 'onmouseup',\n    onMouseWheel: 'onmousewheel',\n    onOffline: 'onoffline',\n    onOnline: 'ononline',\n    onPageHide: 'onpagehide',\n    onPageShow: 'onpageshow',\n    onPaste: 'onpaste',\n    onPause: 'onpause',\n    onPlay: 'onplay',\n    onPlaying: 'onplaying',\n    onPopState: 'onpopstate',\n    onProgress: 'onprogress',\n    onRateChange: 'onratechange',\n    onRepeat: 'onrepeat',\n    onReset: 'onreset',\n    onResize: 'onresize',\n    onScroll: 'onscroll',\n    onSeeked: 'onseeked',\n    onSeeking: 'onseeking',\n    onSelect: 'onselect',\n    onShow: 'onshow',\n    onStalled: 'onstalled',\n    onStorage: 'onstorage',\n    onSubmit: 'onsubmit',\n    onSuspend: 'onsuspend',\n    onTimeUpdate: 'ontimeupdate',\n    onToggle: 'ontoggle',\n    onUnload: 'onunload',\n    onVolumeChange: 'onvolumechange',\n    onWaiting: 'onwaiting',\n    onZoom: 'onzoom',\n    overlinePosition: 'overline-position',\n    overlineThickness: 'overline-thickness',\n    paintOrder: 'paint-order',\n    panose1: 'panose-1',\n    pointerEvents: 'pointer-events',\n    referrerPolicy: 'referrerpolicy',\n    renderingIntent: 'rendering-intent',\n    shapeRendering: 'shape-rendering',\n    stopColor: 'stop-color',\n    stopOpacity: 'stop-opacity',\n    strikethroughPosition: 'strikethrough-position',\n    strikethroughThickness: 'strikethrough-thickness',\n    strokeDashArray: 'stroke-dasharray',\n    strokeDashOffset: 'stroke-dashoffset',\n    strokeLineCap: 'stroke-linecap',\n    strokeLineJoin: 'stroke-linejoin',\n    strokeMiterLimit: 'stroke-miterlimit',\n    strokeOpacity: 'stroke-opacity',\n    strokeWidth: 'stroke-width',\n    tabIndex: 'tabindex',\n    textAnchor: 'text-anchor',\n    textDecoration: 'text-decoration',\n    textRendering: 'text-rendering',\n    typeOf: 'typeof',\n    underlinePosition: 'underline-position',\n    underlineThickness: 'underline-thickness',\n    unicodeBidi: 'unicode-bidi',\n    unicodeRange: 'unicode-range',\n    unitsPerEm: 'units-per-em',\n    vAlphabetic: 'v-alphabetic',\n    vHanging: 'v-hanging',\n    vIdeographic: 'v-ideographic',\n    vMathematical: 'v-mathematical',\n    vectorEffect: 'vector-effect',\n    vertAdvY: 'vert-adv-y',\n    vertOriginX: 'vert-origin-x',\n    vertOriginY: 'vert-origin-y',\n    wordSpacing: 'word-spacing',\n    writingMode: 'writing-mode',\n    xHeight: 'x-height',\n    // These were camelcased in Tiny. Now lowercased in SVG 2\n    playbackOrder: 'playbackorder',\n    timelineBegin: 'timelinebegin'\n  },\n  transform: caseSensitiveTransform,\n  properties: {\n    about: commaOrSpaceSeparated,\n    accentHeight: number,\n    accumulate: null,\n    additive: null,\n    alignmentBaseline: null,\n    alphabetic: number,\n    amplitude: number,\n    arabicForm: null,\n    ascent: number,\n    attributeName: null,\n    attributeType: null,\n    azimuth: number,\n    bandwidth: null,\n    baselineShift: null,\n    baseFrequency: null,\n    baseProfile: null,\n    bbox: null,\n    begin: null,\n    bias: number,\n    by: null,\n    calcMode: null,\n    capHeight: number,\n    className: spaceSeparated,\n    clip: null,\n    clipPath: null,\n    clipPathUnits: null,\n    clipRule: null,\n    color: null,\n    colorInterpolation: null,\n    colorInterpolationFilters: null,\n    colorProfile: null,\n    colorRendering: null,\n    content: null,\n    contentScriptType: null,\n    contentStyleType: null,\n    crossOrigin: null,\n    cursor: null,\n    cx: null,\n    cy: null,\n    d: null,\n    dataType: null,\n    defaultAction: null,\n    descent: number,\n    diffuseConstant: number,\n    direction: null,\n    display: null,\n    dur: null,\n    divisor: number,\n    dominantBaseline: null,\n    download: boolean,\n    dx: null,\n    dy: null,\n    edgeMode: null,\n    editable: null,\n    elevation: number,\n    enableBackground: null,\n    end: null,\n    event: null,\n    exponent: number,\n    externalResourcesRequired: null,\n    fill: null,\n    fillOpacity: number,\n    fillRule: null,\n    filter: null,\n    filterRes: null,\n    filterUnits: null,\n    floodColor: null,\n    floodOpacity: null,\n    focusable: null,\n    focusHighlight: null,\n    fontFamily: null,\n    fontSize: null,\n    fontSizeAdjust: null,\n    fontStretch: null,\n    fontStyle: null,\n    fontVariant: null,\n    fontWeight: null,\n    format: null,\n    fr: null,\n    from: null,\n    fx: null,\n    fy: null,\n    g1: commaSeparated,\n    g2: commaSeparated,\n    glyphName: commaSeparated,\n    glyphOrientationHorizontal: null,\n    glyphOrientationVertical: null,\n    glyphRef: null,\n    gradientTransform: null,\n    gradientUnits: null,\n    handler: null,\n    hanging: number,\n    hatchContentUnits: null,\n    hatchUnits: null,\n    height: null,\n    href: null,\n    hrefLang: null,\n    horizAdvX: number,\n    horizOriginX: number,\n    horizOriginY: number,\n    id: null,\n    ideographic: number,\n    imageRendering: null,\n    initialVisibility: null,\n    in: null,\n    in2: null,\n    intercept: number,\n    k: number,\n    k1: number,\n    k2: number,\n    k3: number,\n    k4: number,\n    kernelMatrix: commaOrSpaceSeparated,\n    kernelUnitLength: null,\n    keyPoints: null,\n    // SEMI_COLON_SEPARATED\n    keySplines: null,\n    // SEMI_COLON_SEPARATED\n    keyTimes: null,\n    // SEMI_COLON_SEPARATED\n    kerning: null,\n    lang: null,\n    lengthAdjust: null,\n    letterSpacing: null,\n    lightingColor: null,\n    limitingConeAngle: number,\n    local: null,\n    markerEnd: null,\n    markerMid: null,\n    markerStart: null,\n    markerHeight: null,\n    markerUnits: null,\n    markerWidth: null,\n    mask: null,\n    maskContentUnits: null,\n    maskUnits: null,\n    mathematical: null,\n    max: null,\n    media: null,\n    mediaCharacterEncoding: null,\n    mediaContentEncodings: null,\n    mediaSize: number,\n    mediaTime: null,\n    method: null,\n    min: null,\n    mode: null,\n    name: null,\n    navDown: null,\n    navDownLeft: null,\n    navDownRight: null,\n    navLeft: null,\n    navNext: null,\n    navPrev: null,\n    navRight: null,\n    navUp: null,\n    navUpLeft: null,\n    navUpRight: null,\n    numOctaves: null,\n    observer: null,\n    offset: null,\n    onAbort: null,\n    onActivate: null,\n    onAfterPrint: null,\n    onBeforePrint: null,\n    onBegin: null,\n    onCancel: null,\n    onCanPlay: null,\n    onCanPlayThrough: null,\n    onChange: null,\n    onClick: null,\n    onClose: null,\n    onCopy: null,\n    onCueChange: null,\n    onCut: null,\n    onDblClick: null,\n    onDrag: null,\n    onDragEnd: null,\n    onDragEnter: null,\n    onDragExit: null,\n    onDragLeave: null,\n    onDragOver: null,\n    onDragStart: null,\n    onDrop: null,\n    onDurationChange: null,\n    onEmptied: null,\n    onEnd: null,\n    onEnded: null,\n    onError: null,\n    onFocus: null,\n    onFocusIn: null,\n    onFocusOut: null,\n    onHashChange: null,\n    onInput: null,\n    onInvalid: null,\n    onKeyDown: null,\n    onKeyPress: null,\n    onKeyUp: null,\n    onLoad: null,\n    onLoadedData: null,\n    onLoadedMetadata: null,\n    onLoadStart: null,\n    onMessage: null,\n    onMouseDown: null,\n    onMouseEnter: null,\n    onMouseLeave: null,\n    onMouseMove: null,\n    onMouseOut: null,\n    onMouseOver: null,\n    onMouseUp: null,\n    onMouseWheel: null,\n    onOffline: null,\n    onOnline: null,\n    onPageHide: null,\n    onPageShow: null,\n    onPaste: null,\n    onPause: null,\n    onPlay: null,\n    onPlaying: null,\n    onPopState: null,\n    onProgress: null,\n    onRateChange: null,\n    onRepeat: null,\n    onReset: null,\n    onResize: null,\n    onScroll: null,\n    onSeeked: null,\n    onSeeking: null,\n    onSelect: null,\n    onShow: null,\n    onStalled: null,\n    onStorage: null,\n    onSubmit: null,\n    onSuspend: null,\n    onTimeUpdate: null,\n    onToggle: null,\n    onUnload: null,\n    onVolumeChange: null,\n    onWaiting: null,\n    onZoom: null,\n    opacity: null,\n    operator: null,\n    order: null,\n    orient: null,\n    orientation: null,\n    origin: null,\n    overflow: null,\n    overlay: null,\n    overlinePosition: number,\n    overlineThickness: number,\n    paintOrder: null,\n    panose1: null,\n    path: null,\n    pathLength: number,\n    patternContentUnits: null,\n    patternTransform: null,\n    patternUnits: null,\n    phase: null,\n    ping: spaceSeparated,\n    pitch: null,\n    playbackOrder: null,\n    pointerEvents: null,\n    points: null,\n    pointsAtX: number,\n    pointsAtY: number,\n    pointsAtZ: number,\n    preserveAlpha: null,\n    preserveAspectRatio: null,\n    primitiveUnits: null,\n    propagate: null,\n    property: commaOrSpaceSeparated,\n    r: null,\n    radius: null,\n    referrerPolicy: null,\n    refX: null,\n    refY: null,\n    rel: commaOrSpaceSeparated,\n    rev: commaOrSpaceSeparated,\n    renderingIntent: null,\n    repeatCount: null,\n    repeatDur: null,\n    requiredExtensions: commaOrSpaceSeparated,\n    requiredFeatures: commaOrSpaceSeparated,\n    requiredFonts: commaOrSpaceSeparated,\n    requiredFormats: commaOrSpaceSeparated,\n    resource: null,\n    restart: null,\n    result: null,\n    rotate: null,\n    rx: null,\n    ry: null,\n    scale: null,\n    seed: null,\n    shapeRendering: null,\n    side: null,\n    slope: null,\n    snapshotTime: null,\n    specularConstant: number,\n    specularExponent: number,\n    spreadMethod: null,\n    spacing: null,\n    startOffset: null,\n    stdDeviation: null,\n    stemh: null,\n    stemv: null,\n    stitchTiles: null,\n    stopColor: null,\n    stopOpacity: null,\n    strikethroughPosition: number,\n    strikethroughThickness: number,\n    string: null,\n    stroke: null,\n    strokeDashArray: commaOrSpaceSeparated,\n    strokeDashOffset: null,\n    strokeLineCap: null,\n    strokeLineJoin: null,\n    strokeMiterLimit: number,\n    strokeOpacity: number,\n    strokeWidth: null,\n    style: null,\n    surfaceScale: number,\n    syncBehavior: null,\n    syncBehaviorDefault: null,\n    syncMaster: null,\n    syncTolerance: null,\n    syncToleranceDefault: null,\n    systemLanguage: commaOrSpaceSeparated,\n    tabIndex: number,\n    tableValues: null,\n    target: null,\n    targetX: number,\n    targetY: number,\n    textAnchor: null,\n    textDecoration: null,\n    textRendering: null,\n    textLength: null,\n    timelineBegin: null,\n    title: null,\n    transformBehavior: null,\n    type: null,\n    typeOf: commaOrSpaceSeparated,\n    to: null,\n    transform: null,\n    u1: null,\n    u2: null,\n    underlinePosition: number,\n    underlineThickness: number,\n    unicode: null,\n    unicodeBidi: null,\n    unicodeRange: null,\n    unitsPerEm: number,\n    values: null,\n    vAlphabetic: number,\n    vMathematical: number,\n    vectorEffect: null,\n    vHanging: number,\n    vIdeographic: number,\n    version: null,\n    vertAdvY: number,\n    vertOriginX: number,\n    vertOriginY: number,\n    viewBox: null,\n    viewTarget: null,\n    visibility: null,\n    width: null,\n    widths: null,\n    wordSpacing: null,\n    writingMode: null,\n    x: null,\n    x1: null,\n    x2: null,\n    xChannelSelector: null,\n    xHeight: number,\n    y: null,\n    y1: null,\n    y2: null,\n    yChannelSelector: null,\n    z: null,\n    zoomAndPan: null\n  }\n});","/**\n * @typedef {import('./lib/util/info.js').Info} Info\n * @typedef {import('./lib/util/schema.js').Schema} Schema\n */\nimport { merge } from './lib/util/merge.js';\nimport { xlink } from './lib/xlink.js';\nimport { xml } from './lib/xml.js';\nimport { xmlns } from './lib/xmlns.js';\nimport { aria } from './lib/aria.js';\nimport { html as htmlBase } from './lib/html.js';\nimport { svg as svgBase } from './lib/svg.js';\nexport { find } from './lib/find.js';\nexport { hastToReact } from './lib/hast-to-react.js';\nexport { normalize } from './lib/normalize.js';\nexport const html = merge([xml, xlink, xmlns, aria, htmlBase], 'html');\nexport const svg = merge([xml, xlink, xmlns, aria, svgBase], 'svg');","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n *\n * @typedef {string} Type\n * @typedef {Object<string, unknown>} Props\n *\n * @typedef {null|undefined|Type|Props|TestFunctionAnything|Array.<Type|Props|TestFunctionAnything>} Test\n */\n\n/**\n * Check if a node passes a test\n *\n * @callback TestFunctionAnything\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean|void}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} X\n * @callback TestFunctionPredicate\n * @param {Node} node\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is X}\n */\n\n/**\n * @callback AssertAnything\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {boolean}\n */\n\n/**\n * Check if a node passes a certain node test\n *\n * @template {Node} Y\n * @callback AssertPredicate\n * @param {unknown} [node]\n * @param {number|null|undefined} [index]\n * @param {Parent|null|undefined} [parent]\n * @returns {node is Y}\n */\nexport const is =\n/**\n * Check if a node passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @type {(\n *   (<T extends Node>(node: unknown, test: T['type']|Partial<T>|TestFunctionPredicate<T>|Array.<T['type']|Partial<T>|TestFunctionPredicate<T>>, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => node is T) &\n *   ((node?: unknown, test?: Test, index?: number|null|undefined, parent?: Parent|null|undefined, context?: unknown) => boolean)\n * )}\n */\n\n/**\n * Check if a node passes a test.\n * When a `parent` node is known the `index` of node should also be given.\n *\n * @param {unknown} [node] Node to check\n * @param {Test} [test]\n * When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * When `array`, checks any one of the subtests pass.\n * @param {number|null|undefined} [index] Position of `node` in `parent`\n * @param {Parent|null|undefined} [parent] Parent of `node`\n * @param {unknown} [context] Context object to invoke `test` with\n * @returns {boolean} Whether test passed and `node` is a `Node` (object with `type` set to non-empty `string`).\n */\n// eslint-disable-next-line max-params\nfunction is(node, test, index, parent, context) {\n  const check = convert(test);\n\n  if (index !== undefined && index !== null && (typeof index !== 'number' || index < 0 || index === Number.POSITIVE_INFINITY)) {\n    throw new Error('Expected positive finite index');\n  }\n\n  if (parent !== undefined && parent !== null && (!is(parent) || !parent.children)) {\n    throw new Error('Expected parent node');\n  }\n\n  if ((parent === undefined || parent === null) !== (index === undefined || index === null)) {\n    throw new Error('Expected both parent and index');\n  } // @ts-expect-error Looks like a node.\n\n\n  return node && node.type && typeof node.type === 'string' ? Boolean(check.call(context, node, index, parent)) : false;\n};\nexport const convert =\n/**\n * @type {(\n *   (<T extends Node>(test: T['type']|Partial<T>|TestFunctionPredicate<T>) => AssertPredicate<T>) &\n *   ((test?: Test) => AssertAnything)\n * )}\n */\n\n/**\n * Generate an assertion from a check.\n * @param {Test} [test]\n * When nullish, checks if `node` is a `Node`.\n * When `string`, works like passing `function (node) {return node.type === test}`.\n * When `function` checks if function passed the node is true.\n * When `object`, checks that all keys in test are in node, and that they have (strictly) equal values.\n * When `array`, checks any one of the subtests pass.\n * @returns {AssertAnything}\n */\nfunction (test) {\n  if (test === undefined || test === null) {\n    return ok;\n  }\n\n  if (typeof test === 'string') {\n    return typeFactory(test);\n  }\n\n  if (typeof test === 'object') {\n    return Array.isArray(test) ? anyFactory(test) : propsFactory(test);\n  }\n\n  if (typeof test === 'function') {\n    return castFactory(test);\n  }\n\n  throw new Error('Expected function, string, or object as test');\n};\n/**\n * @param {Array.<Type|Props|TestFunctionAnything>} tests\n * @returns {AssertAnything}\n */\n\nfunction anyFactory(tests) {\n  /** @type {Array.<AssertAnything>} */\n  const checks = [];\n  let index = -1;\n\n  while (++index < tests.length) {\n    checks[index] = convert(tests[index]);\n  }\n\n  return castFactory(any);\n  /**\n   * @this {unknown}\n   * @param {unknown[]} parameters\n   * @returns {boolean}\n   */\n\n  function any() {\n    let index = -1;\n\n    for (var _len = arguments.length, parameters = new Array(_len), _key = 0; _key < _len; _key++) {\n      parameters[_key] = arguments[_key];\n    }\n\n    while (++index < checks.length) {\n      if (checks[index].call(this, ...parameters)) return true;\n    }\n\n    return false;\n  }\n}\n/**\n * Utility to assert each property in `test` is represented in `node`, and each\n * values are strictly equal.\n *\n * @param {Props} check\n * @returns {AssertAnything}\n */\n\n\nfunction propsFactory(check) {\n  return castFactory(all);\n  /**\n   * @param {Node} node\n   * @returns {boolean}\n   */\n\n  function all(node) {\n    /** @type {string} */\n    let key;\n\n    for (key in check) {\n      // @ts-expect-error: hush, it sure works as an index.\n      if (node[key] !== check[key]) return false;\n    }\n\n    return true;\n  }\n}\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n *\n * @param {Type} check\n * @returns {AssertAnything}\n */\n\n\nfunction typeFactory(check) {\n  return castFactory(type);\n  /**\n   * @param {Node} node\n   */\n\n  function type(node) {\n    return node && node.type === check;\n  }\n}\n/**\n * Utility to convert a string into a function which checks a given node’s type\n * for said string.\n * @param {TestFunctionAnything} check\n * @returns {AssertAnything}\n */\n\n\nfunction castFactory(check) {\n  return assertion;\n  /**\n   * @this {unknown}\n   * @param {Array.<unknown>} parameters\n   * @returns {boolean}\n   */\n\n  function assertion() {\n    for (var _len2 = arguments.length, parameters = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      parameters[_key2] = arguments[_key2];\n    }\n\n    // @ts-expect-error: spreading is fine.\n    return Boolean(check.call(this, ...parameters));\n  }\n} // Utility to return true.\n\n\nfunction ok() {\n  return true;\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('./complex-types').Action} Action\n * @typedef {import('./complex-types').Index} Index\n * @typedef {import('./complex-types').ActionTuple} ActionTuple\n * @typedef {import('./complex-types').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\nimport { convert } from 'unist-util-is';\nimport { color } from './color.js';\n/**\n * Continue traversing as normal\n */\n\nexport const CONTINUE = true;\n/**\n * Do not traverse this node’s children\n */\n\nexport const SKIP = 'skip';\n/**\n * Stop traversing immediately\n */\n\nexport const EXIT = false;\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test node, optional\n * @param visitor Function to run for each node\n * @param reverse Visit the tree in reverse order, defaults to false\n */\n\nexport const visitParents =\n/**\n * @type {(\n *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types').BuildVisitor<Tree>, reverse?: boolean) => void)\n * )}\n */\n\n/**\n * @param {Node} tree\n * @param {Test} test\n * @param {import('./complex-types').Visitor<Node>} visitor\n * @param {boolean} [reverse]\n */\nfunction (tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor; // @ts-expect-error no visitor given, so `visitor` is test.\n\n    visitor = test;\n    test = null;\n  }\n\n  const is = convert(test);\n  const step = reverse ? -1 : 1;\n  factory(tree, null, [])();\n  /**\n   * @param {Node} node\n   * @param {number?} index\n   * @param {Array.<Parent>} parents\n   */\n\n  function factory(node, index, parents) {\n    /** @type {Object.<string, unknown>} */\n    // @ts-expect-error: hush\n    const value = typeof node === 'object' && node !== null ? node : {};\n    /** @type {string|undefined} */\n\n    let name;\n\n    if (typeof value.type === 'string') {\n      name = typeof value.tagName === 'string' ? value.tagName : typeof value.name === 'string' ? value.name : undefined;\n      Object.defineProperty(visit, 'name', {\n        value: 'node (' + color(value.type + (name ? '<' + name + '>' : '')) + ')'\n      });\n    }\n\n    return visit;\n\n    function visit() {\n      /** @type {ActionTuple} */\n      let result = [];\n      /** @type {ActionTuple} */\n\n      let subresult;\n      /** @type {number} */\n\n      let offset;\n      /** @type {Array.<Parent>} */\n\n      let grandparents;\n\n      if (!test || is(node, index, parents[parents.length - 1] || null)) {\n        result = toResult(visitor(node, parents));\n\n        if (result[0] === EXIT) {\n          return result;\n        }\n      } // @ts-expect-error looks like a parent.\n\n\n      if (node.children && result[0] !== SKIP) {\n        // @ts-expect-error looks like a parent.\n        offset = (reverse ? node.children.length : -1) + step; // @ts-expect-error looks like a parent.\n\n        grandparents = parents.concat(node); // @ts-expect-error looks like a parent.\n\n        while (offset > -1 && offset < node.children.length) {\n          // @ts-expect-error looks like a parent.\n          subresult = factory(node.children[offset], offset, grandparents)();\n\n          if (subresult[0] === EXIT) {\n            return subresult;\n          }\n\n          offset = typeof subresult[1] === 'number' ? subresult[1] : offset + step;\n        }\n      }\n\n      return result;\n    }\n  }\n};\n/**\n * @param {VisitorResult} value\n * @returns {ActionTuple}\n */\n\nfunction toResult(value) {\n  if (Array.isArray(value)) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return [CONTINUE, value];\n  }\n\n  return [value];\n}","import { visit } from 'unist-util-visit';\n/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Element} Element\n *\n * @callback AllowElement\n * @param {Element} element\n * @param {number} index\n * @param {Element|Root} parent\n * @returns {boolean|undefined}\n *\n * @typedef Options\n * @property {Array<string>} [allowedElements]\n * @property {Array<string>} [disallowedElements=[]]\n * @property {AllowElement} [allowElement]\n * @property {boolean} [unwrapDisallowed=false]\n */\n\n/**\n * @type {import('unified').Plugin<[Options], Root>}\n */\n\nexport default function rehypeFilter(options) {\n  if (options.allowedElements && options.disallowedElements) {\n    throw new TypeError('Only one of `allowedElements` and `disallowedElements` should be defined');\n  }\n\n  if (options.allowedElements || options.disallowedElements || options.allowElement) {\n    return tree => {\n      visit(tree, 'element', (node, index, parent_) => {\n        const parent =\n        /** @type {Element|Root} */\n        parent_;\n        /** @type {boolean|undefined} */\n\n        let remove;\n\n        if (options.allowedElements) {\n          remove = !options.allowedElements.includes(node.tagName);\n        } else if (options.disallowedElements) {\n          remove = options.disallowedElements.includes(node.tagName);\n        }\n\n        if (!remove && options.allowElement && typeof index === 'number') {\n          remove = !options.allowElement(node, index, parent);\n        }\n\n        if (remove && typeof index === 'number') {\n          if (options.unwrapDisallowed && node.children) {\n            parent.children.splice(index, 1, ...node.children);\n          } else {\n            parent.children.splice(index, 1);\n          }\n\n          return index;\n        }\n\n        return undefined;\n      });\n    };\n  }\n}","/**\n * @typedef {import('unist').Node} Node\n * @typedef {import('unist').Parent} Parent\n * @typedef {import('unist-util-is').Test} Test\n * @typedef {import('unist-util-visit-parents').VisitorResult} VisitorResult\n * @typedef {import('./complex-types').Visitor} Visitor\n */\nimport { visitParents, CONTINUE, SKIP, EXIT } from 'unist-util-visit-parents';\nexport { CONTINUE, SKIP, EXIT };\n/**\n * Visit children of tree which pass a test\n *\n * @param tree Abstract syntax tree to walk\n * @param test Test, optional\n * @param visitor Function to run for each node\n * @param reverse Fisit the tree in reverse, defaults to false\n */\n\nexport const visit =\n/**\n * @type {(\n *   (<Tree extends Node, Check extends Test>(tree: Tree, test: Check, visitor: import('./complex-types').BuildVisitor<Tree, Check>, reverse?: boolean) => void) &\n *   (<Tree extends Node>(tree: Tree, visitor: import('./complex-types').BuildVisitor<Tree>, reverse?: boolean) => void)\n * )}\n */\n\n/**\n * @param {Node} tree\n * @param {Test} test\n * @param {import('./complex-types').Visitor} visitor\n * @param {boolean} [reverse]\n */\nfunction (tree, test, visitor, reverse) {\n  if (typeof test === 'function' && typeof visitor !== 'function') {\n    reverse = visitor;\n    visitor = test;\n    test = null;\n  }\n\n  visitParents(tree, test, overload, reverse);\n  /**\n   * @param {Node} node\n   * @param {Array.<Parent>} parents\n   */\n\n  function overload(node, parents) {\n    const parent = parents[parents.length - 1];\n    return visitor(node, parent ? parent.children.indexOf(node) : null, parent);\n  }\n};","const protocols = ['http', 'https', 'mailto', 'tel'];\n/**\n * @param {string} uri\n * @returns {string}\n */\n\nexport function uriTransformer(uri) {\n  const url = (uri || '').trim();\n  const first = url.charAt(0);\n\n  if (first === '#' || first === '/') {\n    return url;\n  }\n\n  const colon = url.indexOf(':');\n\n  if (colon === -1) {\n    return url;\n  }\n\n  let index = -1;\n\n  while (++index < protocols.length) {\n    const protocol = protocols[index];\n\n    if (colon === protocol.length && url.slice(0, protocol.length).toLowerCase() === protocol) {\n      return url;\n    }\n  }\n\n  index = url.indexOf('?');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  }\n\n  index = url.indexOf('#');\n\n  if (index !== -1 && colon > index) {\n    return url;\n  } // eslint-disable-next-line no-script-url\n\n\n  return 'javascript:void(0)';\n}","/**\n * @typedef {import('./util/schema.js').Schema} Schema\n */\nimport { normalize } from './normalize.js';\nimport { DefinedInfo } from './util/defined-info.js';\nimport { Info } from './util/info.js';\nconst valid = /^data[-\\w.:]+$/i;\nconst dash = /-[a-z]/g;\nconst cap = /[A-Z]/g;\n/**\n * @param {Schema} schema\n * @param {string} value\n * @returns {Info}\n */\n\nexport function find(schema, value) {\n  const normal = normalize(value);\n  let prop = value;\n  let Type = Info;\n\n  if (normal in schema.normal) {\n    return schema.property[schema.normal[normal]];\n  }\n\n  if (normal.length > 4 && normal.slice(0, 4) === 'data' && valid.test(value)) {\n    // Attribute or property.\n    if (value.charAt(4) === '-') {\n      // Turn it into a property.\n      const rest = value.slice(5).replace(dash, camelcase);\n      prop = 'data' + rest.charAt(0).toUpperCase() + rest.slice(1);\n    } else {\n      // Turn it into an attribute.\n      const rest = value.slice(4);\n\n      if (!dash.test(rest)) {\n        let dashes = rest.replace(cap, kebab);\n\n        if (dashes.charAt(0) !== '-') {\n          dashes = '-' + dashes;\n        }\n\n        value = 'data' + dashes;\n      }\n    }\n\n    Type = DefinedInfo;\n  }\n\n  return new Type(prop, value);\n}\n/**\n * @param {string} $0\n * @returns {string}\n */\n\nfunction kebab($0) {\n  return '-' + $0.toLowerCase();\n}\n/**\n * @param {string} $0\n * @returns {string}\n */\n\n\nfunction camelcase($0) {\n  return $0.charAt(1).toUpperCase();\n}","export const hastToReact = {\n  classId: 'classID',\n  dataType: 'datatype',\n  itemId: 'itemID',\n  strokeDashArray: 'strokeDasharray',\n  strokeDashOffset: 'strokeDashoffset',\n  strokeLineCap: 'strokeLinecap',\n  strokeLineJoin: 'strokeLinejoin',\n  strokeMiterLimit: 'strokeMiterlimit',\n  typeOf: 'typeof',\n  xLinkActuate: 'xlinkActuate',\n  xLinkArcRole: 'xlinkArcrole',\n  xLinkHref: 'xlinkHref',\n  xLinkRole: 'xlinkRole',\n  xLinkShow: 'xlinkShow',\n  xLinkTitle: 'xlinkTitle',\n  xLinkType: 'xlinkType',\n  xmlnsXLink: 'xmlnsXlink'\n};","/**\n * @template T\n * @typedef {import('react').ComponentType<T>} ComponentType<T>\n */\n\n/**\n * @template T\n * @typedef {import('react').ComponentPropsWithoutRef<T>} ComponentPropsWithoutRef<T>\n */\n\n/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('unist').Position} Position\n * @typedef {import('hast').Element} Element\n * @typedef {import('hast').ElementContent} ElementContent\n * @typedef {import('hast').Root} Root\n * @typedef {import('hast').Text} Text\n * @typedef {import('hast').Comment} Comment\n * @typedef {import('hast').DocType} Doctype\n * @typedef {import('property-information').Info} Info\n * @typedef {import('property-information').Schema} Schema\n * @typedef {import('./complex-types').ReactMarkdownProps} ReactMarkdownProps\n *\n * @typedef Raw\n * @property {'raw'} type\n * @property {string} value\n *\n * @typedef Context\n * @property {Options} options\n * @property {Schema} schema\n * @property {number} listDepth\n *\n * @callback TransformLink\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {string}\n *\n * @callback TransformImage\n * @param {string} src\n * @param {string} alt\n * @param {string?} title\n * @returns {string}\n *\n * @typedef {import('react').HTMLAttributeAnchorTarget} TransformLinkTargetType\n *\n * @callback TransformLinkTarget\n * @param {string} href\n * @param {Array<ElementContent>} children\n * @param {string?} title\n * @returns {TransformLinkTargetType|undefined}\n *\n * @typedef {keyof JSX.IntrinsicElements} ReactMarkdownNames\n *\n * To do: is `data-sourcepos` typeable?\n *\n * @typedef {ComponentPropsWithoutRef<'code'> & ReactMarkdownProps & {inline?: boolean}} CodeProps\n * @typedef {ComponentPropsWithoutRef<'h1'> & ReactMarkdownProps & {level: number}} HeadingProps\n * @typedef {ComponentPropsWithoutRef<'li'> & ReactMarkdownProps & {checked: boolean|null, index: number, ordered: boolean}} LiProps\n * @typedef {ComponentPropsWithoutRef<'ol'> & ReactMarkdownProps & {depth: number, ordered: true}} OrderedListProps\n * @typedef {ComponentPropsWithoutRef<'table'> & ReactMarkdownProps & {style?: Record<string, unknown>, isHeader: boolean}} TableCellProps\n * @typedef {ComponentPropsWithoutRef<'tr'> & ReactMarkdownProps & {isHeader: boolean}} TableRowProps\n * @typedef {ComponentPropsWithoutRef<'ul'> & ReactMarkdownProps & {depth: number, ordered: false}} UnorderedListProps\n *\n * @typedef {ComponentType<CodeProps>} CodeComponent\n * @typedef {ComponentType<HeadingProps>} HeadingComponent\n * @typedef {ComponentType<LiProps>} LiComponent\n * @typedef {ComponentType<OrderedListProps>} OrderedListComponent\n * @typedef {ComponentType<TableCellProps>} TableCellComponent\n * @typedef {ComponentType<TableRowProps>} TableRowComponent\n * @typedef {ComponentType<UnorderedListProps>} UnorderedListComponent\n *\n * @typedef SpecialComponents\n * @property {CodeComponent|ReactMarkdownNames} code\n * @property {HeadingComponent|ReactMarkdownNames} h1\n * @property {HeadingComponent|ReactMarkdownNames} h2\n * @property {HeadingComponent|ReactMarkdownNames} h3\n * @property {HeadingComponent|ReactMarkdownNames} h4\n * @property {HeadingComponent|ReactMarkdownNames} h5\n * @property {HeadingComponent|ReactMarkdownNames} h6\n * @property {LiComponent|ReactMarkdownNames} li\n * @property {OrderedListComponent|ReactMarkdownNames} ol\n * @property {TableCellComponent|ReactMarkdownNames} td\n * @property {TableCellComponent|ReactMarkdownNames} th\n * @property {TableRowComponent|ReactMarkdownNames} tr\n * @property {UnorderedListComponent|ReactMarkdownNames} ul\n *\n * @typedef {Partial<Omit<import('./complex-types').NormalComponents, keyof SpecialComponents> & SpecialComponents>} Components\n *\n * @typedef Options\n * @property {boolean} [sourcePos=false]\n * @property {boolean} [rawSourcePos=false]\n * @property {boolean} [skipHtml=false]\n * @property {boolean} [includeElementIndex=false]\n * @property {null|false|TransformLink} [transformLinkUri]\n * @property {TransformImage} [transformImageUri]\n * @property {TransformLinkTargetType|TransformLinkTarget} [linkTarget]\n * @property {Components} [components]\n */\nimport React from 'react';\nimport ReactIs from 'react-is';\nimport { whitespace } from 'hast-util-whitespace';\nimport { svg, find, hastToReact } from 'property-information';\nimport { stringify as spaces } from 'space-separated-tokens';\nimport { stringify as commas } from 'comma-separated-tokens';\nimport style from 'style-to-object';\nconst own = {}.hasOwnProperty; // The table-related elements that must not contain whitespace text according\n// to React.\n\nconst tableElements = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr']);\n/**\n * @param {Context} context\n * @param {Element|Root} node\n */\n\nexport function childrenToReact(context, node) {\n  /** @type {Array<ReactNode>} */\n  const children = [];\n  let childIndex = -1;\n  /** @type {Comment|Doctype|Element|Raw|Text} */\n\n  let child;\n\n  while (++childIndex < node.children.length) {\n    child = node.children[childIndex];\n\n    if (child.type === 'element') {\n      children.push(toReact(context, child, childIndex, node));\n    } else if (child.type === 'text') {\n      // Currently, a warning is triggered by react for *any* white space in\n      // tables.\n      // So we drop it.\n      // See: <https://github.com/facebook/react/pull/7081>.\n      // See: <https://github.com/facebook/react/pull/7515>.\n      // See: <https://github.com/remarkjs/remark-react/issues/64>.\n      // See: <https://github.com/remarkjs/react-markdown/issues/576>.\n      if (node.type !== 'element' || !tableElements.has(node.tagName) || !whitespace(child)) {\n        children.push(child.value);\n      }\n    } else if (child.type === 'raw' && !context.options.skipHtml) {\n      // Default behavior is to show (encoded) HTML.\n      children.push(child.value);\n    }\n  }\n\n  return children;\n}\n/**\n * @param {Context} context\n * @param {Element} node\n * @param {number} index\n * @param {Element|Root} parent\n */\n\nfunction toReact(context, node, index, parent) {\n  const options = context.options;\n  const parentSchema = context.schema;\n  /** @type {ReactMarkdownNames} */\n  // @ts-expect-error assume a known HTML/SVG element.\n\n  const name = node.tagName;\n  /** @type {Record<string, unknown>} */\n\n  const properties = {};\n  let schema = parentSchema;\n  /** @type {string} */\n\n  let property;\n\n  if (parentSchema.space === 'html' && name === 'svg') {\n    schema = svg;\n    context.schema = schema;\n  }\n\n  if (node.properties) {\n    for (property in node.properties) {\n      if (own.call(node.properties, property)) {\n        addProperty(properties, property, node.properties[property], context);\n      }\n    }\n  }\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth++;\n  }\n\n  const children = childrenToReact(context, node);\n\n  if (name === 'ol' || name === 'ul') {\n    context.listDepth--;\n  } // Restore parent schema.\n\n\n  context.schema = parentSchema; // Nodes created by plugins do not have positional info, in which case we use\n  // an object that matches the position interface.\n\n  const position = node.position || {\n    start: {\n      line: null,\n      column: null,\n      offset: null\n    },\n    end: {\n      line: null,\n      column: null,\n      offset: null\n    }\n  };\n  const component = options.components && own.call(options.components, name) ? options.components[name] : name;\n  const basic = typeof component === 'string' || component === React.Fragment;\n\n  if (!ReactIs.isValidElementType(component)) {\n    throw new TypeError(\"Component for name `\".concat(name, \"` not defined or is not renderable\"));\n  }\n\n  properties.key = [name, position.start.line, position.start.column, index].join('-');\n\n  if (name === 'a' && options.linkTarget) {\n    properties.target = typeof options.linkTarget === 'function' ? options.linkTarget(String(properties.href || ''), node.children, typeof properties.title === 'string' ? properties.title : null) : options.linkTarget;\n  }\n\n  if (name === 'a' && options.transformLinkUri) {\n    properties.href = options.transformLinkUri(String(properties.href || ''), node.children, typeof properties.title === 'string' ? properties.title : null);\n  }\n\n  if (!basic && name === 'code' && parent.type === 'element' && parent.tagName !== 'pre') {\n    properties.inline = true;\n  }\n\n  if (!basic && (name === 'h1' || name === 'h2' || name === 'h3' || name === 'h4' || name === 'h5' || name === 'h6')) {\n    properties.level = Number.parseInt(name.charAt(1), 10);\n  }\n\n  if (name === 'img' && options.transformImageUri) {\n    properties.src = options.transformImageUri(String(properties.src || ''), String(properties.alt || ''), typeof properties.title === 'string' ? properties.title : null);\n  }\n\n  if (!basic && name === 'li' && parent.type === 'element') {\n    const input = getInputElement(node);\n    properties.checked = input && input.properties ? Boolean(input.properties.checked) : null;\n    properties.index = getElementsBeforeCount(parent, node);\n    properties.ordered = parent.tagName === 'ol';\n  }\n\n  if (!basic && (name === 'ol' || name === 'ul')) {\n    properties.ordered = name === 'ol';\n    properties.depth = context.listDepth;\n  }\n\n  if (name === 'td' || name === 'th') {\n    if (properties.align) {\n      if (!properties.style) properties.style = {}; // @ts-expect-error assume `style` is an object\n\n      properties.style.textAlign = properties.align;\n      delete properties.align;\n    }\n\n    if (!basic) {\n      properties.isHeader = name === 'th';\n    }\n  }\n\n  if (!basic && name === 'tr' && parent.type === 'element') {\n    properties.isHeader = Boolean(parent.tagName === 'thead');\n  } // If `sourcePos` is given, pass source information (line/column info from markdown source).\n\n\n  if (options.sourcePos) {\n    properties['data-sourcepos'] = flattenPosition(position);\n  }\n\n  if (!basic && options.rawSourcePos) {\n    properties.sourcePosition = node.position;\n  } // If `includeElementIndex` is given, pass node index info to components.\n\n\n  if (!basic && options.includeElementIndex) {\n    properties.index = getElementsBeforeCount(parent, node);\n    properties.siblingCount = getElementsBeforeCount(parent);\n  }\n\n  if (!basic) {\n    properties.node = node;\n  } // Ensure no React warnings are emitted for void elements w/ children.\n\n\n  return children.length > 0 ? React.createElement(component, properties, children) : React.createElement(component, properties);\n}\n/**\n * @param {Element|Root} node\n * @returns {Element?}\n */\n\n\nfunction getInputElement(node) {\n  let index = -1;\n\n  while (++index < node.children.length) {\n    const child = node.children[index];\n\n    if (child.type === 'element' && child.tagName === 'input') {\n      return child;\n    }\n  }\n\n  return null;\n}\n/**\n * @param {Element|Root} parent\n * @param {Element} [node]\n * @returns {number}\n */\n\n\nfunction getElementsBeforeCount(parent, node) {\n  let index = -1;\n  let count = 0;\n\n  while (++index < parent.children.length) {\n    if (parent.children[index] === node) break;\n    if (parent.children[index].type === 'element') count++;\n  }\n\n  return count;\n}\n/**\n * @param {Record<string, unknown>} props\n * @param {string} prop\n * @param {unknown} value\n * @param {Context} ctx\n */\n\n\nfunction addProperty(props, prop, value, ctx) {\n  const info = find(ctx.schema, prop);\n  let result = value; // Ignore nullish and `NaN` values.\n  // eslint-disable-next-line no-self-compare\n\n  if (result === null || result === undefined || result !== result) {\n    return;\n  } // Accept `array`.\n  // Most props are space-separated.\n\n\n  if (Array.isArray(result)) {\n    result = info.commaSeparated ? commas(result) : spaces(result);\n  }\n\n  if (info.property === 'style' && typeof result === 'string') {\n    result = parseStyle(result);\n  }\n\n  if (info.space && info.property) {\n    props[own.call(hastToReact, info.property) ? hastToReact[info.property] : info.property] = result;\n  } else if (info.attribute) {\n    props[info.attribute] = result;\n  }\n}\n/**\n * @param {string} value\n * @returns {Record<string, string>}\n */\n\n\nfunction parseStyle(value) {\n  /** @type {Record<string, string>} */\n  const result = {};\n\n  try {\n    style(value, iterator);\n  } catch {// Silent.\n  }\n\n  return result;\n  /**\n   * @param {string} name\n   * @param {string} v\n   */\n\n  function iterator(name, v) {\n    const k = name.slice(0, 4) === '-ms-' ? \"ms-\".concat(name.slice(4)) : name;\n    result[k.replace(/-([a-z])/g, styleReplacer)] = v;\n  }\n}\n/**\n * @param {unknown} _\n * @param {string} $1\n */\n\n\nfunction styleReplacer(_, $1) {\n  return $1.toUpperCase();\n}\n/**\n * @param {Position|{start: {line: null, column: null, offset: null}, end: {line: null, column: null, offset: null}}} pos\n * @returns {string}\n */\n\n\nfunction flattenPosition(pos) {\n  return [pos.start.line, ':', pos.start.column, '-', pos.end.line, ':', pos.end.column].map(d => String(d)).join('');\n}","/**\n * @param {unknown} thing\n * @returns {boolean}\n */\nexport function whitespace(thing) {\n  /** @type {string} */\n  var value = // @ts-ignore looks like a node.\n  thing && typeof thing === 'object' && thing.type === 'text' ? // @ts-ignore looks like a text.\n  thing.value || '' : thing; // HTML whitespace expression.\n  // See <https://html.spec.whatwg.org/#space-character>.\n\n  return typeof value === 'string' && value.replace(/[ \\t\\n\\f\\r]/g, '') === '';\n}","/**\n * @typedef {Object} StringifyOptions\n * @property {boolean} [padLeft=true] Whether to pad a space before a token (`boolean`, default: `true`).\n * @property {boolean} [padRight=false] Whether to pad a space after a token (`boolean`, default: `false`).\n */\n\n/**\n * Parse comma separated tokens to an array.\n *\n * @param {string} value\n * @returns {Array.<string>}\n */\nexport function parse(value) {\n  /** @type {Array.<string>} */\n  var tokens = [];\n  var input = String(value || '');\n  var index = input.indexOf(',');\n  var start = 0;\n  /** @type {boolean} */\n\n  var end;\n  /** @type {string} */\n\n  var token;\n\n  while (!end) {\n    if (index === -1) {\n      index = input.length;\n      end = true;\n    }\n\n    token = input.slice(start, index).trim();\n\n    if (token || !end) {\n      tokens.push(token);\n    }\n\n    start = index + 1;\n    index = input.indexOf(',', start);\n  }\n\n  return tokens;\n}\n/**\n * Serialize an array of strings to comma separated tokens.\n *\n * @param {Array.<string|number>} values\n * @param {StringifyOptions} [options]\n * @returns {string}\n */\n\nexport function stringify(values, options) {\n  var settings = options || {}; // Ensure the last empty entry is seen.\n\n  if (values[values.length - 1] === '') {\n    values = values.concat('');\n  }\n\n  return values.join((settings.padRight ? ' ' : '') + ',' + (settings.padLeft === false ? '' : ' ')).trim();\n}","/**\n * Parse space separated tokens to an array of strings.\n *\n * @param {string} value Space separated tokens\n * @returns {Array.<string>} Tokens\n */\nexport function parse(value) {\n  const input = String(value || '').trim();\n  return input ? input.split(/[ \\t\\n\\r\\f]+/g) : [];\n}\n/**\n * Serialize an array of strings as space separated tokens.\n *\n * @param {Array.<string|number>} values Tokens\n * @returns {string} Space separated tokens\n */\n\nexport function stringify(values) {\n  return values.join(' ').trim();\n}","/**\n * @typedef {import('react').ReactNode} ReactNode\n * @typedef {import('react').ReactElement<{}>} ReactElement\n * @typedef {import('unified').PluggableList} PluggableList\n * @typedef {import('hast').Root} Root\n * @typedef {import('./rehype-filter.js').Options} FilterOptions\n * @typedef {import('./ast-to-react.js').Options} TransformOptions\n *\n * @typedef CoreOptions\n * @property {string} children\n *\n * @typedef PluginOptions\n * @property {PluggableList} [remarkPlugins=[]]\n * @property {PluggableList} [rehypePlugins=[]]\n * @property {import('remark-rehype').Options | undefined} [remarkRehypeOptions={}]\n *\n * @typedef LayoutOptions\n * @property {string} [className]\n *\n * @typedef {CoreOptions & PluginOptions & LayoutOptions & FilterOptions & TransformOptions} ReactMarkdownOptions\n *\n * @typedef Deprecation\n * @property {string} id\n * @property {string} [to]\n */\nimport React from 'react';\nimport { VFile } from 'vfile';\nimport { unified } from 'unified';\nimport remarkParse from 'remark-parse';\nimport remarkRehype from 'remark-rehype';\nimport PropTypes from 'prop-types';\nimport { html } from 'property-information';\nimport rehypeFilter from './rehype-filter.js';\nimport { uriTransformer } from './uri-transformer.js';\nimport { childrenToReact } from './ast-to-react.js';\nconst own = {}.hasOwnProperty;\nconst changelog = 'https://github.com/remarkjs/react-markdown/blob/main/changelog.md';\n/** @type {Record<string, Deprecation>} */\n\nconst deprecated = {\n  plugins: {\n    to: 'plugins',\n    id: 'change-plugins-to-remarkplugins'\n  },\n  renderers: {\n    to: 'components',\n    id: 'change-renderers-to-components'\n  },\n  astPlugins: {\n    id: 'remove-buggy-html-in-markdown-parser'\n  },\n  allowDangerousHtml: {\n    id: 'remove-buggy-html-in-markdown-parser'\n  },\n  escapeHtml: {\n    id: 'remove-buggy-html-in-markdown-parser'\n  },\n  source: {\n    to: 'children',\n    id: 'change-source-to-children'\n  },\n  allowNode: {\n    to: 'allowElement',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  allowedTypes: {\n    to: 'allowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  disallowedTypes: {\n    to: 'disallowedElements',\n    id: 'replace-allownode-allowedtypes-and-disallowedtypes'\n  },\n  includeNodeIndex: {\n    to: 'includeElementIndex',\n    id: 'change-includenodeindex-to-includeelementindex'\n  }\n};\n/**\n * React component to render markdown.\n *\n * @param {ReactMarkdownOptions} options\n * @returns {ReactElement}\n */\n\nexport function ReactMarkdown(options) {\n  for (const key in deprecated) {\n    if (own.call(deprecated, key) && own.call(options, key)) {\n      const deprecation = deprecated[key];\n      console.warn(\"[react-markdown] Warning: please \".concat(deprecation.to ? \"use `\".concat(deprecation.to, \"` instead of\") : 'remove', \" `\").concat(key, \"` (see <\").concat(changelog, \"#\").concat(deprecation.id, \"> for more info)\"));\n      delete deprecated[key];\n    }\n  }\n\n  const processor = unified().use(remarkParse).use(options.remarkPlugins || []).use(remarkRehype, { ...options.remarkRehypeOptions,\n    allowDangerousHtml: true\n  }).use(options.rehypePlugins || []).use(rehypeFilter, options);\n  const file = new VFile();\n\n  if (typeof options.children === 'string') {\n    file.value = options.children;\n  } else if (options.children !== undefined && options.children !== null) {\n    console.warn(\"[react-markdown] Warning: please pass a string as `children` (not: `\".concat(options.children, \"`)\"));\n  }\n\n  const hastNode = processor.runSync(processor.parse(file), file);\n\n  if (hastNode.type !== 'root') {\n    throw new TypeError('Expected a `root` node');\n  }\n  /** @type {ReactElement} */\n\n\n  let result = React.createElement(React.Fragment, {}, childrenToReact({\n    options,\n    schema: html,\n    listDepth: 0\n  }, hastNode));\n\n  if (options.className) {\n    result = React.createElement('div', {\n      className: options.className\n    }, result);\n  }\n\n  return result;\n}\nReactMarkdown.defaultProps = {\n  transformLinkUri: uriTransformer\n};\nReactMarkdown.propTypes = {\n  // Core options:\n  children: PropTypes.string,\n  // Layout options:\n  className: PropTypes.string,\n  // Filter options:\n  allowElement: PropTypes.func,\n  allowedElements: PropTypes.arrayOf(PropTypes.string),\n  disallowedElements: PropTypes.arrayOf(PropTypes.string),\n  unwrapDisallowed: PropTypes.bool,\n  // Plugin options:\n  remarkPlugins: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.bool, PropTypes.string, PropTypes.object, PropTypes.func, PropTypes.arrayOf( // prettier-ignore\n  // type-coverage:ignore-next-line\n  PropTypes.any)]))])),\n  rehypePlugins: PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.object, PropTypes.func, PropTypes.arrayOf(PropTypes.oneOfType([PropTypes.bool, PropTypes.string, PropTypes.object, PropTypes.func, PropTypes.arrayOf( // prettier-ignore\n  // type-coverage:ignore-next-line\n  PropTypes.any)]))])),\n  // Transform options:\n  sourcePos: PropTypes.bool,\n  rawSourcePos: PropTypes.bool,\n  skipHtml: PropTypes.bool,\n  includeElementIndex: PropTypes.bool,\n  transformLinkUri: PropTypes.oneOfType([PropTypes.func, PropTypes.bool]),\n  linkTarget: PropTypes.oneOfType([PropTypes.func, PropTypes.string]),\n  transformImageUri: PropTypes.func,\n  components: PropTypes.object\n};","/**\n * @license React\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';\n\nvar b = Symbol.for(\"react.element\"),\n    c = Symbol.for(\"react.portal\"),\n    d = Symbol.for(\"react.fragment\"),\n    e = Symbol.for(\"react.strict_mode\"),\n    f = Symbol.for(\"react.profiler\"),\n    g = Symbol.for(\"react.provider\"),\n    h = Symbol.for(\"react.context\"),\n    k = Symbol.for(\"react.server_context\"),\n    l = Symbol.for(\"react.forward_ref\"),\n    m = Symbol.for(\"react.suspense\"),\n    n = Symbol.for(\"react.suspense_list\"),\n    p = Symbol.for(\"react.memo\"),\n    q = Symbol.for(\"react.lazy\"),\n    t = Symbol.for(\"react.offscreen\"),\n    u;\nu = Symbol.for(\"react.module.reference\");\n\nfunction v(a) {\n  if (\"object\" === typeof a && null !== a) {\n    var r = a.$$typeof;\n\n    switch (r) {\n      case b:\n        switch (a = a.type, a) {\n          case d:\n          case f:\n          case e:\n          case m:\n          case n:\n            return a;\n\n          default:\n            switch (a = a && a.$$typeof, a) {\n              case k:\n              case h:\n              case l:\n              case q:\n              case p:\n              case g:\n                return a;\n\n              default:\n                return r;\n            }\n\n        }\n\n      case c:\n        return r;\n    }\n  }\n}\n\nexports.ContextConsumer = h;\nexports.ContextProvider = g;\nexports.Element = b;\nexports.ForwardRef = l;\nexports.Fragment = d;\nexports.Lazy = q;\nexports.Memo = p;\nexports.Portal = c;\nexports.Profiler = f;\nexports.StrictMode = e;\nexports.Suspense = m;\nexports.SuspenseList = n;\n\nexports.isAsyncMode = function () {\n  return !1;\n};\n\nexports.isConcurrentMode = function () {\n  return !1;\n};\n\nexports.isContextConsumer = function (a) {\n  return v(a) === h;\n};\n\nexports.isContextProvider = function (a) {\n  return v(a) === g;\n};\n\nexports.isElement = function (a) {\n  return \"object\" === typeof a && null !== a && a.$$typeof === b;\n};\n\nexports.isForwardRef = function (a) {\n  return v(a) === l;\n};\n\nexports.isFragment = function (a) {\n  return v(a) === d;\n};\n\nexports.isLazy = function (a) {\n  return v(a) === q;\n};\n\nexports.isMemo = function (a) {\n  return v(a) === p;\n};\n\nexports.isPortal = function (a) {\n  return v(a) === c;\n};\n\nexports.isProfiler = function (a) {\n  return v(a) === f;\n};\n\nexports.isStrictMode = function (a) {\n  return v(a) === e;\n};\n\nexports.isSuspense = function (a) {\n  return v(a) === m;\n};\n\nexports.isSuspenseList = function (a) {\n  return v(a) === n;\n};\n\nexports.isValidElementType = function (a) {\n  return \"string\" === typeof a || \"function\" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || \"object\" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? !0 : !1;\n};\n\nexports.typeOf = v;","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}","var parse = require('inline-style-parser');\n/**\n * Parses inline style to object.\n *\n * @example\n * // returns { 'line-height': '42' }\n * StyleToObject('line-height: 42;');\n *\n * @param  {String}      style      - The inline style.\n * @param  {Function}    [iterator] - The iterator function.\n * @return {null|Object}\n */\n\n\nfunction StyleToObject(style, iterator) {\n  var output = null;\n\n  if (!style || typeof style !== 'string') {\n    return output;\n  }\n\n  var declaration;\n  var declarations = parse(style);\n  var hasIterator = typeof iterator === 'function';\n  var property;\n  var value;\n\n  for (var i = 0, len = declarations.length; i < len; i++) {\n    declaration = declarations[i];\n    property = declaration.property;\n    value = declaration.value;\n\n    if (hasIterator) {\n      iterator(property, value, declaration);\n    } else if (value) {\n      output || (output = {});\n      output[property] = value;\n    }\n  }\n\n  return output;\n}\n\nmodule.exports = StyleToObject;"],"names":["hasOwn","Object","prototype","hasOwnProperty","toStr","toString","defineProperty","gOPD","getOwnPropertyDescriptor","isArray","arr","Array","call","isPlainObject","obj","key","hasOwnConstructor","hasIsPrototypeOf","constructor","setProperty","target","options","name","enumerable","configurable","value","newValue","writable","getProperty","module","exports","extend","src","copy","copyIsArray","clone","arguments","i","length","deep","COMMENT_REGEX","NEWLINE_REGEX","WHITESPACE_REGEX","PROPERTY_REGEX","COLON_REGEX","VALUE_REGEX","SEMICOLON_REGEX","TRIM_REGEX","EMPTY_STRING","trim","str","replace","style","TypeError","lineno","column","updatePosition","lines","match","lastIndexOf","position","start","line","node","Position","whitespace","this","end","source","content","errorsList","error","msg","err","Error","reason","filename","silent","push","re","m","exec","slice","comments","rules","c","comment","pos","charAt","type","declaration","prop","val","ret","property","decl","decls","declarations","isBuffer","encodeCache","encode","string","exclude","keepEscaped","l","code","nextCode","cache","result","defaultChars","ch","String","fromCharCode","test","toUpperCase","charCodeAt","getEncodeCache","encodeURIComponent","componentChars","stringifyPosition","point","index","VFileMessage","place","origin","parts","super","undefined","indexOf","message","stack","fatal","ruleId","actual","expected","file","url","note","path","basename","ext","assertPath","seenNonSlash","firstNonSlashEnd","extIndex","dirname","unmatchedSlash","extname","startPart","startDot","preDotState","join","joined","_len","segments","_key","normalize","sep","absolute","allowAboveRoot","lastSlashIndex","lastSegmentLength","lastSlash","dots","normalizeString","JSON","stringify","proc","cwd","isUrl","fileURLOrPath","href","urlToPath","URL","protocol","hostname","pathname","third","decodeURIComponent","getPathFromURLPosix","order","VFile","data","messages","history","stored","map","includes","assertNonEmpty","assertPart","stem","encoding","info","fail","part","bail","getPrototypeOf","Symbol","toStringTag","iterator","wrap","middleware","callback","called","_len3","parameters","_key3","fnExpectsCallback","done","apply","exception","Promise","then","_len4","output","_key4","unified","base","transformers","fns","pipeline","run","values","middlewareIndex","pop","next","fn","_len2","_key2","use","middelware","trough","attachers","frozen","namespace","freezeIndex","processor","assertUnfrozen","own","Parser","Compiler","freeze","attacher","transformer","Number","POSITIVE_INFINITY","settings","addPlugin","addList","addPreset","assign","add","plugin","plugins","entry","parse","doc","vfile","assertParser","newable","assertCompiler","assertNode","compile","executor","resolve","reject","tree","runSync","complete","assertDone","process","processSync","destination","keys","asyncName","Boolean","looksLikeAVFile","includeImageAlt","one","alt","children","splice","list","remove","items","chunkStart","from","unshift","combineExtensions","extensions","all","syntaxExtension","extension","hook","left","right","constructs","existing","before","asciiAlpha","regexCheck","asciiDigit","asciiHexDigit","asciiAlphanumeric","asciiPunctuation","asciiAtext","asciiControl","markdownLineEndingOrSpace","markdownLineEnding","markdownSpace","unicodeWhitespace","unicodePunctuation","regex","factorySpace","effects","ok","max","limit","size","enter","prefix","consume","exit","tokenize","contentStart","attempt","parser","contentInitial","lineStart","previous","token","contentType","self","childFlow","childToken","lineStartOffset","continued","item","containerState","continuation","documentContinue","checkNewContainers","_closeFlow","closeFlow","indexBeforeExits","events","indexBeforeFlow","exitContainers","documentContinued","currentConstruct","concrete","flowStart","interrupt","_gfmTableDynamicInterruptHack","check","containerConstruct","thereIsANewContainer","thereIsNoNewContainer","lazy","now","offset","containerContinue","flow","_tokenizer","flowContinue","writeToChild","eof","stream","sliceStream","defineSkip","write","seen","nok","document","disable","null","blankLine","partial","subtokenize","jumps","event","lineIndex","otherIndex","otherEvent","subevents","more","_isInFirstContentOfListItem","subcontent","_container","eventIndex","context","startPosition","startPositions","tokenizer","childEvents","gaps","current","adjust","breaks","_gfmTasklistFirstContentOfListItem","contentEnd","continuationConstruct","contentContinue","prefixed","tail","sliceSerialize","initial","flowInitial","afterConstruct","resolver","resolveAll","createResolver","initializeFactory","field","text","notText","atBreak","resolveAllLineSuffixes","extraResolver","chunks","tabs","bufferIndex","chunk","_index","_bufferIndex","createTokenizer","initialize","columnStart","resolveAllConstructs","consumed","accountForPotentialSkip","fields","constructFactory","construct","addResult","onsuccessfulcheck","expandTabs","atTab","serializeChunks","main","expectedCode","state","startIndex","startBufferIndex","endIndex","endBufferIndex","view","sliceChunks","chunkIndex","go","_","restore","onreturn","returnState","bogusState","listOfConstructs","constructIndex","handleListOfConstructs","def","handleMapOfConstructs","handleConstruct","startPoint","startPrevious","startCurrentConstruct","startEventsIndex","startStack","store","create","resolveTo","thematicBreak","marker","sequence","initialSize","kind","atMarker","inside","onBlank","listItemPrefixWhitespaceConstruct","endOfPrefix","otherPrefix","initialBlankLine","notBlank","furtherBlankLines","notInCurrentItem","indentConstruct","blockQuote","open","after","factoryDestination","literalType","literalMarkerType","rawType","stringType","balance","destinationEnclosedBefore","destinationRaw","destinationEnclosed","destinationEnclosedEscape","destinationRawEscape","factoryLabel","markerType","label","labelEscape","factoryTitle","atFirstTitleBreak","atTitleBreak","title","titleEscape","factoryWhitespace","normalizeIdentifier","toLowerCase","definition","identifier","labelAfter","titleConstruct","defined","codeIndented","afterStartPrefix","afterPrefix","indentedContent","headingAtx","fenceOpenInside","headingBreak","setextUnderline","paragraph","closingSequence","closingSequenceEnd","heading","htmlBlockNames","htmlRawNames","htmlFlow","startTag","buffer","declarationStart","tagCloseStart","continuationDeclarationInside","tagName","commentOpenInside","cdataOpenInside","basicSelfClosing","completeAttributeNameBefore","completeClosingTagAfter","completeEnd","completeAttributeName","completeAttributeNameAfter","completeAttributeValueBefore","completeAttributeValueQuoted","completeAttributeValueUnquoted","completeAttributeValueQuotedAfter","completeAfter","continuationCommentInside","continuationRawTagOpen","continuationClose","continuationCharacterDataInside","continuationAtLineEnding","nextBlankConstruct","htmlContinueStart","htmlLineEnd","continuationRawEndTag","codeFenced","closingFenceConstruct","closingSequenceStart","sizeOpen","nonLazyLine","initialPrefix","sequenceOpen","infoOpen","openAfter","infoAfter","meta","createElement","decodeNamedCharacterReference","characterReference","innerHTML","char","textContent","numeric","characterEscape","lineEnding","labelEnd","labelStart","_balanced","_inactive","balanced","afterLabelEnd","resourceConstruct","fullReferenceConstruct","collapsedReferenceConstruct","close","media","group","insideSpan","destinationAfter","between","afterLabel","labelStartImage","classifyCharacter","attention","attentionMarkers","_open","_close","openingSequence","nextEvents","movePoint","autolink","schemeOrEmailAtext","emailAtext","schemeInsideOrEmailAtext","urlInside","emailAtSignOrDot","emailLabel","emailValue","htmlText","declarationOpen","instruction","tagOpen","commentOpen","cdataOpen","commentStart","commentStartDash","commentClose","atLineEnding","cdata","cdataClose","cdataEnd","instructionClose","tagClose","tagCloseBetween","tagOpenBetween","tagOpenAttributeName","tagOpenAttributeNameAfter","tagOpenAttributeValueBefore","tagOpenAttributeValueQuoted","tagOpenAttributeValueUnquoted","tagOpenAttributeValueQuotedAfter","labelStartLink","hardBreakEscape","codeText","gap","tailExitIndex","headEnterIndex","search","decodeNumericCharacterReference","parseInt","characterEscapeOrReference","decodeString","decode","$0","$1","$2","head","hex","fromMarkdown","config","configure","transforms","canContainEols","opener","link","autolinkProtocol","onenterdata","autolinkEmail","atxHeading","codeFlow","codeFencedFenceInfo","codeFencedFenceMeta","codeTextData","codeFlowValue","definitionDestinationString","definitionLabelString","definitionTitleString","emphasis","hardBreak","hardBreakTrailing","html","htmlFlowData","htmlTextData","image","listItem","listItemValue","onenterlistitemvalue","listOrdered","onenterlistordered","listUnordered","reference","onenterreference","referenceString","resourceDestinationString","resourceTitleString","setextHeading","strong","closer","atxHeadingSequence","onexitatxheadingsequence","onexitautolinkemail","onexitautolinkprotocol","characterEscapeValue","onexitdata","characterReferenceMarkerHexadecimal","onexitcharacterreferencemarker","characterReferenceMarkerNumeric","characterReferenceValue","onexitcharacterreferencevalue","onexitcodefenced","codeFencedFence","onexitcodefencedfence","onexitcodefencedfenceinfo","onexitcodefencedfencemeta","onexitcodeindented","onexitcodetext","onexitdefinitiondestinationstring","onexitdefinitionlabelstring","onexitdefinitiontitlestring","onexithardbreak","onexithtmlflow","onexithtmltext","onexitimage","onexitlabel","labelText","onexitlabeltext","onexitlineending","onexitlink","onexitreferencestring","onexitresourcedestinationstring","onexitresourcetitlestring","resource","onexitresource","onexitsetextheading","setextHeadingLineSequence","onexitsetextheadinglinesequence","setextHeadingText","onexitsetextheadingtext","mdastExtensions","tokenStack","listStack","resume","setData","getData","prepareList","handler","defaultOnError","firstBlankLineIndex","containerBalance","listSpread","tailIndex","tailEvent","_spread","d","and","errorHandler","onExitError","lang","depth","parent","referenceType","ancestor","fragment","ordered","spread","checked","compiler","postprocess","concat","atCarriageReturn","endPosition","lastIndex","Math","ceil","preprocess","combined","u","props","convert","castFactory","typeFactory","tests","checks","any","anyFactory","propsFactory","visitParents","visitor","reverse","is","step","factory","parents","visit","subresult","grandparents","toResult","pointStart","pointEnd","clean","unknown","h","augment","handlers","passThrough","returnNode","unknownHandler","nodes","characterReferences","sanitizeUri","skip","normalizeUri","colon","questionMark","numberSign","slash","loose","footnoteReference","id","safeId","footnoteOrder","counter","footnoteCounts","reuseCounter","clobberPrefix","dataFootnoteRef","ariaDescribedBy","revert","subtype","suffix","contents","listItemLoose","trimLine","codePointAt","blockquote","break","className","delete","footnote","footnoteById","no","dangerous","imageReference","inlineCode","linkReference","listLoose","wrapped","disabled","child","properties","root","table","rows","align","row","out","cellIndex","cell","last","trimLines","toml","ignore","yaml","footnoteDefinition","allowDangerousHtml","footnoteLabel","footnoteLabelTagName","footnoteLabelProperties","footnoteBackLabel","definitions","hName","hProperties","hChildren","ctx","toHast","foot","listItems","referenceIndex","backReferences","backReference","dataFootnoteBackref","ariaLabel","tailTail","dataFootnotes","footer","bridge","mutate","Schema","normal","space","merge","Info","attribute","boolean","booleanish","overloadedBoolean","number","commaSeparated","spaceSeparated","commaOrSpaceSeparated","mustUseProperty","powers","increment","DefinedInfo","mask","mark","transform","attributes","xlink","xLinkActuate","xLinkArcRole","xLinkHref","xLinkRole","xLinkShow","xLinkTitle","xLinkType","xml","xmlLang","xmlBase","xmlSpace","caseSensitiveTransform","caseInsensitiveTransform","xmlns","xmlnsxlink","xmlnsXLink","aria","ariaActiveDescendant","ariaAtomic","ariaAutoComplete","ariaBusy","ariaChecked","ariaColCount","ariaColIndex","ariaColSpan","ariaControls","ariaCurrent","ariaDetails","ariaDisabled","ariaDropEffect","ariaErrorMessage","ariaExpanded","ariaFlowTo","ariaGrabbed","ariaHasPopup","ariaHidden","ariaInvalid","ariaKeyShortcuts","ariaLabelledBy","ariaLevel","ariaLive","ariaModal","ariaMultiLine","ariaMultiSelectable","ariaOrientation","ariaOwns","ariaPlaceholder","ariaPosInSet","ariaPressed","ariaReadOnly","ariaRelevant","ariaRequired","ariaRoleDescription","ariaRowCount","ariaRowIndex","ariaRowSpan","ariaSelected","ariaSetSize","ariaSort","ariaValueMax","ariaValueMin","ariaValueNow","ariaValueText","role","acceptcharset","classname","htmlfor","httpequiv","abbr","accept","acceptCharset","accessKey","action","allow","allowFullScreen","allowPaymentRequest","allowUserMedia","as","async","autoCapitalize","autoComplete","autoFocus","autoPlay","capture","charSet","cite","cols","colSpan","contentEditable","controls","controlsList","coords","crossOrigin","dateTime","decoding","default","defer","dir","dirName","download","draggable","encType","enterKeyHint","form","formAction","formEncType","formMethod","formNoValidate","formTarget","headers","height","hidden","high","hrefLang","htmlFor","httpEquiv","imageSizes","imageSrcSet","inputMode","integrity","isMap","itemId","itemProp","itemRef","itemScope","itemType","language","loading","loop","low","manifest","maxLength","method","min","minLength","multiple","muted","nonce","noModule","noValidate","onAbort","onAfterPrint","onAuxClick","onBeforePrint","onBeforeUnload","onBlur","onCancel","onCanPlay","onCanPlayThrough","onChange","onClick","onClose","onContextLost","onContextMenu","onContextRestored","onCopy","onCueChange","onCut","onDblClick","onDrag","onDragEnd","onDragEnter","onDragExit","onDragLeave","onDragOver","onDragStart","onDrop","onDurationChange","onEmptied","onEnded","onError","onFocus","onFormData","onHashChange","onInput","onInvalid","onKeyDown","onKeyPress","onKeyUp","onLanguageChange","onLoad","onLoadedData","onLoadedMetadata","onLoadEnd","onLoadStart","onMessage","onMessageError","onMouseDown","onMouseEnter","onMouseLeave","onMouseMove","onMouseOut","onMouseOver","onMouseUp","onOffline","onOnline","onPageHide","onPageShow","onPaste","onPause","onPlay","onPlaying","onPopState","onProgress","onRateChange","onRejectionHandled","onReset","onResize","onScroll","onSecurityPolicyViolation","onSeeked","onSeeking","onSelect","onSlotChange","onStalled","onStorage","onSubmit","onSuspend","onTimeUpdate","onToggle","onUnhandledRejection","onUnload","onVolumeChange","onWaiting","onWheel","optimum","pattern","ping","placeholder","playsInline","poster","preload","readOnly","referrerPolicy","rel","required","reversed","rowSpan","sandbox","scope","scoped","seamless","selected","shape","sizes","slot","span","spellCheck","srcDoc","srcLang","srcSet","tabIndex","translate","typeMustMatch","useMap","width","aLink","archive","axis","background","bgColor","border","borderColor","bottomMargin","cellPadding","cellSpacing","charOff","classId","clear","codeBase","codeType","color","compact","declare","face","frame","frameBorder","hSpace","leftMargin","longDesc","lowSrc","marginHeight","marginWidth","noResize","noHref","noShade","noWrap","object","profile","prompt","rev","rightMargin","scheme","scrolling","standby","summary","topMargin","valueType","version","vAlign","vLink","vSpace","allowTransparency","autoCorrect","autoSave","disablePictureInPicture","disableRemotePlayback","results","security","unselectable","svg","accentHeight","alignmentBaseline","arabicForm","baselineShift","capHeight","clipPath","clipRule","colorInterpolation","colorInterpolationFilters","colorProfile","colorRendering","dataType","dominantBaseline","enableBackground","fillOpacity","fillRule","floodColor","floodOpacity","fontFamily","fontSize","fontSizeAdjust","fontStretch","fontStyle","fontVariant","fontWeight","glyphName","glyphOrientationHorizontal","glyphOrientationVertical","horizAdvX","horizOriginX","horizOriginY","imageRendering","letterSpacing","lightingColor","markerEnd","markerMid","markerStart","navDown","navDownLeft","navDownRight","navLeft","navNext","navPrev","navRight","navUp","navUpLeft","navUpRight","onActivate","onBegin","onEnd","onFocusIn","onFocusOut","onMouseWheel","onRepeat","onShow","onZoom","overlinePosition","overlineThickness","paintOrder","panose1","pointerEvents","renderingIntent","shapeRendering","stopColor","stopOpacity","strikethroughPosition","strikethroughThickness","strokeDashArray","strokeDashOffset","strokeLineCap","strokeLineJoin","strokeMiterLimit","strokeOpacity","strokeWidth","textAnchor","textDecoration","textRendering","typeOf","underlinePosition","underlineThickness","unicodeBidi","unicodeRange","unitsPerEm","vAlphabetic","vHanging","vIdeographic","vMathematical","vectorEffect","vertAdvY","vertOriginX","vertOriginY","wordSpacing","writingMode","xHeight","playbackOrder","timelineBegin","about","accumulate","additive","alphabetic","amplitude","ascent","attributeName","attributeType","azimuth","bandwidth","baseFrequency","baseProfile","bbox","begin","bias","by","calcMode","clip","clipPathUnits","contentScriptType","contentStyleType","cursor","cx","cy","defaultAction","descent","diffuseConstant","direction","display","dur","divisor","dx","dy","edgeMode","editable","elevation","exponent","externalResourcesRequired","fill","filter","filterRes","filterUnits","focusable","focusHighlight","format","fr","fx","fy","g1","g2","glyphRef","gradientTransform","gradientUnits","hanging","hatchContentUnits","hatchUnits","ideographic","initialVisibility","in","in2","intercept","k","k1","k2","k3","k4","kernelMatrix","kernelUnitLength","keyPoints","keySplines","keyTimes","kerning","lengthAdjust","limitingConeAngle","local","markerHeight","markerUnits","markerWidth","maskContentUnits","maskUnits","mathematical","mediaCharacterEncoding","mediaContentEncodings","mediaSize","mediaTime","mode","numOctaves","observer","opacity","operator","orient","orientation","overflow","overlay","pathLength","patternContentUnits","patternTransform","patternUnits","phase","pitch","points","pointsAtX","pointsAtY","pointsAtZ","preserveAlpha","preserveAspectRatio","primitiveUnits","propagate","r","radius","refX","refY","repeatCount","repeatDur","requiredExtensions","requiredFeatures","requiredFonts","requiredFormats","restart","rotate","rx","ry","scale","seed","side","slope","snapshotTime","specularConstant","specularExponent","spreadMethod","spacing","startOffset","stdDeviation","stemh","stemv","stitchTiles","stroke","surfaceScale","syncBehavior","syncBehaviorDefault","syncMaster","syncTolerance","syncToleranceDefault","systemLanguage","tableValues","targetX","targetY","textLength","transformBehavior","to","u1","u2","unicode","viewBox","viewTarget","visibility","widths","x","x1","x2","xChannelSelector","y","y1","y2","yChannelSelector","z","zoomAndPan","rehypeFilter","allowedElements","disallowedElements","allowElement","parent_","unwrapDisallowed","protocols","valid","dash","cap","kebab","camelcase","hastToReact","tableElements","Set","childrenToReact","childIndex","toReact","has","thing","skipHtml","parentSchema","schema","addProperty","listDepth","component","components","basic","linkTarget","transformLinkUri","inline","level","transformImageUri","input","getInputElement","getElementsBeforeCount","textAlign","isHeader","sourcePos","rawSourcePos","sourcePosition","includeElementIndex","siblingCount","count","Type","rest","dashes","find","padRight","padLeft","v","styleReplacer","parseStyle","deprecated","renderers","astPlugins","escapeHtml","allowNode","allowedTypes","disallowedTypes","includeNodeIndex","ReactMarkdown","deprecation","console","warn","remarkPlugins","remarkRehypeOptions","rehypePlugins","hastNode","defaultProps","uri","first","propTypes","b","for","e","f","g","n","p","q","t","a","$$typeof","ContextConsumer","ContextProvider","Element","ForwardRef","Fragment","Lazy","Memo","Portal","Profiler","StrictMode","Suspense","SuspenseList","isAsyncMode","isConcurrentMode","isContextConsumer","isContextProvider","isElement","isForwardRef","isFragment","isLazy","isMemo","isPortal","isProfiler","isStrictMode","isSuspense","isSuspenseList","isValidElementType","getModuleId","hasIterator","len"],"sourceRoot":""}