@nicolastoulemont/std 0.7.2 → 0.8.0

package/dist/index-B_wWGszy.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-B_wWGszy.d.mts","names":[],"sources":["../src/shared/lambda.types.ts","../src/shared/apply-fn.types.ts","../src/functions/flow.types.ts","../src/functions/flow.ts","../src/functions/pipe.types.ts","../src/functions/pipe.ts"],"sourcesContent":[],"mappings":";KACY,kDAAkD,OAAO;;;ACMzD,KAAA,OAAO,CAAA,UAAW,CAAX,EAAA,GAAA,CAAA,GAAqB,CAArB,UAAA,CAAA,GAAA,EAAqC,GAArC,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAEf,CAFe,UAAA,CAAA,GAAA,EAAA,GAAA,EAAA,GAAA,KAAA,EAAA,IAAA,CAAA,GAAA,KAAA;;;;;;AAAnB;AAA8B,KCKlB,QDLkB,CAAA,YCKG,CDLH,EAAA,CAAA,GCKU,GDLV,SAAA,CAAA,KAAA,eCK2C,CDL3C,EAAA,GAAA,GAAA,EAAA,CAAA,GAAA,CAAA,GAAA,IAAA,ECMhB,UDNgB,CCML,KDNK,CAAA,EAAA,GCMM,UDNN,CCMiB,GDNjB,ECMsB,UDNtB,CCMiC,KDNjC,CAAA,CAAA,GAAA,KAAA;;;;;KCczB,uBAAuB,cAAc,uCAAuC,yBAAyB,OACtG,cAAc,yBACZ,QAAQ,iBAAiB,WAAW,OAAO,YAC3C,YAAY,WAAW,OAAO,QAAQ,QAAQ,UAChD,cAAc,yBACZ,QAAQ,WACR;;;AAfN;KAqBK,eArB4B,CAAA,YAqBA,CArBA,EAAA,EAAA,KAAA,CAAA,GAqBc,GArBd,SAAA,CAAA,KAAA,eAqB+C,CArB/C,EAAA,GAAA,KAAA,cAqBwE,CArBxE,EAAA,CAAA,GAAA,IAAA,SAAA,EAAA,GAuB3B,OAvB2B,CAuBnB,KAvBmB,EAuBZ,KAvBY,CAAA,SAuBG,OAvBH,CAAA,KAAA,QAAA,CAAA,GAAA,OAAA,GAyBzB,OAzByB,CAyBjB,KAzBiB,EAyBV,KAzBU,CAAA,GA0B3B,OA1B2B,CA0BnB,KA1BmB,EA0BZ,KA1BY,CAAA,SA0BG,OA1BH,CAAA,KAAA,QAAA,CAAA,GA2BzB,eA3ByB,CA2BT,IA3BS,EA2BH,OA3BG,CAAA,GA4BzB,eA5ByB,CA4BT,IA5BS,EA4BH,OA5BG,CA4BK,KA5BL,EA4BY,KA5BZ,CAAA,CAAA,GA6B7B,KA7B6B;;;AFXjC;;;;ACMA;;;;;;;;;ACKA;;;;;;;;;;;AAES;;;;;;;AASsB,iBCuCf,IDvCe,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECuC4B,CDvC5B,EAAA,GCuCkC,CDvClC,CAAA,ECuCsC,QDvCtC,CAAA,CAAA,OCuCuD,EDvCvD,CAAA,CAAA;AAAW,iBCyC1B,IDzC0B,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EC0C1B,CD1C0B,EAAA,GC0CpB,CD1CoB,EAAA,EAAA,EAAA,CAAA,GAAA,EC2C9B,OD3C8B,CC2CtB,CD3CsB,CAAA,EAAA,GC2Cf,CD3Ce,CAAA,EC4CvC,QD5CuC,CAAA,CAAA,OC4CtB,ED5CsB,EAAA,OC4CX,ED5CW,CAAA,CAAA;AAAO,iBC8CjC,ID9CiC,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EC+CjC,CD/CiC,EAAA,GC+C3B,CD/C2B,EAAA,EAAA,EAAA,CAAA,GAAA,ECgDrC,ODhDqC,CCgD7B,CDhD6B,CAAA,EAAA,GCgDtB,CDhDsB,EAAA,EAAA,EAAA,CAAA,GAAA,ECiDrC,ODjDqC,CCiD7B,CDjD6B,CAAA,EAAA,GCiDtB,CDjDsB,CAAA,ECkD9C,QDlD8C,CAAA,CAAA,OCkD7B,EDlD6B,EAAA,OCkDlB,EDlDkB,EAAA,OCkDP,EDlDO,CAAA,CAAA;AAAnC,iBCoDE,IDpDF,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECqDE,CDrDF,EAAA,GCqDQ,CDrDR,EAAA,EAAA,EAAA,CAAA,GAAA,ECsDF,ODtDE,CCsDM,CDtDN,CAAA,EAAA,GCsDa,CDtDb,EAAA,EAAA,EAAA,CAAA,GAAA,ECuDF,ODvDE,CCuDM,CDvDN,CAAA,EAAA,GCuDa,CDvDb,EAAA,EAAA,EAAA,CAAA,GAAA,ECwDF,ODxDE,CCwDM,CDxDN,CAAA,EAAA,GCwDa,CDxDb,CAAA,ECyDX,QDzDW,CAAA,CAAA,OCyDM,EDzDN,EAAA,OCyDiB,EDzDjB,EAAA,OCyD4B,EDzD5B,EAAA,OCyDuC,EDzDvC,CAAA,CAAA;AAAR,iBC2DU,ID3DV,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EC4DU,CD5DV,EAAA,GC4DgB,CD5DhB,EAAA,EAAA,EAAA,CAAA,GAAA,EC6DM,OD7DN,CC6Dc,CD7Dd,CAAA,EAAA,GC6DqB,CD7DrB,EAAA,EAAA,EAAA,CAAA,GAAA,EC8DM,OD9DN,CC8Dc,CD9Dd,CAAA,EAAA,GC8DqB,CD9DrB,EAAA,EAAA,EAAA,CAAA,GAAA,EC+DM,OD/DN,CC+Dc,CD/Dd,CAAA,EAAA,GC+DqB,CD/DrB,EAAA,EAAA,EAAA,CAAA,GAAA,ECgEM,ODhEN,CCgEc,CDhEd,CAAA,EAAA,GCgEqB,CDhErB,CAAA,ECiEH,QDjEG,CAAA,CAAA,OCiEc,EDjEd,EAAA,OCiEyB,EDjEzB,EAAA,OCiEoC,EDjEpC,EAAA,OCiE+C,EDjE/C,EAAA,OCiE0D,EDjE1D,CAAA,CAAA;AACY,iBCkEF,IDlEE,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECmEF,CDnEE,EAAA,GCmEI,CDnEJ,EAAA,EAAA,EAAA,CAAA,GAAA,ECoEN,ODpEM,CCoEE,CDpEF,CAAA,EAAA,GCoES,CDpET,EAAA,EAAA,EAAA,CAAA,GAAA,ECqEN,ODrEM,CCqEE,CDrEF,CAAA,EAAA,GCqES,CDrET,EAAA,EAAA,EAAA,CAAA,GAAA,ECsEN,ODtEM,CCsEE,CDtEF,CAAA,EAAA,GCsES,CDtET,EAAA,EAAA,EAAA,CAAA,GAAA,ECuEN,ODvEM,CCuEE,CDvEF,CAAA,EAAA,GCuES,CDvET,EAAA,EAAA,EAAA,CAAA,GAAA,ECwEN,ODxEM,CCwEE,CDxEF,CAAA,EAAA,GCwES,CDxET,CAAA,ECyEf,QDzEe,CAAA,CAAA,OCyEE,EDzEF,EAAA,OCyEa,EDzEb,EAAA,OCyEwB,EDzExB,EAAA,OCyEmC,EDzEnC,EAAA,OCyE8C,EDzE9C,EAAA,OCyEyD,EDzEzD,CAAA,CAAA;AAAW,iBC2Eb,ID3Ea,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EC4Eb,CD5Ea,EAAA,GC4EP,CD5EO,EAAA,EAAA,EAAA,CAAA,GAAA,EC6EjB,OD7EiB,CC6ET,CD7ES,CAAA,EAAA,GC6EF,CD7EE,EAAA,EAAA,EAAA,CAAA,GAAA,EC8EjB,OD9EiB,CC8ET,CD9ES,CAAA,EAAA,GC8EF,CD9EE,EAAA,EAAA,EAAA,CAAA,GAAA,EC+EjB,OD/EiB,CC+ET,CD/ES,CAAA,EAAA,GC+EF,CD/EE,EAAA,EAAA,EAAA,CAAA,GAAA,ECgFjB,ODhFiB,CCgFT,CDhFS,CAAA,EAAA,GCgFF,CDhFE,EAAA,EAAA,EAAA,CAAA,GAAA,ECiFjB,ODjFiB,CCiFT,CDjFS,CAAA,EAAA,GCiFF,CDjFE,EAAA,EAAA,EAAA,CAAA,GAAA,ECkFjB,ODlFiB,CCkFT,CDlFS,CAAA,EAAA,GCkFF,CDlFE,CAAA,ECmF1B,QDnF0B,CAAA,CAAA,OCmFT,EDnFS,EAAA,OCmFE,EDnFF,EAAA,OCmFa,EDnFb,EAAA,OCmFwB,EDnFxB,EAAA,OCmFmC,EDnFnC,EAAA,OCmF8C,EDnF9C,EAAA,OCmFyD,EDnFzD,CAAA,CAAA;AAAe,iBCqF5B,IDrF4B,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECsF5B,CDtF4B,EAAA,GCsFtB,CDtFsB,EAAA,EAAA,EAAA,CAAA,GAAA,ECuFhC,ODvFgC,CCuFxB,CDvFwB,CAAA,EAAA,GCuFjB,CDvFiB,EAAA,EAAA,EAAA,CAAA,GAAA,ECwFhC,ODxFgC,CCwFxB,CDxFwB,CAAA,EAAA,GCwFjB,CDxFiB,EAAA,EAAA,EAAA,CAAA,GAAA,ECyFhC,ODzFgC,CCyFxB,CDzFwB,CAAA,EAAA,GCyFjB,CDzFiB,EAAA,EAAA,EAAA,CAAA,GAAA,EC0FhC,OD1FgC,CC0FxB,CD1FwB,CAAA,EAAA,GC0FjB,CD1FiB,EAAA,EAAA,EAAA,CAAA,GAAA,EC2FhC,OD3FgC,CC2FxB,CD3FwB,CAAA,EAAA,GC2FjB,CD3FiB,EAAA,EAAA,EAAA,CAAA,GAAA,EC4FhC,OD5FgC,CC4FxB,CD5FwB,CAAA,EAAA,GC4FjB,CD5FiB,EAAA,EAAA,EAAA,CAAA,GAAA,EC6FhC,OD7FgC,CC6FxB,CD7FwB,CAAA,EAAA,GC6FjB,CD7FiB,CAAA,EC8FzC,QD9FyC,CAAA,CAAA,OC8FxB,ED9FwB,EAAA,OC8Fb,ED9Fa,EAAA,OC8FF,ED9FE,EAAA,OC8FS,ED9FT,EAAA,OC8FoB,ED9FpB,EAAA,OC8F+B,ED9F/B,EAAA,OC8F0C,ED9F1C,EAAA,OC8FqD,ED9FrD,CAAA,CAAA;AAAQ,iBCgGpC,IDhGoC,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,ECiGpC,CDjGoC,EAAA,GCiG9B,CDjG8B,EAAA,EAAA,EAAA,CAAA,GAAA,ECkGxC,ODlGwC,CCkGhC,CDlGgC,CAAA,EAAA,GCkGzB,CDlGyB,EAAA,EAAA,EAAA,CAAA,GAAA,ECmGxC,ODnGwC,CCmGhC,CDnGgC,CAAA,EAAA,GCmGzB,CDnGyB,EAAA,EAAA,EAAA,CAAA,GAAA,ECoGxC,ODpGwC,CCoGhC,CDpGgC,CAAA,EAAA,GCoGzB,CDpGyB,EAAA,EAAA,EAAA,CAAA,GAAA,ECqGxC,ODrGwC,CCqGhC,CDrGgC,CAAA,EAAA,GCqGzB,CDrGyB,EAAA,EAAA,EAAA,CAAA,GAAA,ECsGxC,ODtGwC,CCsGhC,CDtGgC,CAAA,EAAA,GCsGzB,CDtGyB,EAAA,EAAA,EAAA,CAAA,GAAA,ECuGxC,ODvGwC,CCuGhC,CDvGgC,CAAA,EAAA,GCuGzB,CDvGyB,EAAA,EAAA,EAAA,CAAA,GAAA,ECwGxC,ODxGwC,CCwGhC,CDxGgC,CAAA,EAAA,GCwGzB,CDxGyB,EAAA,EAAA,EAAA,CAAA,GAAA,ECyGxC,ODzGwC,CCyGhC,CDzGgC,CAAA,EAAA,GCyGzB,CDzGyB,CAAA,EC0GjD,QD1GiD,CAAA,CAAA,OC0GhC,ED1GgC,EAAA,OC0GrB,ED1GqB,EAAA,OC0GV,ED1GU,EAAA,OC0GC,ED1GD,EAAA,OC0GY,ED1GZ,EAAA,OC0GuB,ED1GvB,EAAA,OC0GkC,ED1GlC,EAAA,OC0G6C,ED1G7C,EAAA,OC0GwD,ED1GxD,CAAA,CAAA;AAAhB,iBC4GpB,ID5GoB,CAAA,UAAA,OAAA,EAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAAA,CAAA,GAAA,IAAA,EC6GpB,CD7GoB,EAAA,GC6Gd,CD7Gc,EAAA,EAAA,EAAA,CAAA,GAAA,EC8GxB,OD9GwB,CC8GhB,CD9GgB,CAAA,EAAA,GC8GT,CD9GS,EAAA,EAAA,EAAA,CAAA,GAAA,EC+GxB,OD/GwB,CC+GhB,CD/GgB,CAAA,EAAA,GC+GT,CD/GS,EAAA,EAAA,EAAA,CAAA,GAAA,ECgHxB,ODhHwB,CCgHhB,CDhHgB,CAAA,EAAA,GCgHT,CDhHS,EAAA,EAAA,EAAA,CAAA,GAAA,ECiHxB,ODjHwB,CCiHhB,CDjHgB,CAAA,EAAA,GCiHT,CDjHS,EAAA,EAAA,EAAA,CAAA,GAAA,ECkHxB,ODlHwB,CCkHhB,CDlHgB,CAAA,EAAA,GCkHT,CDlHS,EAAA,EAAA,EAAA,CAAA,GAAA,ECmHxB,ODnHwB,CCmHhB,CDnHgB,CAAA,EAAA,GCmHT,CDnHS,EAAA,EAAA,EAAA,CAAA,GAAA,ECoHxB,ODpHwB,CCoHhB,CDpHgB,CAAA,EAAA,GCoHT,CDpHS,EAAA,EAAA,EAAA,CAAA,GAAA,ECqHxB,ODrHwB,CCqHhB,CDrHgB,CAAA,EAAA,GCqHT,CDrHS,EAAA,GAAA,EAAA,CAAA,GAAA,ECsHvB,ODtHuB,CCsHf,CDtHe,CAAA,EAAA,GCs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KAAA,eGKoD,CHLpD,EAAA,GAAA,KAAA,cGK6E,CHL7E,EAAA,CAAA,GAAA,IAAA,SAAA,EAAA,GGOxB,OHPwB,CGOhB,KHPgB,EGOT,KHPS,CAAA,SGOM,OHPN,CAAA,KAAA,QAAA,CAAA,GGQtB,OHRsB,CGQd,OHRc,CAAA,GGStB,OHTsB,CGSd,KHTc,EGSP,KHTO,CAAA,GGUxB,OHVwB,CGUhB,KHVgB,EGUT,KHVS,CAAA,SGUM,OHVN,CAAA,KAAA,QAAA,CAAA,GGWtB,OHXsB,CGWd,eHXc,CGWE,IHXF,EGWQ,OHXR,CAAA,CAAA,GGYtB,UHZsB,CGYX,IHZW,EGYL,OHZK,CGYG,KHZH,EGYU,KHZV,CAAA,CAAA,GGa1B,KHb0B;;;;KGmBzB,eHjBA,CAAA,YGiB4B,CHjB5B,EAAA,EAAA,KAAA,CAAA,GGiB0C,GHjB1C,SAAA,CAAA,KAAA,eGiB2E,CHjB3E,EAAA,GAAA,KAAA,cGiBoG,CHjBpG,EAAA,CAAA,GAAA,IAAA,SAAA,EAAA,GGmBC,OHnBD,CGmBS,KHnBT,EGmBgB,KHnBhB,CAAA,SGmB+B,OHnB/B,CAAA,KAAA,QAAA,CAAA,GAAA,OAAA,GGqBG,OHrBH,CGqBW,KHrBX,EGqBkB,KHrBlB,CAAA,GGsBC,OHtBD,CGsBS,KHtBT,EGsBgB,KHtBhB,CAAA,SGsB+B,OHtB/B,CAAA,KAAA,QAAA,CAAA,GGuBG,eHvBH,CGuBmB,IHvBnB,EGuByB,OHvBzB,CAAA,GGwBG,eHxBH,CGwBmB,IHxBnB,EGwByB,OHxBzB,CGwBiC,KHxBjC,EGwBwC,KHxBxC,CAAA,CAAA,GGyBD,KHzBC;;;ADRL;;;;ACMA;;;;;;;;;ACKA;;;;;;;;;;;AAES;;;;;AAQL,iBGsCY,IHtCZ,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGsC4B,CHtC5B,EAAA,EAAA,EAAA,CAAA,GAAA,EGsCyC,CHtCzC,EAAA,GGsC+C,CHtC/C,CAAA,EGsCmD,UHtCnD,CAAA,CAAA,OGsCsE,EHtCtE,CAAA,EGsC2E,CHtC3E,CAAA;AAAc,iBGwCF,IHxCE,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGyCX,CHzCW,EAAA,EAAA,EAAA,CAAA,GAAA,EG0CN,CH1CM,EAAA,GG0CA,CH1CA,EAAA,EAAA,EAAA,CAAA,GAAA,EG2CN,OH3CM,CG2CE,CH3CF,CAAA,EAAA,GG2CS,CH3CT,CAAA,EG4Cf,UH5Ce,CAAA,CAAA,OG4CI,EH5CJ,EAAA,OG4Ce,EH5Cf,CAAA,EG4CoB,CH5CpB,CAAA;AACa,iBG6Cf,IH7Ce,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EG8CxB,CH9CwB,EAAA,EAAA,EAAA,CAAA,GAAA,EG+CnB,CH/CmB,EAAA,GG+Cb,CH/Ca,EAAA,EAAA,EAAA,CAAA,GAAA,EGgDnB,OHhDmB,CGgDX,CHhDW,CAAA,EAAA,GGgDJ,CHhDI,EAAA,EAAA,EAAA,CAAA,GAAA,EGiDnB,OHjDmB,CGiDX,CHjDW,CAAA,EAAA,GGiDJ,CHjDI,CAAA,EGkD5B,UHlD4B,CAAA,CAAA,OGkDT,EHlDS,EAAA,OGkDE,EHlDF,EAAA,OGkDa,EHlDb,CAAA,EGkDkB,CHlDlB,CAAA;AAAW,iBGoD1B,IHpD0B,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGqDnC,CHrDmC,EAAA,EAAA,EAAA,CAAA,GAAA,EGsD9B,CHtD8B,EAAA,GGsDxB,CHtDwB,EAAA,EAAA,EAAA,CAAA,GAAA,EGuD9B,OHvD8B,CGuDtB,CHvDsB,CAAA,EAAA,GGuDf,CHvDe,EAAA,EAAA,EAAA,CAAA,GAAA,EGwD9B,OHxD8B,CGwDtB,CHxDsB,CAAA,EAAA,GGwDf,CHxDe,EAAA,EAAA,EAAA,CAAA,GAAA,EGyD9B,OHzD8B,CGyDtB,CHzDsB,CAAA,EAAA,GGyDf,CHzDe,CAAA,EG0DvC,UH1DuC,CAAA,CAAA,OG0DpB,EH1DoB,EAAA,OG0DT,EH1DS,EAAA,OG0DE,EH1DF,EAAA,OG0Da,EH1Db,CAAA,EG0DkB,CH1DlB,CAAA;AAAO,iBG4DjC,IH5DiC,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EG6D1C,CH7D0C,EAAA,EAAA,EAAA,CAAA,GAAA,EG8DrC,CH9DqC,EAAA,GG8D/B,CH9D+B,EAAA,EAAA,EAAA,CAAA,GAAA,EG+DrC,OH/DqC,CG+D7B,CH/D6B,CAAA,EAAA,GG+DtB,CH/DsB,EAAA,EAAA,EAAA,CAAA,GAAA,EGgErC,OHhEqC,CGgE7B,CHhE6B,CAAA,EAAA,GGgEtB,CHhEsB,EAAA,EAAA,EAAA,CAAA,GAAA,EGiErC,OHjEqC,CGiE7B,CHjE6B,CAAA,EAAA,GGiEtB,CHjEsB,EAAA,EAAA,EAAA,CAAA,GAAA,EGkErC,OHlEqC,CGkE7B,CHlE6B,CAAA,EAAA,GGkEtB,CHlEsB,CAAA,EGmE9C,UHnE8C,CAAA,CAAA,OGmE3B,EHnE2B,EAAA,OGmEhB,EHnEgB,EAAA,OGmEL,EHnEK,EAAA,OGmEM,EHnEN,EAAA,OGmEiB,EHnEjB,CAAA,EGmEsB,CHnEtB,CAAA;AAAnC,iBGqEE,IHrEF,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGsEP,CHtEO,EAAA,EAAA,EAAA,CAAA,GAAA,EGuEF,CHvEE,EAAA,GGuEI,CHvEJ,EAAA,EAAA,EAAA,CAAA,GAAA,EGwEF,OHxEE,CGwEM,CHxEN,CAAA,EAAA,GGwEa,CHxEb,EAAA,EAAA,EAAA,CAAA,GAAA,EGyEF,OHzEE,CGyEM,CHzEN,CAAA,EAAA,GGyEa,CHzEb,EAAA,EAAA,EAAA,CAAA,GAAA,EG0EF,OH1EE,CG0EM,CH1EN,CAAA,EAAA,GG0Ea,CH1Eb,EAAA,EAAA,EAAA,CAAA,GAAA,EG2EF,OH3EE,CG2EM,CH3EN,CAAA,EAAA,GG2Ea,CH3Eb,EAAA,EAAA,EAAA,CAAA,GAAA,EG4EF,OH5EE,CG4EM,CH5EN,CAAA,EAAA,GG4Ea,CH5Eb,CAAA,EG6EX,UH7EW,CAAA,CAAA,OG6EQ,EH7ER,EAAA,OG6EmB,EH7EnB,EAAA,OG6E8B,EH7E9B,EAAA,OG6EyC,EH7EzC,EAAA,OG6EoD,EH7EpD,EAAA,OG6E+D,EH7E/D,CAAA,EG6EoE,CH7EpE,CAAA;AAAR,iBG+EU,IH/EV,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGgFC,CHhFD,EAAA,EAAA,EAAA,CAAA,GAAA,EGiFM,CHjFN,EAAA,GGiFY,CHjFZ,EAAA,EAAA,EAAA,CAAA,GAAA,EGkFM,OHlFN,CGkFc,CHlFd,CAAA,EAAA,GGkFqB,CHlFrB,EAAA,EAAA,EAAA,CAAA,GAAA,EGmFM,OHnFN,CGmFc,CHnFd,CAAA,EAAA,GGmFqB,CHnFrB,EAAA,EAAA,EAAA,CAAA,GAAA,EGoFM,OHpFN,CGoFc,CHpFd,CAAA,EAAA,GGoFqB,CHpFrB,EAAA,EAAA,EAAA,CAAA,GAAA,EGqFM,OHrFN,CGqFc,CHrFd,CAAA,EAAA,GGqFqB,CHrFrB,EAAA,EAAA,EAAA,CAAA,GAAA,EGsFM,OHtFN,CGsFc,CHtFd,CAAA,EAAA,GGsFqB,CHtFrB,EAAA,EAAA,EAAA,CAAA,GAAA,EGuFM,OHvFN,CGuFc,CHvFd,CAAA,EAAA,GGuFqB,CHvFrB,CAAA,EGwFH,UHxFG,CAAA,CAAA,OGwFgB,EHxFhB,EAAA,OGwF2B,EHxF3B,EAAA,OGwFsC,EHxFtC,EAAA,OGwFiD,EHxFjD,EAAA,OGwF4D,EHxF5D,EAAA,OGwFuE,EHxFvE,EAAA,OGwFkF,EHxFlF,CAAA,EGwFuF,CHxFvF,CAAA;AACY,iBGyFF,IHzFE,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EG0FX,CH1FW,EAAA,EAAA,EAAA,CAAA,GAAA,EG2FN,CH3FM,EAAA,GG2FA,CH3FA,EAAA,EAAA,EAAA,CAAA,GAAA,EG4FN,OH5FM,CG4FE,CH5FF,CAAA,EAAA,GG4FS,CH5FT,EAAA,EAAA,EAAA,CAAA,GAAA,EG6FN,OH7FM,CG6FE,CH7FF,CAAA,EAAA,GG6FS,CH7FT,EAAA,EAAA,EAAA,CAAA,GAAA,EG8FN,OH9FM,CG8FE,CH9FF,CAAA,EAAA,GG8FS,CH9FT,EAAA,EAAA,EAAA,CAAA,GAAA,EG+FN,OH/FM,CG+FE,CH/FF,CAAA,EAAA,GG+FS,CH/FT,EAAA,EAAA,EAAA,CAAA,GAAA,EGgGN,OHhGM,CGgGE,CHhGF,CAAA,EAAA,GGgGS,CHhGT,EAAA,EAAA,EAAA,CAAA,GAAA,EGiGN,OHjGM,CGiGE,CHjGF,CAAA,EAAA,GGiGS,CHjGT,EAAA,EAAA,EAAA,CAAA,GAAA,EGkGN,OHlGM,CGkGE,CHlGF,CAAA,EAAA,GGkGS,CHlGT,CAAA,EGmGf,UHnGe,CAAA,CAAA,OGmGI,EHnGJ,EAAA,OGmGe,EHnGf,EAAA,OGmG0B,EHnG1B,EAAA,OGmGqC,EHnGrC,EAAA,OGmGgD,EHnGhD,EAAA,OGmG2D,EHnG3D,EAAA,OGmGsE,EHnGtE,EAAA,OGmGiF,EHnGjF,CAAA,EGmGsF,CHnGtF,CAAA;AAAW,iBGqGb,IHrGa,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGsGtB,CHtGsB,EAAA,EAAA,EAAA,CAAA,GAAA,EGuGjB,CHvGiB,EAAA,GGuGX,CHvGW,EAAA,EAAA,EAAA,CAAA,GAAA,EGwGjB,OHxGiB,CGwGT,CHxGS,CAAA,EAAA,GGwGF,CHxGE,EAAA,EAAA,EAAA,CAAA,GAAA,EGyGjB,OHzGiB,CGyGT,CHzGS,CAAA,EAAA,GGyGF,CHzGE,EAAA,EAAA,EAAA,CAAA,GAAA,EG0GjB,OH1GiB,CG0GT,CH1GS,CAAA,EAAA,GG0GF,CH1GE,EAAA,EAAA,EAAA,CAAA,GAAA,EG2GjB,OH3GiB,CG2GT,CH3GS,CAAA,EAAA,GG2GF,CH3GE,EAAA,EAAA,EAAA,CAAA,GAAA,EG4GjB,OH5GiB,CG4GT,CH5GS,CAAA,EAAA,GG4GF,CH5GE,EAAA,EAAA,EAAA,CAAA,GAAA,EG6GjB,OH7GiB,CG6GT,CH7GS,CAAA,EAAA,GG6GF,CH7GE,EAAA,EAAA,EAAA,CAAA,GAAA,EG8GjB,OH9GiB,CG8GT,CH9GS,CAAA,EAAA,GG8GF,CH9GE,EAAA,EAAA,EAAA,CAAA,GAAA,EG+GjB,OH/GiB,CG+GT,CH/GS,CAAA,EAAA,GG+GF,CH/GE,CAAA,EGgH1B,UHhH0B,CAAA,CAAA,OGgHP,EHhHO,EAAA,OGgHI,EHhHJ,EAAA,OGgHe,EHhHf,EAAA,OGgH0B,EHhH1B,EAAA,OGgHqC,EHhHrC,EAAA,OGgHgD,EHhHhD,EAAA,OGgH2D,EHhH3D,EAAA,OGgHsE,EHhHtE,EAAA,OGgHiF,EHhHjF,CAAA,EGgHsF,CHhHtF,CAAA;AAAe,iBGkH5B,IHlH4B,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGmHrC,CHnHqC,EAAA,EAAA,EAAA,CAAA,GAAA,EGoHhC,CHpHgC,EAAA,GGoH1B,CHpH0B,EAAA,EAAA,EAAA,CAAA,GAAA,EGqHhC,OHrHgC,CGqHxB,CHrHwB,CAAA,EAAA,GGqHjB,CHrHiB,EAAA,EAAA,EAAA,CAAA,GAAA,EGsHhC,OHtHgC,CGsHxB,CHtHwB,CAAA,EAAA,GGsHjB,CHtHiB,EAAA,EAAA,EAAA,CAAA,GAAA,EGuHhC,OHvHgC,CGuHxB,CHvHwB,CAAA,EAAA,GGuHjB,CHvHiB,EAAA,EAAA,EAAA,CAAA,GAAA,EGwHhC,OHxHgC,CGwHxB,CHxHwB,CAAA,EAAA,GGwHjB,CHxHiB,EAAA,EAAA,EAAA,CAAA,GAAA,EGyHhC,OHzHgC,CGyHxB,CHzHwB,CAAA,EAAA,GGyHjB,CHzHiB,EAAA,EAAA,EAAA,CAAA,GAAA,EG0HhC,OH1HgC,CG0HxB,CH1HwB,CAAA,EAAA,GG0HjB,CH1HiB,EAAA,EAAA,EAAA,CAAA,GAAA,EG2HhC,OH3HgC,CG2HxB,CH3HwB,CAAA,EAAA,GG2HjB,CH3HiB,EAAA,EAAA,EAAA,CAAA,GAAA,EG4HhC,OH5HgC,CG4HxB,CH5HwB,CAAA,EAAA,GG4HjB,CH5HiB,EAAA,GAAA,EAAA,CAAA,GAAA,EG6H/B,OH7H+B,CG6HvB,CH7HuB,CAAA,EAAA,GG6HhB,CH7HgB,CAAA,EG8HzC,UH9HyC,CAAA,CAAQ,OG+H1C,EH/H0C,EAAhB,OG+Hf,EH/He,EAA9B,OG+H0B,EH/H1B,EACF,OG8HuC,EH9HvC,EAAc,OG8HoC,EH9HpC,EACJ,OG6HmD,EH7HnD,EAAR,OG6HsE,EH7HtE,EACA,OG4HiF,EH5HjF,EAAK,OG4HuF,EH5HvF,EAMN,OGsHwG,GHtHxG,CAA4B,EGuH/B,CHvH+B,CAAA;AAAc,iBG0H/B,IH1H+B,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EG2HxC,CH3HwC,EAAA,EAAA,EAAA,CAAA,GAAA,EG4HnC,CH5HmC,EAAA,GG4H7B,CH5H6B,EAAA,EAAA,EAAA,CAAA,GAAA,EG6HnC,OH7HmC,CG6H3B,CH7H2B,CAAA,EAAA,GG6HpB,CH7HoB,EAAA,EAAA,EAAA,CAAA,GAAA,EG8HnC,OH9HmC,CG8H3B,CH9H2B,CAAA,EAAA,GG8HpB,CH9HoB,EAAA,EAAA,EAAA,CAAA,GAAA,EG+HnC,OH/HmC,CG+H3B,CH/H2B,CAAA,EAAA,GG+HpB,CH/HoB,EAAA,EAAA,EAAA,CAAA,GAAA,EGgInC,OHhImC,CGgI3B,CHhI2B,CAAA,EAAA,GGgIpB,CHhIoB,EAAA,EAAA,EAAA,CAAA,GAAA,EGiInC,OHjImC,CGiI3B,CHjI2B,CAAA,EAAA,GGiIpB,CHjIoB,EAAA,EAAA,EAAA,CAAA,GAAA,EGkInC,OHlImC,CGkI3B,CHlI2B,CAAA,EAAA,GGkIpB,CHlIoB,EAAA,EAAA,EAAA,CAAA,GAAA,EGmInC,OHnImC,CGmI3B,CHnI2B,CAAA,EAAA,GGmIpB,CHnIoB,EAAA,EAAA,EAAA,CAAA,GAAA,EGoInC,OHpImC,CGoI3B,CHpI2B,CAAA,EAAA,GGoIpB,CHpIoB,EAAA,GAAA,EAAA,CAAA,GAAA,EGqIlC,OHrIkC,CGqI1B,CHrI0B,CAAA,EAAA,GGqInB,CHrImB,EAAA,GAAA,EAAA,CAAA,GAAA,EGsIlC,OHtIkC,CGsI1B,CHtI0B,CAAA,EAAA,GGsInB,CHtImB,CAAA,EGuI5C,UHvI4C,CAAA,CAAiC,OGyIrE,EHzIqE,EAAyB,OG0I9F,EH1I8F,EAE3F,OGyIH,EHzIG,EAAO,OG0IV,EH1IU,EAAf,OG2IK,EH3IL,EAA8B,OG4IzB,EH5IyB,EAEpB,OG2IL,EH3IK,EAAO,OG4IZ,EH5IY,EAAf,OG6IG,EH7IH,EACM,OG6IH,GH7IG,EAAO,OG8IV,GH9IU,CAAf,EGgJJ,CHhJI,CAAA;AAA8B,iBGmJpB,IHnJoB,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EGoJ7B,CHpJ6B,EAAA,EAAA,EAAA,CAAA,GAAA,EGqJxB,CHrJwB,EAAA,GGqJlB,CHrJkB,EAAA,EAAA,EAAA,CAAA,GAAA,EGsJxB,OHtJwB,CGsJhB,CHtJgB,CAAA,EAAA,GGsJT,CHtJS,EAAA,EAAA,EAAA,CAAA,GAAA,EGuJxB,OHvJwB,CGuJhB,CHvJgB,CAAA,EAAA,GGuJT,CHvJS,EAAA,EAAA,EAAA,CAAA,GAAA,EGwJxB,OHxJwB,CGwJhB,CHxJgB,CAAA,EAAA,GGwJT,CHxJS,EAAA,EAAA,EAAA,CAAA,GAAA,EGyJxB,OHzJwB,CGyJhB,CHzJgB,CAAA,EAAA,GGyJT,CHzJS,EAAA,EAAA,EAAA,CAAA,GAAA,EG0JxB,OH1JwB,CG0JhB,CH1JgB,CAAA,EAAA,GG0JT,CH1JS,EAAA,EAAA,EAAA,CAAA,GAAA,EG2JxB,OH3JwB,CG2JhB,CH3JgB,CAAA,EAAA,GG2JT,CH3JS,EAAA,EAAA,EAAA,CAAA,GAAA,EG4JxB,OH5JwB,CG4JhB,CH5JgB,CAAA,EAAA,GG4JT,CH5JS,EAAA,EAAA,EAAA,CAAA,GAAA,EG6JxB,OH7JwB,CG6JhB,CH7JgB,CAAA,EAAA,GG6JT,CH7JS,EAAA,GAAA,EAAA,CAAA,GAAA,EG8JvB,OH9JuB,CG8Jf,CH9Je,CAAA,EAAA,GG8JR,CH9JQ,EAAA,GAAA,EAAA,CAAA,GAAA,EG+JvB,OH/JuB,CG+Jf,CH/Je,CAAA,EAAA,GG+JR,CH/JQ,EAAA,GAAA,EAAA,CAAA,GAAA,EGgKvB,OHhKuB,CGgKf,CHhKe,CAAA,EAAA,GGgKR,CHhKQ,CAAA,EGiKjC,UHjKiC,CAAA,CACZ,OGkKb,EHlKa,EAAM,OGmKnB,EHnKmB,EAAtB,OGoKG,EHpKH,EACgB,OGoKb,EHpKa,EAAc,OGqK3B,EHrK2B,EAAO,OGsKlC,EHtKkC,EAAf,OGuKnB,EHvKmB,EAAtB,OGwKG,EHxKH,EACJ,OGwKO,EHxKP,EAAK,OGyKE,GHzKF,SG0KE,YACA,MAET;AFxJc,iBE2JA,IF3JI,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EE4Jb,CF5Ja,EAAA,EAAA,EAAA,CAAA,GAAA,EE6JR,CF7JQ,EAAA,GE6JF,CF7JE,EAAA,EAAA,EAAA,CAAA,GAAA,EE8JR,OF9JQ,CE8JA,CF9JA,CAAA,EAAA,GE8JO,CF9JP,EAAA,EAAA,EAAA,CAAA,GAAA,EE+JR,OF/JQ,CE+JA,CF/JA,CAAA,EAAA,GE+JO,CF/JP,EAAA,EAAA,EAAA,CAAA,GAAA,EEgKR,OFhKQ,CEgKA,CFhKA,CAAA,EAAA,GEgKO,CFhKP,EAAA,EAAA,EAAA,CAAA,GAAA,EEiKR,OFjKQ,CEiKA,CFjKA,CAAA,EAAA,GEiKO,CFjKP,EAAA,EAAA,EAAA,CAAA,GAAA,EEkKR,OFlKQ,CEkKA,CFlKA,CAAA,EAAA,GEkKO,CFlKP,EAAA,EAAA,EAAA,CAAA,GAAA,EEmKR,OFnKQ,CEmKA,CFnKA,CAAA,EAAA,GEmKO,CFnKP,EAAA,EAAA,EAAA,CAAA,GAAA,EEoKR,OFpKQ,CEoKA,CFpKA,CAAA,EAAA,GEoKO,CFpKP,EAAA,EAAA,EAAA,CAAA,GAAA,EEqKR,OFrKQ,CEqKA,CFrKA,CAAA,EAAA,GEqKO,CFrKP,EAAA,GAAA,EAAA,CAAA,GAAA,EEsKP,OFtKO,CEsKC,CFtKD,CAAA,EAAA,GEsKQ,CFtKR,EAAA,GAAA,EAAA,CAAA,GAAA,EEuKP,OFvKO,CEuKC,CFvKD,CAAA,EAAA,GEuKQ,CFvKR,EAAA,GAAA,EAAA,CAAA,GAAA,EEwKP,OFxKO,CEwKC,CFxKD,CAAA,EAAA,GEwKQ,CFxKR,EAAA,GAAA,EAAA,CAAA,GAAA,EEyKP,OFzKO,CEyKC,CFzKD,CAAA,EAAA,GEyKQ,CFzKR,CAAA,EE0KjB,UF1KiB,CAAA,CAAuC,OE4KhD,EF5KgD,EAAM,OE6KtD,EF7KsD,EAAqB,OE8K3E,EF9K2E,EAAjB,OE+K1D,EF/K0D,EAAQ,OEgLlE,EFhLkE,EAE7D,OE+KL,EF/KS,EACJ,OE+KL,EF/KK,EAAM,OEgLX,EFhLW,EACF,OEgLT,EFhLS,EAAR,OEiLD,GFjLC,EAAe,OEkLhB,GFlLgB,EACP,OEkLT,GFlLS,EAAW,OEmLpB,GFnLoB,CAA5B,EEqLD,CFrLC,CAAA;AAAQ,iBEwLK,IFxLL,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EEyLJ,CFzLI,EAAA,EAAA,EAAA,CAAA,GAAA,EE0LC,CF1LD,EAAA,GE0LO,CF1LP,EAAA,EAAA,EAAA,CAAA,GAAA,EE2LC,OF3LD,CE2LS,CF3LT,CAAA,EAAA,GE2LgB,CF3LhB,EAAA,EAAA,EAAA,CAAA,GAAA,EE4LC,OF5LD,CE4LS,CF5LT,CAAA,EAAA,GE4LgB,CF5LhB,EAAA,EAAA,EAAA,CAAA,GAAA,EE6LC,OF7LD,CE6LS,CF7LT,CAAA,EAAA,GE6LgB,CF7LhB,EAAA,EAAA,EAAA,CAAA,GAAA,EE8LC,OF9LD,CE8LS,CF9LT,CAAA,EAAA,GE8LgB,CF9LhB,EAAA,EAAA,EAAA,CAAA,GAAA,EE+LC,OF/LD,CE+LS,CF/LT,CAAA,EAAA,GE+LgB,CF/LhB,EAAA,EAAA,EAAA,CAAA,GAAA,EEgMC,OFhMD,CEgMS,CFhMT,CAAA,EAAA,GEgMgB,CFhMhB,EAAA,EAAA,EAAA,CAAA,GAAA,EEiMC,OFjMD,CEiMS,CFjMT,CAAA,EAAA,GEiMgB,CFjMhB,EAAA,EAAA,EAAA,CAAA,GAAA,EEkMC,OFlMD,CEkMS,CFlMT,CAAA,EAAA,GEkMgB,CFlMhB,EAAA,GAAA,EAAA,CAAA,GAAA,EEmME,OFnMF,CEmMU,CFnMV,CAAA,EAAA,GEmMiB,CFnMjB,EAAA,GAAA,EAAA,CAAA,GAAA,EEoME,OFpMF,CEoMU,CFpMV,CAAA,EAAA,GEoMiB,CFpMjB,EAAA,GAAA,EAAA,CAAA,GAAA,EEqME,OFrMF,CEqMU,CFrMV,CAAA,EAAA,GEqMiB,CFrMjB,EAAA,GAAA,EAAA,CAAA,GAAA,EEsME,OFtMF,CEsMU,CFtMV,CAAA,EAAA,GEsMiB,CFtMjB,EAAA,GAAA,EAAA,CAAA,GAAA,EEuME,OFvMF,CEuMU,CFvMV,CAAA,EAAA,GEuMiB,CFvMjB,CAAA,EEwMR,UFxMQ,CAAA,CAEK,OEwML,EFxMS,EACJ,OEwML,EFxMK,EAAM,OEyMX,EFzMW,EACF,OEyMT,EFzMS,EAAR,OE0MD,EF1MC,EAAe,OE2MhB,EF3MgB,EACP,OE2MT,EF3MS,EAAR,OE4MD,EF5MC,EAAe,OE6MhB,EF7MgB,EACP,OE6MT,GF7MS,EAAW,OE8MpB,GF9MoB,EAAW,OE+M/B,GF/M+B,EAAvC,OEgNQ,GFhNR,EAAQ,OEiNA,GFjNA,CAEX,EEiNE,CFjNc,CAAA;AACA,iBEmNA,IFnNA,CAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA,CAAA,GAAA,EEoNT,CFpNS,EAAA,EAAA,EAAA,CAAA,GAAA,EEqNJ,CFrNI,EAAA,GEqNE,CFrNF,EAAA,EAAA,EAAA,CAAA,GAAA,EEsNJ,OFtNI,CEsNI,CFtNJ,CAAA,EAAA,GEsNW,CFtNX,EAAA,EAAA,EAAA,CAAA,GAAA,EEuNJ,OFvNI,CEuNI,CFvNJ,CAAA,EAAA,GEuNW,CFvNX,EAAA,EAAA,EAAA,CAAA,GAAA,EEwNJ,OFxNI,CEwNI,CFxNJ,CAAA,EAAA,GEwNW,CFxNX,EAAA,EAAA,EAAA,CAAA,GAAA,EEyNJ,OFzNI,CEyNI,CFzNJ,CAAA,EAAA,GEyNW,CFzNX,EAAA,EAAA,EAAA,CAAA,GAAA,EE0NJ,OF1NI,CE0NI,CF1NJ,CAAA,EAAA,GE0NW,CF1NX,EAAA,EAAA,EAAA,CAAA,GAAA,EE2NJ,OF3NI,CE2NI,CF3NJ,CAAA,EAAA,GE2NW,CF3NX,EAAA,EAAA,EAAA,CAAA,GAAA,EE4NJ,OF5NI,CE4NI,CF5NJ,CAAA,EAAA,GE4NW,CF5NX,EAAA,EAAA,EAAA,CAAA,GAAA,EE6NJ,OF7NI,CE6NI,CF7NJ,CAAA,EAAA,GE6NW,CF7NX,EAAA,GAAA,EAAA,CAAA,GAAA,EE8NH,OF9NG,CE8NK,CF9NL,CAAA,EAAA,GE8NY,CF9NZ,EAAA,GAAA,EAAA,CAAA,GAAA,EE+NH,OF/NG,CE+NK,CF/NL,CAAA,EAAA,GE+NY,CF/NZ,EAAA,GAAA,EAAA,CAAA,GAAA,EEgOH,OFhOG,CEgOK,CFhOL,CAAA,EAAA,GEgOY,CFhOZ,EAAA,GAAA,EAAA,CAAA,GAAA,EEiOH,OFjOG,CEiOK,CFjOL,CAAA,EAAA,GEiOY,CFjOZ,EAAA,GAAA,EAAA,CAAA,GAAA,EEkOH,OFlOG,CEkOK,CFlOL,CAAA,EAAA,GEkOY,CFlOZ,EAAA,GAAA,EAAA,CAAA,GAAA,EEmOH,OFnOG,CEmOK,CFnOL,CAAA,EAAA,GEmOY,CFnOZ,CAAA,EEoOb,UFpOa,CAAA,CAAM,OEsOX,EFtOW,EACF,OEsOT,EFtOS,EAAR,OEuOD,EFvOC,EAAe,OEwOhB,EFxOgB,EACP,OEwOT,EFxOS,EAAR,OEyOD,EFzOC,EAAe,OE0OhB,EF1OgB,EACP,OE0OT,EF1OS,EAAR,OE2OD,EF3OC,EAAe,OE4OhB,GF5OgB,EACP,OE4OT,GF5OS,EAAW,OE6OpB,GF7OoB,EAAW,OE8O/B,GF9O+B,EAAW,OE+O1C,GF/O0C,EAAlD,OEgPQ,GFhPR,CAAQ,EEkPT,CFlPS,CAAA"}

