@zerothrow/core/dist/index.cjs.map

Core ZeroThrow functionality - Rust-style Result<T,E> for TypeScript

{"version":3,"sources":["../src/core-exports.ts","../src/error.ts","../src/result.ts","../src/combinators.ts","../src/zt-pocket-knife.ts"],"names":["collect","collectAsync","err","firstSuccess","pipe","attempt"],"mappings":";;;;;;;;;AAAA,IAAA,oBAAA,GAAA;AAAA,QAAA,CAAA,oBAAA,EAAA;AAAA,EAAA,SAAA,EAAA,MAAA,SAAA;AAAA,EAAA,OAAA,EAAA,MAAA,OAAA;AAAA,EAAA,OAAA,EAAA,MAAAA,QAAAA;AAAA,EAAA,YAAA,EAAA,MAAAC,aAAAA;AAAA,EAAA,OAAA,EAAA,MAAA,OAAA;AAAA,EAAA,GAAA,EAAA,MAAAC,IAAAA;AAAA,EAAA,YAAA,EAAA,MAAAC,aAAAA;AAAA,EAAA,SAAA,EAAA,MAAA,SAAA;AAAA,EAAA,KAAA,EAAA,MAAA,KAAA;AAAA,EAAA,IAAA,EAAA,MAAA,IAAA;AAAA,EAAA,QAAA,EAAA,MAAA,QAAA;AAAA,EAAA,EAAA,EAAA,MAAA,EAAA;AAAA,EAAA,IAAA,EAAA,MAAAC,KAAAA;AAAA,EAAA,GAAA,EAAA,MAAA,OAAA;AAAA,EAAA,QAAA,EAAA,MAAA,QAAA;AAAA,EAAA,IAAA,EAAA,MAAA;AAAA,CAAA,CAAA;;;ACYO,IAAM,SAAA,GAAN,MAAM,UAAA,SAAyD,KAAA,CAAM;AAAA,EACjE,IAAA;AAAA,EACA,OAAA;AAAA,EAET,WAAA,CACE,IAAA,EACA,OAAA,EACA,IAAA,GAAuC,EAAC,EACxC;AACA,IAAA,KAAA,CAAM,OAAA,EAAS,EAAE,KAAA,EAAO,IAAA,CAAK,OAAO,CAAA;AACpC,IAAA,IAAA,CAAK,IAAA,GAAO,IAAA;AACZ,IAAA,IAAA,CAAK,UAAU,IAAA,CAAK,OAAA;AACpB,IAAA,IAAA,CAAK,IAAA,GAAO,WAAA;AACZ,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,EAAM,GAAA,CAAA,MAAA,CAAW,SAAS,CAAA;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA,EAKS,QAAA,GAAmB;AAC1B,IAAA,IAAI,MAAA,GAAS,CAAA,EAAG,IAAA,CAAK,IAAI,CAAA,EAAA,EAAK,MAAA,CAAO,IAAA,CAAK,IAAI,CAAC,CAAA,GAAA,EAAM,IAAA,CAAK,OAAO,CAAA,CAAA;AAGjE,IAAA,IAAI,IAAA,CAAK,WAAW,MAAA,CAAO,IAAA,CAAK,KAAK,OAAO,CAAA,CAAE,SAAS,CAAA,EAAG;AACxD,MAAA,MAAA,IAAU;AAAA,WAAA,EAAgB,IAAA,CAAK,SAAA,CAAU,IAAA,CAAK,OAAA,EAAS,IAAA,EAAM,CAAC,CAAA,CAAE,OAAA,CAAQ,KAAA,EAAO,MAAM,CAAC,CAAA,CAAA;AAAA,IACxF;AAGA,IAAA,IAAI,eAAe,IAAA,CAAK,KAAA;AACxB,IAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,IAAA,OAAO,wBAAwB,KAAA,EAAO;AACpC,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAChC,MAAA,MAAM,SAAA,GAAY,aAAa,IAAA,IAAQ,OAAA;AACvC,MAAA,MAAA,IAAU;AAAA,EAAK,MAAM,CAAA,WAAA,EAAc,SAAS,CAAA,EAAA,EAAK,aAAa,OAAO,CAAA,CAAA;AAGrE,MAAA,IAAI,YAAA,YAAwB,UAAA,IAAa,YAAA,CAAa,OAAA,EAAS;AAC7D,QAAA,MAAM,aAAa,IAAA,CAAK,SAAA;AAAA,UACtB,YAAA,CAAa,OAAA;AAAA,UACb,IAAA;AAAA,UACA;AAAA,SACF,CAAE,QAAQ,KAAA,EAAO;AAAA,EAAK,MAAM,CAAA,EAAA,CAAI,CAAA;AAChC,QAAA,MAAA,IAAU;AAAA,EAAK,MAAM,cAAc,UAAU,CAAA,CAAA;AAAA,MAC/C;AAEA,MAAA,YAAA,GAAe,YAAA,CAAa,KAAA;AAC5B,MAAA,KAAA,EAAA;AAAA,IACF;AAEA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,YAAA,GAAuB;AACrB,IAAA,IAAI,SAAA,GAAY,KAAK,KAAA,IAAS,EAAA;AAE9B,IAAA,IAAI,eAAe,IAAA,CAAK,KAAA;AACxB,IAAA,OAAO,wBAAwB,KAAA,EAAO;AACpC,MAAA,SAAA,IACE,kBAAA,IAAsB,YAAA,CAAa,KAAA,IAAS,YAAA,CAAa,QAAA,EAAS,CAAA;AACpE,MAAA,YAAA,GAAe,YAAA,CAAa,KAAA;AAAA,IAC9B;AAEA,IAAA,OAAO,SAAA;AAAA,EACT;AACF;;;ACfA,SAAS,aAAiC,IAAA,EAAoC;AAC5E,EAAA,MAAM,MAAA,GAAS,IAAA;AAEf,EAAA,MAAA,CAAO,OAAA,GAAU,SAAY,EAAA,EAA8C;AACzE,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,OAAO,YAAA,CAAa,EAAE,EAAA,EAAI,KAAA,EAAO,KAAA,EAAO,MAAA,CAAO,KAAA,EAAiB,CAAA;AAChF,IAAA,OAAO,EAAA,CAAG,OAAO,KAAK,CAAA;AAAA,EACxB,CAAA;AAEA,EAAA,MAAA,CAAO,MAAA,GAAS,SAA0B,EAAA,EAAmC;AAC3E,IAAA,IAAI,MAAA,CAAO,EAAA,EAAI,OAAO,YAAA,CAAa,EAAE,IAAI,IAAA,EAAM,KAAA,EAAO,MAAA,CAAO,KAAA,EAAgB,CAAA;AAC7E,IAAA,OAAO,YAAA,CAAa,EAAE,EAAA,EAAI,KAAA,EAAO,OAAO,EAAA,CAAG,MAAA,CAAO,KAAK,CAAA,EAAG,CAAA;AAAA,EAC5D,CAAA;AAEA,EAAA,MAAA,CAAO,GAAA,GAAM,SAAY,EAAA,EAAmC;AAC1D,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,OAAO,YAAA,CAAa,EAAE,EAAA,EAAI,KAAA,EAAO,KAAA,EAAO,MAAA,CAAO,KAAA,EAAiB,CAAA;AAChF,IAAA,OAAO,YAAA,CAAa,EAAE,EAAA,EAAI,IAAA,EAAM,OAAO,EAAA,CAAG,MAAA,CAAO,KAAK,CAAA,EAAG,CAAA;AAAA,EAC3D,CAAA;AAEA,EAAA,MAAA,CAAO,MAAA,GAAS,SAAS,QAAA,EAA4C;AACnE,IAAA,IAAI,MAAA,CAAO,IAAI,OAAO,MAAA;AACtB,IAAA,OAAO,QAAA,EAAS;AAAA,EAClB,CAAA;AAEA,EAAA,MAAA,CAAO,QAAA,GAAW,SAAS,QAAA,EAAgB;AACzC,IAAA,OAAO,MAAA,CAAO,EAAA,GAAK,MAAA,CAAO,KAAA,GAAQ,QAAA;AAAA,EACpC,CAAA;AAEA,EAAA,MAAA,CAAO,gBAAgB,WAAc;AACnC,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,MAAM,MAAA,CAAO,KAAA;AAC7B,IAAA,OAAO,MAAA,CAAO,KAAA;AAAA,EAChB,CAAA;AAEA,EAAA,MAAA,CAAO,GAAA,GAAM,SAAS,EAAA,EAAsC;AAC1D,IAAA,IAAI,MAAA,CAAO,EAAA,EAAI,EAAA,CAAG,MAAA,CAAO,KAAK,CAAA;AAC9B,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAEA,EAAA,MAAA,CAAO,MAAA,GAAS,SAAS,EAAA,EAAsC;AAC7D,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,EAAA,CAAG,OAAO,KAAK,CAAA;AAC/B,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAEA,EAAA,MAAA,CAAO,OAAA,GAAU,SAAS,EAAA,EAAuC;AAC/D,IAAA,IAAI,MAAA,CAAO,EAAA,EAAI,EAAA,CAAG,MAAA,CAAO,KAAK,CAAA;AAAA,SACzB,EAAA,EAAG;AACR,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAEA,EAAA,MAAA,CAAO,OAAO,WAA4B;AACxC,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,OAAO,YAAA,CAAa,EAAE,EAAA,EAAI,KAAA,EAAO,KAAA,EAAO,MAAA,CAAO,KAAA,EAAiB,CAAA;AAChF,IAAA,OAAO,aAAa,EAAE,EAAA,EAAI,IAAA,EAAM,KAAA,EAAO,QAAmB,CAAA;AAAA,EAC5D,CAAA;AAEA,EAAA,OAAO,MAAA;AACT;AAGO,IAAM,EAAA,GAAK,CAAI,KAAA,KACpB,YAAA,CAAa,EAAE,EAAA,EAAI,IAAA,EAAM,OAAO,CAAA;AAE3B,IAAM,GAAA,GAAM,CAAkB,KAAA,KACnC,YAAA,CAAa,EAAE,EAAA,EAAI,KAAA,EAAO,OAAO,CAAA;AAM5B,IAAM,SAAA,GAAY,CAAC,CAAA,KAA0B;AAClD,EAAA,IAAI,CAAA,YAAa,WAAW,OAAO,CAAA;AACnC,EAAA,IAAI,aAAa,KAAA,EAAO;AAEtB,IAAA,IAAI,UAAU,CAAA,IAAK,OAAO,EAAE,IAAA,KAAS,QAAA,IAAY,aAAa,CAAA,EAAG;AAC/D,MAAA,OAAO,CAAA;AAAA,IACT;AACA,IAAA,OAAO,IAAI,UAAU,aAAA,EAAe,CAAA,CAAE,SAAS,EAAE,KAAA,EAAO,GAAG,CAAA;AAAA,EAC7D;AACA,EAAA,OAAO,IAAI,SAAA,CAAU,aAAA,EAAe,MAAA,CAAO,CAAC,CAAC,CAAA;AAC/C,CAAA;AAMO,SAAS,IAAA,CACd,KAAA,EACA,IAAA,EACA,GAAA,EACA,GAAA,EACc;AAEd,EAAA,MAAM,SAAA,GACJ,IAAA,KACC,KAAA,YAAiB,SAAA,GACd,KAAA,CAAM,IAAA,GACN,MAAA,IAAU,KAAA,IAAS,KAAA,CAAM,IAAA,GACtB,KAAA,CAAM,IAAA,GACP,eAAA,CAAA;AAGR,EAAA,MAAM,OAAA,GAAU,OAAO,KAAA,CAAM,OAAA;AAE7B,EAAA,OAAO,IAAI,SAAA,CAAU,SAAA,EAAW,OAAA,EAAS;AAAA,IACvC,KAAA;AAAA,IACA,GAAI,GAAA,KAAQ,MAAA,IAAa,EAAE,SAAS,GAAA;AAAI,GACzC,CAAA;AACH;;;AC5JO,SAAS,QAKX,GAAA,EAA+D;AAClE,EAAA,OAAO,CAAC,KAAA,KACN,GAAA,CAAI,MAAA,CAAO,CAAC,KAAK,EAAA,KAAO,EAAA,CAAG,GAAG,CAAA,EAAG,KAAK,CAAA;AAC1C;AAMO,SAAS,QACd,OAAA,EACgB;AAEhB,EAAA,MAAM,MAAA,GAAc,IAAI,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA;AAC5C,EAAA,IAAI,KAAA,GAAQ,CAAA;AAEZ,EAAA,KAAA,MAAW,UAAU,OAAA,EAAS;AAC5B,IAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,OAAO,MAAA;AACvB,IAAA,MAAA,CAAO,KAAA,EAAO,IAAI,MAAA,CAAO,KAAA;AAAA,EAC3B;AAEA,EAAA,OAAO,GAAG,MAAM,CAAA;AAClB;AAKA,eAAsB,aACpB,QAAA,EACyB;AACzB,EAAA,MAAM,OAAA,GAAU,MAAM,OAAA,CAAQ,GAAA,CAAI,QAAQ,CAAA;AAC1C,EAAA,OAAO,QAAQ,OAAO,CAAA;AACxB;AAOO,SAAS,aACd,QAAA,EACc;AACd,EAAA,IAAI,QAAA,CAAS,WAAW,CAAA,EAAG;AACzB,IAAA,OAAO,GAAA,CAAI,IAAI,SAAA,CAAU,YAAA,EAAc,yBAAyB,CAAiB,CAAA;AAAA,EACnF;AAEA,EAAA,KAAA,MAAWC,YAAW,QAAA,EAAU;AAC9B,IAAA,MAAM,SAASA,QAAAA,EAAQ;AACvB,IAAA,IAAI,MAAA,CAAO,IAAI,OAAO,MAAA;AAAA,EACxB;AAGA,EAAA,OAAO,GAAA,CAAI,IAAI,SAAA,CAAU,YAAA,EAAc,yBAAyB,CAAiB,CAAA;AACnF;;;AHHO,SAASH,IAAAA,CACd,aACA,OAAA,EACiC;AACjC,EAAA,IAAI,OAAO,gBAAgB,QAAA,EAAU;AAEnC,IAAA,OAAO,IAAK,IAAI,SAAA,CAAW,WAAA,EAAa,OAAA,IAAW,WAAW,CAAC,CAAA;AAAA,EACjE;AAEA,EAAA,OAAO,IAAK,WAAW,CAAA;AACzB;AAUO,SAAS,OAAA,CACd,SACA,QAAA,EAC6F;AAE7F,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,OAAO,CAAA,EAAG;AAC1B,IAAA,OAAO,YAAA,CAAa,SAAS,QAAQ,CAAA;AAAA,EACvC;AAGA,EAAA,IAAI;AACF,IAAA,MAAM,SAAS,OAAA,EAAQ;AAGvB,IAAA,IAAI,MAAA,IAAU,OAAO,MAAA,KAAW,QAAA,IAAY,UAAU,MAAA,EAAQ;AAE5D,MAAA,OAAQ,MAAA,CAAsB,IAAA;AAAA,QAC5B,CAAC,KAAA,KAAU,EAAA,CAAG,KAAK,CAAA;AAAA,QACnB,CAAC,KAAA,KAAU;AACT,UAAA,MAAM,IAAA,GAAO,UAAW,KAAK,CAAA;AAC7B,UAAA,OAAO,GAAA,CAAK,QAAA,GAAW,QAAA,CAAS,IAAI,IAAI,IAAI,CAAA;AAAA,QAC9C;AAAA,OACF;AAAA,IACF;AAGA,IAAA,OAAO,GAAG,MAAW,CAAA;AAAA,EACvB,SAAS,CAAA,EAAG;AAEV,IAAA,MAAM,IAAA,GAAO,UAAW,CAAC,CAAA;AACzB,IAAA,OAAO,GAAA,CAAK,QAAA,GAAW,QAAA,CAAS,IAAI,IAAI,IAAI,CAAA;AAAA,EAC9C;AACF;AAIA,eAAe,YAAA,CACb,KACA,GAAA,EACkC;AAClC,EAAA,MAAM,UAAe,EAAC;AAEtB,EAAA,KAAA,MAAW,MAAM,GAAA,EAAK;AAEpB,IAAA,MAAM,cAAA,GAAiB,QAAQ,OAAA,EAAQ,CAAE,KAAK,MAAM,EAAA,EAAI,CAAA,CAAE,IAAA;AAAA,MACxD,CAAC,KAAA,KAAU,EAAA,CAAG,KAAK,CAAA;AAAA,MACnB,CAAC,KAAA,KAAU;AACT,QAAA,MAAM,IAAA,GAAO,UAAW,KAAK,CAAA;AAC7B,QAAA,OAAO,GAAA,CAAK,GAAA,GAAM,GAAA,CAAI,IAAI,IAAI,IAAI,CAAA;AAAA,MACpC;AAAA,KACF;AAEA,IAAA,MAAM,SAAS,MAAM,cAAA;AACrB,IAAA,IAAI,CAAC,OAAO,EAAA,EAAI;AACd,MAAA,OAAO,MAAA;AAAA,IACT;AACA,IAAA,OAAA,CAAQ,IAAA,CAAK,OAAO,KAAK,CAAA;AAAA,EAC3B;AAEA,EAAA,OAAO,GAAG,OAAO,CAAA;AACnB;AAMA,eAAsB,SACpB,EAAA,EACgC;AAChC,EAAA,IAAI;AACF,IAAA,MAAM,KAAA,GAAQ,MAAM,EAAA,EAAG;AACvB,IAAA,OAAO,GAAG,KAAK,CAAA;AAAA,EACjB,SAAS,CAAA,EAAG;AACV,IAAA,MAAM,IAAA,GAAO,UAAW,CAAC,CAAA;AACzB,IAAA,OAAO,IAAK,IAAI,CAAA;AAAA,EAClB;AACF;AAMO,SAAS,QACd,OAAA,EACuB;AACvB,EAAA,MAAM,QAAA,GAAW,OAAA;AAEjB,EAAA,QAAA,CAAS,OAAA,GAAU,SAAiB,EAAA,EAA8F;AAChI,IAAA,OAAO,OAAA,CAAQ,IAAA,CAAK,IAAA,CAAK,CAAA,MAAA,KAAU;AACjC,MAAA,IAAI,CAAC,MAAA,CAAO,EAAA,EAAI,OAAO,GAAA,CAAK,OAAO,KAAK,CAAA;AACxC,MAAA,MAAM,QAAA,GAAW,EAAA,CAAG,MAAA,CAAO,KAAK,CAAA;AAEhC,MAAA,IAAI,QAAA,IAAY,OAAO,QAAA,KAAa,QAAA,IAAY,UAAU,QAAA,EAAU;AAClE,QAAA,OAAO,QAAA;AAAA,MACT;AACA,MAAA,OAAO,QAAA;AAAA,IACT,CAAC,CAAC,CAAA;AAAA,EACJ,CAAA;AAEA,EAAA,QAAA,CAAS,GAAA,GAAM,SAAiB,EAAA,EAAsD;AACpF,IAAA,OAAO,OAAA,CAAQ,KAAK,IAAA,CAAK,CAAA,MAAA,KAAU,OAAO,GAAA,CAAI,EAAE,CAAC,CAAC,CAAA;AAAA,EACpD,CAAA;AAEA,EAAA,QAAA,CAAS,MAAA,GAAS,SAA0C,EAAA,EAAsD;AAChH,IAAA,OAAO,OAAA,CAAQ,KAAK,IAAA,CAAK,CAAA,MAAA,KAAU,OAAO,MAAA,CAAO,EAAE,CAAC,CAAC,CAAA;AAAA,EACvD,CAAA;AAEA,EAAA,QAAA,CAAS,MAAA,GAAS,SAAS,QAAA,EAA+D;AACxF,IAAA,OAAO,OAAA,CAAQ,KAAK,IAAA,CAAK,CAAA,MAAA,KAAU,OAAO,MAAA,CAAO,QAAQ,CAAC,CAAC,CAAA;AAAA,EAC7D,CAAA;AAEA,EAAA,QAAA,CAAS,QAAA,GAAW,SAAS,QAAA,EAA8C;AACzE,IAAA,OAAO,KAAK,IAAA,CAAK,CAAA,MAAA,KAAU,MAAA,CAAO,QAAA,CAAS,QAAQ,CAAC,CAAA;AAAA,EACtD,CAAA;AAEA,EAAA,QAAA,CAAS,gBAAgB,WAAuC;AAC9D,IAAA,OAAO,IAAA,CAAK,IAAA,CAAK,CAAA,MAAA,KAAU,MAAA,CAAO,eAAe,CAAA;AAAA,EACnD,CAAA;AAEA,EAAA,QAAA,CAAS,GAAA,GAAM,SAAS,EAAA,EAAoD;AAC1E,IAAA,OAAO,OAAA,CAAQ,KAAK,IAAA,CAAK,CAAA,MAAA,KAAU,OAAO,GAAA,CAAI,EAAE,CAAC,CAAC,CAAA;AAAA,EACpD,CAAA;AAEA,EAAA,QAAA,CAAS,MAAA,GAAS,SAAS,EAAA,EAAoD;AAC7E,IAAA,OAAO,OAAA,CAAQ,KAAK,IAAA,CAAK,CAAA,MAAA,KAAU,OAAO,MAAA,CAAO,EAAE,CAAC,CAAC,CAAA;AAAA,EACvD,CAAA;AAEA,EAAA,QAAA,CAAS,OAAA,GAAU,SAAS,EAAA,EAAqD;AAC/E,IAAA,OAAO,OAAA,CAAQ,KAAK,IAAA,CAAK,CAAA,MAAA,KAAU,OAAO,OAAA,CAAQ,EAAE,CAAC,CAAC,CAAA;AAAA,EACxD,CAAA;AAEA,EAAA,QAAA,CAAS,OAAO,WAAgC;AAC9C,IAAA,OAAO,QAAQ,IAAA,CAAK,IAAA,CAAK,YAAU,MAAA,CAAO,IAAA,EAAM,CAAC,CAAA;AAAA,EACnD,CAAA;AAEA,EAAA,OAAO,QAAA;AACT;AAGO,SAAS,UACd,EAAA,EACuB;AACvB,EAAA,OAAO,OAAA,CAAQ,IAAI,CAAA;AACrB;AAGO,IAAME,KAAAA,GAAO,IAAA;AACb,IAAMJ,QAAAA,GAAU,OAAA;AAChB,IAAMC,aAAAA,GAAe,YAAA;AACrB,IAAME,aAAAA,GAAe,YAAA;AAGrB,SAAS,SACd,KAAA,EACuB;AACvB,EAAA,IACE,KAAA,KAAU,IAAA,IACV,OAAO,KAAA,KAAU,QAAA,IACjB,EAAE,IAAA,IAAQ,KAAA,CAAA,IACV,OAAQ,KAAA,CAA0B,EAAA,KAAO,SAAA,EACzC;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAEA,EAAA,MAAM,CAAA,GAAI,KAAA;AACV,EAAA,IAAI,CAAA,CAAE,OAAO,IAAA,EAAM;AACjB,IAAA,OAAO,OAAA,IAAW,CAAA;AAAA,EACpB,CAAA,MAAO;AACL,IAAA,OAAO,OAAA,IAAW,CAAA,IAAK,CAAA,CAAE,KAAA,YAAiB,UAAA,CAAW,KAAA;AAAA,EACvD;AACF;AAEO,SAAS,KAAkB,KAAA,EAAgC;AAChE,EAAA,OAAO,QAAA,CAAS,KAAK,CAAA,IAAK,KAAA,CAAM,EAAA,KAAO,IAAA;AACzC;AAEO,SAAS,MACd,KAAA,EACiB;AACjB,EAAA,OAAO,QAAA,CAAS,KAAK,CAAA,IAAK,KAAA,CAAM,EAAA,KAAO,KAAA;AACzC;;;AIlPO,IAAM,EAAA,GAAK;AAAA,EAChB,GAAA,EAAK,OAAA;AAAA,EACL,QAAA;AAAA,EACA,EAAA;AAAA,EACA,GAAA,EAAKD;AACP","file":"index.cjs","sourcesContent":["/**\n * Core Exports - Single source of truth for all public ZeroThrow APIs\n * This file defines the clean, standardized names for the ZeroThrow namespace\n */\n\n// Import everything from current locations\nimport {\n  type Result as _Result,\n  type Ok as _Ok,\n  type Err as _Err,\n  ok,\n  err as _err,\n  wrap as _wrap,\n  normalise as _normalise\n} from './result.js';\n\nimport {\n  ZeroError as _ZeroError,\n  type ErrorCode as _ErrorCode,\n  type ErrorContext as _ErrorContext\n} from './error.js';\n\nimport {\n  pipe as _pipe,\n  collect as _collect,\n  collectAsync as _collectAsync,\n  firstSuccess as _firstSuccess\n} from './combinators.js';\n\n// ==========================================\n// TYPES - Clean names for ZeroThrow namespace\n// ==========================================\n\n// Core Result types (unchanged)\nexport type Result<T, E extends globalThis.Error = _ZeroError> = _Result<T, E>;\nexport type Ok<T> = _Ok<T>;\nexport type Err<E extends globalThis.Error> = _Err<E>;\n\n// Error types (unchanged)\nexport { _ZeroError as ZeroError };\nexport type ErrorCode = _ErrorCode;\nexport type ErrorContext = _ErrorContext;\n\n// NEW: Async type to replace Promise interface\nexport interface Async<TValue, TError extends globalThis.Error = _ZeroError> extends globalThis.Promise<Result<TValue, TError>> {\n  andThen<UValue>(fn: (value: TValue) => Result<UValue, TError> | Async<UValue, TError>): Async<UValue, TError>;\n  map<UValue>(fn: (value: TValue) => UValue): Async<UValue, TError>;\n  mapErr<FError extends globalThis.Error>(fn: (error: TError) => FError): Async<TValue, FError>;\n  orElse(fallback: () => Result<TValue, TError>): Async<TValue, TError>;\n  unwrapOr(fallback: TValue): globalThis.Promise<TValue>;\n  unwrapOrThrow(): globalThis.Promise<TValue>;\n  tap(fn: (value: TValue) => void): Async<TValue, TError>;\n  tapErr(fn: (error: TError) => void): Async<TValue, TError>;\n  finally(fn: (value?: TValue) => void): Async<TValue, TError>;\n  void(): Async<void, TError>;\n}\n\n// ==========================================\n// FUNCTIONS - Clean names for ZeroThrow namespace\n// ==========================================\n\n// Factory functions\nexport { ok };\n\n// Enhanced err with string overloads\nexport function err(error: globalThis.Error): Result<never, globalThis.Error>;\nexport function err(code: string): Result<never, _ZeroError>;\nexport function err(code: string, message: string): Result<never, _ZeroError>;\nexport function err(\n  errorOrCode: globalThis.Error | string, \n  message?: string\n): Result<never, globalThis.Error> {\n  if (typeof errorOrCode === 'string') {\n    // String overload - create ZeroError\n    return _err(new _ZeroError(errorOrCode, message || errorOrCode));\n  }\n  // Error object - use as-is (preserves all error types)\n  return _err(errorOrCode);\n}\n\n// NEW: attempt function (replaces tryR, tryRSync, tryRBatch)\n// Single overloaded function that handles all cases\nexport function attempt<T>(fn: () => T): Result<T, _ZeroError>;\nexport function attempt<T>(fn: () => Promise<T>): Promise<Result<T, _ZeroError>>;\nexport function attempt<T>(fn: () => T, mapError: (e: unknown) => _ZeroError): Result<T, _ZeroError>;\nexport function attempt<T>(fn: () => Promise<T>, mapError: (e: unknown) => _ZeroError): Promise<Result<T, _ZeroError>>;\nexport function attempt<T>(operations: Array<() => T | Promise<T>>): Promise<Result<T[], _ZeroError>>;\nexport function attempt<T>(operations: Array<() => T | Promise<T>>, mapError: (e: unknown) => _ZeroError): Promise<Result<T[], _ZeroError>>;\nexport function attempt<T>(\n  fnOrOps: (() => T) | (() => Promise<T>) | Array<() => T | Promise<T>>,\n  mapError?: (e: unknown) => _ZeroError\n): (Result<T, _ZeroError>) | Promise<Result<T, _ZeroError>> | Promise<Result<T[], _ZeroError>> {\n  // Handle array of operations (batch)\n  if (Array.isArray(fnOrOps)) {\n    return attemptBatch(fnOrOps, mapError);\n  }\n  \n  // Try to execute the function\n  try {\n    const result = fnOrOps();\n    \n    // If it's a promise, handle async\n    if (result && typeof result === 'object' && 'then' in result) {\n      // Don't call fn again, use the existing promise\n      return (result as Promise<T>).then(\n        (value) => ok(value),\n        (error) => {\n          const base = _normalise(error);\n          return _err(mapError ? mapError(base) : base);\n        }\n      );\n    }\n    \n    // Sync result\n    return ok(result as T);\n  } catch (e) {\n    // Function threw synchronously\n    const base = _normalise(e);\n    return _err(mapError ? mapError(base) : base);\n  }\n}\n\n\n// Internal: batch implementation\nasync function attemptBatch<T>(\n  fns: Array<() => T | Promise<T>>,\n  map?: (e: unknown) => _ZeroError\n): Promise<Result<T[], _ZeroError>> {\n  const results: T[] = [];\n\n  for (const fn of fns) {\n    // Always await Promise.resolve to handle both sync and async uniformly\n    const promisedResult = Promise.resolve().then(() => fn()).then(\n      (value) => ok(value),\n      (error) => {\n        const base = _normalise(error);\n        return _err(map ? map(base) : base);\n      }\n    );\n    \n    const result = await promisedResult;\n    if (!result.ok) {\n      return result as Result<T[], _ZeroError>;\n    }\n    results.push(result.value);\n  }\n\n  return ok(results);\n}\n\n// Temporary alias for grace period\nexport { attempt as try };\n\n// NEW: tryAsync for cleaner async ergonomics\nexport async function tryAsync<T>(\n  fn: () => Promise<T>\n): Promise<Result<T, _ZeroError>> {\n  try {\n    const value = await fn();\n    return ok(value);\n  } catch (e) {\n    const base = _normalise(e);\n    return _err(base);\n  }\n}\n\n// Error wrapping (unchanged name)\nexport { _wrap as wrap };\n\n// NEW: enhance function for promise enhancement (replaces promise())\nexport function enhance<TValue, TError extends globalThis.Error = _ZeroError>(\n  promise: globalThis.Promise<Result<TValue, TError>>\n): Async<TValue, TError> {\n  const enhanced = promise as Async<TValue, TError>;\n  \n  enhanced.andThen = function<UValue>(fn: (value: TValue) => Result<UValue, TError> | Async<UValue, TError>): Async<UValue, TError> {\n    return enhance(this.then(result => {\n      if (!result.ok) return _err(result.error) as Result<UValue, TError>;\n      const fnResult = fn(result.value);\n      // If it's already an Async, return it; otherwise wrap the Result\n      if (fnResult && typeof fnResult === 'object' && 'then' in fnResult) {\n        return fnResult as Async<UValue, TError>;\n      }\n      return fnResult as Result<UValue, TError>;\n    }));\n  };\n  \n  enhanced.map = function<UValue>(fn: (value: TValue) => UValue): Async<UValue, TError> {\n    return enhance(this.then(result => result.map(fn)));\n  };\n  \n  enhanced.mapErr = function<FError extends globalThis.Error>(fn: (error: TError) => FError): Async<TValue, FError> {\n    return enhance(this.then(result => result.mapErr(fn))) as Async<TValue, FError>;\n  };\n  \n  enhanced.orElse = function(fallback: () => Result<TValue, TError>): Async<TValue, TError> {\n    return enhance(this.then(result => result.orElse(fallback)));\n  };\n  \n  enhanced.unwrapOr = function(fallback: TValue): globalThis.Promise<TValue> {\n    return this.then(result => result.unwrapOr(fallback));\n  };\n  \n  enhanced.unwrapOrThrow = function(): globalThis.Promise<TValue> {\n    return this.then(result => result.unwrapOrThrow());\n  };\n  \n  enhanced.tap = function(fn: (value: TValue) => void): Async<TValue, TError> {\n    return enhance(this.then(result => result.tap(fn)));\n  };\n  \n  enhanced.tapErr = function(fn: (error: TError) => void): Async<TValue, TError> {\n    return enhance(this.then(result => result.tapErr(fn)));\n  };\n  \n  enhanced.finally = function(fn: (value?: TValue) => void): Async<TValue, TError> {\n    return enhance(this.then(result => result.finally(fn)));\n  };\n  \n  enhanced.void = function(): Async<void, TError> {\n    return enhance(this.then(result => result.void()));\n  };\n  \n  return enhanced;\n}\n\n// NEW: fromAsync helper (replaces async())\nexport function fromAsync<TValue, TError extends globalThis.Error = _ZeroError>(\n  fn: () => globalThis.Promise<Result<TValue, TError>>\n): Async<TValue, TError> {\n  return enhance(fn());\n}\n\n// Combinator functions (unchanged)\nexport const pipe = _pipe;\nexport const collect = _collect;\nexport const collectAsync = _collectAsync;\nexport const firstSuccess = _firstSuccess;\n\n// Type guards\nexport function isResult<T = unknown, E extends globalThis.Error = _ZeroError>(\n  value: unknown\n): value is Result<T, E> {\n  if (\n    value === null ||\n    typeof value !== 'object' ||\n    !('ok' in value) ||\n    typeof (value as { ok: unknown }).ok !== 'boolean'\n  ) {\n    return false;\n  }\n  \n  const v = value as { ok: boolean; value?: unknown; error?: unknown };\n  if (v.ok === true) {\n    return 'value' in v;\n  } else {\n    return 'error' in v && v.error instanceof globalThis.Error;\n  }\n}\n\nexport function isOk<T = unknown>(value: unknown): value is Ok<T> {\n  return isResult(value) && value.ok === true;\n}\n\nexport function isErr<E extends globalThis.Error = _ZeroError>(\n  value: unknown\n): value is Err<E> {\n  return isResult(value) && value.ok === false;\n}\n\n\n","export type ErrorCode = string | number | symbol;\n\nexport interface ErrorContext {\n  [k: string]: unknown;\n}\n\n/**\n * ZeroError wraps a standard JS Error but adds:\n *  - code      : machine‑readable categorisation\n *  - context   : structured payload for logging\n *  - cause     : native Error.cause chain (ES2022)\n */\nexport class ZeroError<C extends ErrorContext = ErrorContext> extends Error {\n  readonly code: ErrorCode;\n  readonly context?: C;\n\n  constructor(\n    code: ErrorCode,\n    message: string,\n    opts: { cause?: Error; context?: C } = {}\n  ) {\n    super(message, { cause: opts.cause });\n    this.code = code;\n    this.context = opts.context as C;\n    this.name = 'ZeroError';\n    Object.setPrototypeOf(this, new.target.prototype); // fix prototype when transpiled\n  }\n\n  /**\n   * Override toString to include full error chain with context\n   */\n  override toString(): string {\n    let result = `${this.name} [${String(this.code)}]: ${this.message}`;\n\n    // Add context if present\n    if (this.context && Object.keys(this.context).length > 0) {\n      result += `\\n  Context: ${JSON.stringify(this.context, null, 2).replace(/\\n/g, '\\n  ')}`;\n    }\n\n    // Add cause chain\n    let currentCause = this.cause;\n    let depth = 1;\n    while (currentCause instanceof Error) {\n      const indent = '  '.repeat(depth);\n      const causeName = currentCause.name || 'Error';\n      result += `\\n${indent}Caused by: ${causeName}: ${currentCause.message}`;\n\n      // If the cause is also a ZeroError, include its context\n      if (currentCause instanceof ZeroError && currentCause.context) {\n        const contextStr = JSON.stringify(\n          currentCause.context,\n          null,\n          2\n        ).replace(/\\n/g, `\\n${indent}  `);\n        result += `\\n${indent}  Context: ${contextStr}`;\n      }\n\n      currentCause = currentCause.cause;\n      depth++;\n    }\n\n    return result;\n  }\n\n  /**\n   * Get the full stack trace including all causes\n   */\n  getFullStack(): string {\n    let fullStack = this.stack || '';\n\n    let currentCause = this.cause;\n    while (currentCause instanceof Error) {\n      fullStack +=\n        '\\n\\nCaused by:\\n' + (currentCause.stack || currentCause.toString());\n      currentCause = currentCause.cause;\n    }\n\n    return fullStack;\n  }\n}\n","import { ZeroError, type ErrorContext, type ErrorCode } from './error.js';\n\nexport type Ok<T> = { ok: true; value: T };\nexport type Err<E extends Error = ZeroError> = { ok: false; error: E };\nexport type Result<T, E extends Error = ZeroError> = (Ok<T> | Err<E>) & ResultMethods<T, E>;\n\n/**\n * Result methods - every Result has these built-in\n */\nexport interface ResultMethods<T, E extends Error = ZeroError> {\n  /**\n   * Chain operations that can fail\n   */\n  andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;\n\n  /**\n   * Transform errors while preserving success values\n   */\n  mapErr<F extends Error>(fn: (error: E) => F): Result<T, F>;\n\n  /**\n   * Transform success values while preserving errors\n   */\n  map<U>(fn: (value: T) => U): Result<U, E>;\n\n  /**\n   * Provide fallback value on error\n   */\n  orElse(fallback: () => Result<T, E>): Result<T, E>;\n\n  /**\n   * Get value or fallback\n   */\n  unwrapOr(fallback: T): T;\n\n  /**\n   * Get value or throw (use sparingly!)\n   */\n  unwrapOrThrow(): T;\n\n  /**\n   * Execute side effect without changing the Result\n   */\n  tap(fn: (value: T) => void): Result<T, E>;\n\n  /**\n   * Execute side effect on error without changing the Result\n   */\n  tapErr(fn: (error: E) => void): Result<T, E>;\n\n  /**\n   * Execute side effect on any result\n   */\n  finally(fn: (value?: T) => void): Result<T, E>;\n\n  /**\n   * Discard the value and return void\n   */\n  void(): Result<void, E>;\n}\n\n/**\n * Create a Result with built-in methods\n */\nfunction createResult<T, E extends Error>(base: Ok<T> | Err<E>): Result<T, E> {\n  const result = base as Result<T, E>;\n\n  result.andThen = function<U>(fn: (value: T) => Result<U, E>): Result<U, E> {\n    if (!result.ok) return createResult({ ok: false, error: result.error } as Err<E>) as Result<U, E>;\n    return fn(result.value);\n  };\n\n  result.mapErr = function<F extends Error>(fn: (error: E) => F): Result<T, F> {\n    if (result.ok) return createResult({ ok: true, value: result.value } as Ok<T>) as Result<T, F>;\n    return createResult({ ok: false, error: fn(result.error) });\n  };\n\n  result.map = function<U>(fn: (value: T) => U): Result<U, E> {\n    if (!result.ok) return createResult({ ok: false, error: result.error } as Err<E>) as Result<U, E>;\n    return createResult({ ok: true, value: fn(result.value) });\n  };\n\n  result.orElse = function(fallback: () => Result<T, E>): Result<T, E> {\n    if (result.ok) return result;\n    return fallback();\n  };\n\n  result.unwrapOr = function(fallback: T): T {\n    return result.ok ? result.value : fallback;\n  };\n\n  result.unwrapOrThrow = function(): T {\n    if (!result.ok) throw result.error;\n    return result.value;\n  };\n\n  result.tap = function(fn: (value: T) => void): Result<T, E> {\n    if (result.ok) fn(result.value);\n    return result;\n  };\n\n  result.tapErr = function(fn: (error: E) => void): Result<T, E> {\n    if (!result.ok) fn(result.error);\n    return result;\n  };\n\n  result.finally = function(fn: (value?: T) => void): Result<T, E> {\n    if (result.ok) fn(result.value);\n    else fn();\n    return result;\n  };\n\n  result.void = function(): Result<void, E> {\n    if (!result.ok) return createResult({ ok: false, error: result.error } as Err<E>) as Result<void, E>;\n    return createResult({ ok: true, value: undefined as void });\n  };\n\n  return result;\n}\n\n// Public API - all Results have combinators built-in\nexport const ok = <T>(value: T): Result<T, ZeroError> => \n  createResult({ ok: true, value });\n\nexport const err = <E extends Error>(error: E): Result<never, E> => \n  createResult({ ok: false, error });\n\n/**\n * Normalise an unknown thrown value into ZeroError\n * Optimized to avoid creating new errors when possible\n */\nexport const normalise = (e: unknown): ZeroError => {\n  if (e instanceof ZeroError) return e;\n  if (e instanceof Error) {\n    // Check if it already has ZeroError-like properties to avoid allocation\n    if ('code' in e && typeof e.code === 'string' && 'context' in e) {\n      return e as ZeroError;\n    }\n    return new ZeroError('UNKNOWN_ERR', e.message, { cause: e });\n  }\n  return new ZeroError('UNKNOWN_ERR', String(e));\n};\n\n/**\n * wrap(cause, code?, msg?, ctx?) lifts an existing error into a new coded layer.\n * If code/msg are not provided, they are extracted from the cause error.\n */\nexport function wrap<C extends ErrorContext = ErrorContext>(\n  cause: Error,\n  code?: ErrorCode,\n  msg?: string,\n  ctx?: C\n): ZeroError<C> {\n  // Extract code from cause if not provided\n  const errorCode =\n    code ??\n    (cause instanceof ZeroError\n      ? cause.code\n      : 'code' in cause && cause.code\n        ? (cause.code as ErrorCode)\n        : 'WRAPPED_ERROR');\n\n  // Use cause's message if msg not provided\n  const message = msg ?? cause.message;\n\n  return new ZeroError(errorCode, message, { \n    cause, \n    ...(ctx !== undefined && { context: ctx })\n  });\n}","import { type Result, ok, err } from './result.js';\nimport { ZeroError } from './error.js';\n\n/**\n * Pipe multiple operations together with full type inference\n *\n * @example\n * const result = pipe(\n *   parseNumber,\n *   validateRange,\n *   formatOutput\n * )(input);\n */\nexport function pipe<\n  T extends readonly [\n    (arg: unknown) => unknown,\n    ...Array<(arg: unknown) => unknown>,\n  ],\n>(...fns: T): (input: Parameters<T[0]>[0]) => ReturnType<T[number]> {\n  return (input: Parameters<T[0]>[0]): ReturnType<T[number]> =>\n    fns.reduce((acc, fn) => fn(acc), input) as ReturnType<T[number]>;\n}\n\n/**\n * Collect all Results - fail if any fail, succeed with array if all succeed\n * Optimized to avoid unnecessary allocations\n */\nexport function collect<T, E extends Error = ZeroError>(\n  results: Array<Result<T, E>>\n): Result<T[], E> {\n  // Pre-allocate array if we know the size\n  const values: T[] = new Array(results.length);\n  let index = 0;\n\n  for (const result of results) {\n    if (!result.ok) return result as Result<T[], E>;\n    values[index++] = result.value;\n  }\n\n  return ok(values) as unknown as Result<T[], E>;\n}\n\n/**\n * Async version of collect for Promise<Result> arrays\n */\nexport async function collectAsync<T, E extends Error = ZeroError>(\n  promises: Array<Promise<Result<T, E>>>\n): Promise<Result<T[], E>> {\n  const results = await Promise.all(promises);\n  return collect(results);\n}\n\n/**\n * Get the first successful Result from an array of Result-producing functions\n * Evaluates lazily - stops on first success\n * Returns custom error if all fail\n */\nexport function firstSuccess<T, E extends Error = ZeroError>(\n  attempts: Array<() => Result<T, E>>\n): Result<T, E> {\n  if (attempts.length === 0) {\n    return err(new ZeroError('ALL_FAILED', 'All alternatives failed') as unknown as E);\n  }\n  \n  for (const attempt of attempts) {\n    const result = attempt();\n    if (result.ok) return result;\n  }\n  \n  // All attempts failed\n  return err(new ZeroError('ALL_FAILED', 'All alternatives failed') as unknown as E);\n}","/**\n * ZT Pocket Knife - Ultra-lean three-function surface\n * The 99% use case: ZT.try(), ZT.ok(), ZT.err()\n */\n\nimport { \n  try as _try,\n  tryAsync as _tryAsync,\n  ok as _ok, \n  err as _err \n} from './core-exports.js';\n\n/**\n * ZT - The pocket knife for daily ZeroThrow use\n * \n * @example\n * ```typescript\n * import { ZT } from '@zerothrow/zerothrow';\n * \n * const result = ZT.try(() => JSON.parse(input));\n * if (!result.ok) {\n *   return ZT.err(new Error('Invalid JSON'));\n * }\n * return ZT.ok(result.value);\n * ```\n */\nexport const ZT = {\n  try: _try,\n  tryAsync: _tryAsync,\n  ok: _ok,\n  err: _err\n} as const;"]}