package/dist/index-BiiE8NS7.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-BiiE8NS7.d.mts","names":[],"sources":["../src/provide/provide.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;KAoBK,iBAAiB,UAAU;;;;KAK3B,iBAAiB,UAAU;AAlBsB;AAaZ;AAKA;;;;;;KAUrC,aAMqC,CAAA,EAAA,EAAA,kBAAA,OAAA,EAAA,WAH7B,UAG6B,CAAA,OAAA,EAAA,OAAA,EAAA,OAAA,CAAA,CAAA,GAFtC,SAEsC,SAAA,IAAA,GADtC,EACsC,CAAA,MAAA,CAAA,SAAA,QAAA,GAApC,MAAoC,CAA7B,WAA6B,CAAjB,EAAiB,CAAA,EAAZ,WAAY,CAAA,EAAA,CAAA,GAAM,EAAN,CAAA,GACpC,OADoC,CAC5B,WAD4B,CAChB,EADgB,CAAA,EACX,WADW,CACC,EADD,CAAA,GACO,EADP,CAAA,GAEtC,SAFsC,SAAA,KAAA,GAGpC,OAHoC,CAG5B,WAH4B,CAGhB,EAHgB,CAAA,EAGX,WAHW,CAGC,EAHD,CAAA,GAGO,EAHP,CAAA,GAIpC,UAJoC,CAIzB,WAJyB,CAIb,EAJa,CAAA,EAIR,WAJQ,CAII,EAJJ,CAAA,GAIU,EAJV,CAAA;;;;;;;;;;;;;;;;;;;;;;;;AAoC1C;;;;;;;AAEuD,iBAFvC,KAEuC,CAAA,IAAA,EAAA,EAAA,EAAA,kBAAA,OAAA,CAAA,CAAA,KAAA,EAD9C,KAC8C,CADxC,IACwC,EADlC,EACkC,EAAA,KAAA,EADvB,SACuB,CAAA,CAAA,EAAA,CAAA,WAAxC,UAAwC,CAAA,OAAA,EAAA,OAAA,EAAX,IAAW,CAAA,CAAA,CAAA,EAAA,EAAA,EAAA,EAAA,GAAO,aAAP,CAAqB,EAArB,EAAyB,SAAzB,EAAoC,EAApC,CAAA;;;;;;AAiMvD;;;;;;;;;;;AAiGA;;;;;;;AAEqC,cAnGxB,OAmGwB,EAAA,CAAA,CAAA,CAAA,CAAA,GAAA,EAlG1B,OAkG0B,CAlGlB,CAkGkB,CAAA,EAAA,GAAA,CAAA,CAAA,EAAA,CAAA,CAAA,CAAA,EAAA,EAjGxB,UAiGwB,CAjGb,CAiGa,EAjGV,CAiGU,EAjGP,CAiGO,CAAA,EAAA,GAjGF,UAiGE,CAjGS,CAiGT,EAjGY,CAiGZ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;cAFxB,sBACE,aAAa,UAAU,oBACtB,WAAW,GAAG,GAAG,IAAI,OAAK,WAAW,GAAG,GAAG,QAAQ,GAAG"}

package/dist/index-CGiLfREk.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CGiLfREk.d.mts","names":[],"sources":["../src/data/data.types.ts","../src/data/data.array.ts","../src/data/data.struct.ts","../src/data/data.tagged.ts","../src/data/data.tagged-error.ts","../src/data/data.tuple.ts","../src/data/data.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-CUZn-ohG.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-CUZn-ohG.d.mts","names":[],"sources":["../src/order/order.types.ts","../src/order/order.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index-Cq2IFito.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-Cq2IFito.d.mts","names":[],"sources":["../src/queue/queue.ts"],"sourcesContent":[],"mappings":";;;;;;;cAsCsB,uBAAA;;;;;;;;;;;;;AAAA;AAgBT,cAAA,gBAAA,SAAyB,qBAAA,CAAA;EAA0E,KAAA,EAAA,UAAA,GAAA,SAAA;AAchH,CAAA,CAAA,CAAA;AAcA,cA5BgH,sBA4B7E,EA5B6E,kBA4BrE,CAAA,mBAAA,CAAA;AAsG3C;AAsWA;AAgBA;AAgBA;;;;;;;;;;cA1fa,iBAAA,SAA0B;;;cAA8D,4BAAA;;;;;;;;;;;;;;cAcxF,qBAAA,SAA8B;;;;;;;;;;;;;;;;;cAsG9B,iCAAgC;;;;;;;;;;;;;;;cAsWhC,iBAAkB,iBAAe;;;;;;;;;;;;;;;cAgBjC,qCAAsC,wBAAsB;;;;;;;;;;;;;;;cAgB5D,sBAAuB,iBAAe"}

package/dist/index-DEAWPlcI.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DEAWPlcI.d.mts","names":[],"sources":["../src/result/result.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;KA4DY,eAAe,SAAW,GAAG;;;;;;;;;;AAAzC;;;;;AAwBA;;AAA4C,cAA/B,EAA+B,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAAf,CAAe,EAAA,GAAX,QAAW,CAAA,CAAA,EAAA,KAAA,CAAA;;;AAkC5C;;;;;AAsCA;;;;;;;;;AAmBa,cAzDA,GA0DU,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EA1DO,CA0DP,EAAA,GA1DW,QA0DX,CAAA,KAAA,EA1D6B,CA0D7B,CAAA;;;;;;;;;AAoCvB;AAwCA;AAwCA;AAwCA;AAwCA;AA+BA;AAqCA;AAkDA;AA6Ba,cA3WA,IA8WZ,EAAA,CAAA,CAAA,EAH0B,CAAA,CAAA,CAAA,MAAA,EA3WQ,QA8WlC,CA9W6C,CA8W7C,EA9WgD,CA8WhD,CAAA,EAAA,GAAA,MAAA,IA9W+D,OA8W/D,CA9WuE,QA8WvE,CA9WkF,CA8WlF,EA9WqF,CA8WrF,CAAA,EAAA;EAgCY,IAAA,EAAA,IAIZ;AA4BD,CAAA,CAAA;AA0BC;;;;;;;;;;;;;;;;cArbY,sBAAuB,SAAW,GAAG,iBAAe,QAAQ,SAAW,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqC1E,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCR,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BR,QAAQ;;;;;;;;;;;;;;;;;;;;;cAqCR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;cA6BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCd,OAAO;;;;;;;;;;;;;;;;;;;;;;cAgCP,SAAS;cA6BhB,MAAI"}

package/dist/index-DKS1g1oC.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DKS1g1oC.d.mts","names":[],"sources":["../src/adt/adt.match.ts","../src/adt/adt.types.ts","../src/adt/adt.union.ts","../src/adt/adt.variant.ts","../src/adt/adt.ts"],"sourcesContent":[],"mappings":"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AAA,MAAA,EE1ClB,GF0CkB,EAAA,MAAA,EEzClB,MFyCkB,CAAA,EExCzB,UFwCyB,CExCd,KFwCc,EExCT,GFwCS,EExCN,MFwCM,CAAA;AAQhB,iBE7CI,SF6CK,CAAA,cAAA,MAAA,EAAA,YE7CiC,gBF6CjC,CAAA,CAAA,IAAA,EE7CyD,KF6CzD,EAAA,MAAA,EE7CsE,GF6CtE,CAAA,EE7C0E,UF6C1E,CE7CqF,KF6CrF,EE7C0F,GF6C1F,CAAA;AAAA;;;AA7DrB;;;;;;;;AAcA;AAeA;;;AAAwD,KG/B5C,QH+B4C,CAAA,CAAA,CAAA,GG/B9B,UH+B8B,CG/BjB,CH+BiB,CAAA;;AAMxD;;;;;AAAuG;AAW5E;AAe3B;;;;AACoD,KGlDxC,eHkDwC,CAAA,CAAA,CAAA,GGlDnB,iBHkDmB,CGlDC,CHkDD,CAAA;;;;;;;;;;;;;AAcxC,KGlDA,YHkDW,CAAA,CAAA,EAAA,YAAA,MAAA,CAAA,GGlDyB,cHkDzB,CGlD0C,CHkD1C,EGlD6C,GHkD7C,CAAA;;;;;;;;;;;;;;AAOU,cG1CpB,KH0CoB,EAAA,OG1Cf,OH0Ce;;;;;;;AAajC;;;;;;;AAUmB,cGlDN,OHkDM,EAAA,OGlDC,SHkDD;;;;;;;;;;;;;;;;AAkBJ,cGnDF,KHmDE,EAAA,OGnDG,OHmDH"}

package/dist/index-DXbYlSnB.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-DXbYlSnB.d.mts","names":[],"sources":["../src/brand/brand.types.ts","../src/brand/brand.ts"],"sourcesContent":[],"mappings":";;;;;;;cAIc,WAA0B,EAAA,OAAA,MAAA;AAAA;AA8BxC;;;;;AAQA,KA9BK,KA8BO,CAAA,UAAO,MAAA,CAAA,GAAA;EAAM,UA7Bb,WAAA,CA6Ba,EA7BC,CA6BD;CAAU;;;AAQnC;AAQA;;;;;;;;;;;;ACZA;;;AAA2C,KDZ/B,SCY+B,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GDZA,CCYA,GDZI,KCYJ,CDZU,CCYV,CAAA;;AAc3C;AA2BA;;;;AAA6E,KD7CjE,OC6CiE,CAAA,CAAA,CAAA,GD7CpD,CC6CoD,SD7C1C,SC6C0C,CAAA,KAAA,EAAA,EAAA,MAAA,CAAA,GAAA,CAAA,GD7CX,CC6CW;;AAwB7E;;;;;AAEC,KD/DW,SC+DX,CAAA,CAAA,CAAA,GAAA,CAAA,KAAA,ED/DkC,CC+DlC,EAAA,GAAA,OAAA;AAuBD;;;;;;AAA0F,KD9E9E,YC8E8E,CAAA,IAAA,OAAA,CAAA,GAAA;EAAO,SAAA,IAAA,EAAA,YAAA;EA2BpF,SAWZ,KAAA,EDlHiB,CCkHjB;EAXgC,SAAA,OAAA,EAAA,MAAA;CACF;AAAA;;;;;;ADhKS;AA8BxC;;;;;AAQA;;;AAAkE,KCItD,ODJsD,CAAA,CAAA,EAAA,UAAA,MAAA,CAAA,GCIvB,SDJuB,CCIX,CDJW,ECIR,CDJQ,CAAA;;AAQlE;AAQA;;;;;;;;;;KCEY,gBAAgB,aAAe;;AAd3C;;;;;AAcA;AA2BA;;;;;;AAwBA;;;;;;AAyBA;;;;AAAkG,cAjDrF,IAiDqF,EAAA,CAAA,UAjDnE,OAiDmE,CAAA,OAAA,EAAA,MAAA,CAAA,CAAA,CAAA,KAAA,EAjDlC,OAiDkC,CAjD1B,CAiD0B,CAAA,EAAA,GAjDrB,CAiDqB;;;;AA2BlG;;;;;;;;;;;;;;;;;cApDa,uBAAwB,iCAAiC,QAAQ,OAAK;;;;;;;;;;;;;;;;;;;;;;cAyBtE,qCAAsC,UAAU,gBAAc,eAAe,QAAQ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;cA2BxF,mBAAoB,qCACpB,UAAU,QAAQ,sCACI,QAAQ,4BAC/B,QAAQ,OAAO,OAAW,GAAG,WAAW,QAAQ"}

package/dist/index-UzMbg1dh.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-UzMbg1dh.d.mts","names":[],"sources":["../src/option/option.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;;;;;;;;;;cA4Da,2BAAkB;;;;;;;;AAA/B;AAcA;AAcA;AAwBA;;AAA8C,KAtClC,kBAAA,GAAqB,YAsCa,CAAA,OAtCO,oBAsCP,CAAA;;;AA8B9C;AAkCA;;;;;;;AAgBA;;AAAkC,KAxGtB,MAwGsB,CAAA,CAAA,CAAA,GAxGV,QAwGU,CAxGC,CAwGD,CAAA;;;;;AAqClC;AAwCA;AAwCA;AAwCA;AA8BA;AA8BA;AAkDA;AA6BA;AAmCA;AA2CA;;;AAAsD,cAtczC,IAscyC,EAAA,CAAA,CAAA,CAAA,CAAA,KAAA,EAtcvB,CAscuB,EAAA,GAtcnB,QAscmB,CAtcR,CAscQ,CAAA;;;AA6BtD;;;;;;;;;;;;;cArca,uBAAsB,SAAW;;;;;;;;;;;;;;;;;cAkCjC,oBAAqB,SAAW,iBAAe,QAAQ,SAAW;;;;;;;;;;;;;;;;cAgBlE,oBAAqB,SAAW,iBAAe,QAAQ,SAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqClE,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCT,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAwCL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;cA8BR,QAAQ;;;;;;;;;;;;;;;;;;;;;cA8BR,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkDL,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;cA6BV,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmCd,OAAO;;;;;;;;;;;;;;cA2CP,yBAA0B,MAAI,SAAW,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BrD,uBAAwB,MAAI,cAAc"}

package/dist/layer-BttmtDrs.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"layer-BttmtDrs.mjs","names":["Context.make","fx","layerGen","layerResult","Context.merge","Context.empty"],"sources":["../src/layer/layer.ts"],"sourcesContent":["/**\n * Layer construction and composition for service dependency graphs.\n *\n * **Mental model**\n * - A `Layer` builds one or more services, potentially requiring other services.\n * - Compose layers and provide dependencies before running `Fx`.\n *\n * **Common tasks**\n * - Build from values with `Layer.ok`.\n * - Build from effects with `Layer.fx` or `Layer.scoped`.\n * - Compose with `Layer.provide` and `Layer.merge`.\n *\n * **Gotchas**\n * - Async layers force async execution paths.\n * - Scoped layers require scope finalization.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.ok(Port, 3000)\n * // => layer that provides Port\n * ```\n *\n * @module\n */\nimport * as Context from \"../context/context\"\nimport type { Context as ContextType } from \"../context/context\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { ScopeService, ExcludeScope } from \"../scope/scope\"\nimport type { ServiceClass } from \"../service/service\"\nimport { asServiceRequest, resolveService } from \"../service/service-resolution\"\nimport type { Layer as LayerType, MergeROut, MergeError, UnprovidedDeps, AllSync } from \"./layer.types\"\n\n/* oxlint-disable no-unsafe-type-assertion -- Layer composition carries erased generic channels and phantom type slots that require assertion-based reconstruction. */\n\n/**\n * Create a layer from a synchronous value (no dependencies).\n */\nconst layerOk = <S>(service: ServiceClass<S>, impl: S): LayerType<S, never, never, true> => ({\n  _tag: \"Layer\",\n  _ROut: undefined as unknown as S,\n  _E: undefined as never,\n  _RIn: undefined as never,\n  _Sync: undefined as unknown as true,\n  build: (): SyncFx<ContextType<S>> => ({\n    _tag: \"SyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as unknown as ContextType<S>,\n      _E: () => undefined as never,\n      _R: () => undefined as never,\n    },\n    // oxlint-disable-next-line require-yield\n    *[Symbol.iterator](): Generator<never, ContextType<S>, unknown> {\n      return Context.make(service, impl)\n    },\n  }),\n})\n\n/**\n * Create a layer that always fails with an error.\n */\nconst layerErr = <E>(error: E): LayerType<never, E, never, true> => ({\n  _tag: \"Layer\",\n  _ROut: undefined as never,\n  _E: undefined as unknown as E,\n  _RIn: undefined as never,\n  _Sync: undefined as unknown as true,\n  build: (): SyncFx<ContextType, E> => ({\n    _tag: \"SyncFx\",\n    [FxTypeId]: {\n      _A: () => undefined as never,\n      _E: () => error,\n      _R: () => undefined as never,\n    },\n    *[Symbol.iterator](): Generator<E, never, unknown> {\n      yield error\n      throw new Error(\"Unreachable\")\n    },\n  }),\n})\n\n/**\n * Create a layer from an Fx computation (can have dependencies).\n * The Sync type parameter is inferred from the input fx:\n * - SyncFx input → Layer with Sync=true\n * - AsyncFx input → Layer with Sync=false\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.fx(Port)(Fx.gen(function* () {\n *   return 3000\n * }))\n * // => effect-backed layer\n * ```\n *\n * @category Constructors\n */\nfunction layerFx<S>(service: ServiceClass<S>): {\n  <E, R>(fx: SyncFx<S, E, R>): LayerType<S, E, R, true>\n  <E, R>(fx: AsyncFx<S, E, R>): LayerType<S, E, R, false>\n  <E, R>(fx: RunnableFx<S, E, R>): LayerType<S, E, R>\n}\nfunction layerFx<S>(service: ServiceClass<S>) {\n  return <E, R>(fx: RunnableFx<S, E, R>): LayerType<S, E, R> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as S,\n    _E: undefined as unknown as E,\n    _RIn: undefined as unknown as R,\n    _Sync: undefined as unknown as boolean,\n    build: (): RunnableFx<ContextType<S>, E, R> => {\n      if (fx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<S>,\n            _E: () => undefined as unknown as E,\n            _R: () => undefined as unknown as R,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, R>, ContextType<S>, unknown> {\n            const gen = fx[Symbol.asyncIterator]()\n            let result = await gen.next()\n            while (result.done !== true) {\n              const value = yield result.value\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(value)\n            }\n            return Context.make(service, result.value)\n          },\n        } as AsyncFx<ContextType<S>, E, R>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<S>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as R,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E, R>, ContextType<S>, unknown> {\n          const gen = fx[Symbol.iterator]()\n          let result = gen.next()\n          while (result.done !== true) {\n            const value = yield result.value\n            result = gen.next(value)\n          }\n          return Context.make(service, result.value)\n        },\n      } as SyncFx<ContextType<S>, E, R>\n    },\n  })\n}\n\n/**\n * Create a scoped layer (with resource cleanup).\n * The Sync type parameter is inferred from the input fx.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n *\n * const Resource = Service.tag<{ close: () => void }>(\"Resource\")\n * const resourceLayer = Layer.scoped(Resource)(Fx.gen(function* () {\n *   return { close: () => undefined }\n * }) as never)\n * // => scoped layer with finalization support\n * ```\n *\n * @category Constructors\n */\nfunction layerScoped<S>(service: ServiceClass<S>): {\n  <E, R>(fx: SyncFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>, true>\n  <E, R>(fx: AsyncFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>, false>\n  <E, R>(fx: RunnableFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>>\n}\nfunction layerScoped<S>(service: ServiceClass<S>) {\n  return <E, R>(fx: RunnableFx<S, E, R | ScopeService>): LayerType<S, E, ExcludeScope<R>> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as S,\n    _E: undefined as unknown as E,\n    _RIn: undefined as unknown as ExcludeScope<R>,\n    _Sync: undefined as unknown as boolean,\n    build: (_memoMap, scope): RunnableFx<ContextType<S>, E, ExcludeScope<R>> => {\n      if (fx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<S>,\n            _E: () => undefined as unknown as E,\n            _R: () => undefined as unknown as ExcludeScope<R>,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, ExcludeScope<R>>, ContextType<S>, unknown> {\n            const gen = fx[Symbol.asyncIterator]()\n            let result = await gen.next()\n            while (result.done !== true) {\n              const yielded = result.value\n              const serviceRequest = asServiceRequest(yielded)\n              if (serviceRequest?.key === \"@std/Scope\") {\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(scope)\n              } else {\n                const value = yield yielded as FxYield<E, ExcludeScope<R>>\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(value)\n              }\n            }\n            return Context.make(service, result.value)\n          },\n        } as AsyncFx<ContextType<S>, E, ExcludeScope<R>>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<S>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as ExcludeScope<R>,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E, ExcludeScope<R>>, ContextType<S>, unknown> {\n          const gen = fx[Symbol.iterator]()\n          let result = gen.next()\n          while (result.done !== true) {\n            const yielded = result.value\n            const serviceRequest = asServiceRequest(yielded)\n            if (serviceRequest?.key === \"@std/Scope\") {\n              result = gen.next(scope)\n            } else {\n              const value = yield yielded as FxYield<E, ExcludeScope<R>>\n              result = gen.next(value)\n            }\n          }\n          return Context.make(service, result.value)\n        },\n      } as SyncFx<ContextType<S>, E, ExcludeScope<R>>\n    },\n  })\n}\n\n// ============================================================================\n// Layer Composition\n// ============================================================================\n\n/**\n * Provide dependencies to a layer and merge outputs.\n * Sync is preserved only if both the deps layer and the consuming layer are sync.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const App = Service.tag<{ start: () => void }>(\"App\")\n * const loggerLayer = Layer.ok(Logger, { log: () => undefined })\n * const appLayer = Layer.ok(App, { start: () => undefined })\n * const provided = Layer.provide(loggerLayer)(appLayer)\n * // => composed layer\n * ```\n *\n * @category Sequencing\n */\nfunction layerProvide<DepsROut, DepsE, DepsRIn, DepsSync extends boolean>(\n  deps: LayerType<DepsROut, DepsE, DepsRIn, DepsSync>,\n): {\n  <ROut, E, RIn extends DepsROut, LayerSync extends boolean>(\n    layer: LayerType<ROut, E, RIn, LayerSync>,\n  ): LayerType<ROut | DepsROut, E | DepsE, DepsRIn, LayerSync extends true ? DepsSync : false>\n}\nfunction layerProvide<DepsROut, DepsE, DepsRIn>(deps: LayerType<DepsROut, DepsE, DepsRIn>) {\n  return <ROut, E, RIn extends DepsROut>(\n    layer: LayerType<ROut, E, RIn>,\n  ): LayerType<ROut | DepsROut, E | DepsE, DepsRIn> => ({\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as ROut | DepsROut,\n    _E: undefined as unknown as E | DepsE,\n    _RIn: undefined as unknown as DepsRIn,\n    _Sync: undefined as unknown as boolean,\n    build: (memoMap, scope): RunnableFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn> => {\n      const depsBuildFx = deps.build(memoMap, scope)\n\n      if (depsBuildFx._tag === \"AsyncFx\") {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<ROut | DepsROut>,\n            _E: () => undefined as unknown as E | DepsE,\n            _R: () => undefined as unknown as DepsRIn,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<\n            FxYield<E | DepsE, DepsRIn>,\n            ContextType<ROut | DepsROut>,\n            unknown\n          > {\n            const depsGen = depsBuildFx[Symbol.asyncIterator]()\n            let depsResult = await depsGen.next()\n            while (depsResult.done !== true) {\n              const value = yield depsResult.value\n              // oxlint-disable-next-line no-await-in-loop\n              depsResult = await depsGen.next(value)\n            }\n            const depsCtx = depsResult.value\n\n            const layerBuildFx = layer.build(memoMap, scope)\n            if (layerBuildFx._tag === \"AsyncFx\") {\n              const layerGen = layerBuildFx[Symbol.asyncIterator]()\n              let layerResult = await layerGen.next()\n              while (layerResult.done !== true) {\n                const yielded = layerResult.value\n                const service = resolveService(depsCtx, yielded)\n                if (service !== undefined) {\n                  // oxlint-disable-next-line no-await-in-loop\n                  layerResult = await layerGen.next(service)\n                  continue\n                }\n                const value = yield yielded as FxYield<E, DepsRIn>\n                // oxlint-disable-next-line no-await-in-loop\n                layerResult = await layerGen.next(value)\n              }\n              return Context.merge(depsCtx, layerResult.value)\n            }\n\n            const layerGen = layerBuildFx[Symbol.iterator]()\n            let layerResult = layerGen.next()\n            while (layerResult.done !== true) {\n              const yielded = layerResult.value\n              const service = resolveService(depsCtx, yielded)\n              if (service !== undefined) {\n                layerResult = layerGen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<E, DepsRIn>\n              layerResult = layerGen.next(value)\n            }\n            return Context.merge(depsCtx, layerResult.value)\n          },\n        } as AsyncFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<ROut | DepsROut>,\n          _E: () => undefined as unknown as E | DepsE,\n          _R: () => undefined as unknown as DepsRIn,\n        },\n        *[Symbol.iterator](): Generator<FxYield<E | DepsE, DepsRIn>, ContextType<ROut | DepsROut>, unknown> {\n          const depsGen = depsBuildFx[Symbol.iterator]()\n          let depsResult = depsGen.next()\n          while (depsResult.done !== true) {\n            const value = yield depsResult.value\n            depsResult = depsGen.next(value)\n          }\n          const depsCtx = depsResult.value\n\n          const layerBuildFx = layer.build(memoMap, scope)\n          if (layerBuildFx._tag === \"SyncFx\") {\n            const syncGen = layerBuildFx[Symbol.iterator]()\n            let layerResult = syncGen.next()\n            while (layerResult.done !== true) {\n              const yielded = layerResult.value\n              const service = resolveService(depsCtx, yielded)\n              if (service !== undefined) {\n                layerResult = syncGen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<E, DepsRIn>\n              layerResult = syncGen.next(value)\n            }\n            return Context.merge(depsCtx, layerResult.value)\n          }\n          throw new Error(\"Cannot use async layer in sync context\")\n        },\n      } as SyncFx<ContextType<ROut | DepsROut>, E | DepsE, DepsRIn>\n    },\n  })\n}\n\n/**\n * Merge multiple layers with automatic dependency resolution.\n * The merged layer is sync only if ALL input layers are sync.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const Clock = Service.tag<{ now: () => number }>(\"Clock\")\n * const merged = Layer.merge(\n *   Layer.ok(Logger, { log: () => undefined }),\n *   Layer.ok(Clock, { now: () => Date.now() }),\n * )\n * // => layer that provides Logger | Clock\n * ```\n *\n * @category Combining\n */\nfunction layerMerge<L extends LayerType<unknown, unknown, unknown>[]>(\n  ...layers: L\n): LayerType<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>, AllSync<L>>\nfunction layerMerge<L extends LayerType<unknown, unknown, unknown>[]>(\n  ...layers: L\n): LayerType<MergeROut<L>, MergeError<L>, UnprovidedDeps<L>> {\n  return {\n    _tag: \"Layer\",\n    _ROut: undefined as unknown as MergeROut<L>,\n    _E: undefined as unknown as MergeError<L>,\n    _RIn: undefined as unknown as UnprovidedDeps<L>,\n    _Sync: undefined as unknown as boolean,\n    build: (memoMap, scope): RunnableFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>> => {\n      const hasAsync = layers.some((l) => l.build(memoMap, scope)._tag === \"AsyncFx\")\n\n      if (hasAsync) {\n        return {\n          _tag: \"AsyncFx\",\n          [FxTypeId]: {\n            _A: () => undefined as unknown as ContextType<MergeROut<L>>,\n            _E: () => undefined as unknown as MergeError<L>,\n            _R: () => undefined as unknown as UnprovidedDeps<L>,\n          },\n          async *[Symbol.asyncIterator](): AsyncGenerator<\n            FxYield<MergeError<L>, UnprovidedDeps<L>>,\n            ContextType<MergeROut<L>>,\n            unknown\n          > {\n            let ctx = Context.empty() as ContextType<unknown>\n            for (const layer of layers) {\n              const buildFx = layer.build(memoMap, scope)\n              if (buildFx._tag === \"AsyncFx\") {\n                const gen = buildFx[Symbol.asyncIterator]()\n                // oxlint-disable-next-line no-await-in-loop\n                let result = await gen.next()\n                while (result.done !== true) {\n                  const yielded = result.value\n                  const service = resolveService(ctx, yielded)\n                  if (service !== undefined) {\n                    // oxlint-disable-next-line no-await-in-loop\n                    result = await gen.next(service)\n                    continue\n                  }\n                  const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n                  // oxlint-disable-next-line no-await-in-loop\n                  result = await gen.next(value)\n                }\n                ctx = Context.merge(ctx, result.value)\n              } else {\n                const gen = buildFx[Symbol.iterator]()\n                let result = gen.next()\n                while (result.done !== true) {\n                  const yielded = result.value\n                  const service = resolveService(ctx, yielded)\n                  if (service !== undefined) {\n                    result = gen.next(service)\n                    continue\n                  }\n                  const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n                  result = gen.next(value)\n                }\n                ctx = Context.merge(ctx, result.value)\n              }\n            }\n            return ctx as ContextType<MergeROut<L>>\n          },\n        } as AsyncFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>>\n      }\n\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as ContextType<MergeROut<L>>,\n          _E: () => undefined as unknown as MergeError<L>,\n          _R: () => undefined as unknown as UnprovidedDeps<L>,\n        },\n        *[Symbol.iterator](): Generator<FxYield<MergeError<L>, UnprovidedDeps<L>>, ContextType<MergeROut<L>>, unknown> {\n          let ctx = Context.empty() as ContextType<unknown>\n          for (const layer of layers) {\n            const buildFx = layer.build(memoMap, scope)\n            if (buildFx._tag !== \"SyncFx\") {\n              throw new Error(\"Expected sync layer in sync context\")\n            }\n            const gen = buildFx[Symbol.iterator]()\n            let result = gen.next()\n            while (result.done !== true) {\n              const yielded = result.value\n              const service = resolveService(ctx, yielded)\n              if (service !== undefined) {\n                result = gen.next(service)\n                continue\n              }\n              const value = yield yielded as FxYield<MergeError<L>, UnprovidedDeps<L>>\n              result = gen.next(value)\n            }\n            ctx = Context.merge(ctx, result.value)\n          }\n          return ctx as ContextType<MergeROut<L>>\n        },\n      } as SyncFx<ContextType<MergeROut<L>>, MergeError<L>, UnprovidedDeps<L>>\n    },\n  }\n}\n\n/**\n * Create a successful no-dependency layer from a plain service value.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.ok(Port, 3000)\n * // => layer that provides Port\n * ```\n *\n * @category Constructors\n */\nexport const ok = layerOk\n\n/**\n * Create a layer that always fails with an error.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * const failingLayer = Layer.err(\"missing-config\")\n * // => layer that always fails with Err(\"missing-config\")\n * ```\n *\n * @category Constructors\n */\nexport const err = layerErr\n\n/**\n * Create a layer from an effectful service builder.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.fx(Port)(Fx.gen(function* () {\n *   return 3000\n * }))\n * // => effect-backed layer\n * ```\n *\n * @category Constructors\n */\nexport const fx = layerFx\n\n/**\n * Create a scoped layer that registers resource finalizers.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n *\n * const Resource = Service.tag<{ close: () => void }>(\"Resource\")\n * const resourceLayer = Layer.scoped(Resource)(Fx.gen(function* () {\n *   return { close: () => undefined }\n * }) as never)\n * // => scoped layer with finalization support\n * ```\n *\n * @category Constructors\n */\nexport const scoped = layerScoped\n\n/**\n * Provide one layer to another, satisfying dependencies.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const App = Service.tag<{ start: () => void }>(\"App\")\n * const loggerLayer = Layer.ok(Logger, { log: () => undefined })\n * const appLayer = Layer.ok(App, { start: () => undefined })\n * const provided = Layer.provide(loggerLayer)(appLayer)\n * // => composed layer\n * ```\n *\n * @category Sequencing\n */\nexport const provide = layerProvide\n\n/**\n * Merge multiple layers into a single composite layer.\n *\n * @example\n * ```ts\n * import { Layer } from \"@nicolastoulemont/std\"\n *\n * import { Service } from \"@nicolastoulemont/std\"\n *\n * const Logger = Service.tag<{ log: (message: string) => void }>(\"Logger\")\n * const Clock = Service.tag<{ now: () => number }>(\"Clock\")\n * const merged = Layer.merge(\n *   Layer.ok(Logger, { log: () => undefined }),\n *   Layer.ok(Clock, { now: () => Date.now() }),\n * )\n * // => layer that provides Logger | Clock\n * ```\n *\n * @category Combining\n */\nexport const merge = layerMerge\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"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"}

package/dist/multithread-xUUh4eLn.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"multithread-xUUh4eLn.mjs","names":[],"sources":["../src/multithread/multithread.ts"],"sourcesContent":["/**\n * Parallel worker orchestration helpers built on optional `multithreading` runtime.\n *\n * **Mental model**\n * - `MultithreadOp` represents cancelable worker execution.\n * - Use `run`, `task`, and collection combinators (`map`, `forEach`, `race`).\n *\n * **Common tasks**\n * - Execute one worker with `Multithread.run`.\n * - Create reusable tasks with `Multithread.task`.\n * - Process collections in parallel with `Multithread.map` / `forEach`.\n *\n * **Gotchas**\n * - Requires optional `multithreading` peer dependency.\n * - Runtime should be configured before first operation.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.run((ctx) => (ctx.isCancelled() ? 0 : 42))\n * // => cancelable operation with result() and abort()\n * ```\n *\n * @module\n */\nimport { FxTypeId } from \"../fx/fx.types\"\nimport { err, ok } from \"../result/result\"\nimport type { Result as ResultType } from \"../result/result.types\"\nimport type {\n  MultithreadAllFailedError,\n  MultithreadCancelledError,\n  MultithreadCtx,\n  MultithreadError,\n  MultithreadFilter,\n  MultithreadFilterWorker,\n  MultithreadFirstSuccess,\n  MultithreadFlatMap,\n  MultithreadFlatMapWorker,\n  MultithreadForEach,\n  MultithreadMap,\n  MultithreadMapWorker,\n  MultithreadOp,\n  MultithreadParallelOptions,\n  MultithreadRace,\n  MultithreadRun,\n  MultithreadRuntimeAlreadyInitializedError,\n  MultithreadRuntimeUnavailableError,\n  MultithreadSignal,\n  MultithreadTask,\n  MultithreadWorkerExecutionError,\n  WorkerReturn,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported worker context passed to multithread workers.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = typeof Multithread.MultithreadCtx\n   * ```\n   *\n   * @category Re-exports\n   */\n  type MultithreadCtx,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported union of multithread runtime and worker errors.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = typeof Multithread.MultithreadError\n   * ```\n   *\n   * @category Re-exports\n   */\n  type MultithreadError,\n} from \"./multithread.types\"\nexport {\n  /**\n   * Re-exported cancelable multithread operation type.\n   *\n   * @example\n   * ```ts\n   * import { Multithread } from \"@nicolastoulemont/std\"\n   *\n   * type Example = typeof Multithread.MultithreadOp<unknown, unknown>\n   * ```\n   *\n   * @category Re-exports\n   */\n  type MultithreadOp,\n} from \"./multithread.types\"\n\n/**\n * Internal runtime shape loaded from the optional \"multithreading\" peer dependency.\n */\ntype MultithreadingRuntime = {\n  initRuntime(config: { maxWorkers: number }): void\n  shutdown(): void\n  move<Args extends unknown[]>(...args: Args): unknown\n  spawn<R>(\n    payload: unknown,\n    fn: (...args: unknown[]) => R | Promise<R>,\n  ): {\n    join(): Promise<{ ok: boolean; value?: R; error?: Error }>\n    abort(): void\n  }\n}\n\ntype WorkerLike = (...args: unknown[]) => unknown\ntype WorkerEntrypoint = (...args: unknown[]) => Promise<unknown>\n\ntype InternalCancelController = {\n  readonly signal: MultithreadSignal\n  isCancelled(): boolean\n  cancel(): void\n  onCancel(listener: () => void): void\n}\n\nconst CANCELLED_ERROR_MESSAGE = \"@nicolastoulemont/std/multithread/cancelled\"\n\nlet runtimeConfig: { maxWorkers: number } | undefined\nlet runtimeInitialized = false\nlet runtimeImportPromise: Promise<MultithreadingRuntime> | undefined\n\nconst workerEntrypointCache = new WeakMap<object, WorkerEntrypoint>()\n\nconst makeRuntimeUnavailableError = (\n  cause?: unknown,\n  message = 'Optional peer dependency \"multithreading\" is unavailable. Install it to use Multithread APIs.',\n): MultithreadRuntimeUnavailableError => ({\n  _tag: \"MultithreadRuntimeUnavailableError\",\n  message,\n  cause,\n})\n\nconst makeRuntimeAlreadyInitializedError = (\n  message = \"Multithread runtime is already initialized and can no longer be configured.\",\n): MultithreadRuntimeAlreadyInitializedError => ({\n  _tag: \"MultithreadRuntimeAlreadyInitializedError\",\n  message,\n})\n\nconst makeWorkerExecutionError = (message: string, cause: unknown): MultithreadWorkerExecutionError => ({\n  _tag: \"MultithreadWorkerExecutionError\",\n  message,\n  cause,\n})\n\nconst makeCancelledError = (\n  message = \"Multithread operation was cancelled before completion.\",\n): MultithreadCancelledError => ({\n  _tag: \"MultithreadCancelledError\",\n  message,\n})\n\nconst makeAllFailedError = (message: string, errors: readonly unknown[]): MultithreadAllFailedError => ({\n  _tag: \"MultithreadAllFailedError\",\n  message,\n  errors,\n})\n\nconst getErrorMessage = (cause: unknown): string | undefined =>\n  cause instanceof Error ? cause.message : typeof cause === \"string\" ? cause : undefined\n\nconst isCancelledCause = (cause: unknown): boolean => {\n  const message = getErrorMessage(cause)\n  return message === CANCELLED_ERROR_MESSAGE || message === \"Task aborted\"\n}\n\nconst isCallerLocationFailure = (cause: unknown): boolean => {\n  const message = getErrorMessage(cause)\n  return typeof message === \"string\" && message.startsWith(\"Could not parse coordinates from:\")\n}\n\nconst isResultLike = (value: unknown): value is ResultType<unknown, unknown> => {\n  if (typeof value !== \"object\" || value === null || !(\"_tag\" in value)) return false\n  const tag = Reflect.get(value, \"_tag\")\n  if (tag === \"Ok\") return \"value\" in value\n  if (tag === \"Err\") return \"error\" in value\n  return false\n}\n\nconst resultOk = <A>(value: A): ResultType<A, never> => ok(value)\nconst resultErr = <E>(error: E): ResultType<never, E> => err(error)\n\nconst normalizeWorkerReturn = <A, E>(value: unknown): ResultType<A, E> => {\n  if (isResultLike(value)) {\n    // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- isResultLike confirms runtime shape; generic channels are erased.\n    return value as ResultType<A, E>\n  }\n  // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Worker return value is user-defined and mapped to generic success type.\n  return resultOk(value as A)\n}\n\nconst runFromInputResult = (\n  input: unknown,\n  execute: (value: unknown) => MultithreadOp<unknown, unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> => {\n  if (!isResultLike(input)) {\n    return execute(input)\n  }\n\n  if (input._tag === \"Err\") {\n    return Promise.resolve(resultErr(input.error))\n  }\n\n  return execute(input.value).result()\n}\n\nconst normalizeParallelism = (parallelism: number | undefined, fallback: number): number => {\n  if (typeof parallelism !== \"number\" || !Number.isFinite(parallelism)) return fallback\n  const rounded = Math.floor(parallelism)\n  return rounded > 0 ? rounded : fallback\n}\n\nconst isWorkerLike = (value: unknown): value is WorkerLike => typeof value === \"function\"\n\nconst isParallelOptions = (value: unknown): value is MultithreadParallelOptions =>\n  typeof value === \"object\" && value !== null\n\nconst resolveParallelOptions = (value: unknown): MultithreadParallelOptions | undefined =>\n  isParallelOptions(value) ? value : undefined\n\nconst getDefaultParallelism = (): number => {\n  if (runtimeConfig !== undefined) {\n    return runtimeConfig.maxWorkers\n  }\n  if (typeof navigator !== \"undefined\" && typeof navigator.hardwareConcurrency === \"number\") {\n    return normalizeParallelism(navigator.hardwareConcurrency, 4)\n  }\n  return 4\n}\n\nconst createSharedSignal = (): MultithreadSignal => {\n  if (typeof SharedArrayBuffer !== \"function\") return null\n  return new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT))\n}\n\nconst createCancelController = (): InternalCancelController => {\n  const signal = createSharedSignal()\n  const listeners = new Set<() => void>()\n  let cancelled = false\n\n  const isCancelled = (): boolean => cancelled || (signal !== null && Atomics.load(signal, 0) === 1)\n\n  const cancel = (): void => {\n    if (cancelled) return\n    cancelled = true\n\n    if (signal !== null) {\n      Atomics.store(signal, 0, 1)\n      Atomics.notify(signal, 0)\n    }\n\n    const activeListeners = Array.from(listeners)\n    listeners.clear()\n\n    for (const listener of activeListeners) {\n      try {\n        listener()\n      } catch {\n        // Intentionally ignore listener disposal errors during cancellation fanout.\n      }\n    }\n  }\n\n  const onCancel = (listener: () => void): void => {\n    if (cancelled) {\n      listener()\n      return\n    }\n    listeners.add(listener)\n  }\n\n  return {\n    signal,\n    isCancelled,\n    cancel,\n    onCancel,\n  }\n}\n\nconst loadRuntimeModule = async (): Promise<ResultType<MultithreadingRuntime, MultithreadError>> => {\n  try {\n    runtimeImportPromise ??= import(\"multithreading\") as Promise<MultithreadingRuntime>\n    return resultOk(await runtimeImportPromise)\n  } catch (cause) {\n    return resultErr(makeRuntimeUnavailableError(cause))\n  }\n}\n\nconst getRuntime = async (): Promise<ResultType<MultithreadingRuntime, MultithreadError>> => {\n  const runtimeResult = await loadRuntimeModule()\n  if (runtimeResult._tag === \"Err\") return runtimeResult\n\n  const runtime = runtimeResult.value\n\n  if (!runtimeInitialized) {\n    try {\n      if (runtimeConfig !== undefined) {\n        runtime.initRuntime(runtimeConfig)\n      }\n      runtimeInitialized = true\n    } catch (cause) {\n      return resultErr(makeWorkerExecutionError(\"Failed to initialize multithreading runtime.\", cause))\n    }\n  }\n\n  return resultOk(runtime)\n}\n\nconst createWorkerEntrypoint = <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n): WorkerEntrypoint => {\n  const cached = workerEntrypointCache.get(worker)\n  if (cached !== undefined) {\n    return cached\n  }\n\n  const source = worker.toString()\n  // oxlint-disable-next-line typescript-eslint/no-implied-eval, typescript-eslint/no-unsafe-type-assertion -- Worker code must be reconstructed from serialized callback source and typed at runtime.\n  const factory = new Function(\n    `\nreturn async function (...__args) {\n  const __signal = __args.pop()\n  const __isCancelled = () => __signal !== null && Atomics.load(__signal, 0) === 1\n  const __throwIfCancelled = () => {\n    if (__isCancelled()) {\n      throw new Error(${JSON.stringify(CANCELLED_ERROR_MESSAGE)})\n    }\n  }\n  const __ctx = {\n    signal: __signal,\n    isCancelled: __isCancelled,\n    throwIfCancelled: __throwIfCancelled,\n  }\n  const __worker = (${source})\n  return await __worker(...__args, __ctx)\n}\n`,\n  ) as () => WorkerEntrypoint\n\n  const entrypoint = factory()\n  workerEntrypointCache.set(worker, entrypoint)\n  return entrypoint\n}\n\nconst createMultithreadOperation = <A, E>(\n  execute: (controller: InternalCancelController) => Promise<ResultType<A, E | MultithreadError>>,\n): MultithreadOp<A, E | MultithreadError> => {\n  const controller = createCancelController()\n  let runPromise: Promise<ResultType<A, E | MultithreadError>> | undefined\n\n  const start = (): Promise<ResultType<A, E | MultithreadError>> => {\n    if (runPromise !== undefined) return runPromise\n\n    if (controller.isCancelled()) {\n      runPromise = Promise.resolve(resultErr(makeCancelledError()))\n      return runPromise\n    }\n\n    runPromise = execute(controller)\n      .catch((cause: unknown) => resultErr(makeWorkerExecutionError(\"Multithread operation failed.\", cause)))\n      .then((result) => {\n        if (controller.isCancelled()) {\n          return resultErr(makeCancelledError())\n        }\n        return result\n      })\n\n    return runPromise\n  }\n\n  const then: PromiseLike<ResultType<A, E | MultithreadError>>[\"then\"] = (onfulfilled, onrejected) =>\n    start().then(onfulfilled, onrejected)\n\n  return {\n    _tag: \"MultithreadOp\",\n    [FxTypeId]: {\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _A: () => undefined as unknown as A,\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _E: () => undefined as unknown as E | MultithreadError,\n      // oxlint-disable-next-line typescript-eslint/no-unsafe-type-assertion -- Fx marker channels are phantom-only type metadata.\n      _R: () => undefined as never,\n    },\n    result: start,\n    abort: () => {\n      controller.cancel()\n    },\n    // oxlint-disable-next-line eslint-plugin-unicorn/no-thenable -- MultithreadOp is intentionally PromiseLike for `await op` ergonomics.\n    then,\n    async *[Symbol.asyncIterator](): AsyncGenerator<E | MultithreadError, A, unknown> {\n      const result = await start()\n      if (result._tag === \"Err\") {\n        yield result.error\n        throw new Error(\"Unreachable: Fx.gen should short-circuit on yielded Multithread errors\")\n      }\n      return result.value\n    },\n  }\n}\n\nconst runWorkerLocally = async <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  args: Args,\n  controller: InternalCancelController,\n): Promise<ResultType<A, E | MultithreadError>> => {\n  if (controller.isCancelled()) {\n    return resultErr(makeCancelledError())\n  }\n\n  const ctx: MultithreadCtx = {\n    signal: controller.signal,\n    isCancelled: () => controller.isCancelled(),\n    throwIfCancelled: () => {\n      if (controller.isCancelled()) throw new Error(CANCELLED_ERROR_MESSAGE)\n    },\n  }\n\n  try {\n    const value = await worker(...args, ctx)\n\n    if (controller.isCancelled()) {\n      return resultErr(makeCancelledError())\n    }\n\n    const normalized = normalizeWorkerReturn<A, E>(value)\n    if (normalized._tag === \"Err\") {\n      return resultErr(normalized.error)\n    }\n\n    return resultOk(normalized.value)\n  } catch (cause) {\n    if (controller.isCancelled() || isCancelledCause(cause)) {\n      return resultErr(makeCancelledError())\n    }\n    return resultErr(makeWorkerExecutionError(\"Multithread worker failed during execution.\", cause))\n  }\n}\n\nconst runDataFirst = <Args extends readonly unknown[], A, E>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  args: Args,\n): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (controller.isCancelled()) {\n      return resultErr(makeCancelledError())\n    }\n\n    const runtimeResult = await getRuntime()\n    if (runtimeResult._tag === \"Err\") return resultErr(runtimeResult.error)\n\n    const runtime = runtimeResult.value\n    const entrypoint = createWorkerEntrypoint(worker)\n\n    let joinHandle: ReturnType<MultithreadingRuntime[\"spawn\"]> | undefined\n\n    try {\n      const movedPayload = runtime.move(...args, controller.signal)\n      joinHandle = runtime.spawn(movedPayload, entrypoint)\n      controller.onCancel(() => {\n        joinHandle?.abort()\n      })\n    } catch (cause) {\n      if (isCallerLocationFailure(cause)) {\n        return runWorkerLocally(worker, args, controller)\n      }\n      if (controller.isCancelled() || isCancelledCause(cause)) {\n        return resultErr(makeCancelledError())\n      }\n      return resultErr(makeWorkerExecutionError(\"Failed to start multithread worker.\", cause))\n    }\n\n    try {\n      const joined = await joinHandle.join()\n\n      if (controller.isCancelled()) {\n        return resultErr(makeCancelledError())\n      }\n\n      if (!joined.ok) {\n        const joinError = joined.error ?? new Error(\"Multithread worker returned an unknown error.\")\n        if (isCancelledCause(joinError)) {\n          return resultErr(makeCancelledError())\n        }\n        return resultErr(makeWorkerExecutionError(\"Multithread worker failed during execution.\", joinError))\n      }\n\n      const normalized = normalizeWorkerReturn<A, E>(joined.value)\n      if (normalized._tag === \"Err\") {\n        return resultErr(normalized.error)\n      }\n      return resultOk(normalized.value)\n    } catch (cause) {\n      if (controller.isCancelled() || isCancelledCause(cause)) {\n        return resultErr(makeCancelledError())\n      }\n      return resultErr(makeWorkerExecutionError(\"Failed to join multithread worker.\", cause))\n    }\n  })\n\nfunction runOverload<A, E = never>(\n  worker: (ctx: MultithreadCtx) => WorkerReturn<A, E>,\n): MultithreadOp<A, E | MultithreadError>\nfunction runOverload<Args extends readonly unknown[], A, E = never>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n  ...args: Args\n): MultithreadOp<A, E | MultithreadError>\nfunction runOverload(worker: unknown, ...args: unknown[]): MultithreadOp<unknown, unknown> {\n  if (!isWorkerLike(worker)) {\n    throw new TypeError(\"Multithread.run expects a worker function as first argument.\")\n  }\n  return runDataFirst(worker, args)\n}\n\n/**\n * Execute one worker task as a cancelable `MultithreadOp`.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.run((ctx) => (ctx.isCancelled() ? 0 : 42))\n * // => cancelable operation with result() and abort()\n * ```\n *\n * @category Constructors\n */\nexport const run: MultithreadRun = runOverload\n\nfunction taskOverload<A, E = never>(\n  worker: (ctx: MultithreadCtx) => WorkerReturn<A, E>,\n): () => MultithreadOp<A, E | MultithreadError>\nfunction taskOverload<Args extends readonly unknown[], A, E = never>(\n  worker: (...args: [...Args, MultithreadCtx]) => WorkerReturn<A, E>,\n): (...args: Args) => MultithreadOp<A, E | MultithreadError>\nfunction taskOverload(worker: unknown): (...args: unknown[]) => MultithreadOp<unknown, unknown> {\n  if (!isWorkerLike(worker)) {\n    throw new TypeError(\"Multithread.task expects a worker function.\")\n  }\n  return (...args: unknown[]) => runDataFirst(worker, args)\n}\n\n/**\n * Create a reusable worker task factory.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const create = Multithread.task((ctx) => (ctx.isCancelled() ? 0 : 16))\n * const op = create()\n * // => operation that resolves to 16 when executed\n * ```\n *\n * @category Constructors\n */\nexport const task: MultithreadTask = taskOverload\n\nconst executeInParallel = <A, B, E>(\n  values: readonly A[],\n  createItemOperation: (value: A, index: number) => MultithreadOp<B, E | MultithreadError>,\n  parallelism: number,\n  controller: InternalCancelController,\n): Promise<ResultType<readonly B[], E | MultithreadError>> => {\n  if (values.length === 0) {\n    return Promise.resolve(resultOk<readonly B[]>([]))\n  }\n\n  return new Promise<ResultType<readonly B[], E | MultithreadError>>((resolve) => {\n    const operations = new Map<number, MultithreadOp<B, E | MultithreadError>>()\n    const output: B[] = []\n\n    let inFlight = 0\n    let nextIndex = 0\n    let completed = 0\n    let settled = false\n\n    const abortAll = (): void => {\n      for (const operation of operations.values()) {\n        operation.abort()\n      }\n      operations.clear()\n    }\n\n    const settle = (result: ResultType<readonly B[], E | MultithreadError>): void => {\n      if (settled) return\n      settled = true\n      abortAll()\n      resolve(result)\n    }\n\n    controller.onCancel(() => {\n      settle(resultErr(makeCancelledError()))\n    })\n\n    const handleOperation = (index: number, operation: MultithreadOp<B, E | MultithreadError>): void => {\n      void (async () => {\n        try {\n          const result = await operation.result()\n\n          inFlight -= 1\n          operations.delete(index)\n\n          if (settled) return\n\n          if (result._tag === \"Err\") {\n            settle(resultErr(result.error))\n            return\n          }\n\n          output[index] = result.value\n          completed += 1\n\n          if (completed === values.length) {\n            settled = true\n            resolve(resultOk(output))\n            return\n          }\n\n          launch()\n        } catch (cause) {\n          inFlight -= 1\n          operations.delete(index)\n\n          if (settled) return\n\n          if (controller.isCancelled() || isCancelledCause(cause)) {\n            settle(resultErr(makeCancelledError()))\n            return\n          }\n\n          settle(resultErr(makeWorkerExecutionError(\"Failed while executing multithread batch.\", cause)))\n        }\n      })()\n    }\n\n    const launch = (): void => {\n      while (!settled && inFlight < parallelism && nextIndex < values.length) {\n        const index = nextIndex\n        nextIndex += 1\n\n        const operation = createItemOperation(values[index]!, index)\n        operations.set(index, operation)\n        inFlight += 1\n\n        handleOperation(index, operation)\n      }\n    }\n\n    launch()\n  })\n}\n\nconst mapDataFirst = <A, B, E>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError> =>\n  createMultithreadOperation((controller) => {\n    const parallelism = normalizeParallelism(options?.parallelism, getDefaultParallelism())\n    return executeInParallel(values, (value, index) => runDataFirst(worker, [value, index]), parallelism, controller)\n  })\n\nfunction mapOverload<A, B, E = never>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError>\nfunction mapOverload<A, B, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\nfunction mapOverload<A, B, E = never>(\n  worker: MultithreadMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly B[], E | MultithreadError>\nfunction mapOverload<A, B, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadMapWorker<A, B, E>,\n  workerOrOptions?: MultithreadMapWorker<A, B, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly B[], E | MultithreadError>\n  | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        mapDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.map(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    mapDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly B[], E | MultithreadError>\n    | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n}\n\n/**\n * Map a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.map([1, 2, 3], (value) => value * 2)\n * // => operation that resolves to [2, 4, 6]\n * ```\n *\n * @category Mapping\n */\nexport const map: MultithreadMap = mapOverload\n\nconst forEachDataFirst = <A, E>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<void, E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<void, E | MultithreadError>> => {\n    const mapped = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (mapped._tag === \"Err\") return resultErr(mapped.error)\n    return resultOk(undefined)\n  })\n\nfunction forEachOverload<A, E = never>(\n  values: readonly A[],\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<void, E | MultithreadError>\nfunction forEachOverload<A, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<void, E | InputE | MultithreadError>>\nfunction forEachOverload<A, E = never>(\n  worker: MultithreadMapWorker<A, unknown, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n  : MultithreadOp<void, E | MultithreadError>\nfunction forEachOverload<A, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadMapWorker<A, unknown, E>,\n  workerOrOptions?: MultithreadMapWorker<A, unknown, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<void, E | MultithreadError>\n  | Promise<ResultType<void, E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n      : MultithreadOp<void, E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        forEachDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<void, E | ResultInputE | MultithreadError>>\n      : MultithreadOp<void, E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.forEach(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    forEachDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as MultithreadOp<void, E | MultithreadError> | Promise<ResultType<void, E | InputE | MultithreadError>>\n}\n\n/**\n * Run side-effecting parallel work for each item.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.forEach([\"a\", \"b\"], (value) => value.toUpperCase())\n * // => operation that resolves to void after all items complete\n * ```\n *\n * @category Sequencing\n */\nexport const forEach: MultithreadForEach = forEachOverload\n\nconst filterDataFirst = <A, E>(\n  values: readonly A[],\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly A[], E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<readonly A[], E | MultithreadError>> => {\n    const decisions = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (decisions._tag === \"Err\") return resultErr(decisions.error)\n\n    const filtered: A[] = []\n    for (let index = 0; index < values.length; index += 1) {\n      if (decisions.value[index] === true) {\n        filtered.push(values[index]!)\n      }\n    }\n\n    return resultOk(filtered)\n  })\n\nfunction filterOverload<A, E = never>(\n  values: readonly A[],\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly A[], E | MultithreadError>\nfunction filterOverload<A, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\nfunction filterOverload<A, E = never>(\n  worker: MultithreadFilterWorker<A, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly A[], E | MultithreadError>\nfunction filterOverload<A, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadFilterWorker<A, E>,\n  workerOrOptions?: MultithreadFilterWorker<A, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly A[], E | MultithreadError>\n  | Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly A[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        filterDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly A[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly A[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.filter(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    filterDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly A[], E | MultithreadError>\n    | Promise<ResultType<readonly A[], E | InputE | MultithreadError>>\n}\n\n/**\n * Filter a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.filter([1, 2, 3, 4], (value) => value % 2 === 0)\n * // => operation that resolves to [2, 4]\n * ```\n *\n * @category Filtering\n */\nexport const filter: MultithreadFilter = filterOverload\n\nconst flatMapDataFirst = <A, B, E>(\n  values: readonly A[],\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError> =>\n  createMultithreadOperation(async (controller): Promise<ResultType<readonly B[], E | MultithreadError>> => {\n    const chunks = await executeInParallel(\n      values,\n      (value, index) => runDataFirst(worker, [value, index]),\n      normalizeParallelism(options?.parallelism, getDefaultParallelism()),\n      controller,\n    )\n\n    if (chunks._tag === \"Err\") return resultErr(chunks.error)\n\n    const flattened: B[] = []\n    for (const chunk of chunks.value) {\n      flattened.push(...chunk)\n    }\n\n    return resultOk(flattened)\n  })\n\nfunction flatMapOverload<A, B, E = never>(\n  values: readonly A[],\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): MultithreadOp<readonly B[], E | MultithreadError>\nfunction flatMapOverload<A, B, E = never, InputE = never>(\n  values: ResultType<readonly A[], InputE>,\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\nfunction flatMapOverload<A, B, E = never>(\n  worker: MultithreadFlatMapWorker<A, B, E>,\n  options?: MultithreadParallelOptions,\n): <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n  values: Input,\n) => Input extends ResultType<readonly A[], infer ResultInputE>\n  ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n  : MultithreadOp<readonly B[], E | MultithreadError>\nfunction flatMapOverload<A, B, E = never, InputE = never>(\n  valuesOrWorker: readonly A[] | ResultType<readonly A[], InputE> | MultithreadFlatMapWorker<A, B, E>,\n  workerOrOptions?: MultithreadFlatMapWorker<A, B, E> | MultithreadParallelOptions,\n  options?: MultithreadParallelOptions,\n):\n  | MultithreadOp<readonly B[], E | MultithreadError>\n  | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n  | (<Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>) {\n  if (typeof valuesOrWorker === \"function\") {\n    const curriedOptions = resolveParallelOptions(workerOrOptions)\n    return ((values: readonly A[] | ResultType<readonly A[], unknown>) =>\n      runFromInputResult(values, (resolvedValues) =>\n        flatMapDataFirst(resolvedValues as readonly A[], valuesOrWorker, curriedOptions),\n      )) as <Input extends readonly A[] | ResultType<readonly A[], unknown>>(\n      values: Input,\n    ) => Input extends ResultType<readonly A[], infer ResultInputE>\n      ? Promise<ResultType<readonly B[], E | ResultInputE | MultithreadError>>\n      : MultithreadOp<readonly B[], E | MultithreadError>\n  }\n\n  if (typeof workerOrOptions !== \"function\") {\n    throw new TypeError(\"Multithread.flatMap(values, worker, options) requires a worker function.\")\n  }\n\n  return runFromInputResult(valuesOrWorker, (resolvedValues) =>\n    flatMapDataFirst(resolvedValues as readonly A[], workerOrOptions, options),\n  ) as\n    | MultithreadOp<readonly B[], E | MultithreadError>\n    | Promise<ResultType<readonly B[], E | InputE | MultithreadError>>\n}\n\n/**\n * Flat-map a collection in parallel.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const op = Multithread.flatMap([1, 2], (value) => [value, value * 10])\n * // => operation that resolves to [1, 10, 2, 20]\n * ```\n *\n * @category Sequencing\n */\nexport const flatMap: MultithreadFlatMap = flatMapOverload\n\nconst raceDataFirst = <A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation((controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (operations.length === 0) {\n      return Promise.resolve(resultErr(makeAllFailedError(\"Cannot race an empty list of operations.\", [])))\n    }\n\n    return new Promise<ResultType<A, E | MultithreadError>>((resolve) => {\n      let settled = false\n\n      const abortAll = (): void => {\n        for (const operation of operations) {\n          operation.abort()\n        }\n      }\n\n      const settle = (result: ResultType<A, E | MultithreadError>): void => {\n        if (settled) return\n        settled = true\n        abortAll()\n        resolve(result)\n      }\n\n      controller.onCancel(() => {\n        settle(resultErr(makeCancelledError()))\n      })\n\n      const watchOperation = (operation: MultithreadOp<A, E>): void => {\n        void (async () => {\n          try {\n            const result = await operation.result()\n            settle(result)\n          } catch (cause) {\n            if (controller.isCancelled() || isCancelledCause(cause)) {\n              settle(resultErr(makeCancelledError()))\n              return\n            }\n\n            settle(resultErr(makeWorkerExecutionError(\"Multithread race failed.\", cause)))\n          }\n        })()\n      }\n\n      for (const operation of operations) {\n        watchOperation(operation)\n      }\n    })\n  })\n\nfunction raceOverload<A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError>\nfunction raceOverload<A, E, InputE = never>(\n  operations: ResultType<readonly MultithreadOp<A, E>[], InputE>,\n): Promise<ResultType<A, E | InputE | MultithreadError>>\nfunction raceOverload<Ops extends readonly MultithreadOp<unknown, unknown>[]>(\n  operations: Ops,\n): MultithreadOp<\n  Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n  (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | MultithreadError\n>\nfunction raceOverload<Ops extends readonly MultithreadOp<unknown, unknown>[], InputE = never>(\n  operations: ResultType<Ops, InputE>,\n): Promise<\n  ResultType<\n    Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n    (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | InputE | MultithreadError\n  >\n>\nfunction raceOverload(\n  operations:\n    | readonly MultithreadOp<unknown, unknown>[]\n    | ResultType<readonly MultithreadOp<unknown, unknown>[], unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> {\n  return runFromInputResult(operations, (resolvedOperations) =>\n    raceDataFirst(resolvedOperations as readonly MultithreadOp<unknown, unknown>[]),\n  )\n}\n\n/**\n * Resolve with the first successfully completed operation.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const fast = Multithread.run(() => 1)\n * const slow = Multithread.run(() => 2)\n * const op = Multithread.race([fast, slow])\n * // => operation that resolves with the first finished result\n * ```\n *\n * @category Combining\n */\nexport const race: MultithreadRace = raceOverload\n\nconst firstSuccessDataFirst = <A, E>(\n  operations: readonly MultithreadOp<A, E>[],\n): MultithreadOp<A, E | MultithreadError> =>\n  createMultithreadOperation((controller): Promise<ResultType<A, E | MultithreadError>> => {\n    if (operations.length === 0) {\n      return Promise.resolve(\n        resultErr(makeAllFailedError(\"Cannot select a first success from an empty list of operations.\", [])),\n      )\n    }\n\n    return new Promise<ResultType<A, E | MultithreadError>>((resolve) => {\n      const failures: unknown[] = Array.from({ length: operations.length })\n      let pending = operations.length\n      let settled = false\n\n      const abortAll = (): void => {\n        for (const operation of operations) {\n          operation.abort()\n        }\n      }\n\n      const settle = (result: ResultType<A, E | MultithreadError>): void => {\n        if (settled) return\n        settled = true\n        abortAll()\n        resolve(result)\n      }\n\n      controller.onCancel(() => {\n        settle(resultErr(makeCancelledError()))\n      })\n\n      const watchOperation = (operation: MultithreadOp<A, E>, index: number): void => {\n        void (async () => {\n          try {\n            const result = await operation.result()\n\n            if (settled) return\n\n            if (result._tag === \"Ok\") {\n              settle(resultOk(result.value))\n              return\n            }\n\n            failures[index] = result.error\n            pending -= 1\n\n            if (pending === 0) {\n              settle(\n                resultErr(\n                  makeAllFailedError(\n                    \"All multithread operations failed before any success was produced.\",\n                    failures.filter((failure) => failure !== undefined),\n                  ),\n                ),\n              )\n            }\n          } catch (cause) {\n            if (settled) return\n\n            if (controller.isCancelled() || isCancelledCause(cause)) {\n              settle(resultErr(makeCancelledError()))\n              return\n            }\n\n            failures[index] = makeWorkerExecutionError(\"Multithread operation rejected unexpectedly.\", cause)\n            pending -= 1\n\n            if (pending === 0) {\n              settle(\n                resultErr(\n                  makeAllFailedError(\n                    \"All multithread operations failed before any success was produced.\",\n                    failures.filter((failure) => failure !== undefined),\n                  ),\n                ),\n              )\n            }\n          }\n        })()\n      }\n\n      operations.forEach((operation, index) => {\n        watchOperation(operation, index)\n      })\n    })\n  })\n\nfunction firstSuccessOverload<A, E>(operations: readonly MultithreadOp<A, E>[]): MultithreadOp<A, E | MultithreadError>\nfunction firstSuccessOverload<A, E, InputE = never>(\n  operations: ResultType<readonly MultithreadOp<A, E>[], InputE>,\n): Promise<ResultType<A, E | InputE | MultithreadError>>\nfunction firstSuccessOverload<Ops extends readonly MultithreadOp<unknown, unknown>[]>(\n  operations: Ops,\n): MultithreadOp<\n  Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n  (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | MultithreadError\n>\nfunction firstSuccessOverload<Ops extends readonly MultithreadOp<unknown, unknown>[], InputE = never>(\n  operations: ResultType<Ops, InputE>,\n): Promise<\n  ResultType<\n    Ops[number] extends MultithreadOp<infer A, unknown> ? A : never,\n    (Ops[number] extends MultithreadOp<unknown, infer OpE> ? OpE : never) | InputE | MultithreadError\n  >\n>\nfunction firstSuccessOverload(\n  operations:\n    | readonly MultithreadOp<unknown, unknown>[]\n    | ResultType<readonly MultithreadOp<unknown, unknown>[], unknown>,\n): MultithreadOp<unknown, unknown> | Promise<ResultType<unknown, unknown>> {\n  return runFromInputResult(operations, (resolvedOperations) =>\n    firstSuccessDataFirst(resolvedOperations as readonly MultithreadOp<unknown, unknown>[]),\n  )\n}\n\n/**\n * Return the first successful operation, aggregating failures if none succeed.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * import { Result } from \"@nicolastoulemont/std\"\n *\n * const fail = Multithread.run(() => Result.err(\"boom\"))\n * const pass = Multithread.run(() => Result.ok(1))\n * const op = Multithread.firstSuccess([fail, pass])\n * // => operation that resolves with 1\n * ```\n *\n * @category Combining\n */\nexport const firstSuccess: MultithreadFirstSuccess = firstSuccessOverload\n\n/**\n * Configure max worker count used by the underlying runtime.\n *\n * Must be called before first multithread operation starts.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const configured = Multithread.configure({ maxWorkers: 4 })\n * // => { _tag: \"Ok\", value: undefined }\n * ```\n *\n * @category Constructors\n */\nexport const configure = (config: { maxWorkers: number }): ResultType<void, MultithreadError> => {\n  if (runtimeInitialized) {\n    return resultErr(makeRuntimeAlreadyInitializedError())\n  }\n\n  runtimeConfig = {\n    maxWorkers: normalizeParallelism(config.maxWorkers, 1),\n  }\n\n  return resultOk(undefined)\n}\n\n/**\n * Shutdown worker runtime.\n *\n * This function is idempotent.\n *\n * @example\n * ```ts\n * import { Multithread } from \"@nicolastoulemont/std\"\n *\n * const shutdownPromise = Multithread.shutdown()\n * // => Promise<Result<void, MultithreadError>>\n * ```\n *\n * @category Utilities\n */\nexport const shutdown = async (): Promise<ResultType<void, MultithreadError>> => {\n  if (!runtimeInitialized) {\n    return resultOk(undefined)\n  }\n\n  const runtimeResult = await loadRuntimeModule()\n  if (runtimeResult._tag === \"Err\") {\n    runtimeInitialized = false\n    return resultErr(runtimeResult.error)\n  }\n\n  try {\n    runtimeResult.value.shutdown()\n    return resultOk(undefined)\n  } catch (cause) {\n    return resultErr(makeWorkerExecutionError(\"Failed to shutdown multithreading runtime.\", cause))\n  } finally {\n    runtimeInitialized = false\n  }\n}\n"],"mappings":"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"}

package/dist/option-Tfbo4wty.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"option-Tfbo4wty.mjs","names":["NoSuchElementErrorCtor","values"],"sources":["../src/option/option.ts"],"sourcesContent":["/**\n * Optional value primitives for modeling presence (`Some`) and absence (`None`).\n *\n * **Mental model**\n * - `Option<A>` is either a value or no value.\n * - Prefer `Option` when missing data is expected and not exceptional.\n *\n * **Common tasks**\n * - Construct with `Option.some`, `Option.none`, `Option.fromNullable`.\n * - Transform with `Option.map`, `Option.flatMap`, `Option.filter`.\n * - Extract with `Option.unwrapOr`, `Option.match`.\n *\n * **Gotchas**\n * - `Option.none` short-circuits in `Fx.gen`.\n * - Use `Option.match` for exhaustive branch handling.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const name = Option.fromNullable(\"Ada\")\n * const upper = Option.map(name, (value) => value.toUpperCase())\n * ```\n *\n * @module\n */\nimport { FxTypeId } from \"../fx/fx.types\"\nimport { dual } from \"../shared/dual\"\nimport { isPromise } from \"../shared/is-promise\"\nimport { pipeMethod } from \"../shared/pipeable\"\nimport { NoSuchElementError as NoSuchElementErrorCtor } from \"./option.types\"\nimport type {\n  Option as OptionType,\n  OptionAll,\n  OptionFlatMap,\n  OptionMap,\n  OptionMatch,\n  OptionTap,\n  OptionOrElse,\n  OptionFilter,\n  OptionUnwrapOr,\n  OptionUnwrapOrElse,\n  FromTryReturn,\n} from \"./option.types\"\n\n/**\n * Re-exported error type used when yielding `Option.none()` in `Fx.gen`.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const error = new Option.NoSuchElementError()\n * // => error.name === \"NoSuchElementError\"\n * ```\n *\n * @category Re-exports\n */\nexport const NoSuchElementError = NoSuchElementErrorCtor\n\n/**\n * Re-exported `NoSuchElementError` instance type.\n *\n * @example\n * ```ts\n * import type { Option } from \"@nicolastoulemont/std\"\n *\n * type Example = Option.NoSuchElementError\n * ```\n *\n * @category Re-exports\n */\nexport type NoSuchElementError = InstanceType<typeof NoSuchElementErrorCtor>\n\n/**\n * Re-exported `Option` type.\n *\n * @example\n * ```ts\n * import type { Option } from \"@nicolastoulemont/std\"\n *\n * type Example = Option.Option<unknown>\n * ```\n *\n * @category Re-exports\n */\nexport type Option<T> = OptionType<T>\n\n/* oxlint-disable no-unsafe-type-assertion -- Option runtime values carry erased Fx phantom channels that require explicit marker assertions. */\n\n// ============================================================================\n// Constructors\n// ============================================================================\n\n/**\n * Create an Option with a value.\n *\n * @param value - The value to wrap\n * @returns An Option with `_tag: \"Some\"`\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.some(42)\n * // => { _tag: \"Some\", value: 42 }\n * ```\n *\n * @category Constructors\n */\nexport const some = <T>(value: T): OptionType<T> => ({\n  _tag: \"Some\",\n  value,\n  [FxTypeId]: {\n    _A: () => value,\n    _E: () => undefined as never,\n    _R: () => undefined as never,\n  },\n  pipe: pipeMethod,\n  // oxlint-disable-next-line require-yield\n  *[Symbol.iterator](): Generator<NoSuchElementError, T, unknown> {\n    return value\n  },\n})\n\n/**\n * Create an Option with no value.\n *\n * @returns An Option with `_tag: \"None\"`\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.none<number>()\n * // => { _tag: \"None\" }\n * ```\n *\n * @category Constructors\n */\nexport const none = <T = never>(): OptionType<T> => ({\n  _tag: \"None\",\n  [FxTypeId]: {\n    _A: () => undefined as never,\n    _E: () => undefined as unknown as NoSuchElementError,\n    _R: () => undefined as never,\n  },\n  pipe: pipeMethod,\n  *[Symbol.iterator](): Generator<NoSuchElementError, never, unknown> {\n    yield new NoSuchElementError()\n    throw new Error(\"Unreachable: Fx.gen should short-circuit on NoSuchElementError\")\n  },\n})\n\n// ============================================================================\n// Type Guards\n// ============================================================================\n\n/**\n * Check if an Option has a value.\n *\n * @param option - The Option to check\n * @returns true if the Option is some\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.isSome(Option.some(1))\n * // => true\n * ```\n *\n * @category Guards\n */\nexport const isSome = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { _tag: \"Some\" }> =>\n  option._tag === \"Some\"\n\n/**\n * isNone utility.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.isNone(Option.none())\n * // => true\n * ```\n *\n * @category Guards\n */\nexport const isNone = <T>(option: OptionType<T>): option is Extract<OptionType<T>, { _tag: \"None\" }> =>\n  option._tag === \"None\"\n\n// ============================================================================\n// Transformations (curried for pipe)\n// ============================================================================\n\n/**\n * Transform the value of an Option.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `map(option, fn)`\n * - Data-last: `pipe(option, map(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function to transform the value\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.map(input, (n) => n + 1)\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.map((n: number) => n + 1)(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n *\n * @category Mapping\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const map: OptionMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (option._tag === \"None\") return option as any\n  const mapped = fn(option.value)\n  if (isPromise(mapped)) {\n    return Promise.resolve(mapped).then(some) as any\n  }\n  return some(mapped) as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Chain operations that return Options.\n * If the Option is none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `flatMap(option, fn)`\n * - Data-last: `pipe(option, flatMap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<U>\n * - Async fn: returns Promise<Option<U>>\n *\n * @param fn - Function that takes a value and returns an Option (or Promise<Option>)\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.flatMap(input, (n) => Option.some(n + 1))\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.flatMap((n: number) => Option.some(n + 1))(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n *\n * @category Sequencing\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const flatMap: OptionFlatMap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) =>\n  option._tag === \"Some\" ? fn(option.value) : option,\n)\n\n/**\n * Perform a side effect on the value without modifying the Option.\n * Useful for debugging, logging, or other side effects in a pipeline.\n * If the Option is none, the function is not called.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `tap(option, fn)`\n * - Data-last: `pipe(option, tap(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * @param fn - Function to call with the value (return value is ignored)\n * @returns A function that takes an Option and returns the same Option\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * let seen = 0\n * const input = Option.some(2)\n * const dataFirst = Option.tap(input, (n) => {\n *   seen = n\n * })\n * // => { _tag: \"Some\", value: 2 }\n *\n * const dataLast = Option.tap((n: number) => {\n *   seen = n\n * })(input)\n * // => { _tag: \"Some\", value: 2 }\n * ```\n *\n * @category Sequencing\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types in curried functions */\nexport const tap: OptionTap = dual(2, (option: OptionType<unknown>, fn: (value: unknown) => unknown) => {\n  if (option._tag === \"None\") return option as any\n  const sideEffect = fn(option.value)\n  if (isPromise(sideEffect)) {\n    return Promise.resolve(sideEffect).then(() => option) as any\n  }\n  return option as any\n})\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-type-assertion */\n\n/**\n * Recover from none by providing an alternative Option.\n * If the Option is some, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `orElse(option, fn)`\n * - Data-last: `pipe(option, orElse(fn))`\n *\n * Supports both sync and async functions:\n * - Sync fn: returns Option<T | U>\n * - Async fn: returns Promise<Option<T | U>>\n *\n * @param fn - Function that returns an alternative Option\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.orElse(input, () => Option.some(0))\n * // => { _tag: \"Some\", value: 0 }\n *\n * const dataLast = Option.orElse(() => Option.some(0))(input)\n * // => { _tag: \"Some\", value: 0 }\n * ```\n *\n * @category Combining\n */\n// oxlint-disable-next-line no-explicit-any, no-unsafe-return, no-unsafe-type-assertion -- Required for overloaded return types\nexport const orElse: OptionOrElse = dual(2, (option: OptionType<unknown>, fn: () => unknown) =>\n  option._tag === \"Some\" ? option : fn(),\n)\n\n/**\n * Filter an Option based on a predicate.\n * If the predicate returns false, converts to none.\n * If the Option is already none, it passes through unchanged.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `filter(option, predicate)`\n * - Data-last: `pipe(option, filter(predicate))`\n *\n * @param predicate - Function that returns true to keep the value\n * @returns A function that takes an Option and returns a new Option\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(3)\n * const dataFirst = Option.filter(input, (n) => n > 0)\n * // => { _tag: \"Some\", value: 3 }\n *\n * const dataLast = Option.filter((n: number) => n > 0)(input)\n * // => { _tag: \"Some\", value: 3 }\n * ```\n *\n * @category Filtering\n */\nexport const filter: OptionFilter = dual(2, (option: OptionType<unknown>, predicate: (value: unknown) => boolean) => {\n  if (option._tag === \"None\") return option\n  return predicate(option.value) ? option : none()\n})\n\n// ============================================================================\n// Combinators\n// ============================================================================\n\n/**\n * Combine multiple Options into a single Option.\n * Supports both array and object inputs.\n *\n * - If all Options are some, returns some with all values\n * - If any Option is none, returns none (short-circuits)\n *\n * For arrays of 1-6 elements, tuple types are inferred automatically.\n * For longer arrays, use `as const` to preserve tuple structure.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const combined = Option.all([Option.some(1), Option.some(2)] as const)\n * // => { _tag: \"Some\", value: [1, 2] }\n * ```\n *\n * @category Combining\n */\n/* oxlint-disable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion, no-unsafe-argument -- Required for handling union types in overloaded function */\nexport const all: OptionAll = (options: any): any => {\n  if (Array.isArray(options)) {\n    const values: unknown[] = []\n    for (const option of options) {\n      if (option._tag === \"None\") return option\n      values.push(option.value)\n    }\n    return some(values)\n  }\n\n  const values: Record<string, unknown> = {}\n  for (const [key, option] of Object.entries(options)) {\n    const o = option as OptionType<unknown>\n    if (o._tag === \"None\") return option\n    values[key] = o.value\n  }\n  return some(values)\n}\n/* oxlint-enable no-explicit-any, no-unsafe-return, no-unsafe-member-access, strict-boolean-expressions, no-unsafe-type-assertion */\n\n// ============================================================================\n// Extraction\n// ============================================================================\n\n/**\n * Get the value or a default value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOr(option, defaultValue)`\n * - Data-last: `pipe(option, unwrapOr(defaultValue))`\n *\n * Uses NoInfer to prevent type inference from the default value.\n *\n * @param defaultValue - Value to return if the Option is none\n * @returns A function that takes an Option and returns the value or default\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.unwrapOr(input, 0)\n * // => 0\n *\n * const dataLast = Option.unwrapOr(0)(input)\n * // => 0\n * ```\n *\n * @category Getters\n */\nexport const unwrapOr: OptionUnwrapOr = dual(\n  2,\n  <T>(option: OptionType<T>, defaultValue: NoInfer<T>): T => (option._tag === \"Some\" ? option.value : defaultValue),\n)\n\n/**\n * Get the value or compute a value.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `unwrapOrElse(option, fn)`\n * - Data-last: `pipe(option, unwrapOrElse(fn))`\n *\n * @param fn - Function to compute a value\n * @returns A function that takes an Option and returns the value or computed value\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.none<number>()\n * const dataFirst = Option.unwrapOrElse(input, () => 0)\n * // => 0\n *\n * const dataLast = Option.unwrapOrElse(() => 0)(input)\n * // => 0\n * ```\n *\n * @category Getters\n */\nexport const unwrapOrElse: OptionUnwrapOrElse = dual(\n  2,\n  <T>(option: OptionType<T>, fn: () => T): T => (option._tag === \"Some\" ? option.value : fn()),\n)\n\n/**\n * Pattern match on an Option, handling both some and none cases.\n *\n * Supports both data-first and data-last calling styles:\n * - Data-first: `match(option, { Some: ..., None: ... })`\n * - Data-last: `pipe(option, match({ Some: ..., None: ... }))`\n *\n * @param handlers - Object with `Some` and `None` handlers\n * @returns A function that takes an Option and returns the handler result\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const input = Option.some(2)\n * const dataFirst = Option.match(input, {\n *   Some: (value) => `some:${value}` ,\n *   None: () => \"none\" ,\n * })\n * // => \"some:2\"\n *\n * const dataLast = Option.match({\n *   Some: (value: number) => `some:${value}` ,\n *   None: () => \"none\" ,\n * })(input)\n * // => \"some:2\"\n * ```\n *\n * @category Pattern Matching\n */\nexport const match: OptionMatch = dual(\n  2,\n  <T, U>(option: OptionType<T>, handlers: { Some: (value: T) => U; None: () => U }): U =>\n    option._tag === \"Some\" ? handlers.Some(option.value) : handlers.None(),\n)\n\n// ============================================================================\n// Conversions\n// ============================================================================\n\n/**\n * Convert a nullable value to an Option.\n * `null` and `undefined` become `Option.none()`, other values become `Option.some(value)`.\n * The return type narrows to `Option<NonNullable<T>>`.\n *\n * @param value - The value to convert\n * @returns An Option\n *\n * @example\n * ```ts\n * fromNullable(42) // { _tag: \"Some\", value: 42 }\n * fromNullable(null) // { _tag: \"None\" }\n * fromNullable(undefined) // { _tag: \"None\" }\n *\n * const maybeName = \"Alice\" as string | undefined\n * const option = fromNullable(maybeName) // Option<string>\n * ```\n */\nconst isNonNullable = <T>(value: T): value is NonNullable<T> => value !== null && value !== undefined\n\n/**\n * fromNullable utility.\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const value = Option.fromNullable(\"Ada\")\n * // => { _tag: \"Some\", value: \"Ada\" }\n * ```\n *\n * @category Conversions\n */\nexport const fromNullable = <T>(value: T): OptionType<NonNullable<T>> => (isNonNullable(value) ? some(value) : none())\n\n/**\n * Wrap a function that might throw into an Option.\n * Supports both sync and async functions with automatic type inference.\n *\n * - Sync fn: returns Option<T>\n * - Async fn: returns Promise<Option<T>>\n *\n * **Note on `any` return types:** If your function returns `any` (e.g., `JSON.parse`),\n * you should add an explicit return type annotation. This is because TypeScript's\n * conditional types cannot determine if `any` is a Promise or not, resulting in a\n * union type `Promise<Option<unknown>> | Option<any>` that won't work\n * with Option utilities like `isSome` or `isNone`.\n *\n * @param fn - Function that might throw (sync or async)\n * @returns An Option with the return value or none\n *\n * @example\n * ```ts\n * import { Option } from \"@nicolastoulemont/std\"\n *\n * const parsed = Option.fromTry(() => Number.parseInt(\"42\", 10))\n * // => { _tag: \"Some\", value: 42 }\n * ```\n *\n * @category Conversions\n */\n/* oxlint-disable no-explicit-any, no-unsafe-type-assertion -- Required for conditional return type */\nexport const fromTry = <T>(fn: () => T): FromTryReturn<T> => {\n  try {\n    const result = fn()\n    if (isPromise(result)) {\n      return Promise.resolve(result)\n        .then(some)\n        .catch(() => none()) as unknown as FromTryReturn<T>\n    }\n    return some(result) as unknown as FromTryReturn<T>\n  } catch {\n    return none() as unknown as FromTryReturn<T>\n  }\n}\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"qeA4DA,MAAa,EAAqBA,EAoDrB,EAAW,IAA6B,CACnD,KAAM,OACN,SACC,GAAW,CACV,OAAU,EACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,KAAM,EAEN,EAAE,OAAO,WAAuD,CAC9D,OAAO,GAEV,EAiBY,OAAwC,CACnD,KAAM,QACL,GAAW,CACV,OAAU,IAAA,GACV,OAAU,IAAA,GACV,OAAU,IAAA,GACX,CACD,KAAM,EACN,EAAE,OAAO,WAA2D,CAElE,MADA,MAAM,IAAI,EACA,MAAM,iEAAiE,EAEpF,EAsBY,EAAa,GACxB,EAAO,OAAS,OAeL,EAAa,GACxB,EAAO,OAAS,OAoCL,EAAiB,EAAK,GAAI,EAA6B,IAAoC,CACtG,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,IAAM,EAAS,EAAG,EAAO,MAAM,CAI/B,OAHI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAAC,KAAK,EAAK,CAEpC,EAAK,EAAO,EACnB,CAiCW,EAAyB,EAAK,GAAI,EAA6B,IAC1E,EAAO,OAAS,OAAS,EAAG,EAAO,MAAM,CAAG,EAC7C,CAsCY,EAAiB,EAAK,GAAI,EAA6B,IAAoC,CACtG,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,IAAM,EAAa,EAAG,EAAO,MAAM,CAInC,OAHI,EAAU,EAAW,CAChB,QAAQ,QAAQ,EAAW,CAAC,SAAW,EAAO,CAEhD,GACP,CAiCW,EAAuB,EAAK,GAAI,EAA6B,IACxE,EAAO,OAAS,OAAS,EAAS,GAAI,CACvC,CA4BY,EAAuB,EAAK,GAAI,EAA6B,IACpE,EAAO,OAAS,QACb,EAAU,EAAO,MAAM,CADK,EACO,GAAM,CAChD,CA2BW,EAAkB,GAAsB,CACnD,GAAI,MAAM,QAAQ,EAAQ,CAAE,CAC1B,IAAMC,EAAoB,EAAE,CAC5B,IAAK,IAAM,KAAU,EAAS,CAC5B,GAAI,EAAO,OAAS,OAAQ,OAAO,EACnC,EAAO,KAAK,EAAO,MAAM,CAE3B,OAAO,EAAKA,EAAO,CAGrB,IAAM,EAAkC,EAAE,CAC1C,IAAK,GAAM,CAAC,EAAK,KAAW,OAAO,QAAQ,EAAQ,CAAE,CACnD,IAAM,EAAI,EACV,GAAI,EAAE,OAAS,OAAQ,OAAO,EAC9B,EAAO,GAAO,EAAE,MAElB,OAAO,EAAK,EAAO,EAkCR,EAA2B,EACtC,GACI,EAAuB,IAAiC,EAAO,OAAS,OAAS,EAAO,MAAQ,EACrG,CA0BY,EAAmC,EAC9C,GACI,EAAuB,IAAoB,EAAO,OAAS,OAAS,EAAO,MAAQ,GAAI,CAC5F,CAgCY,EAAqB,EAChC,GACO,EAAuB,IAC5B,EAAO,OAAS,OAAS,EAAS,KAAK,EAAO,MAAM,CAAG,EAAS,MAAM,CACzE,CAwBK,EAAoB,GAAsC,GAAU,KAe7D,EAAmB,GAA0C,EAAc,EAAM,CAAG,EAAK,EAAM,CAAG,GAAM,CA6BxG,EAAc,GAAkC,CAC3D,GAAI,CACF,IAAM,EAAS,GAAI,CAMnB,OALI,EAAU,EAAO,CACZ,QAAQ,QAAQ,EAAO,CAC3B,KAAK,EAAK,CACV,UAAY,GAAM,CAAC,CAEjB,EAAK,EAAO,MACb,CACN,OAAO,GAAM"}

package/dist/order-D5c4QChk.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./chunk-C934ptG5.mjs";import{t}from"./dual-CZhzZslG.mjs";var n=e({alwaysEqual:()=>l,array:()=>_,between:()=>E,bigint:()=>s,boolean:()=>o,by:()=>d,clamp:()=>T,date:()=>c,greaterThan:()=>x,greaterThanOrEqual:()=>S,lessThan:()=>y,lessThanOrEqual:()=>b,make:()=>r,max:()=>w,merge:()=>h,min:()=>C,number:()=>a,reverse:()=>u,sort:()=>D,sortBy:()=>k,sortWith:()=>O,string:()=>i,struct:()=>v,tuple:()=>g});function r(e){return(t,n)=>t===n?0:e(t,n)}const i=r((e,t)=>e<t?-1:1),a=r((e,t)=>Number.isNaN(e)&&Number.isNaN(t)?0:Number.isNaN(e)?-1:Number.isNaN(t)?1:e<t?-1:1),o=r((e,t)=>e<t?-1:1),s=r((e,t)=>e<t?-1:1),c=r((e,t)=>a(e.getTime(),t.getTime()));function l(){return r(()=>0)}function u(e){return r((t,n)=>e(n,t))}const d=t(2,(e,t)=>r((n,r)=>e(t(n),t(r)))),f=(e,t)=>r((n,r)=>{let i=e(n,r);return i===0?t(n,r):i}),p=e=>{let t=Array.from(e);return t.length===0?l():t.length===1?t[0]:r((e,n)=>{for(let r of t){let t=r(e,n);if(t!==0)return t}return 0})};function m(e,t){if(t!==void 0){if(typeof e!=`function`)throw TypeError(`Order.merge(self, that) requires two order functions`);return f(e,t)}return typeof e==`function`?t=>f(t,e):p(e)}const h=m;function g(e){return r((t,n)=>{for(let r=0;r<e.length;r++){let i=e[r],a=i(t[r],n[r]);if(a!==0)return a}return 0})}function _(e){return r((t,n)=>{let r=Math.min(t.length,n.length);for(let i=0;i<r;i++){let r=e(t[i],n[i]);if(r!==0)return r}return a(t.length,n.length)})}function v(e){let t=Object.keys(e);return r((n,r)=>{for(let i of t){let t=e[i](n[i],r[i]);if(t!==0)return t}return 0})}const y=e=>t(2,(t,n)=>e(t,n)===-1),b=e=>t(2,(t,n)=>e(t,n)!==1),x=e=>t(2,(t,n)=>e(t,n)===1),S=e=>t(2,(t,n)=>e(t,n)!==-1),C=e=>t(2,(t,n)=>t===n||e(t,n)<1?t:n),w=e=>t(2,(t,n)=>t===n||e(t,n)>-1?t:n),T=e=>t(2,(t,n)=>C(e)(n.maximum,w(e)(n.minimum,t))),E=e=>t(2,(t,n)=>!y(e)(t,n.minimum)&&!x(e)(t,n.maximum)),D=t(2,(e,t)=>{let n=Array.from(e);return n.sort((e,n)=>t(e,n)),n}),O=t(3,(e,t,n)=>{let r=Array.from(e,e=>[e,t(e)]);return r.sort(([,e],[,t])=>n(e,t)),r.map(([e])=>e)}),k=(...e)=>{if(e.length===0)return e=>Array.from(e);let t=h(e);return e=>D(e,t)};export{n as t};
-//# sourceMappingURL=order-D5c4QChk.mjs.map

package/dist/order-D5c4QChk.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"order-D5c4QChk.mjs","names":[],"sources":["../src/order/order.ts"],"sourcesContent":["/**\n * Ordering combinators and instances for deterministic sorting and comparisons.\n *\n * **Mental model**\n * - `Order<A>` compares two values and returns `-1 | 0 | 1`.\n * - Compose reusable comparators with `by`, `merge`, and `reverse`.\n *\n * **Common tasks**\n * - Use built-ins like `Order.number`, `Order.string`, `Order.date`.\n * - Build custom orders with `Order.make`, `Order.by`, `Order.struct`.\n * - Sort with `Order.sort`, `Order.sortWith`, `Order.sortBy`.\n *\n * **Gotchas**\n * - Orders should be total and stable for predictable sorting.\n * - `Order.merge` uses lexicographic tie-breaking.\n *\n * **Quickstart**\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byAge = Order.by(Order.number, (user: { age: number }) => user.age)\n * const sorted = Order.sort([{ age: 2 }, { age: 1 }], byAge)\n * ```\n *\n * @module\n */\nimport { dual } from \"../shared/dual\"\nimport type { Order as OrderType, OrderBounds, Ordering as OrderingType } from \"./order.types\"\n\n/**\n * Re-exported `Order` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Order<unknown>\n * ```\n *\n * @category Re-exports\n */\nexport type Order<A> = OrderType<A>\n\n/**\n * Re-exported `Ordering` type.\n *\n * @example\n * ```ts\n * import type { Order } from \"@nicolastoulemont/std\"\n *\n * type Example = Order.Ordering\n * ```\n *\n * @category Re-exports\n */\nexport type Ordering = OrderingType\n\n/**\n * Create an `Order` from a comparison function.\n *\n * The created order short-circuits identical references (`===`) to `0`.\n *\n * @param compare - Comparison function returning `-1 | 0 | 1`\n * @returns An order function\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const byLength = Order.make<string>((self, that) =>\n *   self.length < that.length ? -1 : self.length > that.length ? 1 : 0,\n * )\n * const result = byLength(\"a\", \"bbb\")\n * // => -1\n * ```\n *\n * @category Constructors\n */\nexport function make<A>(compare: (self: A, that: A) => Ordering): OrderType<A> {\n  return (self, that) => (self === that ? 0 : compare(self, that))\n}\n\n/**\n * `Order` instance for strings (lexicographic, case-sensitive).\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.string(\"a\", \"b\")\n * // => -1\n * ```\n *\n * @category Instances\n */\nexport const string: OrderType<string> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for numbers.\n *\n * - `NaN` equals `NaN`\n * - `NaN` is less than any non-`NaN`\n * - `0` equals `-0`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.number(1, 2)\n * // => -1\n * ```\n *\n * @category Instances\n */\nexport const number: OrderType<number> = make((self, that) => {\n  if (Number.isNaN(self) && Number.isNaN(that)) return 0\n  if (Number.isNaN(self)) return -1\n  if (Number.isNaN(that)) return 1\n  return self < that ? -1 : 1\n})\n\n/**\n * `Order` instance for booleans where `false < true`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.boolean(false, true)\n * // => -1\n * ```\n *\n * @category Instances\n */\nexport const boolean: OrderType<boolean> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for bigints.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.bigint(1n, 2n)\n * // => -1\n * ```\n *\n * @category Instances\n */\nexport const bigint: OrderType<bigint> = make((self, that) => (self < that ? -1 : 1))\n\n/**\n * `Order` instance for dates based on `getTime()`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.date(new Date(\"2024-01-01\"), new Date(\"2024-01-02\"))\n * // => -1\n * ```\n *\n * @category Instances\n */\nexport const date: OrderType<Date> = make((self, that) => number(self.getTime(), that.getTime()))\n\n/**\n * Create an order that treats all values as equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.alwaysEqual<number>()\n * const result = compare(1, 2)\n * // => 0\n * ```\n *\n * @category Constructors\n */\nexport function alwaysEqual<A>(): OrderType<A> {\n  return make(() => 0)\n}\n\n/**\n * Reverse an existing order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const desc = Order.reverse(Order.number)\n * const result = desc(1, 2)\n * // => 1\n * ```\n *\n * @category Combinators\n */\nexport function reverse<A>(order: OrderType<A>): OrderType<A> {\n  return make((self, that) => order(that, self))\n}\n\n/**\n * Map inputs before comparison.\n *\n * Supports data-first and data-last styles:\n * - `by(order, project)`\n * - `pipe(order, by(project))`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { age: number }\n * const dataFirst = Order.by(Order.number, (user: User) => user.age)\n * const compareFirst = dataFirst({ age: 1 }, { age: 2 })\n * // => -1\n *\n * const dataLast = Order.by((user: User) => user.age)(Order.number)\n * const compareLast = dataLast({ age: 1 }, { age: 2 })\n * // => -1\n * ```\n *\n * @category Combinators\n */\nexport const by: {\n  <B, A>(project: (value: B) => A): (order: OrderType<A>) => OrderType<B>\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B>\n} = dual(\n  2,\n  <A, B>(order: OrderType<A>, project: (value: B) => A): OrderType<B> =>\n    make((self, that) => order(project(self), project(that))),\n)\n\nconst mergeBinary = <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A> =>\n  make((a, b) => {\n    const result = self(a, b)\n    if (result !== 0) return result\n    return that(a, b)\n  })\n\nconst mergeAll = <A>(orders: Iterable<OrderType<A>>): OrderType<A> => {\n  const all = Array.from(orders)\n  if (all.length === 0) return alwaysEqual()\n  if (all.length === 1) return all[0]!\n\n  return make((a, b) => {\n    for (const order of all) {\n      const result = order(a, b)\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\nfunction mergeOverload<A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\nfunction mergeOverload<A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\nfunction mergeOverload<A>(orders: Iterable<OrderType<A>>): OrderType<A>\nfunction mergeOverload<A>(\n  selfOrThatOrOrders: OrderType<A> | Iterable<OrderType<A>>,\n  that?: OrderType<A>,\n): ((self: OrderType<A>) => OrderType<A>) | OrderType<A> {\n  if (that !== undefined) {\n    if (typeof selfOrThatOrOrders !== \"function\") {\n      throw new TypeError(\"Order.merge(self, that) requires two order functions\")\n    }\n    return mergeBinary(selfOrThatOrOrders, that)\n  }\n\n  if (typeof selfOrThatOrOrders === \"function\") {\n    return (self: OrderType<A>) => mergeBinary(self, selfOrThatOrOrders)\n  }\n\n  return mergeAll(selfOrThatOrOrders)\n}\n\n/**\n * Merge orders lexicographically.\n *\n * Supports three forms:\n * - `merge(self, that)`\n * - `merge(that)(self)`\n * - `merge([order1, order2, ...])`\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * type User = { first: string; last: string }\n * const byLast = Order.by(Order.string, (user: User) => user.last)\n * const byFirst = Order.by(Order.string, (user: User) => user.first)\n * const compare = Order.merge([byLast, byFirst])({ first: \"Ada\", last: \"Lovelace\" }, { first: \"Alan\", last: \"Turing\" })\n * // => -1\n * ```\n *\n * @category Combining\n */\nexport const merge: {\n  <A>(that: OrderType<A>): (self: OrderType<A>) => OrderType<A>\n  <A>(self: OrderType<A>, that: OrderType<A>): OrderType<A>\n  <A>(orders: Iterable<OrderType<A>>): OrderType<A>\n} = mergeOverload\n\n/**\n * Create an order for tuples, compared left-to-right.\n */\ntype TupleOrders<Elements extends ReadonlyArray<unknown>> = {\n  readonly [K in keyof Elements]: OrderType<Elements[K]>\n}\n\n/**\n * tuple utility.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.tuple([Order.string, Order.number] as const)([\"a\", 1], [\"a\", 2])\n * // => -1\n * ```\n *\n * @category Constructors\n */\nexport function tuple<const Elements extends ReadonlyArray<unknown>>(\n  orders: TupleOrders<Elements>,\n): OrderType<Elements> {\n  return make((self, that) => {\n    for (let i = 0; i < orders.length; i++) {\n      const order = orders[i]!\n      const result = order(self[i], that[i])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Create an order for arrays.\n *\n * Arrays are compared element-by-element, then by length when all compared\n * elements are equal.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.array(Order.number)([1, 2], [1, 3])\n * // => -1\n * ```\n *\n * @category Constructors\n */\nexport function array<A>(order: OrderType<A>): OrderType<readonly A[]> {\n  return make((self, that) => {\n    const minLength = Math.min(self.length, that.length)\n    for (let i = 0; i < minLength; i++) {\n      const result = order(self[i]!, that[i]!)\n      if (result !== 0) return result\n    }\n    return number(self.length, that.length)\n  })\n}\n\n/**\n * Create an order for objects by key order in `fields`.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const compare = Order.struct<{ id: number; name: string }>({\n *   id: Order.number,\n *   name: Order.string,\n * })({ id: 1, name: \"a\" }, { id: 1, name: \"b\" })\n * // => -1\n * ```\n *\n * @category Constructors\n */\nexport function struct<const R extends Record<string, unknown>>(fields: {\n  readonly [K in keyof R]: OrderType<R[K]>\n}): OrderType<R> {\n  const keys = Object.keys(fields) as Array<keyof R>\n\n  return make((self, that) => {\n    for (const key of keys) {\n      const result = fields[key](self[key], that[key])\n      if (result !== 0) return result\n    }\n    return 0\n  })\n}\n\n/**\n * Test strict less-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThan(Order.number)(1, 2)\n * // => true\n * ```\n *\n * @category Predicates\n */\nexport const lessThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === -1)\n\n/**\n * Test less-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.lessThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n *\n * @category Predicates\n */\nexport const lessThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== 1)\n\n/**\n * Test strict greater-than using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThan(Order.number)(3, 2)\n * // => true\n * ```\n *\n * @category Predicates\n */\nexport const greaterThan = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) === 1)\n\n/**\n * Test greater-than-or-equal using an order.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const result = Order.greaterThanOrEqual(Order.number)(2, 2)\n * // => true\n * ```\n *\n * @category Predicates\n */\nexport const greaterThanOrEqual = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => boolean\n  (self: A, that: A): boolean\n} => dual(2, (self: A, that: A) => order(self, that) !== -1)\n\n/**\n * Get the minimum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.min(Order.number)(3, 5)\n * // => 3\n * ```\n *\n * @category Combinators\n */\nexport const min = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) < 1 ? self : that))\n\n/**\n * Get the maximum of two values.\n *\n * If equal, returns the first argument.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.max(Order.number)(3, 5)\n * // => 5\n * ```\n *\n * @category Combinators\n */\nexport const max = <A>(\n  order: OrderType<A>,\n): {\n  (that: A): (self: A) => A\n  (self: A, that: A): A\n} => dual(2, (self: A, that: A) => (self === that || order(self, that) > -1 ? self : that))\n\n/**\n * Clamp a value to inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const value = Order.clamp(Order.number)(7, { minimum: 0, maximum: 5 })\n * // => 5\n * ```\n *\n * @category Combinators\n */\nexport const clamp = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => A\n  (self: A, bounds: OrderBounds<A>): A\n} => dual(2, (self: A, bounds: OrderBounds<A>): A => min(order)(bounds.maximum, max(order)(bounds.minimum, self)))\n\n/**\n * Check whether a value is within inclusive bounds.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const isBetween = Order.between(Order.number)(3, { minimum: 0, maximum: 5 })\n * // => true\n * ```\n *\n * @category Predicates\n */\nexport const between = <A>(\n  order: OrderType<A>,\n): {\n  (bounds: OrderBounds<A>): (self: A) => boolean\n  (self: A, bounds: OrderBounds<A>): boolean\n} =>\n  dual(\n    2,\n    (self: A, bounds: OrderBounds<A>): boolean =>\n      !lessThan(order)(self, bounds.minimum) && !greaterThan(order)(self, bounds.maximum),\n  )\n\n/**\n * Sort an iterable by an order, returning a new array.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const values = [3, 1, 2]\n * const dataFirst = Order.sort(values, Order.number)\n * // => [1, 2, 3]\n *\n * const dataLast = Order.sort(Order.number)(values)\n * // => [1, 2, 3]\n * ```\n *\n * @category Utilities\n */\nexport const sort: {\n  <B>(order: OrderType<B>): <A extends B>(input: Iterable<A>) => A[]\n  <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[]\n} = dual(2, <A extends B, B>(input: Iterable<A>, order: OrderType<B>): A[] => {\n  const output = Array.from(input)\n  output.sort((self, that) => order(self, that))\n  return output\n})\n\n/**\n * Sort an iterable by a projected value.\n *\n * Supports data-first and data-last styles.\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2 }, { age: 1 }]\n * const dataFirst = Order.sortWith(users, (user) => user.age, Order.number)\n * // => [{ age: 1 }, { age: 2 }]\n *\n * const dataLast = Order.sortWith((user: { age: number }) => user.age, Order.number)(users)\n * // => [{ age: 1 }, { age: 2 }]\n * ```\n *\n * @category Utilities\n */\nexport const sortWith: {\n  <A, B>(project: (value: A) => B, order: OrderType<B>): (input: Iterable<A>) => A[]\n  <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[]\n} = dual(3, <A, B>(input: Iterable<A>, project: (value: A) => B, order: OrderType<B>): A[] => {\n  const output = Array.from(input, (value) => [value, project(value)] as const)\n  output.sort(([, a], [, b]) => order(a, b))\n  return output.map(([value]) => value)\n})\n\n/**\n * Sort an iterable by multiple orders, in sequence.\n *\n * - first order has highest priority\n * - ties are broken by subsequent orders\n * - no orders returns a shallow copy preserving iteration order\n *\n * @example\n * ```ts\n * import { Order } from \"@nicolastoulemont/std\"\n *\n * const users = [{ age: 2, name: \"b\" }, { age: 1, name: \"a\" }]\n * const sorted = Order.sortBy(Order.by(Order.number, (user: { age: number; name: string }) => user.age))(users)\n * // => [{ age: 1, name: \"a\" }, { age: 2, name: \"b\" }]\n * ```\n *\n * @category Utilities\n */\nexport const sortBy = <A>(...orders: readonly OrderType<A>[]) => {\n  if (orders.length === 0) {\n    return (input: Iterable<A>): A[] => Array.from(input)\n  }\n\n  const merged = merge(orders)\n  return (input: Iterable<A>): A[] => sort(input, merged)\n}\n"],"mappings":"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"}

package/dist/pipeable-COGyGMUV.mjs

@@ -1,2 +0,0 @@
-import{t as e}from"./flow-D8_tllWl.mjs";function t(...t){return t.length===0?this:e(...t)(this)}export{t};
-//# sourceMappingURL=pipeable-COGyGMUV.mjs.map

package/dist/predicate-DUhhQqWY.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"predicate-DUhhQqWY.mjs","names":[],"sources":["../src/predicate/predicate.ts"],"sourcesContent":["import type { Predicate as PredicateType, Refinement } from \"./predicate.types\"\n\n/**\n * Negate a predicate.\n * Returns true when the original predicate returns false, and vice versa.\n *\n * @template T - The type being tested\n * @param predicate - The predicate to negate\n * @returns A new predicate that returns the opposite boolean\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isOdd = Predicate.not((n: number) => n % 2 === 0)\n * const result = isOdd(3)\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const not = <T>(predicate: PredicateType<T>): PredicateType<T> => {\n  return (value: T): boolean => !predicate(value)\n}\n\n/**\n * Combine predicates with logical AND.\n * Returns true only when ALL predicates return true.\n * Short-circuits on first false (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if all predicates pass\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isPositiveEven = Predicate.and<number>((n) => n > 0, (n) => n % 2 === 0)\n * const result = isPositiveEven(4)\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const and = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (!predicate(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine predicates with logical OR.\n * Returns true when ANY predicate returns true.\n * Short-circuits on first true (lazy evaluation).\n *\n * @template T - The type being tested\n * @param predicates - The predicates to combine\n * @returns A new predicate that returns true if any predicate passes\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isWeekend = Predicate.or<string>((day) => day === \"sat\", (day) => day === \"sun\")\n * const result = isWeekend(\"sun\")\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const or = <T>(...predicates: readonly PredicateType<T>[]): PredicateType<T> => {\n  return (value: T): boolean => {\n    for (const predicate of predicates) {\n      if (predicate(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate that tests if ALL elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if all match\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const allPositive = Predicate.all((n: number) => n > 0)\n * const result = allPositive([1, 2, 3])\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const all = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.every(predicate)\n}\n\n/**\n * Create a predicate that tests if ANY element in an array matches.\n * Returns false for empty arrays.\n *\n * @template T - The element type\n * @param predicate - The predicate to test each element\n * @returns A predicate that takes an array and returns true if any match\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const someNegative = Predicate.some((n: number) => n < 0)\n * const result = someNegative([1, -1, 3])\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const some = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => arr.some(predicate)\n}\n\n/**\n * Create a predicate that tests if NO elements in an array match.\n * Returns true for empty arrays (vacuous truth).\n * Equivalent to `not(some(predicate))`.\n *\n * @template T - The element type\n * @param predicate - The predicate that should NOT match any element\n * @returns A predicate that takes an array and returns true if none match\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const noneZero = Predicate.none((n: number) => n === 0)\n * const result = noneZero([1, 2, 3])\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const none = <T>(predicate: PredicateType<T>): PredicateType<readonly T[]> => {\n  return (arr: readonly T[]): boolean => !arr.some(predicate)\n}\n\n/**\n * Combine refinements with logical AND, preserving type narrowing.\n * Use this instead of `and` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if all refinements pass\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isString = (value: unknown): value is string => typeof value === \"string\"\n * const isNonEmpty = (value: unknown): value is string => typeof value === \"string\" && value.length > 0\n * const refine = Predicate.andRefinement(isString, isNonEmpty)\n * const result = refine(\"hello\")\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const andRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (!refinement(value)) return false\n    }\n    return true\n  }\n}\n\n/**\n * Combine refinements with logical OR, preserving type narrowing.\n * Use this instead of `or` when you need to preserve type guard behavior.\n *\n * @template T - The base type\n * @template U - The narrowed type (must extend T)\n * @param refinements - The refinements to combine\n * @returns A refinement that narrows to U if any refinement passes\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isGuest = (value: unknown): value is string => value === \"guest\"\n * const isAdmin = (value: unknown): value is string => value === \"admin\"\n * const refine = Predicate.orRefinement(isGuest, isAdmin)\n * const result = refine(\"admin\")\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const orRefinement = <T, U extends T>(...refinements: readonly Refinement<T, U>[]): Refinement<T, U> => {\n  return (value: T): value is U => {\n    for (const refinement of refinements) {\n      if (refinement(value)) return true\n    }\n    return false\n  }\n}\n\n/**\n * Create a predicate from a constant boolean value.\n * Useful for testing or as a placeholder.\n *\n * @template T - The type (can be anything)\n * @param value - The constant boolean to return\n * @returns A predicate that always returns the given value\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const always = Predicate.constant<number>(true)\n * const result = always(123)\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const constant = <T>(value: boolean): PredicateType<T> => {\n  return (): boolean => value\n}\n\n/**\n * Create a predicate that checks strict equality.\n *\n * @template T - The type being compared\n * @param expected - The value to compare against\n * @returns A predicate that returns true if value === expected\n *\n * @example\n * ```ts\n * import { Predicate } from \"@nicolastoulemont/std\"\n *\n * const isReady = Predicate.equals(\"ready\")\n * const result = isReady(\"ready\")\n * // => true\n * ```\n *\n * @category Utilities\n */\nexport const equals = <T>(expected: T): PredicateType<T> => {\n  return (value: T): boolean => value === expected\n}\n"],"mappings":"oLAqBA,MAAa,EAAU,GACb,GAAsB,CAAC,EAAU,EAAM,CAuBpC,GAAU,GAAG,IAChB,GAAsB,CAC5B,IAAK,IAAM,KAAa,EACtB,GAAI,CAAC,EAAU,EAAM,CAAE,MAAO,GAEhC,MAAO,IAwBE,GAAS,GAAG,IACf,GAAsB,CAC5B,IAAK,IAAM,KAAa,EACtB,GAAI,EAAU,EAAM,CAAE,MAAO,GAE/B,MAAO,IAuBE,EAAU,GACb,GAA+B,EAAI,MAAM,EAAU,CAsBhD,EAAW,GACd,GAA+B,EAAI,KAAK,EAAU,CAuB/C,EAAW,GACd,GAA+B,CAAC,EAAI,KAAK,EAAU,CAyBhD,GAAiC,GAAG,IACvC,GAAyB,CAC/B,IAAK,IAAM,KAAc,EACvB,GAAI,CAAC,EAAW,EAAM,CAAE,MAAO,GAEjC,MAAO,IA0BE,GAAgC,GAAG,IACtC,GAAyB,CAC/B,IAAK,IAAM,KAAc,EACvB,GAAI,EAAW,EAAM,CAAE,MAAO,GAEhC,MAAO,IAuBE,EAAe,OACJ,EAqBX,EAAa,GAChB,GAAsB,IAAU"}

package/dist/provide-BmSM3Ruy.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"provide-BmSM3Ruy.mjs","names":["layer","service","layer","makeScope","fxGen","fxResult","service"],"sources":["../src/provide/memo-map.ts","../src/provide/provide.ts"],"sourcesContent":["import type { Context } from \"../context/context\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { Layer } from \"../layer/layer.types\"\nimport { ok } from \"../result/result\"\nimport type { ScopeService } from \"../scope/scope\"\nimport { asServiceRequest } from \"../service/service-resolution\"\n\n/* oxlint-disable no-unsafe-type-assertion, only-throw-error -- MemoMap bridges erased generic Fx channels and re-emits typed domain errors from generator boundaries. */\n\n// ============================================================================\n// MemoMap\n// ============================================================================\n\ntype AnyLayer = Layer<unknown, unknown, unknown>\n\n/**\n * MemoMap caches built layers so each layer is only built once.\n * Multiple dependents share the same service instance.\n *\n * This implements the \"service singleton\" pattern where a service\n * is instantiated once and shared across all consumers.\n *\n * @example\n * ```ts\n * // Database is built once, shared by DocumentService and TeamService\n * const AppLayer = Layer.merge(\n *   ConfigLive,\n *   LoggerLive,\n *   DatabaseLive,       // Built once\n *   DocumentServiceLive, // Uses shared Database\n *   TeamServiceLive,     // Uses same Database instance\n * )\n * ```\n */\nexport class MemoMap {\n  private cache = new Map<\n    AnyLayer,\n    {\n      promise?: Promise<Context<unknown>>\n      context?: Context<unknown>\n      building?: boolean\n    }\n  >()\n\n  /**\n   * Get a cached context or build the layer if not cached.\n   *\n   * @param layer - The layer to get or build\n   * @param scope - The scope for resource management\n   * @param deps - Context containing the layer's dependencies\n   * @returns A RunnableFx producing the layer's context\n   */\n  getOrBuild<ROut, E, RIn>(\n    layer: Layer<ROut, E, RIn>,\n    scope: ScopeService,\n    deps: Context<RIn>,\n  ): RunnableFx<Context<ROut>, E> {\n    const cached = this.cache.get(layer as AnyLayer)\n\n    // Already built - return cached context\n    if (cached?.context) {\n      return {\n        _tag: \"SyncFx\",\n        [FxTypeId]: {\n          _A: () => cached.context as Context<ROut>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        run: () => ok(cached.context as Context<ROut>),\n        // oxlint-disable-next-line require-yield\n        *[Symbol.iterator](): Generator<FxYield<E, never>, Context<ROut>, unknown> {\n          return cached.context as Context<ROut>\n        },\n      } as SyncFx<Context<ROut>, E>\n    }\n\n    // Building in progress (async) - wait for it\n    if (cached?.promise) {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as Context<ROut>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        run: async () => {\n          const ctx = await cached.promise!\n          return ok(ctx as Context<ROut>)\n        },\n        // oxlint-disable-next-line require-yield\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, never>, Context<ROut>, unknown> {\n          const ctx = await cached.promise!\n          return ctx as Context<ROut>\n        },\n      } as AsyncFx<Context<ROut>, E>\n    }\n\n    // Need to build - mark as building\n    this.cache.set(layer as AnyLayer, { building: true })\n\n    // Build the layer with provided dependencies\n    const buildFx = layer.build(this, scope)\n    const cacheRef = this.cache\n\n    // Determine if async\n    if (buildFx._tag === \"AsyncFx\") {\n      // Create a promise for the build\n      const buildPromise = (async () => {\n        const gen = buildFx[Symbol.asyncIterator]()\n        let result = await gen.next()\n\n        // Resolve service requests from deps\n        while (result.done !== true) {\n          const yielded = result.value\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            // It's an error - rethrow\n            throw yielded\n          }\n          const service = deps._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found during layer build`)\n          }\n          // oxlint-disable-next-line no-await-in-loop\n          result = await gen.next(service)\n        }\n\n        const ctx = result.value\n        cacheRef.set(layer as AnyLayer, { context: ctx })\n        return ctx\n      })()\n\n      this.cache.set(layer as AnyLayer, { promise: buildPromise })\n\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as Context<ROut>,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        run: async () => {\n          try {\n            const ctx = await buildPromise\n            return ok(ctx)\n          } catch (e) {\n            return {\n              ok: false,\n              error: e as E,\n              *[Symbol.iterator]() {\n                yield e as E\n                throw new Error(\"Unreachable\")\n              },\n            }\n          }\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, never>, Context<ROut>, unknown> {\n          try {\n            const ctx = await buildPromise\n            return ctx\n          } catch (e) {\n            yield e as E\n            throw new Error(\"Unreachable\", { cause: e })\n          }\n        },\n      } as AsyncFx<Context<ROut>, E>\n    }\n\n    // Sync build\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as Context<ROut>,\n        _E: () => undefined as unknown as E,\n        _R: () => undefined as never,\n      },\n      run: () => {\n        const gen = buildFx[Symbol.iterator]()\n        let result = gen.next()\n\n        // Resolve service requests from deps\n        while (result.done !== true) {\n          const yielded = result.value\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            // It's an error\n            return {\n              ok: false,\n              error: yielded as E,\n              *[Symbol.iterator]() {\n                yield yielded as E\n                throw new Error(\"Unreachable\")\n              },\n            }\n          }\n          const service = deps._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found during layer build`)\n          }\n          result = gen.next(service)\n        }\n\n        const ctx = result.value\n        cacheRef.set(layer as AnyLayer, { context: ctx })\n        return ok(ctx)\n      },\n      *[Symbol.iterator](): Generator<FxYield<E, never>, Context<ROut>, unknown> {\n        const gen = buildFx[Symbol.iterator]()\n        let result = gen.next()\n\n        // Resolve service requests from deps\n        while (result.done !== true) {\n          const yielded = result.value\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            // It's an error - yield it\n            yield yielded as E\n            throw new Error(\"Unreachable\")\n          }\n          const service = deps._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found during layer build`)\n          }\n          result = gen.next(service)\n        }\n\n        cacheRef.set(layer as AnyLayer, { context: result.value })\n        return result.value\n      },\n    } as SyncFx<Context<ROut>, E>\n  }\n\n  /**\n   * Clear the cache.\n   * Useful for testing.\n   */\n  clear(): void {\n    this.cache.clear()\n  }\n\n  /**\n   * Get the number of cached layers.\n   */\n  get size(): number {\n    return this.cache.size\n  }\n}\n\n/* oxlint-enable no-unsafe-type-assertion, only-throw-error */\n","import type { Context } from \"../context/context\"\nimport { runSync, runAsync } from \"../fx/fx.runtime\"\nimport { FxTypeId } from \"../fx/fx.types\"\nimport type { RunnableFx, SyncFx, AsyncFx, FxYield } from \"../fx/fx.types\"\nimport type { Layer } from \"../layer/layer.types\"\nimport { ok } from \"../result/result\"\nimport { make as makeScope } from \"../scope/scope\"\nimport type { ServiceClass } from \"../service/service\"\nimport { asServiceRequest, resolveService } from \"../service/service-resolution\"\nimport { MemoMap } from \"./memo-map\"\n\n/* oxlint-disable no-unsafe-type-assertion -- layer/service re-thread generic Fx channels through runtime service injection points. */\n\n// ============================================================================\n// Provide Layer\n// ============================================================================\n\n/**\n * Extract the value type from an Fx.\n */\ntype FxValueType<F> = F extends RunnableFx<infer A, unknown, unknown> ? A : never\n\n/**\n * Extract the error type from an Fx.\n */\ntype FxErrorType<F> = F extends RunnableFx<unknown, infer E, unknown> ? E : never\n\n/**\n * Type for the result of provide based on layer sync and fx type.\n * Uses infer to extract A and E from the actual Fx type.\n * - Sync layer + SyncFx → SyncFx\n * - Sync layer + AsyncFx → AsyncFx\n * - Async layer + any fx → AsyncFx\n * - Unknown sync layer + any fx → RunnableFx (fallback)\n */\ntype ProvideResult<\n  E2,\n  LayerSync extends boolean,\n  Fx extends RunnableFx<unknown, unknown, unknown>,\n> = LayerSync extends true\n  ? Fx[\"_tag\"] extends \"SyncFx\"\n    ? SyncFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n    : AsyncFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n  : LayerSync extends false\n    ? AsyncFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n    : RunnableFx<FxValueType<Fx>, FxErrorType<Fx> | E2>\n\n/**\n * Provide a layer to an Fx computation, resolving all service requirements.\n * Creates a new scope for resource management.\n *\n * Type preservation:\n * - Sync layer + SyncFx → SyncFx\n * - Sync layer + AsyncFx → AsyncFx\n * - Async layer + any fx → AsyncFx\n * - Unknown sync layer + any fx → RunnableFx (fallback)\n *\n * @param layer - The layer providing services (must have no external requirements)\n * @returns A function that takes an Fx and returns an Fx with dependencies resolved\n *\n * @example\n * ```ts\n * import { Provide } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Layer, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const portLayer = Layer.ok(Port, 3000)\n * const readPort = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const provided = Provide.layer(portLayer)(readPort)\n * // => Fx with Port dependency resolved\n * ```\n *\n * @category Utilities\n */\nexport function layer<ROut, E2, LayerSync extends boolean>(\n  layer: Layer<ROut, E2, never, LayerSync>,\n): <Fx extends RunnableFx<unknown, unknown, ROut>>(fx: Fx) => ProvideResult<E2, LayerSync, Fx>\nexport function layer<ROut, E2>(layer: Layer<ROut, E2>) {\n  return <A, E, R extends ROut>(fx: RunnableFx<A, E, R>): RunnableFx<A, E | E2> => {\n    // Build mode selection should remain stable for this wrapper,\n    // while actual layer state (scope + memoization) must be per-execution.\n    const layerBuildTag = layer.build(new MemoMap(), makeScope())._tag\n\n    const createRunLayerState = (): {\n      readonly scope: ReturnType<typeof makeScope>\n      readonly layerBuildFx: ReturnType<typeof layer.build>\n    } => {\n      const memoMap = new MemoMap()\n      const scope = makeScope()\n      return {\n        scope,\n        layerBuildFx: layer.build(memoMap, scope),\n      }\n    }\n\n    if (layerBuildTag === \"AsyncFx\" || fx._tag === \"AsyncFx\") {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as A,\n          _E: () => undefined as unknown as E | E2,\n          _R: () => undefined as never,\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E | E2, Exclude<R, ROut>>, A, unknown> {\n          const { scope, layerBuildFx } = createRunLayerState()\n\n          try {\n            // Build the layer\n            let ctx: Context<ROut>\n\n            if (layerBuildFx._tag === \"AsyncFx\") {\n              const gen = layerBuildFx[Symbol.asyncIterator]()\n              let result = await gen.next()\n\n              while (result.done !== true) {\n                yield result.value as E2\n                // oxlint-disable-next-line no-await-in-loop\n                result = await gen.next(undefined)\n              }\n              ctx = result.value\n            } else {\n              const gen = layerBuildFx[Symbol.iterator]()\n              let result = gen.next()\n\n              while (result.done !== true) {\n                yield result.value as E2\n                result = gen.next(undefined)\n              }\n              ctx = result.value\n            }\n\n            // Run the fx with the context\n            if (fx._tag === \"AsyncFx\") {\n              const fxGen = fx[Symbol.asyncIterator]()\n              let fxResult = await fxGen.next()\n\n              while (fxResult.done !== true) {\n                const yielded = fxResult.value\n\n                const service = resolveService(ctx, yielded)\n                if (service !== undefined) {\n                  // oxlint-disable-next-line no-await-in-loop\n                  fxResult = await fxGen.next(service)\n                  continue\n                }\n\n                // Pass through (error or unsatisfied service)\n                const value = yield yielded as FxYield<E, Exclude<R, ROut>>\n                // oxlint-disable-next-line no-await-in-loop\n                fxResult = await fxGen.next(value)\n              }\n\n              return fxResult.value\n            }\n\n            // Sync fx\n            const fxGen = fx[Symbol.iterator]()\n            let fxResult = fxGen.next()\n\n            while (fxResult.done !== true) {\n              const yielded = fxResult.value\n\n              const service = resolveService(ctx, yielded)\n              if (service !== undefined) {\n                fxResult = fxGen.next(service)\n                continue\n              }\n\n              const value = yield yielded as FxYield<E, Exclude<R, ROut>>\n              fxResult = fxGen.next(value)\n            }\n\n            return fxResult.value\n          } finally {\n            const closeResult = scope.close(ok(undefined))\n            if (closeResult._tag === \"AsyncFx\") {\n              await runAsync(closeResult)\n            } else {\n              runSync(closeResult)\n            }\n          }\n        },\n      } as AsyncFx<A, E | E2>\n    }\n\n    // Both sync\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as A,\n        _E: () => undefined as unknown as E | E2,\n        _R: () => undefined as never,\n      },\n      *[Symbol.iterator](): Generator<FxYield<E | E2, Exclude<R, ROut>>, A, unknown> {\n        const { scope, layerBuildFx } = createRunLayerState()\n\n        if (layerBuildFx._tag === \"AsyncFx\") {\n          throw new Error(\n            \"Provide.layer sync execution encountered an async layer build. Ensure async layers are treated as async at composition time.\",\n          )\n        }\n\n        try {\n          // Build the layer\n          const layerGen = layerBuildFx[Symbol.iterator]()\n          let layerResult = layerGen.next()\n\n          while (layerResult.done !== true) {\n            yield layerResult.value as E2\n            layerResult = layerGen.next(undefined)\n          }\n\n          const ctx = layerResult.value\n\n          // Run the fx with the context\n          const fxGen = fx[Symbol.iterator]()\n          let fxResult = fxGen.next()\n\n          while (fxResult.done !== true) {\n            const yielded = fxResult.value\n\n            const service = resolveService(ctx, yielded)\n            if (service !== undefined) {\n              fxResult = fxGen.next(service)\n              continue\n            }\n\n            const value = yield yielded as FxYield<E, Exclude<R, ROut>>\n            fxResult = fxGen.next(value)\n          }\n\n          return fxResult.value\n        } finally {\n          const closeResult = scope.close(ok(undefined))\n          // In sync-only branch, closeResult is always SyncFx\n          runSync(closeResult as SyncFx<void>)\n        }\n      },\n    } as SyncFx<A, E | E2>\n  }\n}\n\n// ============================================================================\n// Provide Context\n// ============================================================================\n\n/**\n * Provide a context directly to an Fx computation.\n *\n * @param ctx - The context containing services\n * @returns A function that takes an Fx and returns an Fx with dependencies resolved\n *\n * @example\n * ```ts\n * import { Provide } from \"@nicolastoulemont/std\"\n *\n * import { Context, Fx, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const ctx = Context.make(Port, 3000)\n * const readPort = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const provided = Provide.context(ctx)(readPort)\n * // => Fx runnable without Port requirement\n * ```\n *\n * @category Utilities\n */\nexport const context =\n  <R>(ctx: Context<R>) =>\n  <A, E>(fx: RunnableFx<A, E, R>): RunnableFx<A, E> => {\n    if (fx._tag === \"AsyncFx\") {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as A,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as never,\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, never>, A, unknown> {\n          const gen = fx[Symbol.asyncIterator]()\n          let result = await gen.next()\n\n          while (result.done !== true) {\n            const yielded = result.value\n\n            const serviceRequest = asServiceRequest(yielded)\n            if (serviceRequest === undefined) {\n              yield yielded as E\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(undefined)\n              continue\n            }\n            const service = ctx._services.get(serviceRequest.key)\n            if (service === undefined) {\n              throw new Error(`Service \"${serviceRequest.key}\" not found`)\n            }\n            // oxlint-disable-next-line no-await-in-loop\n            result = await gen.next(service)\n          }\n\n          return result.value\n        },\n      } as AsyncFx<A, E>\n    }\n\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as A,\n        _E: () => undefined as unknown as E,\n        _R: () => undefined as never,\n      },\n      *[Symbol.iterator](): Generator<FxYield<E, never>, A, unknown> {\n        const gen = fx[Symbol.iterator]()\n        let result = gen.next()\n\n        while (result.done !== true) {\n          const yielded = result.value\n\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest === undefined) {\n            yield yielded as E\n            result = gen.next(undefined)\n            continue\n          }\n          const service = ctx._services.get(serviceRequest.key)\n          if (service === undefined) {\n            throw new Error(`Service \"${serviceRequest.key}\" not found`)\n          }\n          result = gen.next(service)\n        }\n\n        return result.value\n      },\n    } as SyncFx<A, E>\n  }\n\n// ============================================================================\n// Provide Service\n// ============================================================================\n\n/**\n * Provide a single service to an Fx computation.\n *\n * @param service - The service class (tag)\n * @param impl - The service implementation\n * @returns A function that takes an Fx and returns an Fx with the service provided\n *\n * @example\n * ```ts\n * import { Provide } from \"@nicolastoulemont/std\"\n *\n * import { Fx, Service } from \"@nicolastoulemont/std\"\n *\n * const Port = Service.tag<number>(\"Port\")\n * const readPort = Fx.gen(function* () {\n *   return yield* Port\n * })\n * const provided = Provide.service(Port, 3000)(readPort)\n * // => Fx runnable without Port requirement\n * ```\n *\n * @category Utilities\n */\nexport const service =\n  <S>(service: ServiceClass<S>, impl: S) =>\n  <A, E, R>(fx: RunnableFx<A, E, R | S>): RunnableFx<A, E, Exclude<R, S>> => {\n    if (fx._tag === \"AsyncFx\") {\n      return {\n        _tag: \"AsyncFx\",\n        [FxTypeId]: {\n          _A: () => undefined as unknown as A,\n          _E: () => undefined as unknown as E,\n          _R: () => undefined as unknown as Exclude<R, S>,\n        },\n        async *[Symbol.asyncIterator](): AsyncGenerator<FxYield<E, Exclude<R, S>>, A, unknown> {\n          const gen = fx[Symbol.asyncIterator]()\n          let result = await gen.next()\n\n          while (result.done !== true) {\n            const yielded = result.value\n\n            const serviceRequest = asServiceRequest(yielded)\n            if (serviceRequest?.key === service.key) {\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(impl)\n            } else {\n              const value = yield yielded as FxYield<E, Exclude<R, S>>\n              // oxlint-disable-next-line no-await-in-loop\n              result = await gen.next(value)\n            }\n          }\n\n          return result.value\n        },\n      } as AsyncFx<A, E, Exclude<R, S>>\n    }\n\n    return {\n      _tag: \"SyncFx\",\n      [FxTypeId]: {\n        _A: () => undefined as unknown as A,\n        _E: () => undefined as unknown as E,\n        _R: () => undefined as unknown as Exclude<R, S>,\n      },\n      *[Symbol.iterator](): Generator<FxYield<E, Exclude<R, S>>, A, unknown> {\n        const gen = fx[Symbol.iterator]()\n        let result = gen.next()\n\n        while (result.done !== true) {\n          const yielded = result.value\n\n          const serviceRequest = asServiceRequest(yielded)\n          if (serviceRequest?.key === service.key) {\n            result = gen.next(impl)\n          } else {\n            const value = yield yielded as FxYield<E, Exclude<R, S>>\n            result = gen.next(value)\n          }\n        }\n\n        return result.value\n      },\n    } as SyncFx<A, E, Exclude<R, S>>\n  }\n\n/* oxlint-enable no-unsafe-type-assertion */\n"],"mappings":"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"}