@yipe/dice 0.12.0 → 0.12.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (12) hide show
  1. package/README.md +15 -11
  2. package/dist/builder/index.cjs +104 -35
  3. package/dist/builder/index.cjs.map +1 -1
  4. package/dist/builder/index.js +104 -35
  5. package/dist/builder/index.js.map +1 -1
  6. package/dist/index.cjs +104 -35
  7. package/dist/index.cjs.map +1 -1
  8. package/dist/index.js +104 -35
  9. package/dist/index.js.map +1 -1
  10. package/dist/parser/dice.d.ts +9 -2
  11. package/dist/parser/dice.d.ts.map +1 -1
  12. package/package.json +1 -1
package/dist/index.cjs.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"sources":["../src/common/bounce.ts","../src/common/errors.ts","../src/common/lru-cache.ts","../src/common/types.ts","../src/pmf/query.ts","../src/pmf/pmf.ts","../src/parser/dice.ts","../src/parser/scaleDice.ts","../src/parser/parser.ts","../src/parser/rollType.ts","../src/pmf/mixture.ts"],"names":["binom","result","cumulativeSum","check"],"mappings":";;;AAqCO,SAAS,WAAA,CAAY,KAAA,EAAe,OAAA,GAAU,CAAA,EAAG,SAAS,CAAA,EAAa;AAC5E,EAAA,MAAM,IAAI,IAAA,CAAK,GAAA,CAAI,GAAG,IAAA,CAAK,KAAA,CAAM,KAAK,CAAC,CAAA;AACvC,EAAA,IAAI,CAAA,IAAK,CAAA,EAAG,OAAO,EAAC;AAEpB,EAAA,IAAI,UAAU,IAAI,KAAA,CAAc,CAAC,CAAA,CAAE,IAAA,CAAK,IAAI,CAAC,CAAA;AAE7C,EAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,IAAA,CAAK,GAAA,CAAI,IAAA,CAAK,KAAA,CAAM,MAAM,CAAA,EAAG,CAAC,CAAC,CAAA;AACrD,EAAA,IAAI,IAAI,CAAA,EAAG;AACT,IAAA,MAAM,aAAa,CAAA,GAAI,CAAA;AACvB,IAAA,MAAM,gBAAgB,UAAA,GAAa,CAAA;AACnC,IAAA,OAAA,GAAU,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,EAAG,CAAA,KAAA,CAAO,IAAI,CAAA,GAAI,CAAA,GAAI,CAAA,GAAI,CAAA,IAAK,aAAa,CAAA;AAAA,EACrE;AAEA,EAAA,MAAM,OAAO,IAAA,CAAK,GAAA,CAAI,GAAG,IAAA,CAAK,KAAA,CAAM,OAAO,CAAC,CAAA;AAC5C,EAAA,IAAI,OAAO,CAAA,EAAG;AACZ,IAAA,MAAM,YAAY,IAAI,KAAA,CAAc,CAAC,CAAA,CAAE,KAAK,CAAC,CAAA;AAC7C,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,CAAA,EAAG,CAAA,EAAA,EAAK;AAC3B,MAAA,MAAM,MAAA,GAAS,KAAK,GAAA,CAAI,CAAA,EAAG,KAAK,GAAA,CAAI,CAAA,EAAG,IAAI,CAAC,CAAA;AAC5C,MAAA,SAAA,CAAU,MAAA,GAAS,CAAC,CAAA,IAAK,OAAA,CAAQ,IAAI,CAAC,CAAA;AAAA,IACxC;AACA,IAAA,OAAA,GAAU,SAAA;AAAA,EACZ;AAEA,EAAA,OAAO,OAAA;AACT;AAGA,SAAS,KAAA,CAAM,GAAW,CAAA,EAAmB;AAC3C,EAAA,IAAI,CAAA,GAAI,CAAA,IAAK,CAAA,GAAI,CAAA,EAAG,OAAO,CAAA;AAC3B,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,IAAS,CAAA,GAAI,GAAG,CAAA,GAAI,CAAA,EAAG,KAAK,MAAA,GAAU,MAAA,IAAU,CAAA,GAAI,CAAA,CAAA,IAAO,CAAA,GAAI,CAAA,CAAA;AAC/D,EAAA,OAAO,MAAA;AACT;AASA,SAAS,YAAA,CACP,IAAA,EACA,KAAA,EACA,YAAA,EACA,WAAA,EACQ;AACR,EAAA,MAAM,QAAQ,CAAA,GAAI,KAAA;AAElB,EAAA,MAAM,EAAA,GACJ,MAAM,YAAA,EAAc,IAAI,IAAI,IAAA,CAAK,GAAA,CAAI,OAAO,IAAI,CAAA,GAChD,cAAc,KAAA,CAAM,YAAA,EAAc,OAAO,CAAC,CAAA,GAAI,KAAK,GAAA,CAAI,KAAA,EAAO,OAAO,CAAC,CAAA;AACxE,EAAA,IAAI,UAAA,GAAa,CAAA;AACjB,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,IAAA,EAAM,KAAK,UAAA,IAAc,CAAA;AAC9C,EAAA,OAAO,UAAA,GAAa,EAAA;AACtB;AAGA,SAAS,MAAA,CAAO,IAAA,EAAc,KAAA,EAAe,cAAA,EAAgC;AAC3E,EAAA,IAAI,IAAA,IAAQ,GAAG,OAAO,CAAA;AACtB,EAAA,IAAI,IAAA,GAAO,OAAO,OAAO,CAAA;AAEzB,EAAA,IAAI,kBAAkB,CAAA,EAAG;AAGvB,IAAA,MAAM,eAAe,KAAA,GAAQ,cAAA;AAC7B,IAAA,MAAM,kBAAkB,YAAA,GAAe,CAAA;AACvC,IAAA,IAAI,IAAA,GAAO,iBAAiB,OAAO,CAAA;AACnC,IAAA,MAAM,cAAc,cAAA,GAAiB,KAAA;AACrC,IAAA,MAAM,QAAA,GAAW,YAAA,CAAa,IAAA,EAAM,KAAA,EAAO,cAAc,WAAW,CAAA;AACpE,IAAA,OAAO,IAAA,CAAK,IAAI,CAAA,EAAG,IAAA,CAAK,IAAI,CAAA,EAAG,CAAA,GAAI,QAAQ,CAAC,CAAA;AAAA,EAC9C;AAGA,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,GAAI,MAAM,CAAA,EAAA,EAAK,SAAA,IAAA,CAAc,QAAQ,CAAA,IAAK,KAAA;AAC1D,EAAA,OAAO,CAAA,GAAI,SAAA;AACb;AAeO,SAAS,mBAAA,CACd,SAAA,EACA,QAAA,EACA,OAAA,EACQ;AACR,EAAA,IAAI,SAAA,IAAa,GAAG,OAAO,CAAA;AAC3B,EAAA,IAAI,SAAA,GAAY,UAAU,OAAO,CAAA;AAEjC,EAAA,MAAM,cAAA,GAAiB,SAAS,cAAA,IAAkB,CAAA;AAClD,EAAA,MAAM,gBAAA,GAAmB,SAAS,gBAAA,IAAoB,CAAA;AAEtD,EAAA,MAAM,WAAA,GAAc,MAAA,CAAO,SAAA,EAAW,QAAA,EAAU,cAAc,CAAA;AAG9D,EAAA,MAAM,cAAc,IAAA,CAAK,GAAA,CAAI,KAAK,KAAA,CAAM,gBAAgB,GAAG,SAAS,CAAA;AACpE,EAAA,IAAI,WAAA,IAAe,CAAA,IAAK,WAAA,IAAe,CAAA,EAAG,OAAO,WAAA;AAOjD,EAAA,MAAM,YAAY,cAAA,IAAkB,CAAA;AACpC,EAAA,MAAM,UAAA,GAAa,SAAA,GAAY,QAAA,GAAW,cAAA,GAAiB,QAAA;AAC3D,EAAA,MAAM,WAAA,GAAc,SAAA,GAAY,cAAA,GAAiB,QAAA,GAAW,CAAA;AAC5D,EAAA,MAAM,UAAA,GAAa,CAAC,QAAA,EAAkB,SAAA,EAAmB,SAAA,KACvD,YAAA,CAAa,QAAA,EAAU,QAAA,EAAU,UAAA,GAAa,SAAA,EAAW,SAAA,GAAY,CAAA,GAAI,WAAW,CAAA;AAItF,EAAA,IAAI,aAAA,GAAgB,CAAA;AACpB,EAAA,IAAI,aAAA,GAAgB,CAAA;AACpB,EAAA,KAAA,IAAS,QAAA,GAAW,CAAA,EAAG,QAAA,IAAY,WAAA,EAAa,QAAA,EAAA,EAAY;AAC1D,IAAA,MAAM,YAAA,GAAe,UAAA,CAAW,QAAA,EAAU,SAAA,GAAY,UAAU,KAAK,CAAA;AACrE,IAAA,aAAA,GAAgB,IAAA,CAAK,GAAA,CAAI,aAAA,EAAe,YAAY,CAAA;AACpD,IAAA,aAAA,GAAgB,IAAA,CAAK,GAAA,CAAI,aAAA,EAAe,YAAY,CAAA;AACpD,IAAA,IAAI,WAAW,SAAA,EAAW;AACxB,MAAA,aAAA,GAAgB,IAAA,CAAK,IAAI,aAAA,EAAe,UAAA,CAAW,UAAU,SAAA,GAAY,CAAA,GAAI,QAAA,EAAU,IAAI,CAAC,CAAA;AAAA,IAC9F;AAAA,EACF;AAGA,EAAA,MAAM,UAAA,GAAa,YAAA,CAAa,SAAA,EAAW,QAAA,EAAU,YAAY,CAAC,CAAA;AAClE,EAAA,MAAM,UAAA,GAAa,YAAY,WAAA,GAAc,YAAA,CAAa,YAAY,CAAA,EAAG,QAAA,EAAU,YAAY,CAAC,CAAA;AAEhG,EAAA,OAAO,IAAA,CAAK,GAAA;AAAA,IACV,CAAA;AAAA,IACA,WAAA,GAAc,UAAA,IAAc,CAAA,GAAI,aAAA,CAAA,GAAiB,cAAc,CAAA,GAAI,aAAA;AAAA,GACrE;AACF;AAgBO,SAAS,mBAAA,CAAoB,MAAc,OAAA,EAAiD;AACjG,EAAA,IAAI,IAAA,uBAAW,GAAA,CAAoB,CAAC,CAAC,CAAA,EAAG,CAAC,CAAC,CAAC,CAAA;AAC3C,EAAA,KAAA,IAAS,GAAA,GAAM,CAAA,EAAG,GAAA,GAAM,IAAA,EAAM,GAAA,EAAA,EAAO;AACnC,IAAA,MAAM,IAAA,uBAAW,GAAA,EAAoB;AACrC,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,IAAA,EAAM;AAC9B,MAAA,KAAA,IAAS,IAAA,GAAO,CAAA,EAAG,IAAA,IAAQ,OAAA,CAAQ,QAAQ,IAAA,EAAA,EAAQ;AACjD,QAAA,MAAM,CAAA,GAAI,OAAA,CAAQ,IAAA,GAAO,CAAC,CAAA,IAAK,CAAA;AAC/B,QAAA,IAAI,KAAK,CAAA,EAAG;AACZ,QAAA,MAAM,IAAI,GAAA,GAAM,IAAA;AAChB,QAAA,IAAA,CAAK,GAAA,CAAI,IAAI,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA,IAAK,CAAA,IAAK,OAAO,CAAC,CAAA;AAAA,MAC3C;AAAA,IACF;AACA,IAAA,IAAA,GAAO,IAAA;AAAA,EACT;AACA,EAAA,OAAO,IAAA;AACT;AASA,SAAS,0BAAA,CAA2B,MAAc,OAAA,EAAiD;AACjG,EAAA,MAAM,YAAY,OAAA,CAAQ,MAAA;AAC1B,EAAA,IAAI,qBAAK,IAAI,GAAA,CAAiC,CAAC,CAAC,mBAAG,IAAI,GAAA,CAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AAEtE,EAAA,KAAA,IAAS,IAAA,GAAO,CAAA,EAAG,IAAA,IAAQ,SAAA,EAAW,IAAA,EAAA,EAAQ;AAC5C,IAAA,MAAM,CAAA,GAAI,OAAA,CAAQ,IAAA,GAAO,CAAC,CAAA,IAAK,CAAA;AAC/B,IAAA,MAAM,IAAA,uBAAW,GAAA,EAAiC;AAClD,IAAA,KAAA,MAAW,CAAC,KAAA,EAAO,MAAM,CAAA,IAAK,EAAA,EAAI,IAAA,CAAK,GAAA,CAAI,KAAA,EAAO,IAAI,GAAA,CAAI,MAAM,CAAC,CAAA;AAEjE,IAAA,IAAI,IAAI,CAAA,EAAG;AACT,MAAA,KAAA,MAAW,CAAC,KAAA,EAAO,MAAM,CAAA,IAAK,EAAA,EAAI;AAChC,QAAA,MAAM,YAAY,KAAA,GAAQ,CAAA;AAC1B,QAAA,IAAI,YAAY,IAAA,EAAM;AACtB,QAAA,MAAM,SAAS,IAAA,CAAK,GAAA,CAAI,SAAS,CAAA,wBAAS,GAAA,EAAoB;AAC9D,QAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,MAAA,EAAQ;AAChC,UAAA,MAAM,IAAI,GAAA,GAAM,IAAA;AAChB,UAAA,MAAA,CAAO,GAAA,CAAI,IAAI,MAAA,CAAO,GAAA,CAAI,CAAC,CAAA,IAAK,CAAA,IAAK,OAAO,CAAC,CAAA;AAAA,QAC/C;AACA,QAAA,IAAA,CAAK,GAAA,CAAI,WAAW,MAAM,CAAA;AAAA,MAC5B;AAAA,IACF;AACA,IAAA,EAAA,GAAK,IAAA;AAAA,EACP;AAEA,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,IAAA,EAAM,KAAK,SAAA,IAAa,CAAA;AAE7C,EAAA,MAAM,SAAS,EAAA,CAAG,GAAA,CAAI,IAAI,CAAA,wBAAS,GAAA,EAAoB;AACvD,EAAA,MAAM,MAAA,uBAAa,GAAA,EAAoB;AACvC,EAAA,KAAA,MAAW,CAAC,KAAK,IAAI,CAAA,IAAK,QAAQ,MAAA,CAAO,GAAA,CAAI,GAAA,EAAK,IAAA,GAAO,SAAS,CAAA;AAClE,EAAA,OAAO,MAAA;AACT;AAOO,SAAS,gBAAA,CAAiB,MAAc,OAAA,EAAiD;AAC9F,EAAA,IAAI,IAAA,IAAQ,CAAA,EAAG,uBAAO,IAAI,GAAA,EAAI;AAE9B,EAAA,MAAM,KAAA,GAAQ,mBAAA,CAAoB,IAAA,EAAM,OAAO,CAAA;AAC/C,EAAA,MAAM,QAAA,GAAW,0BAAA,CAA2B,IAAA,EAAM,OAAO,CAAA;AAKzD,EAAA,MAAM,IAAA,GAAO,mBAAA,CAAoB,IAAA,GAAO,CAAA,EAAG,OAAO,CAAA;AAClD,EAAA,MAAM,SAAA,uBAAgB,GAAA,EAAY;AAClC,EAAA,OAAA,CAAQ,OAAA,CAAQ,CAAC,MAAA,EAAQ,KAAA,KAAU;AACjC,IAAA,IAAI,UAAU,CAAA,EAAG;AACjB,IAAA,KAAA,MAAW,GAAA,IAAO,KAAK,IAAA,EAAK,YAAa,GAAA,CAAI,CAAA,IAAK,KAAA,GAAQ,CAAA,CAAA,GAAK,GAAG,CAAA;AAAA,EACpE,CAAC,CAAA;AAED,EAAA,MAAM,MAAA,uBAAa,GAAA,EAAoB;AACvC,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,IAAI,CAAA,IAAK,KAAA,EAAO;AAC/B,IAAA,IAAI,CAAC,SAAA,CAAU,GAAA,CAAI,GAAG,CAAA,EAAG;AACzB,IAAA,MAAM,SAAA,GAAY,KAAK,GAAA,CAAI,CAAA,EAAG,QAAQ,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA,IAAK,CAAA,CAAE,CAAA;AAC7D,IAAA,IAAI,SAAA,GAAY,CAAA,EAAG,MAAA,CAAO,GAAA,CAAI,KAAK,SAAS,CAAA;AAAA,EAC9C;AACA,EAAA,OAAO,MAAA;AACT;AASA,SAAS,2BAAA,CACP,IAAA,EACA,KAAA,EACA,MAAA,EACqB;AACrB,EAAA,MAAM,QAAA,GAAW,CAAC,CAAA,EAAW,CAAA,KAAwB;AACnD,IAAA,MAAM,SAAS,IAAI,KAAA,CAAc,IAAI,CAAC,CAAA,CAAE,KAAK,CAAC,CAAA;AAC9C,IAAA,MAAA,CAAO,CAAC,CAAA,GAAI,CAAA;AACZ,IAAA,KAAA,IAAS,KAAA,GAAQ,CAAA,EAAG,KAAA,GAAQ,CAAA,EAAG,KAAA,EAAA,EAAS;AACtC,MAAA,MAAM,OAAO,IAAI,KAAA,CAAc,IAAI,CAAC,CAAA,CAAE,KAAK,CAAC,CAAA;AAC5C,MAAA,KAAA,IAAS,SAAA,GAAY,CAAA,EAAG,SAAA,IAAa,KAAA,EAAO,SAAA,EAAA,EAAa;AACvD,QAAA,MAAM,IAAA,GAAO,OAAO,SAAS,CAAA;AAC7B,QAAA,IAAI,QAAQ,CAAA,EAAG;AACf,QAAA,IAAA,CAAK,SAAS,CAAA,IAAK,IAAA,IAAQ,CAAA,GAAI,CAAA,CAAA;AAC/B,QAAA,IAAA,CAAK,SAAA,GAAY,CAAC,CAAA,IAAK,IAAA,GAAO,CAAA;AAAA,MAChC;AACA,MAAA,KAAA,IAAS,CAAA,GAAI,GAAG,CAAA,IAAK,CAAA,EAAG,KAAK,MAAA,CAAO,CAAC,CAAA,GAAI,IAAA,CAAK,CAAC,CAAA;AAAA,IACjD;AACA,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAEA,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAiC;AAClD,EAAA,MAAM,CAAA,GAAI,CAAC,OAAA,EAAiB,eAAA,KAAiD;AAC3E,IAAA,IAAI,OAAA,KAAY,CAAA,EAAG,uBAAO,IAAI,GAAA,CAAI,CAAC,CAAC,KAAA,EAAO,CAAC,CAAC,CAAC,CAAA;AAC9C,IAAA,IAAI,oBAAoB,CAAA,EAAG;AACzB,MAAA,MAAMA,MAAAA,GAAQ,QAAA,CAAS,OAAA,EAAS,IAAI,CAAA;AACpC,MAAA,MAAMC,OAAAA,uBAAa,GAAA,EAAoB;AACvC,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,OAAA,EAAS,CAAA,EAAA,EAAK;AACjC,QAAA,MAAM,IAAA,GAAOD,OAAM,CAAC,CAAA;AACpB,QAAA,IAAI,IAAA,GAAO,CAAA,EAAGC,OAAAA,CAAO,GAAA,CAAI,CAAA,EAAG,CAAC,CAAA,CAAA,EAAI,OAAA,GAAU,CAAC,CAAA,CAAA,EAAI,IAAI,CAAA;AAAA,MACtD;AACA,MAAA,OAAOA,OAAAA;AAAA,IACT;AAEA,IAAA,MAAM,GAAA,GAAM,CAAA,EAAG,OAAO,CAAA,CAAA,EAAI,eAAe,CAAA,CAAA;AACzC,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA;AAC3B,IAAA,IAAI,QAAQ,OAAO,MAAA;AAEnB,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAoB;AACvC,IAAA,MAAM,UAAA,GAAa,CAAC,EAAA,EAAY,IAAA,KAAuB;AACrD,MAAA,MAAA,CAAO,IAAI,EAAA,EAAA,CAAK,MAAA,CAAO,IAAI,EAAE,CAAA,IAAK,KAAK,IAAI,CAAA;AAAA,IAC7C,CAAA;AAEA,IAAA,KAAA,MAAW,CAAC,IAAI,IAAI,CAAA,IAAK,EAAE,OAAA,EAAS,eAAA,GAAkB,CAAC,CAAA,EAAG;AACxD,MAAA,MAAM,CAAC,GAAG,CAAC,CAAA,GAAI,GAAG,KAAA,CAAM,GAAG,CAAA,CAAE,GAAA,CAAI,MAAM,CAAA;AACvC,MAAA,UAAA,CAAW,GAAG,CAAA,GAAI,CAAC,IAAI,CAAC,CAAA,CAAA,EAAI,OAAO,IAAI,CAAA;AAAA,IACzC;AACA,IAAA,KAAA,MAAW,CAAC,IAAI,IAAI,CAAA,IAAK,EAAE,OAAA,GAAU,CAAA,EAAG,eAAe,CAAA,EAAG;AACxD,MAAA,MAAM,CAAC,GAAG,CAAC,CAAA,GAAI,GAAG,KAAA,CAAM,GAAG,CAAA,CAAE,GAAA,CAAI,MAAM,CAAA;AACvC,MAAA,UAAA,CAAW,CAAA,EAAG,CAAC,CAAA,CAAA,EAAI,CAAA,GAAI,CAAC,CAAA,CAAA,EAAI,IAAA,IAAQ,IAAI,IAAA,CAAK,CAAA;AAAA,IAC/C;AAEA,IAAA,IAAA,CAAK,GAAA,CAAI,KAAK,MAAM,CAAA;AACpB,IAAA,OAAO,MAAA;AAAA,EACT,CAAA;AAEA,EAAA,OAAO,CAAA,CAAE,OAAO,MAAM,CAAA;AACxB;AAGA,SAAS,sBAAA,CAAuB,OAAe,OAAA,EAAoC;AACjF,EAAA,MAAM,YAAY,IAAI,KAAA,CAAc,QAAQ,CAAC,CAAA,CAAE,KAAK,CAAC,CAAA;AACrD,EAAA,SAAA,CAAU,CAAC,CAAA,GAAI,CAAA;AACf,EAAA,KAAA,MAAW,UAAU,OAAA,EAAS;AAC5B,IAAA,IAAI,UAAU,CAAA,EAAG;AACjB,IAAA,KAAA,IAAS,MAAA,GAAS,KAAA,EAAO,MAAA,IAAU,CAAA,EAAG,MAAA,EAAA,EAAU,SAAA,CAAU,MAAM,CAAA,IAAK,SAAA,CAAU,MAAA,GAAS,CAAC,CAAA,GAAI,MAAA;AAAA,EAC/F;AACA,EAAA,IAAI,SAAA,GAAY,CAAA;AAChB,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,KAAA,EAAO,KAAK,SAAA,IAAa,CAAA;AAC9C,EAAA,OAAO,SAAA,GAAY,UAAU,KAAK,CAAA;AACpC;AAoBO,SAAS,6BAAA,CACd,OAAA,EACA,KAAA,EACA,MAAA,EACQ;AACR,EAAA,IAAI,KAAA,IAAS,CAAA,IAAK,OAAA,CAAQ,MAAA,KAAW,GAAG,OAAO,CAAA;AAE/C,EAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,OAAA,CAAQ,MAAA,GAAS,CAAC,CAAA;AACvC,EAAA,MAAM,MAAA,GAAS,IAAA,GAAO,CAAA,GAAI,OAAA,CAAQ,MAAM,CAAA,EAAG,EAAE,CAAA,CAAE,GAAA,CAAI,CAAC,MAAA,KAAW,MAAA,IAAU,CAAA,GAAI,IAAA,CAAK,IAAI,EAAC;AAEvF,EAAA,IAAI,WAAA,GAAc,CAAA;AAClB,EAAA,KAAA,MAAW,CAAC,IAAI,MAAM,CAAA,IAAK,4BAA4B,IAAA,EAAM,KAAA,EAAO,MAAM,CAAA,EAAG;AAC3E,IAAA,MAAM,CAAC,GAAG,CAAC,CAAA,GAAI,GAAG,KAAA,CAAM,GAAG,CAAA,CAAE,GAAA,CAAI,MAAM,CAAA;AACvC,IAAA,IAAI,CAAA,IAAK,GAAG,WAAA,IAAe,MAAA;AAAA,SAAA,IAElB,KAAK,CAAA,EAAG,WAAA,IAAe,UAAU,CAAA,GAAI,sBAAA,CAAuB,GAAG,MAAM,CAAA,CAAA;AAAA,EAChF;AACA,EAAA,OAAO,KAAK,GAAA,CAAI,CAAA,EAAG,KAAK,GAAA,CAAI,CAAA,EAAG,WAAW,CAAC,CAAA;AAC7C;;;AC7XO,IAAM,cAAA,GAAN,MAAM,eAAA,SAAuB,KAAA,CAAM;AAAA,EAOxC,WAAA,CACE,SACA,OAAA,EACA;AACA,IAAA,KAAA,CAAM,OAAO,CAAA;AACb,IAAA,IAAA,CAAK,IAAA,GAAO,gBAAA;AACZ,IAAA,IAAA,CAAK,aAAa,OAAA,EAAS,UAAA;AAC3B,IAAA,IAAA,CAAK,QAAQ,OAAA,EAAS,KAAA;AAEtB,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,EAAM,eAAA,CAAe,SAAS,CAAA;AAAA,EACtD;AACF;;;AC7BA,IAAI,cAAA,GAAiB,IAAA;AAMrB,IAAI,eAAA,GAAkB,CAAA;AAQf,SAAS,kBAAkB,OAAA,EAAwB;AACxD,EAAA,cAAA,GAAiB,OAAA;AACjB,EAAA,IAAI,CAAC,OAAA,EAAS,eAAA,EAAA;AAChB;AAGO,SAAS,iBAAA,GAA6B;AAC3C,EAAA,OAAO,cAAA;AACT;AAYO,IAAM,WAAN,MAAqB;AAAA;AAAA;AAAA;AAAA;AAAA,EAU1B,WAAA,CACmB,OAAA,GAAU,GAAA,EAC3B,OAAA,GAA8B,EAAC,EAC/B;AAFiB,IAAA,IAAA,CAAA,OAAA,GAAA,OAAA;AAVnB,IAAA,IAAA,CAAQ,KAAA,uBAAY,GAAA,EAAU;AAG9B,IAAA,IAAA,CAAQ,UAAA,GAAa,eAAA;AAUnB,IAAA,IAAA,CAAK,WAAW,OAAA,CAAQ,QAAA;AACxB,IAAA,IAAA,CAAK,oBAAA,GAAuB,QAAQ,oBAAA,IAAwB,KAAA;AAAA,EAC9D;AAAA;AAAA,EAGQ,IAAA,GAAa;AACnB,IAAA,IAAI,IAAA,CAAK,oBAAA,IAAwB,IAAA,CAAK,UAAA,KAAe,eAAA,EAAiB;AACpE,MAAA,IAAA,CAAK,MAAM,KAAA,EAAM;AACjB,MAAA,IAAA,CAAK,UAAA,GAAa,eAAA;AAAA,IACpB;AAAA,EACF;AAAA,EAEA,IAAY,OAAA,GAAmB;AAC7B,IAAA,IAAA,CAAK,IAAA,EAAK;AACV,IAAA,OAAO,IAAA,CAAK,OAAA,GAAU,CAAA,KAAM,cAAA,IAAkB,CAAC,IAAA,CAAK,oBAAA,CAAA;AAAA,EACtD;AAAA,EAEA,IAAI,GAAA,EAAuB;AACzB,IAAA,IAAI,CAAC,IAAA,CAAK,OAAA,EAAS,OAAO,MAAA;AAC1B,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAG,CAAA;AAChC,IAAA,IAAI,KAAA,KAAU,QAAW,OAAO,MAAA;AAEhC,IAAA,IAAA,CAAK,KAAA,CAAM,OAAO,GAAG,CAAA;AACrB,IAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAA,EAAK,KAAK,CAAA;AACzB,IAAA,OAAO,KAAA;AAAA,EACT;AAAA,EAEA,OAAO,GAAA,EAAc;AACnB,IAAA,IAAA,CAAK,KAAA,CAAM,OAAO,GAAG,CAAA;AAAA,EACvB;AAAA,EAEA,GAAA,CAAI,KAAQ,KAAA,EAAgB;AAC1B,IAAA,IAAI,CAAC,IAAA,CAAK,OAAA,EAAS,OAAO,IAAA;AAC1B,IAAA,IAAA,CAAK,WAAW,KAAK,CAAA;AACrB,IAAA,IAAA,CAAK,KAAA,CAAM,OAAO,GAAG,CAAA;AACrB,IAAA,IAAI,IAAA,CAAK,KAAA,CAAM,IAAA,IAAQ,IAAA,CAAK,OAAA,EAAS;AACnC,MAAA,MAAM,YAAY,IAAA,CAAK,KAAA,CAAM,IAAA,EAAK,CAAE,MAAK,CAAE,KAAA;AAC3C,MAAA,IAAA,CAAK,KAAA,CAAM,OAAO,SAAc,CAAA;AAAA,IAClC;AACA,IAAA,IAAA,CAAK,KAAA,CAAM,GAAA,CAAI,GAAA,EAAK,KAAK,CAAA;AACzB,IAAA,OAAO,IAAA;AAAA,EACT;AAAA,EAEA,KAAA,GAAc;AACZ,IAAA,IAAA,CAAK,MAAM,KAAA,EAAM;AAAA,EACnB;AAAA,EAEA,IAAI,IAAA,GAAe;AACjB,IAAA,IAAA,CAAK,IAAA,EAAK;AACV,IAAA,OAAO,KAAK,KAAA,CAAM,IAAA;AAAA,EACpB;AAAA,EAEA,IAAI,GAAA,EAAiB;AACnB,IAAA,OAAO,IAAA,CAAK,OAAA,IAAW,IAAA,CAAK,KAAA,CAAM,IAAI,GAAG,CAAA;AAAA,EAC3C;AAAA,EAEA,IAAA,GAA4B;AAC1B,IAAA,IAAA,CAAK,IAAA,EAAK;AACV,IAAA,OAAO,IAAA,CAAK,MAAM,IAAA,EAAK;AAAA,EACzB;AAAA,EAEA,MAAA,GAA8B;AAC5B,IAAA,IAAA,CAAK,IAAA,EAAK;AACV,IAAA,OAAO,IAAA,CAAK,MAAM,MAAA,EAAO;AAAA,EAC3B;AACF;;;ACjHO,IAAM,GAAA,GAAM;AA0EZ,SAAS,eAAA,CAAgB,SAAA,EAAmB,QAAA,GAAqB,MAAA,EAAgB;AACtF,EAAA,MAAM,OAAO,SAAA,GAAY,EAAA;AACzB,EAAA,QAAQ,QAAA;AAAU,IAChB,KAAK,WAAA;AACH,MAAA,OAAO,CAAA,GAAA,CAAK,IAAI,IAAA,KAAS,CAAA;AAAA,IAC3B,KAAK,gBAAA;AACH,MAAA,OAAO,CAAA,GAAA,CAAK,IAAI,IAAA,KAAS,CAAA;AAAA,IAC3B,KAAK,cAAA;AACH,MAAA,OAAO,IAAA,IAAQ,CAAA;AAAA,IACjB,KAAK,MAAA;AAAA,IACL;AACE,MAAA,OAAO,IAAA;AAAA;AAEb;AAOO,IAAM,iBAAA,GAAiC;AAQvC,IAAM,iBAAA,GAAmC;AAAA,EAC9C,UAAA;AAAA,EACA,YAAA;AAAA,EACA,UAAA;AAAA,EACA,UAAA;AAAA,EACA,IAAA;AAAA,EACA,KAAA;AAAA,EACA;AACF;AAMO,IAAM,qBAAA,GAAuC;AAAA,EAClD,MAAA;AAAA,EACA,KAAA;AAAA,EACA,YAAA;AAAA,EACA,UAAA;AAAA,EACA,UAAA;AAAA,EACA,IAAA;AAAA,EACA;AACF;AAOO,SAAS,YAAA,CACd,QAAA,EACA,KAAA,GAA2B,iBAAA,EACtB;AACL,EAAA,MAAM,IAAA,GAAO,IAAI,GAAA,CAAI,KAAA,CAAM,GAAA,CAAI,CAAC,CAAA,EAAG,CAAA,KAAM,CAAC,CAAA,EAAG,CAAC,CAAC,CAAC,CAAA;AAChD,EAAA,OAAO,CAAC,GAAG,QAAQ,EAAE,IAAA,CAAK,CAAC,GAAG,CAAA,KAAM;AAClC,IAAA,MAAM,EAAA,GAAK,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA;AACrB,IAAA,MAAM,EAAA,GAAK,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA;AACrB,IAAA,IAAI,EAAA,KAAO,MAAA,IAAa,EAAA,KAAO,MAAA,SAAkB,EAAA,GAAK,EAAA;AACtD,IAAA,IAAI,EAAA,KAAO,QAAW,OAAO,EAAA;AAC7B,IAAA,IAAI,EAAA,KAAO,QAAW,OAAO,CAAA;AAC7B,IAAA,OAAO,CAAA,CAAE,cAAc,CAAC,CAAA;AAAA,EAC1B,CAAC,CAAA;AACH;AAEO,IAAM,QAAA,GAA0B,CAAC,KAAA,EAAO,MAAM;AAC9C,IAAM,UAAA,GAA4B,CAAC,MAAM;AACzC,IAAM,SAAA,GAA2B,CAAC,KAAK;AACvC,IAAM,UAAA,GAA4B,CAAC,UAAA,EAAY,YAAY;AAC3D,IAAM,gBAAA,GAAkC,CAAC,YAAY;AACrD,IAAM,cAAA,GAAgC,CAAC,UAAU;AACjD,IAAM,cAAA,GAAgC,CAAC,UAAU;AACjD,IAAM,mBAAA,GAAqC,CAAC,IAAI;;;AC7IhD,IAAM,UAAA,GAAN,MAAM,UAAA,CAAU;AAAA,EAOrB,WAAA,CAAY,OAAA,EAAsB,QAAA,EAAgB,GAAA,GAAM,GAAA,EAAK;AAC3D,IAAA,IAAA,CAAK,UAAU,KAAA,CAAM,OAAA,CAAQ,OAAO,CAAA,GAAI,OAAA,GAAU,CAAC,OAAO,CAAA;AAC1D,IAAA,IAAI,KAAK,OAAA,CAAQ,IAAA,CAAK,CAAC,CAAA,KAAM,CAAA,KAAM,MAAS,CAAA,EAAG;AAC7C,MAAA,MAAM,IAAI,MAAM,sCAAsC,CAAA;AAAA,IACxD;AACA,IAAA,IAAA,CAAK,IAAA,GAAO,GAAA;AAKZ,IAAA,IAAA,CAAK,oBAAoB,QAAA,KAAa,MAAA;AACtC,IAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,MAAA,IAAA,CAAK,SAAA,GACH,IAAA,CAAK,GAAA,CAAI,QAAA,CAAS,IAAA,EAAK,GAAI,CAAC,CAAA,IAAK,GAAA,GAAM,QAAA,GAAW,QAAA,CAAS,SAAA,EAAU;AAAA,IACzE;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,IAAI,QAAA,GAAgB;AAClB,IAAA,IAAI,IAAA,CAAK,cAAc,MAAA,EAAW;AAChC,MAAA,MAAM,CAAA,GAAI,GAAA,CAAI,YAAA,CAAa,IAAA,CAAK,OAAO,CAAA;AACvC,MAAA,IAAA,CAAK,SAAA,GACH,IAAA,CAAK,GAAA,CAAI,CAAA,CAAE,IAAA,EAAK,GAAI,CAAC,CAAA,IAAK,IAAA,CAAK,IAAA,GAAO,CAAA,GAAI,CAAA,CAAE,SAAA,EAAU;AAAA,IAC1D;AACA,IAAA,OAAO,IAAA,CAAK,SAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA2BA,uBAAA,GAA+B;AAC7B,IAAA,IAAI,KAAK,iBAAA,EAAmB;AAC1B,MAAA,OAAO,IAAA,CAAK,iBAAA;AAAA,IACd;AAOA,IAAA,IAAI,KAAK,iBAAA,EAAmB;AAC1B,MAAA,IAAA,CAAK,iBAAA,GAAoB,IAAA,CAAK,QAAA,CAAS,eAAA,EAAgB;AACvD,MAAA,OAAO,IAAA,CAAK,iBAAA;AAAA,IACd;AAKA,IAAA,IAAI,IAAA,CAAK,QAAQ,KAAA,CAAM,CAAC,QAAQ,GAAA,CAAI,cAAA,EAAgB,CAAA,EAAG;AACrD,MAAA,IAAA,CAAK,oBAAoB,IAAA,CAAK,QAAA;AAC9B,MAAA,OAAO,IAAA,CAAK,iBAAA;AAAA,IACd;AAIA,IAAA,MAAM,eAAA,GAAkB,KAAK,OAAA,CAAQ,GAAA,CAAI,CAAC,GAAA,KAAQ,GAAA,CAAI,iBAAiB,CAAA;AACvE,IAAA,MAAM,WAAW,GAAA,CAAI,YAAA,CAAa,eAAA,EAAiB,IAAA,CAAK,SAAS,OAAO,CAAA;AAGxE,IAAA,MAAM,UAAA,GACJ,IAAA,CAAK,GAAA,CAAI,QAAA,CAAS,IAAA,EAAK,GAAI,CAAC,CAAA,IAAK,IAAA,CAAK,QAAA,CAAS,OAAA,GAC3C,QAAA,GACA,SAAS,SAAA,EAAU;AAEzB,IAAA,IAAA,CAAK,iBAAA,GAAoB,UAAA;AACzB,IAAA,OAAO,UAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,kBAAA,GAAuD;AACrD,IAAA,OAAO,IAAA,CAAK,uBAAA,EAAwB,CAAE,kBAAA,EAAmB;AAAA,EAC3D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,4BAA4B,OAAA,EAII;AAC9B,IAAA,OAAO,IAAA,CAAK,uBAAA,EAAwB,CAAE,2BAAA,CAA4B,OAAO,CAAA;AAAA,EAC3E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,iBAAiB,KAAA,EAAuB;AACtC,IAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,IAAA,KAAA,MAAW,MAAA,IAAU,KAAK,OAAA,EAAS;AACjC,MAAA,IAAI,MAAA,CAAO,UAAA,CAAW,KAAK,CAAA,EAAG,KAAA,EAAA;AAAA,IAChC;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAA,GAAe;AAIb,IAAA,IAAI,KAAK,iBAAA,EAAmB;AAC1B,MAAA,IAAI,CAAA,GAAI,CAAA;AACR,MAAA,KAAA,MAAW,CAAC,aAAa,GAAG,CAAA,IAAK,KAAK,QAAA,EAAU,CAAA,IAAK,cAAc,GAAA,CAAI,CAAA;AACvE,MAAA,OAAO,CAAA;AAAA,IACT;AAGA,IAAA,IAAI,SAAA,GAAY,CAAA;AAChB,IAAA,KAAA,MAAW,MAAA,IAAU,KAAK,OAAA,EAAS;AACjC,MAAA,MAAM,IAAA,GAAO,OAAO,IAAA,EAAK;AACzB,MAAA,IAAI,QAAQ,CAAA,EAAG;AAGf,MAAA,SAAA,IACE,IAAA,CAAK,GAAA,CAAI,IAAA,GAAO,CAAC,CAAA,IAAK,IAAA,CAAK,IAAA,GAAO,MAAA,CAAO,IAAA,EAAK,GAAI,MAAA,CAAO,IAAA,EAAK,GAAI,IAAA;AAAA,IACtE;AACA,IAAA,OAAO,SAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,QAAA,GAAmB;AAGjB,IAAA,IAAI,KAAK,iBAAA,EAAmB;AAC1B,MAAA,MAAM,EAAA,GAAK,KAAK,IAAA,EAAK;AACrB,MAAA,IAAI,CAAA,GAAI,CAAA;AACR,MAAA,KAAA,MAAW,CAAC,WAAA,EAAa,GAAG,CAAA,IAAK,KAAK,QAAA,EAAU;AAC9C,QAAA,MAAM,MAAM,WAAA,GAAc,EAAA;AAC1B,QAAA,CAAA,IAAK,GAAA,GAAM,MAAM,GAAA,CAAI,CAAA;AAAA,MACvB;AACA,MAAA,OAAO,CAAA;AAAA,IACT;AAIA,IAAA,IAAI,aAAA,GAAgB,CAAA;AACpB,IAAA,KAAA,MAAW,MAAA,IAAU,KAAK,OAAA,EAAS;AACjC,MAAA,MAAM,IAAA,GAAO,OAAO,IAAA,EAAK;AACzB,MAAA,IAAI,QAAQ,CAAA,EAAG;AACf,MAAA,IAAI,KAAK,GAAA,CAAI,IAAA,GAAO,CAAC,CAAA,IAAK,KAAK,IAAA,EAAM;AAEnC,QAAA,aAAA,IAAiB,OAAO,QAAA,EAAS;AAAA,MACnC,CAAA,MAAO;AAEL,QAAA,IAAI,EAAA,GAAK,CAAA;AACT,QAAA,KAAA,MAAW,CAAC,GAAG,CAAC,CAAA,IAAK,QAAQ,EAAA,IAAM,CAAA,IAAK,EAAE,CAAA,GAAI,IAAA,CAAA;AAC9C,QAAA,IAAI,CAAA,GAAI,CAAA;AACR,QAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,MAAA,EAAQ;AAC3B,UAAA,MAAM,MAAM,CAAA,GAAI,EAAA;AAChB,UAAA,CAAA,IAAK,GAAA,GAAM,GAAA,IAAO,CAAA,CAAE,CAAA,GAAI,IAAA,CAAA;AAAA,QAC1B;AACA,QAAA,aAAA,IAAiB,CAAA;AAAA,MACnB;AAAA,IACF;AACA,IAAA,OAAO,aAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAA,GAAiB;AACf,IAAA,OAAO,IAAA,CAAK,IAAA,CAAK,IAAA,CAAK,QAAA,EAAU,CAAA;AAAA,EAClC;AAAA;AAAA,EAGA,KAAA,GAAgB;AACd,IAAA,OAAO,KAAK,MAAA,EAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA,EAKA,IAAI,CAAA,EAAmB;AACrB,IAAA,OAAO,IAAA,CAAK,gBAAgB,CAAC,CAAA;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,gBAAgB,CAAA,EAAmB;AACjC,IAAA,IAAI,qBAAA,GAAwB,CAAA;AAC5B,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,KAAK,QAAA,EAAU;AACzD,MAAA,IAAI,eAAe,CAAA,EAAG;AACpB,QAAA,qBAAA,IAAyB,cAAA,CAAe,CAAA;AAAA,MAC1C;AAAA,IACF;AACA,IAAA,OAAO,qBAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,KAAK,CAAA,EAAmB;AACtB,IAAA,OAAO,IAAA,CAAK,iBAAiB,CAAC,CAAA;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,iBAAiB,SAAA,EAA2B;AAC1C,IAAA,IAAI,cAAA,GAAiB,CAAA;AACrB,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,KAAK,QAAA,EAAU;AACzD,MAAA,IAAI,eAAe,SAAA,EAAW;AAC5B,QAAA,cAAA,IAAkB,cAAA,CAAe,CAAA;AAAA,MACnC;AAAA,IACF;AACA,IAAA,OAAO,cAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,YAAY,gBAAA,EAAsC;AAChD,IAAA,OAAO,gBAAA,CAAiB,IAAI,CAAC,CAAA,KAAM,KAAK,QAAA,CAAS,QAAA,CAAS,CAAC,CAAC,CAAA;AAAA,EAC9D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA,GAAc;AACZ,IAAA,OAAO,IAAA,CAAK,SAAS,GAAA,EAAI;AAAA,EAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,GAAA,GAAc;AACZ,IAAA,OAAO,IAAA,CAAK,SAAS,GAAA,EAAI;AAAA,EAC3B;AAAA,EAEQ,UAAA,CAAW,WAAmB,KAAA,EAA4B;AAChE,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,OAAA,CAAQ,SAAS,CAAA;AACrC,IAAA,IAAI,cAAA,GAAiB,CAAA;AACrB,IAAA,KAAA,MAAW,GAAG,cAAc,CAAA,IAAK,MAAA,EAAQ;AACvC,MAAA,cAAA,IAAkB,cAAA,CAAe,KAAA,CAAM,KAAK,CAAA,IAAK,CAAA;AAAA,IACnD;AAIA,IAAA,MAAM,IAAA,GAAO,OAAO,IAAA,EAAK;AACzB,IAAA,OAAO,IAAA,GAAO,CAAA,GAAI,cAAA,GAAiB,IAAA,GAAO,CAAA;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaQ,kBAAkB,MAAA,EAAiC;AACzD,IAAA,MAAM,CAAA,GAAI,KAAK,OAAA,CAAQ,MAAA;AACvB,IAAA,MAAM,oBAAA,GAAuB,KAAK,OAAA,CAAQ,GAAA;AAAA,MAAI,CAAC,WAC7C,IAAI,UAAA,CAAU,CAAC,MAAM,CAAC,CAAA,CAAE,aAAA,CAAc,MAAM;AAAA,KAC9C;AAEA,IAAA,MAAM,OAAO,IAAI,KAAA,CAAM,IAAI,CAAC,CAAA,CAAE,KAAK,CAAC,CAAA;AACpC,IAAA,IAAA,CAAK,CAAC,CAAA,GAAI,CAAA;AACV,IAAA,KAAA,MAAW,eAAe,oBAAA,EAAsB;AAC9C,MAAA,KAAA,IAAS,YAAA,GAAe,CAAA,EAAG,YAAA,IAAgB,CAAA,EAAG,YAAA,EAAA,EAAgB;AAC5D,QAAA,IAAA,CAAK,YAAY,CAAA,GACf,IAAA,CAAK,YAAY,CAAA,IAAK,IAAI,WAAA,CAAA,GAC1B,IAAA,CAAK,YAAA,GAAe,CAAC,CAAA,GAAI,WAAA;AAAA,MAC7B;AACA,MAAA,IAAA,CAAK,CAAC,KAAK,CAAA,GAAI,WAAA;AAAA,IACjB;AACA,IAAA,OAAO,IAAA;AAAA,EACT;AAAA,EAEA,YAAA,CAAa,QAAqC,CAAA,EAAmB;AACnE,IAAA,MAAM,CAAA,GAAI,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,GAAI,CAAC,GAAG,IAAI,GAAA,CAAI,MAAM,CAAC,CAAA,GAAI,CAAC,MAAM,CAAA;AAChE,IAAA,MAAM,CAAA,GAAI,KAAK,OAAA,CAAQ,MAAA;AAEvB,IAAA,IAAI,CAAA,IAAK,GAAG,OAAO,CAAA;AACnB,IAAA,IAAI,CAAA,GAAI,GAAG,OAAO,CAAA;AAIlB,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,iBAAA,CAAkB,CAAC,CAAA;AACrC,IAAA,IAAI,IAAA,GAAO,CAAA;AACX,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,CAAA,EAAG,CAAA,EAAA,EAAK;AAC3B,MAAA,IAAA,IAAQ,KAAK,CAAC,CAAA;AAAA,IAChB;AAEA,IAAA,IAAI,IAAA,GAAO,GAAG,OAAO,CAAA;AACrB,IAAA,IAAI,IAAA,GAAO,GAAG,OAAO,CAAA;AACrB,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,eAAe,MAAA,EAA6C;AAC1D,IAAA,MAAM,cAAA,GAAiB,OAAO,MAAA,KAAW,QAAA,GAAW,CAAC,MAAM,CAAA,GAAI,CAAC,GAAG,IAAI,GAAA,CAAI,MAAM,CAAC,CAAA;AAElF,IAAA,IAAI,sBAAA,GAAyB,CAAA;AAC7B,IAAA,KAAA,IAAS,YAAY,CAAA,EAAG,SAAA,GAAY,IAAA,CAAK,OAAA,CAAQ,QAAQ,SAAA,EAAA,EAAa;AAIpE,MAAA,IAAI,mBAAA,GAAsB,CAAA;AAC1B,MAAA,KAAA,MAAW,SAAS,cAAA,EAAgB;AAClC,QAAA,mBAAA,IAAuB,IAAA,CAAK,UAAA,CAAW,SAAA,EAAW,KAAK,CAAA;AAAA,MACzD;AACA,MAAA,IAAI,mBAAA,GAAsB,GAAG,mBAAA,GAAsB,CAAA;AAAA,WAAA,IAC1C,mBAAA,GAAsB,GAAG,mBAAA,GAAsB,CAAA;AACxD,MAAA,sBAAA,IAA0B,CAAA,GAAI,mBAAA;AAAA,IAChC;AACA,IAAA,MAAM,SAAS,CAAA,GAAI,sBAAA;AACnB,IAAA,OAAO,MAAA,GAAS,CAAA,GAAI,CAAA,GAAI,MAAA,GAAS,IAAI,CAAA,GAAI,MAAA;AAAA,EAC3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBQ,4BAAA,CACN,OACA,IAAA,EACU;AACV,IAAA,MAAM,uBAAA,GAA0B,KAAK,OAAA,CAAQ,GAAA;AAAA,MAAI,CAAC,CAAA,EAAG,SAAA,KACnD,IAAA,CAAK,UAAA,CAAW,WAAW,KAAK;AAAA,KAClC;AACA,IAAA,MAAM,gBAAgB,IAAI,KAAA,CAAM,OAAO,CAAC,CAAA,CAAE,KAAK,CAAC,CAAA;AAChD,IAAA,aAAA,CAAc,CAAC,CAAA,GAAI,CAAA;AAEnB,IAAA,KAAA,MAAW,qBAAqB,uBAAA,EAAyB;AACvD,MAAA,KAAA,IAAS,YAAA,GAAe,IAAA,EAAM,YAAA,IAAgB,CAAA,EAAG,YAAA,EAAA,EAAgB;AAC/D,QAAA,aAAA,CAAc,YAAY,CAAA,GACxB,aAAA,CAAc,YAAY,CAAA,IAAK,IAAI,iBAAA,CAAA,GACnC,aAAA,CAAc,YAAA,GAAe,CAAC,CAAA,GAAI,iBAAA;AAAA,MACtC;AACA,MAAA,aAAA,CAAc,CAAC,KAAK,CAAA,GAAI,iBAAA;AAAA,IAC1B;AAEA,IAAA,OAAO,aAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBA,YAAA,CAAa,QAAqC,CAAA,EAAmB;AACnE,IAAA,IAAI,CAAA,GAAI,GAAG,OAAO,CAAA;AAElB,IAAA,IAAI,OAAO,WAAW,QAAA,EAAU;AAC9B,MAAA,MAAM,gBAAA,GAAmB,IAAA,CAAK,4BAAA,CAA6B,MAAA,EAAQ,CAAC,CAAA;AACpE,MAAA,OAAO,iBAAiB,CAAC,CAAA;AAAA,IAC3B;AAIA,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,iBAAA,CAAkB,MAAM,CAAA;AAC1C,IAAA,OAAO,KAAK,CAAA,IAAK,CAAA,GAAI,KAAK,MAAA,GAAS,IAAA,CAAK,CAAC,CAAA,GAAI,CAAA;AAAA,EAC/C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,WAAA,CAAY,QAAqC,CAAA,EAAmB;AAElE,IAAA,IAAI,OAAO,WAAW,QAAA,EAAU;AAC9B,MAAA,MAAM,gBAAA,GAAmB,IAAA,CAAK,4BAAA,CAA6B,MAAA,EAAQ,CAAC,CAAA;AACpE,MAAA,IAAIC,cAAAA,GAAgB,CAAA;AACpB,MAAA,KAAA,IAAS,YAAA,GAAe,CAAA,EAAG,YAAA,IAAgB,CAAA,EAAG,YAAA,EAAA,EAAgB;AAC5D,QAAAA,cAAAA,IAAiB,iBAAiB,YAAY,CAAA;AAAA,MAChD;AACA,MAAA,OAAOA,cAAAA;AAAA,IACT;AAIA,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,iBAAA,CAAkB,MAAM,CAAA;AAC1C,IAAA,MAAM,QAAQ,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,IAAA,CAAK,SAAS,CAAC,CAAA;AACzC,IAAA,IAAI,aAAA,GAAgB,CAAA;AACpB,IAAA,KAAA,IAAS,YAAA,GAAe,CAAA,EAAG,YAAA,IAAgB,KAAA,EAAO,YAAA,EAAA,EAAgB;AAChE,MAAA,aAAA,IAAiB,KAAK,YAAY,CAAA;AAAA,IACpC;AACA,IAAA,OAAO,aAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,mBAAmB,MAAA,EAA6C;AAC9D,IAAA,MAAM,MAAA,GAAS,KAAA,CAAM,OAAA,CAAQ,MAAM,CAAA,GAAI,CAAC,GAAG,IAAI,GAAA,CAAI,MAAM,CAAC,CAAA,GAAI,CAAC,MAAM,CAAA;AAErE,IAAA,IAAI,KAAA,GAAQ,CAAA;AAGZ,IAAA,KAAA,MAAW,MAAA,IAAU,KAAK,OAAA,EAAS;AACjC,MAAA,MAAM,IAAA,GAAO,OAAO,IAAA,EAAK;AACzB,MAAA,IAAI,QAAQ,CAAA,EAAG;AACf,MAAA,IAAI,YAAA,GAAe,CAAA;AACnB,MAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,MAAA,EAAQ;AAC/B,QAAA,IAAI,CAAA,GAAI,CAAA;AACR,QAAA,KAAA,MAAW,SAAS,MAAA,EAAQ,CAAA,IAAK,GAAA,CAAI,KAAA,CAAM,KAAK,CAAA,IAAK,CAAA;AACrD,QAAA,YAAA,IAAgB,GAAA,GAAM,CAAA;AAAA,MACxB;AACA,MAAA,KAAA,IAAS,IAAA,CAAK,IAAI,IAAA,GAAO,CAAC,KAAK,IAAA,CAAK,IAAA,GAAO,eAAe,YAAA,GAAe,IAAA;AAAA,IAC3E;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA8CA,gBAAgB,MAAA,EAKd;AAEA,IAAA,MAAM,aAAa,OAAO,MAAA,KAAW,QAAA,GAAW,CAAC,MAAM,CAAA,GAAI,MAAA;AAE3D,IAAA,IAAI,SAAA,GAAY,QAAA;AAChB,IAAA,IAAI,SAAA,GAAY,CAAA,QAAA;AAChB,IAAA,IAAI,WAAA,GAAc,CAAA;AAClB,IAAA,IAAI,UAAA,GAAa,CAAA;AAEjB,IAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,cAAc,CAAA,IAAK,KAAK,QAAA,EAAU;AAEpD,MAAA,IAAI,cAAA,GAAiB,KAAA;AACrB,MAAA,IAAI,eAAA,GAAkB,CAAA;AAEtB,MAAA,KAAA,MAAW,SAAS,UAAA,EAAY;AAC9B,QAAA,MAAM,KAAA,GAAQ,cAAA,CAAe,KAAA,CAAM,KAAK,CAAA;AACxC,QAAA,IAAI,KAAA,IAAS,QAAQ,CAAA,EAAG;AACtB,UAAA,cAAA,GAAiB,IAAA;AACjB,UAAA,eAAA,IAAmB,KAAA;AAAA,QACrB;AAAA,MACF;AAEA,MAAA,IAAI,MAAA,GAAS,KAAK,cAAA,EAAgB;AAChC,QAAA,SAAA,GAAY,IAAA,CAAK,GAAA,CAAI,SAAA,EAAW,MAAM,CAAA;AACtC,QAAA,SAAA,GAAY,IAAA,CAAK,GAAA,CAAI,SAAA,EAAW,MAAM,CAAA;AAGtC,QAAA,MAAM,WAAA,GACJ,UAAA,CAAW,MAAA,KAAW,CAAA,GAAI,kBAAkB,cAAA,CAAe,CAAA;AAC7D,QAAA,WAAA,IAAe,MAAA,GAAS,WAAA;AACxB,QAAA,UAAA,IAAc,WAAA;AAAA,MAChB;AAAA,IACF;AAEA,IAAA,OAAO;AAAA,MACL,GAAA,EAAK,SAAA,KAAc,QAAA,GAAW,CAAA,GAAI,SAAA;AAAA,MAClC,GAAA,EAAK,SAAA,KAAc,CAAA,QAAA,GAAY,CAAA,GAAI,SAAA;AAAA,MACnC,GAAA,EAAK,UAAA,GAAa,CAAA,GAAI,WAAA,GAAc,UAAA,GAAa,CAAA;AAAA,MACjD,KAAA,EAAO;AAAA,KACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA+CA,oBAAoB,WAAA,EAKlB;AAEA,IAAA,MAAM,WAAA,GAAc,KAAK,OAAA,CAAQ,GAAA;AAAA,MAAI,CAAC,WACpC,IAAI,UAAA,CAAU,CAAC,MAAM,CAAC,CAAA,CAAE,eAAA,CAAgB,WAAW;AAAA,KACrD;AAGA,IAAA,IAAI,YAAY,IAAA,CAAK,CAAC,UAAU,KAAA,CAAM,KAAA,KAAU,CAAC,CAAA,EAAG;AAClD,MAAA,OAAO,EAAE,KAAK,CAAA,EAAG,GAAA,EAAK,GAAG,GAAA,EAAK,CAAA,EAAG,OAAO,CAAA,EAAE;AAAA,IAC5C;AAGA,IAAA,MAAM,WAAA,GAAc,YAAY,MAAA,CAAO,CAAC,KAAK,KAAA,KAAU,GAAA,GAAM,KAAA,CAAM,GAAA,EAAK,CAAC,CAAA;AACzE,IAAA,MAAM,WAAA,GAAc,YAAY,MAAA,CAAO,CAAC,KAAK,KAAA,KAAU,GAAA,GAAM,KAAA,CAAM,GAAA,EAAK,CAAC,CAAA;AACzE,IAAA,MAAM,WAAA,GAAc,YAAY,MAAA,CAAO,CAAC,KAAK,KAAA,KAAU,GAAA,GAAM,KAAA,CAAM,GAAA,EAAK,CAAC,CAAA;AACzE,IAAA,MAAM,eAAe,WAAA,CAAY,MAAA;AAAA,MAC/B,CAAC,OAAA,EAAS,KAAA,KAAU,OAAA,GAAU,KAAA,CAAM,KAAA;AAAA,MACpC;AAAA,KACF;AAEA,IAAA,OAAO;AAAA,MACL,GAAA,EAAK,WAAA;AAAA,MACL,GAAA,EAAK,WAAA;AAAA,MACL,GAAA,EAAK,WAAA;AAAA,MACL,KAAA,EAAO;AAAA,KACT;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,cAAc,MAAA,EAA6C;AACzD,IAAA,OAAO,IAAA,CAAK,eAAe,MAAM,CAAA;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,UAAA,GAAqB;AAEnB,IAAA,OAAO,IAAA,CAAK,aAAA,CAAc,CAAC,YAAA,EAAc,UAAU,CAAC,CAAA;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,aAAA,GAAiD;AAC/C,IAAA,OAAO,KAAK,QAAA,CAAS,OAAA,EAAQ,CAAE,GAAA,CAAI,CAAC,WAAA,MAAiB;AAAA,MACnD,CAAA,EAAG,WAAA;AAAA,MACH,GAAG,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,GAAA,CAAI,WAAW,CAAA,CAAG;AAAA,KACzC,CAAE,CAAA;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,cAAA,CACE,MAAA,GAAwB,EAAC,EAC0C;AACnE,IAAA,OAAO,KAAK,QAAA,CAAS,OAAA,EAAQ,CAAE,GAAA,CAAI,CAAC,WAAA,KAAgB;AAClD,MAAA,MAAM,cAAA,GAAiB,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,IAAI,WAAW,CAAA;AACxD,MAAA,MAAM,QAAA,GAGF;AAAA,QACF,MAAA,EAAQ,WAAA;AAAA,QACR,OAAO,cAAA,CAAe;AAAA,OACxB;AACA,MAAA,KAAA,MAAW,gBAAgB,MAAA,EAAQ;AACjC,QAAA,QAAA,CAAS,YAAY,CAAA,GAAI,cAAA,CAAe,KAAA,CAAM,YAAY,CAAA,IAAK,CAAA;AAAA,MACjE;AACA,MAAA,OAAO,QAAA;AAAA,IACT,CAAC,CAAA;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,kBAAA,CACE,MAAA,GAAwB,EAAC,EACzB,UAAU,GAAA,EACgE;AAC1E,IAAA,MAAM,YAAA,GAAe,IAAA,CAAK,QAAA,CAAS,OAAA,EAAQ;AAE3C,IAAA,MAAM,QAAA,GAAW,MAAA,CAAO,GAAA,CAAI,CAAC,YAAA,MAAkB;AAAA,MAC7C,KAAA,EAAO,YAAA;AAAA,MACP,IAAA,EAAM,YAAA,CAAa,GAAA,CAAI,CAAC,GAAA,KAAQ;AAC9B,QAAA,MAAM,GAAA,GAAM,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,IAAI,GAAG,CAAA;AACrC,QAAA,MAAM,IAAI,GAAA,GAAO,GAAA,CAAI,KAAA,CAAM,YAAY,KAAgB,CAAA,GAAI,CAAA;AAC3D,QAAA,OAAO,CAAA,IAAK,UAAU,CAAA,GAAI,CAAA;AAAA,MAC5B,CAAC;AAAA,KACH,CAAE,CAAA;AAEF,IAAA,OAAO,EAAE,MAAA,EAAQ,YAAA,EAAc,QAAA,EAAS;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,WAAA,CAAY,gBAAyB,IAAA,EAGnC;AACA,IAAA,MAAM,eAAA,GAAkB,IAAA,CAAK,QAAA,CAAS,OAAA,EAAQ;AAC9C,IAAA,IAAI,eAAA,CAAgB,WAAW,CAAA,EAAG;AAChC,MAAA,OAAO,EAAE,OAAA,EAAS,EAAC,EAAG,IAAA,EAAM,EAAC,EAAE;AAAA,IACjC;AAGA,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,GAAA,CAAI,GAAG,eAAe,CAAA;AAC7C,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,GAAA,CAAI,GAAG,eAAe,CAAA;AAC7C,IAAA,MAAM,UAAU,KAAA,CAAM,IAAA;AAAA,MACpB,EAAE,MAAA,EAAQ,SAAA,GAAY,SAAA,GAAY,CAAA,EAAE;AAAA,MACpC,CAAC,CAAA,EAAG,CAAA,KAAM,SAAA,GAAY;AAAA,KACxB;AAEA,IAAA,IAAI,qBAAA,GAAwB,CAAA;AAC5B,IAAA,MAAM,UAAoB,EAAC;AAE3B,IAAA,KAAA,MAAW,UAAU,OAAA,EAAS;AAC5B,MAAA,MAAM,GAAA,GAAM,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,IAAI,MAAM,CAAA;AACxC,MAAA,IAAI,GAAA,EAAK;AACP,QAAA,qBAAA,IAAyB,GAAA,CAAI,CAAA;AAAA,MAC/B;AACA,MAAA,OAAA,CAAQ,IAAA;AAAA,QACN,aAAA,GAAgB,wBAAwB,GAAA,GAAM;AAAA,OAChD;AAAA,IACF;AAEA,IAAA,OAAO;AAAA,MACL,OAAA;AAAA,MACA,IAAA,EAAM;AAAA,KACR;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,YAAA,CAAa,gBAAyB,IAAA,EAGpC;AACA,IAAA,MAAM,eAAA,GAAkB,IAAA,CAAK,QAAA,CAAS,OAAA,EAAQ;AAC9C,IAAA,IAAI,eAAA,CAAgB,WAAW,CAAA,EAAG;AAChC,MAAA,OAAO,EAAE,OAAA,EAAS,EAAC,EAAG,IAAA,EAAM,EAAC,EAAE;AAAA,IACjC;AAGA,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,GAAA,CAAI,GAAG,eAAe,CAAA;AAC7C,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,GAAA,CAAI,GAAG,eAAe,CAAA;AAC7C,IAAA,MAAM,UAAU,KAAA,CAAM,IAAA;AAAA,MACpB,EAAE,MAAA,EAAQ,SAAA,GAAY,SAAA,GAAY,CAAA,EAAE;AAAA,MACpC,CAAC,CAAA,EAAG,CAAA,KAAM,SAAA,GAAY;AAAA,KACxB;AAGA,IAAA,IAAI,qBAAA,GAAwB,CAAA;AAC5B,IAAA,MAAM,WAAqB,EAAC;AAE5B,IAAA,KAAA,MAAW,UAAU,OAAA,EAAS;AAE5B,MAAA,MAAM,OAAO,CAAA,GAAI,qBAAA;AACjB,MAAA,QAAA,CAAS,IAAA,CAAK,aAAA,GAAgB,IAAA,GAAO,GAAA,GAAM,IAAI,CAAA;AAG/C,MAAA,MAAM,GAAA,GAAM,IAAA,CAAK,QAAA,CAAS,GAAA,CAAI,IAAI,MAAM,CAAA;AACxC,MAAA,IAAI,GAAA,EAAK;AACP,QAAA,qBAAA,IAAyB,GAAA,CAAI,CAAA;AAAA,MAC/B;AAAA,IACF;AAEA,IAAA,OAAO;AAAA,MACL,OAAA;AAAA,MACA,IAAA,EAAM;AAAA,KACR;AAAA,EACF;AAAA;AAAA,EAGA,qBAAA,CAAsB,YAAY,CAAA,EAAW;AAC3C,IAAA,IAAI,GAAA,GAAM,CAAA;AACV,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,IAAA,CAAK,QAAA,CAAS,GAAA,EAAK,IAAI,CAAA,GAAI,SAAA,EAAW,GAAA,IAAO,GAAA,CAAI,CAAA;AACxE,IAAA,OAAO,GAAA;AAAA,EACT;AAAA;AAAA,EAGA,YAAY,KAAA,EAAsC;AAChD,IAAA,MAAM,KAAA,uBAAY,GAAA,EAAY;AAC9B,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,IAAA,CAAK,SAAS,GAAA,EAAK;AACvC,MAAA,KAAA,MAAW,KAAK,GAAA,CAAI,KAAA;AAClB,QAAA,IAAI,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA,IAAM,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA,GAAe,CAAA,EAAG,KAAA,CAAM,GAAA,CAAI,CAAC,CAAA;AAAA,IACjE;AACA,IAAA,IAAI,MAAM,IAAA,KAAS,CAAA;AACjB,MAAA,CAAC,KAAA,EAAO,MAAA,EAAQ,UAAU,CAAA,CAAE,OAAA,CAAQ,CAAC,CAAA,KAAM,KAAA,CAAM,GAAA,CAAI,CAAC,CAAC,CAAA;AACzD,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,IAAA,CAAK,KAAK,CAAA,CAAE,MAAA;AAAA,MAC7B,CAAC,CAAA,KAAM,KAAA,EAAO,QAAA,CAAS,CAAgB,CAAA,IAAK;AAAA,KAC9C;AACA,IAAA,IAAI,SAAS,KAAA,CAAM,MAAA;AACjB,MAAA,IAAA,CAAK,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,KAAA,CAAM,OAAA,CAAQ,CAAC,CAAA,GAAI,GAAA,IAAO,KAAA,CAAM,OAAA,CAAQ,CAAC,IAAI,GAAA,CAAI,CAAA;AACvE,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA,EAGA,aAAA,CACE,QAAA,GAA0B,IAAA,CAAK,WAAA,EAAY,EACjB;AAC1B,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAyB;AAC5C,IAAA,QAAA,CAAS,QAAQ,CAAC,CAAA,KAAM,OAAO,GAAA,CAAI,CAAA,EAAG,CAAC,CAAC,CAAA;AACxC,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,IAAA,CAAK,SAAS,GAAA,EAAK;AACvC,MAAA,KAAA,MAAW,KAAK,QAAA,EAAU;AACxB,QAAA,MAAM,CAAA,GAAK,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA,IAAgB,CAAA;AACtC,QAAA,MAAA,CAAO,IAAI,CAAA,EAAA,CAAI,MAAA,CAAO,IAAI,CAAC,CAAA,IAAK,KAAK,CAAC,CAAA;AAAA,MACxC;AAAA,IACF;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA,EAGA,mBAAA,CACE,QAAA,GAA0B,IAAA,CAAK,WAAA,EAAY,EACkB;AAE7D,IAAA,MAAM,KAAA,GAAQ,IAAA,CAAK,cAAA,CAAe,QAAQ,CAAA;AAC1C,IAAA,MAAM,MAAA,uBAAa,GAAA,EAGjB;AACF,IAAA,QAAA,CAAS,OAAA,CAAQ,CAAC,CAAA,KAAM,MAAA,CAAO,GAAA,CAAI,CAAA,EAAG,EAAE,GAAA,EAAK,CAAA,EAAG,IAAA,EAAM,CAAA,EAAG,CAAC,CAAA;AAE1D,IAAA,KAAA,MAAW,OAAO,KAAA,EAAO;AACvB,MAAA,MAAM,MAAM,GAAA,CAAI,MAAA;AAChB,MAAA,KAAA,MAAW,KAAK,QAAA,EAAU;AACxB,QAAA,MAAM,CAAA,GAAK,GAAA,CAAI,CAAC,CAAA,IAAgB,CAAA;AAChC,QAAA,IAAI,IAAI,CAAA,EAAG;AACT,UAAA,MAAM,CAAA,GAAI,MAAA,CAAO,GAAA,CAAI,CAAC,CAAA;AACtB,UAAA,CAAA,CAAE,OAAO,GAAA,GAAM,CAAA;AACf,UAAA,CAAA,CAAE,IAAA,IAAQ,CAAA;AACV,UAAA,IAAI,EAAE,GAAA,KAAQ,MAAA,IAAa,MAAM,CAAA,CAAE,GAAA,IAAO,GAAA,GAAM,GAAA;AAChD,UAAA,IAAI,EAAE,GAAA,KAAQ,MAAA,IAAa,MAAM,CAAA,CAAE,GAAA,IAAO,GAAA,GAAM,GAAA;AAAA,QAClD;AAAA,MACF;AAAA,IACF;AAEA,IAAA,MAAM,GAAA,uBAAU,GAAA,EAGd;AACF,IAAA,KAAA,MAAW,KAAK,QAAA,EAAU;AACxB,MAAA,MAAM,CAAA,GAAI,MAAA,CAAO,GAAA,CAAI,CAAC,CAAA;AACtB,MAAA,MAAM,MAAM,CAAA,CAAE,IAAA,GAAO,IAAI,CAAA,CAAE,GAAA,GAAM,EAAE,IAAA,GAAO,CAAA;AAC1C,MAAA,GAAA,CAAI,GAAA,CAAI,CAAA,EAAG,EAAE,GAAA,EAAK,CAAA,CAAE,GAAA,IAAO,CAAA,EAAG,GAAA,EAAK,GAAA,EAAK,CAAA,CAAE,GAAA,IAAO,CAAA,EAAG,CAAA;AAAA,IACtD;AACA,IAAA,OAAO,GAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA2BA,YAAA,CACE,WAAmC,iBAAA,EACA;AACnC,IAAA,MAAM,KAAA,uBAAY,GAAA,EAAkC;AACpD,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,OAAA,CAAQ,GAAA,CAAI,CAAC,GAAA,KAAQ,IAAI,UAAA,CAAU,CAAC,GAAG,CAAA,EAAG,MAAA,EAAW,IAAA,CAAK,IAAI,CAAC,CAAA;AAEtF,IAAA,KAAA,MAAW,WAAW,QAAA,EAAU;AAC9B,MAAA,MAAM,qBAAA,GAAwB,IAAA,CAAK,cAAA,CAAe,OAAO,CAAA;AACzD,MAAA,IAAI,yBAAyB,CAAA,EAAG;AAEhC,MAAA,MAAM,cAAc,EAAE,GAAA,EAAK,GAAG,GAAA,EAAK,CAAA,EAAG,KAAK,CAAA,EAAE;AAC7C,MAAA,IAAI,YAAA,GAAe,CAAA;AACnB,MAAA,KAAA,MAAW,UAAU,SAAA,EAAW;AAC9B,QAAA,IAAI,MAAA,CAAO,cAAA,CAAe,OAAO,CAAA,IAAK,CAAA,EAAG;AACzC,QAAA,YAAA,EAAA;AACA,QAAA,MAAM,IAAA,GAAO,MAAA,CAAO,eAAA,CAAgB,OAAO,CAAA;AAC3C,QAAA,WAAA,CAAY,OAAO,IAAA,CAAK,GAAA;AACxB,QAAA,WAAA,CAAY,OAAO,IAAA,CAAK,GAAA;AACxB,QAAA,WAAA,CAAY,OAAO,IAAA,CAAK,GAAA;AAAA,MAC1B;AAEA,MAAA,KAAA,CAAM,IAAI,OAAA,EAAS;AAAA,QACjB,qBAAA;AAAA,QACA,gBACE,YAAA,GAAe,CAAA,GAAI,KAAK,YAAA,CAAa,OAAA,EAAS,YAAY,CAAA,GAAI,CAAA;AAAA,QAChE;AAAA,OACD,CAAA;AAAA,IACH;AAEA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,SAAS,KAAA,EAA0C;AAEjD,IAAA,MAAM,UAAA,uBAAiB,GAAA,EAAY;AACnC,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,IAAA,CAAK,SAAS,GAAA,EAAK;AACvC,MAAA,KAAA,MAAW,CAAA,IAAK,IAAI,KAAA,EAAO;AACzB,QAAA,IAAI,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA,IAAM,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA,GAAe,CAAA,EAAG,UAAA,CAAW,GAAA,CAAI,CAAC,CAAA;AAAA,MACpE;AAAA,IACF;AACA,IAAA,IAAI,UAAA,CAAW,SAAS,CAAA,EAAG;AACzB,MAAA,KAAA,MAAW,CAAA,IAAK,UAAA,CAAU,gBAAA,EAAkB,UAAA,CAAW,IAAI,CAAC,CAAA;AAAA,IAC9D;AAEA,IAAA,IAAI,QAAA,GAAW,KAAA,CAAM,IAAA,CAAK,UAAU,CAAA;AAGpC,IAAA,IAAI,KAAA,IAAS,MAAM,MAAA,EAAQ;AACzB,MAAA,MAAM,OAAA,GAAU,IAAI,GAAA,CAAI,KAAK,CAAA;AAC7B,MAAA,QAAA,GAAW,SAAS,MAAA,CAAO,CAAC,MAAM,OAAA,CAAQ,GAAA,CAAI,CAAgB,CAAC,CAAA;AAC/D,MAAA,MAAM,IAAA,GAAO,IAAI,GAAA,CAAI,KAAA,CAAM,GAAA,CAAI,CAAC,CAAA,EAAG,CAAA,KAAM,CAAC,CAAA,EAAG,CAAC,CAAC,CAAC,CAAA;AAChD,MAAA,QAAA,CAAS,IAAA;AAAA,QACP,CAAC,CAAA,EAAG,CAAA,KAAA,CACD,IAAA,CAAK,GAAA,CAAI,CAAgB,CAAA,IAAK,GAAA,KAC9B,IAAA,CAAK,GAAA,CAAI,CAAgB,CAAA,IAAK,GAAA;AAAA,OACnC;AAAA,IACF;AAGA,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,cAAA,CAAe,QAAyB,CAAA;AAE1D,IAAA,MAAM,QAAA,uBAAe,GAAA,EAGnB;AACF,IAAA,KAAA,MAAW,MAAM,QAAA,EAAU;AACzB,MAAA,QAAA,CAAS,IAAI,EAAA,EAAmB,EAAE,KAAK,CAAA,EAAG,IAAA,EAAM,GAAG,CAAA;AAAA,IACrD;AAEA,IAAA,KAAA,MAAW,OAAO,IAAA,EAAM;AACtB,MAAA,MAAM,MAAM,GAAA,CAAI,MAAA;AAChB,MAAA,KAAA,MAAW,MAAM,QAAA,EAAU;AACzB,QAAA,MAAM,CAAA,GAAK,GAAA,CAAI,EAAE,CAAA,IAAgB,CAAA;AACjC,QAAA,IAAI,KAAK,CAAA,EAAG;AAEZ,QAAA,MAAM,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,EAAiB,CAAA;AACxC,QAAA,CAAA,CAAE,OAAO,GAAA,GAAM,CAAA;AACf,QAAA,CAAA,CAAE,IAAA,IAAQ,CAAA;AACV,QAAA,IAAI,EAAE,GAAA,KAAQ,MAAA,IAAa,MAAM,CAAA,CAAE,GAAA,IAAO,GAAA,GAAM,GAAA;AAChD,QAAA,IAAI,EAAE,GAAA,KAAQ,MAAA,IAAa,MAAM,CAAA,CAAE,GAAA,IAAO,GAAA,GAAM,GAAA;AAAA,MAClD;AAAA,IACF;AAEA,IAAA,MAAM,CAAA,GAAI,KAAK,OAAA,CAAQ,MAAA;AACvB,IAAA,MAAM,UAAA,uBAAiB,GAAA,EAAkC;AACzD,IAAA,KAAA,MAAW,MAAM,QAAA,EAAU;AACzB,MAAA,MAAM,CAAA,GAAI,QAAA,CAAS,GAAA,CAAI,EAAiB,CAAA;AACxC,MAAA,MAAM,MAAM,CAAA,CAAE,IAAA,GAAO,IAAI,CAAA,CAAE,GAAA,GAAM,EAAE,IAAA,GAAO,CAAA;AAI1C,MAAA,UAAA,CAAW,IAAI,EAAA,EAAmB;AAAA,QAChC,qBAAA,EAAuB,IAAA,CAAK,cAAA,CAAe,EAAiB,CAAA;AAAA,QAC5D,cAAA,EAAgB,IAAA,CAAK,YAAA,CAAa,EAAA,EAAmB,CAAC,CAAA;AAAA,QACtD,WAAA,EAAa,EAAE,GAAA,EAAK,CAAA,CAAE,GAAA,IAAO,GAAG,GAAA,EAAK,GAAA,EAAK,CAAA,CAAE,GAAA,IAAO,CAAA;AAAE,OACtD,CAAA;AAAA,IACH;AAGA,IAAA,MAAM,UAAA,GAAa,KAAK,IAAA,EAAK;AAE7B,IAAA,IAAI,YAAA,GAAe,CAAA;AACnB,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,IAAA,CAAK,QAAA,CAAS,GAAA,EAAK,IAAI,CAAA,GAAI,CAAA,EAAG,YAAA,IAAgB,GAAA,CAAI,CAAA;AAEzE,IAAA,MAAM,WAAA,GAAc;AAAA,MAClB,GAAA,EAAK,IAAA,CAAK,QAAA,CAAS,QAAA,CAAS,IAAI,CAAA;AAAA,MAChC,GAAA,EAAK,IAAA,CAAK,QAAA,CAAS,QAAA,CAAS,GAAG,CAAA;AAAA,MAC/B,GAAA,EAAK,IAAA,CAAK,QAAA,CAAS,QAAA,CAAS,IAAI;AAAA,KAClC;AAEA,IAAA,OAAO,EAAE,UAAA,EAAY,YAAA,EAAc,WAAA,EAAa,UAAU,UAAA,EAAW;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,SAAA,GAAuB;AACrB,IAAA,OAAO,IAAI,UAAA,CAAU,CAAC,KAAK,QAAA,CAAS,SAAA,EAAW,CAAC,CAAA;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,OAAA,CAAQ,KAAc,YAAA,EAAmC;AACvD,IAAA,OAAO,IAAI,WAAU,CAAC,IAAA,CAAK,SAAS,OAAA,CAAQ,GAAA,EAAK,YAAY,CAAC,CAAC,CAAA;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,SAAA,CAAU,QAAmB,WAAA,EAAgC;AAC3D,IAAA,OAAO,IAAI,UAAA,CAAU;AAAA,MACnB,IAAA,CAAK,QAAA,CAAS,SAAA,CAAU,MAAA,CAAO,UAAU,WAAW;AAAA,KACrD,CAAA;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,UAAU,MAAA,EAA2B;AACnC,IAAA,OAAO,IAAI,WAAU,CAAC,IAAA,CAAK,SAAS,SAAA,CAAU,MAAM,CAAC,CAAC,CAAA;AAAA,EACxD;AAAA,EAEA,SAAA,GAAoB;AAClB,IAAA,OAAO,IAAA,CAAK,SAAS,IAAA,EAAK;AAAA,EAC5B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,UACE,uBAAA,EACW;AACX,IAAA,OAAO,IAAI,WAAU,CAAC,IAAA,CAAK,SAAS,SAAA,CAAU,uBAAuB,CAAC,CAAC,CAAA;AAAA,EACzE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,WAAA,CACE,MAAA,EACA,QAAA,GAAuC,OAAA,EACvC,cAAc,CAAA,EACH;AACX,IAAA,OAAO,IAAI,UAAA,CAAU,CAAC,IAAA,CAAK,QAAA,CAAS,YAAY,MAAA,EAAQ,QAAA,EAAU,WAAW,CAAC,CAAC,CAAA;AAAA,EACjF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAmBA,SAAS,KAAA,EAA6B;AACpC,IAAA,MAAM,UAAU,CAAC,GAAG,KAAK,OAAA,EAAS,GAAG,MAAM,OAAO,CAAA;AAClD,IAAA,OAAO,IAAI,WAAU,OAAO,CAAA;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWO,iBAAA,CACL,cAAA,EACA,aAAA,EACA,GAAA,GAAM,GAAA,EACqE;AAC3E,IAAA,MAAM,OAAO,IAAA,CAAK,OAAA;AAClB,IAAA,IAAI,CAAC,KAAK,MAAA,EAAQ;AAChB,MAAA,MAAM,IAAI,MAAM,mDAAmD,CAAA;AAAA,IACrE;AAEA,IAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KACb,KAAA,CAAM,QAAQ,CAAC,CAAA,GAAI,CAAA,GAAI,CAAC,CAAC,CAAA;AAC3B,IAAA,MAAM,OAAA,GAAU,CAAC,CAAA,KAAc,IAAA,CAAK,GAAA,CAAI,GAAG,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,CAAC,CAAC,CAAA;AACzD,IAAA,MAAM,MAAM,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,OAAO,OAAO,CAAA;AAG5C,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,GAAA,CAAI,CAAC,GAAA,KAAQ;AAC5B,MAAA,MAAM,EAAA,GAAK,IAAI,UAAA,CAAU,CAAC,GAAG,CAAC,CAAA;AAC9B,MAAA,MAAM,EAAA,GAAK,EAAA,CAAG,cAAA,CAAe,KAAA,CAAM,cAAc,CAAC,CAAA;AAClD,MAAA,MAAM,EAAA,GAAK,EAAA,CAAG,cAAA,CAAe,KAAA,CAAM,aAAa,CAAC,CAAA;AACjD,MAAA,IAAI,EAAA,GAAK,KAAK,GAAA,EAAK;AACjB,QAAA,MAAM,IAAI,KAAA;AAAA,UACR;AAAA,SACF;AAAA,MACF;AACA,MAAA,OAAO,EAAE,IAAI,EAAA,EAAG;AAAA,IAClB,CAAC,CAAA;AAGD,IAAA,IAAI,SAAA,GAAY,CAAA;AAChB,IAAA,IAAI,YAAA,GAAe,CAAA;AACnB,IAAA,IAAI,eAAA,GAAkB,CAAA;AACtB,IAAA,IAAI,KAAA,GAAQ,CAAA;AAEZ,IAAA,KAAA,MAAW,EAAE,EAAA,EAAI,EAAA,EAAG,IAAK,GAAA,EAAK;AAC5B,MAAA,YAAA,IAAgB,SAAA,GAAY,EAAA;AAC5B,MAAA,eAAA,IAAmB,aAAa,EAAA,GAAK,EAAA,CAAA;AACrC,MAAA,MAAM,OAAO,CAAA,GAAI,EAAA;AACjB,MAAA,SAAA,IAAa,IAAA;AACb,MAAA,KAAA,IAAS,IAAA;AAAA,IACX;AAEA,IAAA,MAAM,OAAO,CAAA,GAAI,KAAA;AAGjB,IAAA,MAAM,CAAA,GAAI,QAAQ,eAAe,CAAA;AACjC,IAAA,MAAM,CAAA,GAAI,QAAQ,YAAY,CAAA;AAC9B,IAAA,MAAM,GAAA,GAAM,QAAQ,IAAI,CAAA;AACxB,IAAA,MAAM,IAAA,GAAO,QAAQ,KAAK,CAAA;AAE1B,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,CAAA,GAAI,CAAA,GAAI,GAAG,CAAA,GAAI,GAAA,GAAM,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,GAAG,CAAA,EAAG;AAClD,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,6DAAA,EACE,CAAA,GAAI,CACN,CAAA,OAAA,EAAU,GAAG,CAAA;AAAA,OACf;AAAA,IACF;AAEA,IAAA,OAAO,CAAC,CAAA,EAAG,CAAA,EAAG,GAAA,EAAK,IAAI,CAAA;AAAA,EACzB;AACF,CAAA;AAn1Ca,UAAA,CAyCa,gBAAA,GAA2C;AAAA,EACjE,KAAA;AAAA,EACA,MAAA;AAAA,EACA;AACF,CAAA;AA7CK,IAAM,SAAA,GAAN;;;ACJP,IAAM,qBAAA,GAA8C;AAAA,EAClD,QAAA,EAAU,CAAC,GAAA,KAAQ,GAAA,CAAI,MAAA,EAAO;AAAA,EAC9B,oBAAA,EAAsB;AACxB,CAAA;AAEO,IAAM,QAAA,GAAW,IAAI,QAAA,CAAsB,GAAA,EAAM,qBAAqB;AAM7E,IAAM,uBAAA,GAA0B,KAAA;AAOhC,IAAM,YAAA,GAAN,cAA2B,GAAA,CAAiB;AAAA,EAC1C,YAAY,MAAA,EAAkC;AAC5C,IAAA,KAAA,EAAM;AACN,IAAA,KAAA,MAAW,CAAC,OAAO,GAAG,CAAA,IAAK,QAAQ,KAAA,CAAM,GAAA,CAAI,OAAO,GAAG,CAAA;AAAA,EACzD;AAAA,EAES,IAAI,KAAA,EAAsB;AACjC,IAAA,MAAM,IAAI,SAAA,CAAU,CAAA,wBAAA,EAA2B,KAAK,CAAA,6CAAA,CAA+C,CAAA;AAAA,EACrG;AAAA,EAES,OAAO,KAAA,EAAsB;AACpC,IAAA,MAAM,IAAI,SAAA,CAAU,CAAA,2BAAA,EAA8B,KAAK,CAAA,6CAAA,CAA+C,CAAA;AAAA,EACxG;AAAA,EAES,KAAA,GAAe;AACtB,IAAA,MAAM,IAAI,UAAU,mEAAmE,CAAA;AAAA,EACzF;AACF,CAAA;AAkCO,IAAM,IAAA,GAAN,MAAM,IAAA,CAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAqBf,WAAA,CACkB,GAAA,mBAAgC,IAAI,GAAA,IACpC,OAAA,GAAU,GAAA,EACV,UAAA,GAAa,KAAA,EACb,aAAqB,CAAA,KAAA,EAAQ,IAAA,CAAI,eAAA,EAAiB,CAAA,CAAA,EACjD,uBAAuB,IAAA,EACxC;AALgB,IAAA,IAAA,CAAA,GAAA,GAAA,GAAA;AACA,IAAA,IAAA,CAAA,OAAA,GAAA,OAAA;AACA,IAAA,IAAA,CAAA,UAAA,GAAA,UAAA;AACA,IAAA,IAAA,CAAA,UAAA,GAAA,UAAA;AACC,IAAA,IAAA,CAAA,oBAAA,GAAA,oBAAA;AAZnB,IAAA,IAAA,CAAQ,OAAA,GAAU,KAAA;AAAA,EAaf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMH,OAAO,YAAY,OAAA,EAAwC;AACzD,IAAA,OAAO,IAAI,QAAA,CAAsB,OAAA,EAAS,qBAAqB,CAAA;AAAA,EACjE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAA,GAAe;AACb,IAAA,IAAI,IAAA,CAAK,SAAS,OAAO,IAAA;AACzB,IAAA,MAAM,GAAA,GAAM,IAAI,YAAA,CAAa,IAAA,CAAK,GAAG,CAAA;AACrC,IAAA,KAAA,MAAW,GAAA,IAAO,GAAA,CAAI,MAAA,EAAO,EAAG;AAC9B,MAAA,MAAA,CAAO,MAAA,CAAO,IAAI,KAAK,CAAA;AACvB,MAAA,IAAI,GAAA,CAAI,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,IAAI,IAAI,CAAA;AACpC,MAAA,MAAA,CAAO,OAAO,GAAG,CAAA;AAAA,IACnB;AAEA,IAAA,MAAA,CAAO,OAAO,GAAG,CAAA;AAEjB,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,EAAgB,KAAA,EAAO,EAAE,KAAA,EAAO,GAAA,EAAK,QAAA,EAAU,KAAA,EAAO,UAAA,EAAY,IAAA,EAAM,YAAA,EAAc,KAAA,EAAO,CAAA;AACnH,IAAA,IAAA,CAAK,OAAA,GAAU,IAAA;AACf,IAAA,OAAO,IAAA;AAAA,EACT;AAAA,EAEA,OAAO,KAAA,CAAM,OAAA,GAAU,GAAA,EAAK,aAAa,OAAA,EAAS;AAChD,IAAA,OAAO,IAAI,IAAA,iBAAI,IAAI,KAAI,EAAG,OAAA,EAAS,OAAO,UAAU,CAAA;AAAA,EACtD;AAAA;AAAA,EAGA,OAAO,IAAA,CAAK,OAAA,GAAU,GAAA,EAAU;AAC9B,IAAA,MAAM,CAAA,uBAAQ,GAAA,EAAI;AAClB,IAAA,CAAA,CAAE,GAAA,CAAI,CAAA,EAAG,EAAE,CAAA,EAAG,CAAA,EAAG,KAAA,EAAO,EAAE,IAAA,EAAM,CAAA,EAAE,EAAG,IAAA,EAAM,IAAI,CAAA;AAC/C,IAAA,OAAO,IAAI,IAAA,CAAI,CAAA,EAAG,OAAA,EAAS,OAAO,MAAM,CAAA;AAAA,EAC1C;AAAA,EAEA,OAAO,KAAA,CAAM,KAAA,EAAe,OAAA,GAAU,GAAA,EAAU;AAC9C,IAAA,OAAO,IAAA,CAAI,OAAA,iBAAQ,IAAI,GAAA,CAAI,CAAC,CAAC,KAAA,EAAO,CAAC,CAAC,CAAC,CAAA,EAAG,OAAO,CAAA;AAAA,EACnD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,OAAO,QAAA,CAAS,OAAA,GAAU,GAAA,EAAU;AAClC,IAAA,MAAM,CAAA,uBAAQ,GAAA,EAAiB;AAC/B,IAAA,CAAA,CAAE,GAAA,CAAI,CAAA,EAAG,EAAE,CAAA,EAAG,GAAG,KAAA,EAAO,EAAE,CAAC,iBAAiB,GAAG,CAAA,EAAE,EAAG,IAAA,EAAM,IAAI,CAAA;AAC9D,IAAA,OAAO,IAAI,IAAA,CAAI,CAAA,EAAG,OAAA,EAAS,OAAO,UAAU,CAAA;AAAA,EAC9C;AAAA;AAAA,EAGA,OAAO,SAAA,GAAiB;AACtB,IAAA,OAAO,IAAA,CAAI,IAAA,EAAK,CAAE,SAAA,CAAU,CAAC,CAAA;AAAA,EAC/B;AAAA;AAAA,EAGA,CAAC,MAAA,CAAO,QAAQ,CAAA,GAAqC;AACnD,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,MAAA,CAAO,QAAQ,CAAA,EAAE;AAAA,EACnC;AAAA,EAEA,OAAO,UAAA,GAAa;AAClB,IAAA,QAAA,CAAS,KAAA,EAAM;AAAA,EACjB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO,MAAA,CACL,UAAA,EACA,UAAA,EACA,kBAAA,EACK;AACL,IAAA,IAAI,CAAA,GAAI,kBAAA;AACR,IAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,CAAC,GAAG,CAAA,GAAI,CAAA;AAC7B,IAAA,IAAI,CAAA,GAAI,GAAG,CAAA,GAAI,CAAA;AACf,IAAA,IAAI,CAAA,GAAI,GAAG,CAAA,GAAI,CAAA;AAEf,IAAA,MAAM,IAAI,CAAA,GAAI,CAAA;AAKd,IAAA,IAAI,CAAA,KAAM,CAAA,EAAG,OAAO,UAAA,CAAW,UAAU,CAAC,CAAA;AAC1C,IAAA,IAAI,CAAA,KAAM,CAAA,EAAG,OAAO,UAAA,CAAW,UAAU,CAAC,CAAA;AAG1C,IAAA,MAAM,GAAA,GAAM,UAAA,CAAW,OAAA,IAAW,UAAA,CAAW,OAAA;AAC7C,IAAA,MAAM,KAAK,CAAA,OAAA,EAAU,UAAA,CAAW,UAAU,CAAA,CAAA,EAAI,EAAE,OAAA,CAAQ,CAAC,CAAC,CAAA,GAAA,EACxD,WAAW,UACb,CAAA,CAAA,EAAI,CAAA,CAAE,OAAA,CAAQ,CAAC,CAAC,CAAA,CAAA,CAAA;AAQhB,IAAA,MAAM,SAAA,uBAAgB,GAAA,EAAiB;AACvC,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,GAAG,CAAA,IAAK,WAAW,GAAA,EAAK;AAC/C,MAAA,IAAA,CAAI,UAAU,SAAA,EAAW,WAAA,EAAa,KAAI,QAAA,CAAS,GAAA,EAAK,CAAC,CAAC,CAAA;AAAA,IAC5D;AACA,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,GAAG,CAAA,IAAK,WAAW,GAAA,EAAK;AAC/C,MAAA,IAAA,CAAI,UAAU,SAAA,EAAW,WAAA,EAAa,KAAI,QAAA,CAAS,GAAA,EAAK,CAAC,CAAC,CAAA;AAAA,IAC5D;AAEA,IAAA,OAAO,IAAI,IAAA,CAAI,SAAA,EAAW,GAAA,EAAK,OAAO,EAAE,CAAA;AAAA,EAC1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAoBA,OAAO,eAAA,CAAgB,UAAA,EAAiB,WAAA,EAA0B;AAChE,IAAA,OAAO,KAAI,MAAA,CAAO,UAAA,EAAY,IAAA,CAAI,IAAA,IAAQ,WAAW,CAAA;AAAA,EACvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA2BA,IAAA,CAAK,GAAW,QAAA,EAAe;AAC7B,IAAA,OAAO,IAAA,CAAI,MAAA,CAAO,IAAA,EAAM,QAAA,EAAU,CAAC,CAAA;AAAA,EACrC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAkBA,OAAO,SAAA,CACL,OAAA,EACA,GAAA,GAAM,GAAA,EACD;AACL,IAAA,MAAM,QAAQ,OAAA,CAAQ,GAAA;AAAA,MAAI,CAAC,CAAA,KACzB,KAAA,CAAM,OAAA,CAAQ,CAAC,CAAA,GAAI,EAAE,GAAA,EAAK,CAAA,CAAE,CAAC,CAAA,EAAG,MAAA,EAAQ,CAAA,CAAE,CAAC,GAAE,GAAI;AAAA,KACnD;AAGA,IAAA,KAAA,MAAW,EAAE,MAAA,EAAO,IAAK,KAAA,EAAO;AAC9B,MAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,MAAM,CAAA,IAAK,MAAA,GAAS,CAAC,GAAA,EAAK;AAC7C,QAAA,MAAM,IAAI,KAAA,CAAM,CAAA,8BAAA,EAAiC,MAAM,CAAA,CAAA,CAAG,CAAA;AAAA,MAC5D;AAAA,IACF;AAGA,IAAA,IAAI,WAAA,GAAc,KAAA,CAAM,MAAA,CAAO,CAAC,CAAA,EAAG,EAAE,MAAA,EAAO,KAAM,CAAA,GAAI,MAAA,EAAQ,CAAC,CAAA;AAG/D,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,WAAW,CAAA,IAAK,KAAK,WAAA,GAAc,CAAA;AAChD,IAAA,IAAI,KAAK,GAAA,CAAI,CAAA,GAAI,WAAW,CAAA,IAAK,KAAK,WAAA,GAAc,CAAA;AAEpD,IAAA,IAAI,WAAA,GAAc,IAAI,GAAA,EAAK;AACzB,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,4BAAA,EAA+B,WAAW,CAAA,sBAAA,EAAyB,GAAG,CAAA,CAAA;AAAA,OACxE;AAAA,IACF;AAGA,IAAA,IAAI,GAAA,GAAM,IAAA,CAAI,KAAA,CAAM,GAAG,CAAA;AACvB,IAAA,KAAA,MAAW,EAAE,GAAA,EAAK,MAAA,EAAO,IAAK,KAAA,EAAO;AACnC,MAAA,IAAI,SAAS,GAAA,EAAK,GAAA,GAAM,GAAA,CAAI,SAAA,CAAU,KAAK,MAAM,CAAA;AAAA,IACnD;AAGA,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,IAAI,WAAW,CAAA;AAC5C,IAAA,IAAI,WAAW,GAAA,EAAK;AAClB,MAAA,GAAA,GAAM,GAAA,CAAI,SAAA,CAAU,IAAA,CAAI,IAAA,IAAQ,QAAQ,CAAA;AAAA,IAC1C;AAEA,IAAA,OAAO,GAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,OAAO,GAAA,CACL,OAAA,EACA,GAAA,GAAM,GAAA,EACD;AACL,IAAA,MAAM,QAAQ,OAAA,CAAQ,GAAA;AAAA,MAAI,CAAC,CAAA,KACzB,KAAA,CAAM,OAAA,CAAQ,CAAC,CAAA,GAAI,EAAE,GAAA,EAAK,CAAA,CAAE,CAAC,CAAA,EAAG,MAAA,EAAQ,CAAA,CAAE,CAAC,GAAE,GAAI;AAAA,KACnD;AAGA,IAAA,KAAA,MAAW,EAAE,MAAA,EAAO,IAAK,KAAA,EAAO;AAC9B,MAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,MAAM,CAAA,EAAG;AAC5B,QAAA,MAAM,IAAI,KAAA,CAAM,CAAA,wBAAA,EAA2B,MAAM,CAAA,CAAA,CAAG,CAAA;AAAA,MACtD;AAAA,IACF;AAEA,IAAA,IAAI,GAAA,GAAM,IAAA,CAAI,KAAA,CAAM,GAAG,CAAA;AACvB,IAAA,KAAA,MAAW,EAAE,GAAA,EAAK,MAAA,EAAO,IAAK,KAAA,EAAO;AACnC,MAAA,IAAI,IAAA,CAAK,GAAA,CAAI,MAAM,CAAA,IAAK,GAAA,EAAK;AAC7B,MAAA,GAAA,GAAM,GAAA,CAAI,SAAA,CAAU,GAAA,EAAK,MAAM,CAAA;AAAA,IACjC;AACA,IAAA,OAAO,GAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,cAAA,GAA0B;AACxB,IAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AACpC,MAAA,IAAI,MAAA,KAAW,CAAA,IAAK,GAAA,CAAI,IAAA,IAAQ,MAAA,CAAO,KAAK,GAAA,CAAI,IAAI,CAAA,CAAE,MAAA,GAAS,CAAA,EAAG;AAChE,QAAA,OAAO,IAAA;AAAA,MACT;AAEA,MAAA,IAAI,SAAS,CAAA,EAAG;AAAA,IAClB;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA,EAEA,eAAA,GAAuB;AAErB,IAAA,IAAI,IAAA,CAAK,cAAA,EAAe,EAAG,OAAO,IAAA;AAElC,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAiB;AAEpC,IAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AACpC,MAAA,MAAM,OAAwB,EAAC;AAG/B,MAAA,KAAA,MAAW,OAAA,IAAW,IAAI,KAAA,EAAO;AAC/B,QAAA,MAAM,WAAA,GAAc,GAAA,CAAI,KAAA,CAAM,OAAO,CAAA;AACrC,QAAA,IAAI,cAAc,CAAA,EAAG;AACnB,UAAA,IAAA,CAAK,OAAO,IAAI,MAAA,GAAS,WAAA;AAAA,QAC3B;AAAA,MACF;AAGA,MAAA,MAAA,CAAO,IAAI,MAAA,EAAQ;AAAA,QACjB,GAAG,GAAA,CAAI,CAAA;AAAA,QACP,KAAA,EAAO,EAAE,GAAG,GAAA,CAAI,KAAA,EAAM;AAAA,QACtB,MAAM,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,CAAE,MAAA,GAAS,IAAI,IAAA,GAAO;AAAA,OAC7C,CAAA;AAAA,IACH;AAGA,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,MAAA;AAAA,MACA,IAAA,CAAK,OAAA;AAAA,MACL,IAAA,CAAK,UAAA;AAAA,MACL,CAAA,EAAG,KAAK,UAAU,CAAA,KAAA;AAAA,KACpB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,OAAO,IAAA,CAAK,OAAA,EAA0B,GAAA,GAAM,GAAA,EAAU;AAEpD,IAAA,MAAM,QAAA,GAAW,QAAQ,MAAA,CAAO,CAAC,CAAC,CAAC,CAAA,KAAM,IAAI,GAAG,CAAA;AAEhD,IAAA,IAAI,QAAA,CAAS,WAAW,CAAA,EAAG;AACzB,MAAA,OAAO,KAAI,SAAA,EAAU;AAAA,IACvB;AAGA,IAAA,IAAI,GAAA,GAAkB,IAAA;AACtB,IAAA,IAAI,GAAA,GAAM,CAAA;AAEV,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,QAAA,EAAU;AAC/B,MAAA,IAAI,QAAQ,IAAA,EAAM;AAChB,QAAA,GAAA,GAAM,GAAA;AACN,QAAA,GAAA,GAAM,CAAA;AAAA,MACR,CAAA,MAAO;AACL,QAAA,MAAM,CAAA,GAAI,KAAK,GAAA,GAAM,CAAA,CAAA;AACrB,QAAA,GAAA,GAAM,IAAA,CAAI,MAAA,CAAO,GAAA,EAAK,GAAA,EAAK,CAAC,CAAA;AAC5B,QAAA,GAAA,IAAO,CAAA;AAAA,MACT;AAAA,IACF;AAGA,IAAA,OAAO,GAAA,IAAO,KAAI,SAAA,EAAU;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,mBAAA,GAA+B;AACpC,IAAA,OAAO,IAAA,CAAK,oBAAA;AAAA,EACd;AAAA,EAEQ,gBAAA,CAAiB,GAAW,GAAA,EAAqB;AAOvD,IAAA,MAAM,KAAK,IAAA,CAAK,UAAA;AAChB,IAAA,IAAI,GAAA,GAAM,GAAG,EAAE,CAAA,CAAA;AACf,IAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,GAAI,GAAG,CAAA,EAAA,EAAK,GAAA,IAAO,IAAI,EAAE,CAAA,CAAA;AACzC,IAAA,OAAO,GAAG,GAAG,CAAA,CAAA,EAAI,GAAG,CAAA,CAAA,EAAI,IAAA,CAAK,aAAa,CAAA,CAAA;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,KAAA,CAAM,CAAA,EAAW,GAAA,GAAM,IAAA,CAAK,OAAA,EAAc;AACxC,IAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,IAAK,KAAK,CAAA,EAAG;AAClC,MAAA,MAAM,IAAI,MAAM,wCAAwC,CAAA;AAAA,IAC1D;AACA,IAAA,IAAI,CAAA,KAAM,GAAG,OAAO,IAAA;AAEpB,IAAA,MAAM,OAAA,GAAU,OAAO,IAAA,CAAK,OAAA;AAE5B,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,gBAAA,CAAiB,CAAA,EAAG,OAAO,CAAA;AAC5C,IAAA,MAAM,MAAA,GAAS,QAAA,CAAS,GAAA,CAAI,GAAG,CAAA;AAC/B,IAAA,IAAI,QAAQ,OAAO,MAAA;AAGnB,IAAA,IAAI,IAAA,GAAY,IAAA,CAAK,UAAA,GAAa,IAAA,GAAO,KAAK,SAAA,EAAU;AACxD,IAAA,IAAI,MAAA,GAAc,IAAA;AAClB,IAAA,IAAI,MAAM,CAAA,GAAI,CAAA;AAEd,IAAA,OAAO,MAAM,CAAA,EAAG;AACd,MAAA,IAAI,MAAM,CAAA,EAAG;AACX,QAAA,MAAA,GAAS,MAAA,CAAO,QAAA,CAAS,IAAA,EAAM,OAAO,CAAA;AAAA,MACxC;AACA,MAAA,GAAA,KAAQ,CAAA;AACR,MAAA,IAAI,MAAM,CAAA,EAAG;AACX,QAAA,IAAA,GAAO,IAAA,CAAK,QAAA,CAAS,IAAA,EAAM,OAAO,CAAA;AAAA,MACpC;AAAA,IACF;AAGA,IAAA,MAAM,SAAS,IAAI,IAAA;AAAA,MACjB,MAAA,CAAO,GAAA;AAAA,MACP,MAAA,CAAO,OAAA;AAAA,MACP,MAAA,CAAO,UAAA;AAAA,MACP,MAAA,CAAO,UAAA;AAAA,MACP;AAAA,KACF;AACA,IAAA,QAAA,CAAS,GAAA,CAAI,KAAK,MAAM,CAAA;AACxB,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA,EAKA,UAAU,CAAA,EAAkB;AAC1B,IAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,IAAK,KAAK,CAAA,EAAG;AAClC,MAAA,MAAM,IAAI,MAAM,4CAA4C,CAAA;AAAA,IAC9D;AACA,IAAA,IAAI,CAAA,KAAM,CAAA,EAAG,OAAO,CAAC,IAAI,CAAA;AACzB,IAAA,OAAO,MAAM,IAAA,CAAK,EAAE,QAAQ,CAAA,EAAE,EAAG,MAAM,IAAI,CAAA;AAAA,EAC7C;AAAA,EAEA,IAAA,GAAe;AACb,IAAA,IAAI,IAAA,CAAK,eAAe,MAAA,EAAW;AACjC,MAAA,IAAI,oBAAA,GAAuB,CAAA;AAC3B,MAAA,KAAA,MAAW,EAAE,CAAA,EAAE,IAAK,IAAA,CAAK,GAAA,CAAI,QAAO,EAAG;AACrC,QAAA,oBAAA,IAAwB,CAAA;AAAA,MAC1B;AACA,MAAA,IAAA,CAAK,UAAA,GAAa,oBAAA;AAAA,IACpB;AACA,IAAA,OAAO,IAAA,CAAK,UAAA;AAAA,EACd;AAAA,EAEA,YAAY,OAAA,EAAyB;AACnC,IAAA,IAAI,oBAAA,GAAuB,CAAA;AAC3B,IAAA,KAAA,MAAW,EAAE,CAAA,EAAG,KAAA,MAAW,IAAA,CAAK,GAAA,CAAI,QAAO,EAAG;AAC5C,MAAA,oBAAA,IAAwB,CAAA,IAAM,KAAA,CAAM,OAAO,CAAA,IAAgB,CAAA,CAAA;AAAA,IAC7D;AACA,IAAA,OAAO,oBAAA;AAAA,EACT;AAAA;AAAA,EAGA,SAAA,GAAoB;AAClB,IAAA,OAAO,CAAC,GAAG,IAAA,CAAK,GAAA,CAAI,IAAA,EAAM,CAAA,CAAE,MAAA,CAAO,CAAC,GAAA,EAAK,GAAA,KAAQ,GAAA,GAAM,KAAK,CAAC,CAAA;AAAA,EAC/D;AAAA,EAEA,SAAA,GAAiB;AACf,IAAA,IAAI,IAAA,CAAK,YAAY,OAAO,IAAA;AAC5B,IAAA,MAAM,mBAAA,GAAsB,KAAK,IAAA,EAAK;AACtC,IAAA,IAAI,mBAAA,KAAwB,GAAG,OAAO,IAAA;AAItC,IAAA,MAAM,aAAA,uBAAoB,GAAA,EAAiB;AAC3C,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,KAAK,GAAA,EAAK;AACpD,MAAA,MAAM,kBAAmC,EAAC;AAC1C,MAAA,KAAA,MAAW,QAAA,IAAY,eAAe,KAAA,EAAO;AAC3C,QAAA,eAAA,CAAgB,QAAQ,CAAA,GACrB,cAAA,CAAe,KAAA,CAAM,QAAQ,CAAA,GAAe,mBAAA;AAAA,MACjD;AAEA,MAAA,IAAI,oBAAA;AACJ,MAAA,IAAI,eAAe,IAAA,EAAM;AACvB,QAAA,oBAAA,GAAuB,EAAC;AACxB,QAAA,KAAA,MAAW,QAAA,IAAY,eAAe,IAAA,EAAM;AAC1C,UAAA,oBAAA,CAAqB,QAAQ,CAAA,GAC1B,cAAA,CAAe,IAAA,CAAK,QAAQ,CAAA,GAAe,mBAAA;AAAA,QAChD;AAAA,MACF;AAEA,MAAA,aAAA,CAAc,IAAI,WAAA,EAAa;AAAA,QAC7B,CAAA,EAAG,eAAe,CAAA,GAAI,mBAAA;AAAA,QACtB,KAAA,EAAO,eAAA;AAAA,QACP,IAAA,EAAM;AAAA,OACP,CAAA;AAAA,IACH;AACA,IAAA,OAAO,IAAI,IAAA,CAAI,aAAA,EAAe,KAAK,OAAA,EAAS,IAAA,EAAM,KAAK,UAAU,CAAA;AAAA,EACnE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAA,CAAQ,GAAA,GAAM,IAAA,CAAK,OAAA,EAAS,eAAe,KAAA,EAAY;AACrD,IAAA,IAAI,MAAA,GAAS,CAAA,QAAA;AACb,IAAA,IAAI,YAAA,EAAc;AAChB,MAAA,KAAA,MAAW,GAAA,IAAO,IAAA,CAAK,GAAA,CAAI,IAAA,EAAK,EAAG;AACjC,QAAA,IAAI,GAAA,GAAM,QAAQ,MAAA,GAAS,GAAA;AAAA,MAC7B;AAAA,IACF;AAEA,IAAA,MAAM,YAAA,uBAAmB,GAAA,EAAiB;AAE1C,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,KAAK,GAAA,EAAK;AACpD,MAAA,MAAM,UAAA,GACJ,cAAA,CAAe,CAAA,IAAK,GAAA,IAAQ,gBAAgB,WAAA,KAAgB,MAAA;AAE9D,MAAA,IAAI,CAAC,UAAA,EAAY;AAMjB,MAAA,MAAM,UAAA,GAAa,IAAA,CAAI,QAAA,CAAS,cAAc,CAAA;AAE9C,MAAA,KAAA,MAAW,QAAA,IAAY,WAAW,KAAA,EAAO;AACvC,QAAA,IAAI,IAAA,CAAK,IAAI,UAAA,CAAW,KAAA,CAAM,QAAQ,CAAA,IAAK,CAAC,IAAI,GAAA,EAAK;AACnD,UAAA,OAAO,UAAA,CAAW,MAAM,QAAQ,CAAA;AAAA,QAClC;AAAA,MACF;AAEA,MAAA,IAAI,WAAW,IAAA,EAAM;AACnB,QAAA,KAAA,MAAW,QAAA,IAAY,WAAW,IAAA,EAAM;AACtC,UAAA,IAAI,IAAA,CAAK,IAAI,UAAA,CAAW,IAAA,CAAK,QAAQ,CAAA,IAAK,CAAC,IAAI,GAAA,EAAK;AAClD,YAAA,OAAO,UAAA,CAAW,KAAK,QAAQ,CAAA;AAAA,UACjC;AAAA,QACF;AACA,QAAA,IAAI,OAAO,IAAA,CAAK,UAAA,CAAW,IAAI,CAAA,CAAE,WAAW,CAAA,EAAG;AAC7C,UAAA,UAAA,CAAW,IAAA,GAAO,MAAA;AAAA,QACpB;AAAA,MACF;AAEA,MAAA,YAAA,CAAa,GAAA,CAAI,aAAa,UAAU,CAAA;AAAA,IAC1C;AAEA,IAAA,OAAO,IAAI,IAAA,CAAI,YAAA,EAAc,KAAK,IAAA,CAAK,UAAA,EAAY,KAAK,UAAU,CAAA;AAAA,EACpE;AAAA;AAAA;AAAA,EAIA,OAAA,GAAoB;AAClB,IAAA,IAAI,IAAA,CAAK,aAAa,MAAA,EAAW;AAC/B,MAAA,IAAA,CAAK,QAAA,GAAW,CAAC,GAAG,IAAA,CAAK,GAAA,CAAI,IAAA,EAAM,CAAA,CAAE,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,IAAI,CAAC,CAAA;AAAA,IAC3D;AACA,IAAA,OAAO,IAAA,CAAK,QAAA;AAAA,EACd;AAAA;AAAA,EAGA,GAAA,GAAc;AACZ,IAAA,IAAI,IAAA,CAAK,SAAS,MAAA,EAAW;AAC3B,MAAA,MAAM,OAAA,GAAU,KAAK,OAAA,EAAQ;AAC7B,MAAA,IAAA,CAAK,OAAO,OAAA,CAAQ,MAAA,GAAS,CAAA,GAAI,OAAA,CAAQ,CAAC,CAAA,GAAI,CAAA;AAAA,IAChD;AACA,IAAA,OAAO,IAAA,CAAK,IAAA;AAAA,EACd;AAAA;AAAA,EAGA,GAAA,GAAc;AACZ,IAAA,IAAI,IAAA,CAAK,SAAS,MAAA,EAAW;AAC3B,MAAA,MAAM,OAAA,GAAU,KAAK,OAAA,EAAQ;AAC7B,MAAA,IAAA,CAAK,IAAA,GAAO,QAAQ,MAAA,GAAS,CAAA,GAAI,QAAQ,OAAA,CAAQ,MAAA,GAAS,CAAC,CAAA,GAAI,CAAA;AAAA,IACjE;AACA,IAAA,OAAO,IAAA,CAAK,IAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,IAAA,GAAe;AACb,IAAA,IAAI,IAAA,CAAK,UAAU,MAAA,EAAW;AAC5B,MAAA,IAAI,QAAA,GAAW,CAAA;AACf,MAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,KAAK,GAAA,EAAK;AACpD,QAAA,QAAA,IAAY,cAAc,cAAA,CAAe,CAAA;AAAA,MAC3C;AACA,MAAA,IAAA,CAAK,KAAA,GAAQ,QAAA;AAAA,IACf;AACA,IAAA,OAAO,IAAA,CAAK,KAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,QAAA,GAAmB;AACjB,IAAA,IAAI,IAAA,CAAK,cAAc,MAAA,EAAW;AAChC,MAAA,MAAM,IAAA,GAAO,KAAK,IAAA,EAAK;AACvB,MAAA,MAAM,cAAc,IAAA,GAAO,CAAA,IAAK,KAAK,GAAA,CAAI,IAAA,GAAO,CAAC,CAAA,GAAI,GAAA;AACrD,MAAA,MAAM,YAAY,WAAA,GAAc,IAAA,CAAK,MAAK,GAAI,IAAA,GAAO,KAAK,IAAA,EAAK;AAC/D,MAAA,IAAI,WAAA,GAAc,CAAA;AAClB,MAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,KAAK,GAAA,EAAK;AACpD,QAAA,MAAM,oBAAoB,WAAA,GAAc,SAAA;AACxC,QAAA,WAAA,IAAe,iBAAA,GAAoB,oBAAoB,cAAA,CAAe,CAAA;AAAA,MACxE;AACA,MAAA,IAAA,CAAK,SAAA,GAAY,WAAA,GAAc,WAAA,GAAc,IAAA,GAAO,WAAA;AAAA,IACtD;AACA,IAAA,OAAO,IAAA,CAAK,SAAA;AAAA,EACd;AAAA;AAAA;AAAA;AAAA,EAKA,KAAA,GAAgB;AACd,IAAA,IAAI,IAAA,CAAK,WAAW,MAAA,EAAW;AAC7B,MAAA,IAAA,CAAK,MAAA,GAAS,IAAA,CAAK,IAAA,CAAK,IAAA,CAAK,UAAU,CAAA;AAAA,IACzC;AACA,IAAA,OAAO,IAAA,CAAK,MAAA;AAAA,EACd;AAAA;AAAA,EAGA,OAAe,SAAS,GAAA,EAAe;AACrC,IAAA,OAAO;AAAA,MACL,GAAG,GAAA,CAAI,CAAA;AAAA,MACP,KAAA,EAAO,EAAE,GAAG,GAAA,CAAI,KAAA,EAAM;AAAA,MACtB,MAAM,GAAA,CAAI,IAAA,GAAO,EAAE,GAAG,GAAA,CAAI,MAAK,GAAI;AAAA,KACrC;AAAA,EACF;AAAA;AAAA,EAGA,OAAe,QAAA,CAAS,GAAA,EAAU,MAAA,EAAqB;AACrD,IAAA,MAAM,QAAyB,EAAC;AAChC,IAAA,KAAA,MAAW,CAAA,IAAK,IAAI,KAAA,EAAO;AACzB,MAAA,KAAA,CAAM,CAAC,CAAA,GAAK,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA,GAAe,MAAA;AAAA,IACxC;AAEA,IAAA,IAAI,IAAA;AACJ,IAAA,IAAI,IAAI,IAAA,EAAM;AACZ,MAAA,IAAA,GAAO,EAAC;AACR,MAAA,KAAA,MAAW,CAAA,IAAK,IAAI,IAAA,EAAM;AACxB,QAAA,IAAA,CAAK,CAAC,CAAA,GAAK,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA,GAAe,MAAA;AAAA,MACtC;AAAA,IACF;AAEA,IAAA,OAAO,EAAE,CAAA,EAAG,GAAA,CAAI,CAAA,GAAI,MAAA,EAAQ,OAAO,IAAA,EAAK;AAAA,EAC1C;AAAA,EAEA,OAAe,SAAA,CACb,cAAA,EACA,WAAA,EACA,QAAA,EACA;AACA,IAAA,MAAM,WAAA,GAAc,cAAA,CAAe,GAAA,CAAI,WAAW,CAAA;AAClD,IAAA,IAAI,CAAC,WAAA,EAAa;AAChB,MAAA,cAAA,CAAe,GAAA,CAAI,WAAA,EAAa,IAAA,CAAI,QAAA,CAAS,QAAQ,CAAC,CAAA;AACtD,MAAA;AAAA,IACF;AAEA,IAAA,WAAA,CAAY,KAAK,QAAA,CAAS,CAAA;AAE1B,IAAA,KAAA,MAAW,QAAA,IAAY,SAAS,KAAA,EAAO;AACrC,MAAA,WAAA,CAAY,KAAA,CAAM,QAAQ,CAAA,GAAA,CACvB,WAAA,CAAY,KAAA,CAAM,QAAQ,CAAA,IAAK,CAAA,IAC/B,QAAA,CAAS,KAAA,CAAM,QAAQ,CAAA;AAAA,IAC5B;AAEA,IAAA,IAAI,SAAS,IAAA,EAAM;AACjB,MAAA,IAAI,CAAC,YAAY,IAAA,EAAM;AACrB,QAAA,WAAA,CAAY,OAAO,EAAC;AAAA,MACtB;AACA,MAAA,KAAA,MAAW,QAAA,IAAY,SAAS,IAAA,EAAM;AACpC,QAAA,WAAA,CAAY,IAAA,CAAK,QAAQ,CAAA,GAAA,CACtB,WAAA,CAAY,IAAA,CAAK,QAAQ,CAAA,IAAK,CAAA,IAC9B,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA;AAAA,MAC3B;AAAA,IACF;AAAA,EACF;AAAA;AAAA,EAGA,IAAI,KAAA,EAAiB;AACnB,IAAA,OAAO,IAAA,CAAK,SAAA,CAAU,KAAA,EAAO,CAAC,CAAA;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA,CAAU,QAAa,WAAA,EAA0B;AAC/C,IAAA,IAAI,WAAA,KAAgB,GAAG,OAAO,IAAA;AAE9B,IAAA,MAAM,SAAA,uBAAgB,GAAA,EAAiB;AACvC,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AACjC,MAAA,SAAA,CAAU,GAAA,CAAI,GAAA,EAAK,IAAA,CAAI,QAAA,CAAS,GAAG,CAAC,CAAA;AAAA,IACtC;AAEA,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,OAAO,GAAA,EAAK;AACtD,MAAA,IAAA,CAAI,SAAA;AAAA,QACF,SAAA;AAAA,QACA,WAAA;AAAA,QACA,IAAA,CAAI,QAAA,CAAS,cAAA,EAAgB,WAAW;AAAA,OAC1C;AAAA,IACF;AAEA,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,SAAA;AAAA,MACA,IAAA,CAAK,OAAA;AAAA,MACL,KAAA;AAAA,MACA,GAAG,IAAA,CAAK,UAAU,WAAW,MAAA,CAAO,UAAU,IAAI,WAAW,CAAA,CAAA;AAAA,KAC/D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBA,kBAAkB,SAAA,EAAwB;AACxC,IAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,SAAS,CAAA,IAAK,SAAA,IAAa,GAAG,OAAO,IAAA;AAC1D,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,SAAS,CAAA;AAClC,IAAA,MAAM,SAAA,GAAA,CAAa,CAAA,GAAI,IAAA,IAAQ,IAAA,CAAK,IAAA,EAAK;AAEzC,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAiB;AACpC,IAAA,IAAI,OAAO,CAAA,EAAG;AACZ,MAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AACpC,QAAA,MAAA,CAAO,IAAI,MAAA,EAAQ,IAAA,CAAI,QAAA,CAAS,GAAA,EAAK,IAAI,CAAC,CAAA;AAAA,MAC5C;AAAA,IACF;AACA,IAAA,IAAI,YAAY,CAAA,EAAG;AACjB,MAAA,IAAA,CAAI,SAAA,CAAU,QAAQ,CAAA,EAAG;AAAA,QACvB,CAAA,EAAG,SAAA;AAAA,QACH,KAAA,EAAO,EAAE,CAAC,iBAAiB,GAAG,SAAA,EAAU;AAAA,QACxC,MAAM;AAAC,OACR,CAAA;AAAA,IACH;AAEA,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,MAAA;AAAA,MACA,IAAA,CAAK,OAAA;AAAA,MACL,KAAA;AAAA,MACA,CAAA,KAAA,EAAQ,IAAA,CAAK,UAAU,CAAA,CAAA,EAAI,IAAI,CAAA,CAAA;AAAA,KACjC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,cAAc,MAAA,EAAgD;AAC5D,IAAA,MAAM,CAAA,uBAAQ,GAAA,EAAiB;AAC/B,IAAA,MAAM,CAAA,uBAAQ,GAAA,EAAiB;AAC/B,IAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AACpC,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,IAAA,CAAK,IAAI,CAAA,EAAG,MAAA,CAAO,MAAM,CAAC,CAAC,CAAA;AACjD,MAAA,IAAI,CAAA,GAAI,GAAG,CAAA,CAAE,GAAA,CAAI,QAAQ,IAAA,CAAI,QAAA,CAAS,GAAA,EAAK,CAAC,CAAC,CAAA;AAC7C,MAAA,IAAI,CAAA,GAAI,CAAA,EAAG,CAAA,CAAE,GAAA,CAAI,MAAA,EAAQ,KAAI,QAAA,CAAS,GAAA,EAAK,CAAA,GAAI,CAAC,CAAC,CAAA;AAAA,IACnD;AACA,IAAA,OAAO;AAAA,MACL,IAAI,KAAI,CAAA,EAAG,IAAA,CAAK,SAAS,KAAA,EAAO,CAAA,OAAA,EAAU,IAAA,CAAK,UAAU,CAAA,CAAA,CAAG,CAAA;AAAA,MAC5D,IAAI,KAAI,CAAA,EAAG,IAAA,CAAK,SAAS,KAAA,EAAO,CAAA,OAAA,EAAU,IAAA,CAAK,UAAU,CAAA,CAAA,CAAG;AAAA,KAC9D;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAuBA,QAAA,GAAgB;AACd,IAAA,MAAM,SAAA,GAAY,KAAK,IAAA,EAAK;AAC5B,IAAA,IAAI,SAAA,IAAa,GAAG,OAAO,IAAA;AAE3B,IAAA,MAAM,SAAA,uBAAgB,GAAA,EAAiB;AACvC,IAAA,IAAI,GAAA,GAAM,CAAA;AAEV,IAAA,KAAA,MAAW,MAAA,IAAU,IAAA,CAAK,OAAA,EAAQ,EAAG;AACnC,MAAA,MAAM,GAAA,GAAM,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,MAAM,CAAA;AAC/B,MAAA,MAAM,WAAA,GAAc,IAAI,CAAA,GAAI,SAAA;AAC5B,MAAA,IAAI,eAAe,CAAA,EAAG;AAEtB,MAAA,MAAM,OAAA,GAAU,GAAA;AAChB,MAAA,GAAA,IAAO,WAAA;AAQP,MAAA,SAAA,CAAU,IAAI,MAAA,EAAQ,IAAA,CAAI,SAAS,GAAA,EAAK,GAAA,GAAM,OAAO,CAAC,CAAA;AAAA,IACxD;AAEA,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,SAAA;AAAA,MACA,IAAA,CAAK,OAAA;AAAA,MACL,IAAA,CAAK,UAAA;AAAA,MACL,CAAA,SAAA,EAAY,KAAK,UAAU,CAAA,CAAA;AAAA,KAC7B;AAAA,EACF;AAAA,EAEA,UAAU,MAAA,EAAqB;AAC7B,IAAA,IAAI,MAAA,KAAW,GAAG,OAAO,IAAA;AAEzB,IAAA,MAAM,SAAA,uBAAgB,GAAA,EAAiB;AACvC,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,cAAc,CAAA,IAAK,KAAK,GAAA,EAAK;AACpD,MAAA,SAAA,CAAU,IAAI,WAAA,EAAa,IAAA,CAAI,QAAA,CAAS,cAAA,EAAgB,MAAM,CAAC,CAAA;AAAA,IACjE;AACA,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,SAAA;AAAA,MACA,IAAA,CAAK,OAAA;AAAA,MACL,KAAA;AAAA,MACA,CAAA,MAAA,EAAS,IAAA,CAAK,UAAU,CAAA,CAAA,EAAI,MAAM,CAAA,CAAA;AAAA,KACpC;AAAA,EACF;AAAA,EAEA,UAAU,uBAAA,EAA+D;AACvE,IAAA,MAAM,cAAA,uBAAqB,GAAA,EAAiB;AAC5C,IAAA,KAAA,MAAW,CAAC,cAAA,EAAgB,cAAc,CAAA,IAAK,KAAK,GAAA,EAAK;AACvD,MAAA,MAAM,iBAAA,GAAoB,wBAAwB,cAAc,CAAA;AAChE,MAAA,IAAA,CAAI,SAAA;AAAA,QACF,cAAA;AAAA,QACA,iBAAA;AAAA,QACA,IAAA,CAAI,SAAS,cAAc;AAAA,OAC7B;AAAA,IACF;AACA,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,cAAA;AAAA,MACA,IAAA,CAAK,OAAA;AAAA,MACL,IAAA,CAAK,UAAA;AAAA,MACL,CAAA,IAAA,EAAO,KAAK,UAAU,CAAA,CAAA;AAAA,KACxB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,WAAA,CACE,MAAA,EACA,QAAA,GAAuC,OAAA,EACvC,cAAc,CAAA,EACT;AACL,IAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,MAAM,CAAA,EAAG;AAC5B,MAAA,MAAM,IAAI,UAAA,CAAW,CAAA,yCAAA,EAA4C,MAAM,CAAA,CAAE,CAAA;AAAA,IAC3E;AACA,IAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,WAAW,CAAA,IAAK,gBAAgB,CAAA,EAAG;AACtD,MAAA,MAAM,IAAI,UAAA,CAAW,CAAA,2DAAA,EAA8D,WAAW,CAAA,CAAE,CAAA;AAAA,IAClG;AACA,IAAA,MAAM,QAAQ,MAAA,CAAO,SAAA,CAAU,MAAM,CAAA,IAAK,MAAA,CAAO,UAAU,WAAW,CAAA;AACtE,IAAA,OAAO,IAAA,CAAK,SAAA,CAAU,CAAC,WAAA,KAAgB;AACrC,MAAA,IAAI,KAAA,IAAS,MAAA,CAAO,SAAA,CAAU,WAAW,CAAA,EAAG;AAC1C,QAAA,MAAM,YAAY,WAAA,GAAc,MAAA;AAChC,QAAA,IAAI,aAAa,OAAA,EAAS;AACxB,UAAA,OAAO,KAAK,KAAA,CAAA,CAAO,CAAA,GAAI,SAAA,GAAY,WAAA,KAAgB,IAAI,WAAA,CAAY,CAAA;AAAA,QACrE;AACA,QAAA,MAAM,WAAW,SAAA,GAAY,WAAA;AAC7B,QAAA,OAAO,QAAA,KAAa,SAAS,IAAA,CAAK,IAAA,CAAK,QAAQ,CAAA,GAAI,IAAA,CAAK,MAAM,QAAQ,CAAA;AAAA,MACxE;AACA,MAAA,MAAM,MAAA,GAAU,cAAc,MAAA,GAAU,WAAA;AACxC,MAAA,OAAO,QAAA,KAAa,OAAA,GAChB,IAAA,CAAK,KAAA,CAAM,MAAM,CAAA,GACjB,QAAA,KAAa,MAAA,GACb,IAAA,CAAK,IAAA,CAAK,MAAM,CAAA,GAChB,IAAA,CAAK,MAAM,MAAM,CAAA;AAAA,IACvB,CAAC,CAAA;AAAA,EACH;AAAA,EAEQ,qBAAA,CACN,EAAA,EACA,EAAA,EACA,GAAA,EACA,GAAA,EACQ;AACR,IAAA,MAAM,CAAC,GAAA,EAAK,GAAG,CAAA,GAAI,CAAC,GAAG,UAAA,EAAY,EAAA,CAAG,UAAU,CAAA,CAAE,IAAA,EAAK;AAEvD,IAAA,OAAO,MAAM,GAAA,GAAM,KAAA,GAAQ,GAAG,CAAA,CAAA,EAAI,GAAG,CAAA,CAAA,EAAI,GAAG,CAAA,CAAA,EAAI,GAAG,IAAI,EAAA,CAAG,WAAA,EAAa,CAAA,CAAA,EAAI,EAAA,CAAG,aAAa,CAAA,CAAA;AAAA,EAC7F;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAeA,WAAA,GAAsB;AACpB,IAAA,IAAI,IAAA,CAAK,iBAAiB,MAAA,EAAW;AACnC,MAAA,MAAM,MAAA,GAAS,CAAC,CAAA,KACd,CAAA,KAAM,MAAA,GACF,EAAA,GACA,MAAA,CAAO,IAAA,CAAK,CAAC,CAAA,CACV,IAAA,EAAK,CACL,GAAA,CAAI,CAAC,CAAA,KAAM,CAAA,EAAG,IAAA,CAAK,SAAA,CAAU,CAAC,CAAC,CAAA,CAAA,EAAI,CAAA,CAAE,CAAC,CAAC,CAAA,CAAE,CAAA,CACzC,IAAA,CAAK,GAAG,CAAA;AACjB,MAAA,MAAM,OAAO,CAAC,GAAG,IAAA,CAAK,GAAA,CAAI,SAAS,CAAA,CAAE,IAAA,CAAK,CAAC,GAAG,CAAA,KAAM,CAAA,CAAE,CAAC,CAAA,GAAI,CAAA,CAAE,CAAC,CAAC,CAAA;AAC/D,MAAA,MAAM,QAAkB,EAAC;AACzB,MAAA,KAAA,MAAW,CAAC,WAAA,EAAa,GAAG,CAAA,IAAK,IAAA,EAAM;AACrC,QAAA,KAAA,CAAM,KAAK,CAAA,EAAG,WAAW,CAAA,CAAA,EAAI,GAAA,CAAI,CAAC,CAAA,CAAA,EAAI,MAAA,CAAO,GAAA,CAAI,KAAK,CAAC,CAAA,EAAA,EAAK,MAAA,CAAO,GAAA,CAAI,IAAI,CAAC,CAAA,CAAA,CAAG,CAAA;AAAA,MACjF;AACA,MAAA,IAAA,CAAK,YAAA,GAAe,CAAA,EAAG,IAAA,CAAK,UAAA,GAAa,CAAA,GAAI,CAAC,CAAA,CAAA,EAAI,KAAA,CAAM,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA;AAAA,IACnE;AACA,IAAA,OAAO,IAAA,CAAK,YAAA;AAAA,EACd;AAAA,EAEA,QAAA,CAAS,KAAA,EAAY,GAAA,EAAc,GAAA,GAAM,KAAA,EAAY;AACnD,IAAA,MAAM,OAAA,GAAU,OAAO,IAAA,CAAK,OAAA;AAG5B,IAAA,MAAM,IAAA,GAAO,CAAC,CAAA,KACZ,GAAA,GAAM,IAAI,IAAA,CAAK,GAAA,CAAI,CAAA,CAAE,IAAA,KAAS,CAAC,CAAA,IAAK,OAAA,GAAU,CAAA,GAAI,EAAE,SAAA,EAAU;AAChE,IAAA,MAAM,EAAA,GAAK,KAAK,IAAI,CAAA;AACpB,IAAA,MAAM,EAAA,GAAK,KAAK,KAAK,CAAA;AAErB,IAAA,MAAM,CAAC,CAAA,EAAG,CAAC,CAAA,GAAI,GAAG,UAAA,IAAc,EAAA,CAAG,UAAA,GAAa,CAAC,EAAA,EAAI,EAAE,CAAA,GAAI,CAAC,IAAI,EAAE,CAAA;AAClE,IAAA,MAAM,WAAW,IAAA,CAAK,qBAAA,CAAsB,CAAA,EAAG,CAAA,EAAG,SAAS,GAAG,CAAA;AAC9D,IAAA,MAAM,MAAA,GAAS,QAAA,CAAS,GAAA,CAAI,QAAQ,CAAA;AACpC,IAAA,IAAI,QAAQ,OAAO,MAAA;AASnB,IAAA,MAAM,YAAA,GAAe,CAAC,CAAA,KACpB,CAAA,KAAM,SAAY,MAAA,GAAa,MAAA,CAAO,QAAQ,CAAC,CAAA;AACjD,IAAA,MAAM,QAAA,GAAW,CAAC,GAAG,CAAA,CAAE,GAAG,CAAA,CAAE,GAAA,CAAI,CAAC,CAAC,IAAA,EAAM,IAAI,CAAA,MAAO;AAAA,MACjD,IAAA;AAAA,MACA,IAAI,IAAA,CAAK,CAAA;AAAA,MACT,KAAA,EAAO,YAAA,CAAa,IAAA,CAAK,KAAK,CAAA;AAAA,MAC9B,IAAA,EAAM,YAAA,CAAa,IAAA,CAAK,IAAI;AAAA,KAC9B,CAAE,CAAA;AACF,IAAA,MAAM,WAAA,uBAAkB,GAAA,EAAiB;AACzC,IAAA,KAAA,MAAW,CAAC,IAAA,EAAM,IAAI,CAAA,IAAK,EAAE,GAAA,EAAK;AAChC,MAAA,MAAM,KAAK,IAAA,CAAK,CAAA;AAChB,MAAA,MAAM,MAAA,GAAS,YAAA,CAAa,IAAA,CAAK,KAAK,CAAA;AACtC,MAAA,MAAM,KAAA,GAAQ,YAAA,CAAa,IAAA,CAAK,IAAI,CAAA;AACpC,MAAA,KAAA,MAAW,EAAE,MAAM,EAAA,EAAI,KAAA,EAAO,QAAQ,IAAA,EAAM,KAAA,MAAW,QAAA,EAAU;AAC/D,QAAA,MAAM,MAAM,IAAA,GAAO,IAAA;AAEnB,QAAA,IAAI,IAAA,GAAO,WAAA,CAAY,GAAA,CAAI,GAAG,CAAA;AAC9B,QAAA,IAAI,SAAS,MAAA,EAAW;AACtB,UAAA,IAAA,GAAO,EAAE,CAAA,EAAG,CAAA,EAAG,KAAA,EAAO,EAAC,EAAE;AACzB,UAAA,WAAA,CAAY,GAAA,CAAI,KAAK,IAAI,CAAA;AAAA,QAC3B;AAEA,QAAA,IAAA,CAAK,KAAK,EAAA,GAAK,EAAA;AAEf,QAAA,MAAM,KAAK,IAAA,CAAK,KAAA;AAChB,QAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,MAAA,EAAQ,EAAA,CAAG,CAAC,CAAA,GAAA,CAAK,EAAA,CAAG,CAAC,CAAA,IAAK,CAAA,IAAK,CAAA,GAAI,EAAA;AACxD,QAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,MAAA,EAAQ,EAAA,CAAG,CAAC,CAAA,GAAA,CAAK,EAAA,CAAG,CAAC,CAAA,IAAK,CAAA,IAAK,CAAA,GAAI,EAAA;AAExD,QAAA,IAAI,SAAS,KAAA,EAAO;AAClB,UAAA,IAAI,KAAK,IAAA,CAAK,IAAA;AACd,UAAA,IAAI,OAAO,MAAA,EAAW;AACpB,YAAA,EAAA,GAAK,EAAC;AACN,YAAA,IAAA,CAAK,IAAA,GAAO,EAAA;AAAA,UACd;AACA,UAAA,IAAI,KAAA,EAAO,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,KAAA,EAAO,EAAA,CAAG,CAAC,CAAA,GAAA,CAAK,EAAA,CAAG,CAAC,CAAA,IAAK,KAAK,CAAA,GAAI,EAAA;AAClE,UAAA,IAAI,KAAA,EAAO,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,KAAA,EAAO,EAAA,CAAG,CAAC,CAAA,GAAA,CAAK,EAAA,CAAG,CAAC,CAAA,IAAK,KAAK,CAAA,GAAI,EAAA;AAAA,QACpE;AAAA,MACF;AAAA,IACF;AAEA,IAAA,IAAI,SAAS,IAAI,IAAA;AAAA,MACf,WAAA;AAAA,MACA,OAAA;AAAA,MACA,CAAC,GAAA;AAAA,MACD,CAAA,EAAG,EAAE,UAAU,CAAA,EAAG,MAAM,GAAA,GAAM,GAAG,CAAA,EAAG,CAAA,CAAE,UAAU,CAAA;AAAA,KAClD;AAGA,IAAA,MAAM,IAAA,GAAA,CAAQ,MAAM,CAAA,CAAE,IAAA,KAAS,CAAA,KAAM,GAAA,GAAM,CAAA,CAAE,IAAA,EAAK,GAAI,CAAA,CAAA;AACtD,IAAA,MAAM,IAAA,GAAO,OAAO,IAAA,EAAK;AAIzB,IAAA,IAAI,IAAA,KAAS,KAAK,IAAA,KAAS,CAAA,IAAK,KAAK,GAAA,CAAI,IAAA,GAAO,IAAI,CAAA,GAAI,OAAA,EAAS;AAC/D,MAAA,MAAA,GAAS,MAAA,CAAO,SAAA,CAAU,IAAA,GAAO,IAAI,CAAA;AAAA,IACvC;AACA,IAAA,IAAI,CAAC,GAAA,IAAO,IAAA,KAAS,CAAA,IAAK,IAAA,CAAK,IAAI,MAAA,CAAO,IAAA,EAAK,GAAI,CAAC,CAAA,GAAI,OAAA;AACtD,MAAA,MAAA,GAAS,OAAO,SAAA,EAAU;AAE5B,IAAA,QAAA,CAAS,GAAA,CAAI,UAAU,MAAM,CAAA;AAC7B,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA,EAGA,UAAA,CAAW,OAAY,GAAA,EAAmB;AACxC,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,GAAA,EAAK,IAAI,CAAA;AAAA,EACvC;AAAA;AAAA,EAGA,OAAe,kBAAA,CAAmB,OAAA,EAAgB,GAAA,EAAkB;AAClE,IAAA,IAAI,MAAA,GAAS,QAAQ,CAAC,CAAA;AACtB,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,OAAA,CAAQ,QAAQ,CAAA,EAAA,EAAK;AACvC,MAAA,MAAA,GAAS,MAAA,CAAO,QAAA,CAAS,OAAA,CAAQ,CAAC,GAAG,GAAG,CAAA;AAAA,IAC1C;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,OAAO,YAAA,CAAa,OAAA,EAAgB,GAAA,GAAM,GAAA,EAAU;AAClD,IAAA,IAAI,QAAQ,MAAA,KAAW,CAAA,EAAG,OAAO,IAAA,CAAI,MAAM,GAAG,CAAA;AAC9C,IAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,CAAA,EAAG,OAAO,QAAQ,CAAC,CAAA;AAI1C,IAAA,OAAO,IAAA,CAAI,kBAAA,CAAmB,OAAA,EAAS,GAAG,CAAA;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,MAAA,GAIE;AACA,IAAA,OAAO;AAAA,MACL,MAAM,CAAC,GAAG,IAAA,CAAK,GAAA,CAAI,SAAS,CAAA;AAAA,MAC5B,YAAY,IAAA,CAAK,UAAA;AAAA,MACjB,YAAY,IAAA,CAAK;AAAA,KACnB;AAAA,EACF;AAAA;AAAA,EAGA,YAAA,GAAuB;AACrB,IAAA,OAAO,IAAA,CAAK,UAAU,IAAI,CAAA;AAAA,EAC5B;AAAA,EAEA,OAAO,SAAS,QAAA,EAIb;AACD,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,IAAI,GAAA,CAAI,QAAA,CAAS,IAAI,CAAA;AAAA,MACrB,GAAA;AAAA,MACA,CAAC,CAAC,QAAA,CAAS,UAAA;AAAA,MACX,SAAS,UAAA,IAAc;AAAA,KACzB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,KAAA,CAAM,MAAA,EAAgB,OAAA,GAAU,CAAA,EAAQ;AACtC,IAAA,MAAM,IAAA,GAAO,KAAK,GAAA,CAAI,IAAA;AACtB,IAAA,IAAI,IAAA,KAAS,GAAG,OAAO,IAAA;AAGvB,IAAA,IAAI,IAAA,GAAO,CAAA;AACX,IAAA,IAAI,YAAY,MAAA,CAAO,iBAAA;AACvB,IAAA,IAAI,YAAY,MAAA,CAAO,iBAAA;AACvB,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AACjC,MAAA,IAAI,GAAA,CAAI,CAAA,GAAI,IAAA,EAAM,IAAA,GAAO,GAAA,CAAI,CAAA;AAC7B,MAAA,IAAI,GAAA,GAAM,WAAW,SAAA,GAAY,GAAA;AACjC,MAAA,IAAI,GAAA,GAAM,WAAW,SAAA,GAAY,GAAA;AAAA,IACnC;AACA,IAAA,IAAI,IAAA,KAAS,CAAA;AACX,MAAA,OAAO,IAAI,IAAA,CAAI,IAAI,GAAA,CAAI,IAAA,CAAK,GAAG,CAAA,EAAG,MAAA,EAAQ,KAAA,EAAO,IAAA,CAAK,UAAU,CAAA;AAElE,IAAA,MAAM,SAAS,MAAA,GAAS,IAAA;AACxB,IAAA,MAAM,UAAU,CAAC,GAAG,IAAA,CAAK,GAAA,CAAI,SAAS,CAAA;AAGtC,IAAA,MAAM,cAAA,uBAAqB,GAAA,EAAiB;AAC5C,IAAA,MAAM,OAAA,GAAU,CAAC,CAAA,KAAc;AAC7B,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,CAAC,CAAA;AACxB,MAAA,IAAI,CAAA,EAAG,cAAA,CAAe,GAAA,CAAI,CAAA,EAAG,CAAC,CAAA;AAAA,IAChC,CAAA;AACA,IAAA,OAAA,CAAQ,SAAS,CAAA;AACjB,IAAA,IAAI,SAAA,KAAc,SAAA,EAAW,OAAA,CAAQ,SAAS,CAAA;AAG9C,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,OAAA,EAAS;AAChC,MAAA,IAAI,IAAI,CAAA,IAAK,MAAA,EAAQ,cAAA,CAAe,GAAA,CAAI,KAAK,GAAG,CAAA;AAAA,IAClD;AAGA,IAAA,IAAI,OAAA,GAAU,CAAA,IAAK,cAAA,CAAe,IAAA,GAAO,OAAA,EAAS;AAEhD,MAAA,OAAA,CAAQ,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,CAAC,CAAA,CAAE,CAAA,GAAI,CAAA,CAAE,CAAC,CAAA,CAAE,CAAC,CAAA;AACtC,MAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,OAAA,EAAS;AAChC,QAAA,IAAI,CAAC,cAAA,CAAe,GAAA,CAAI,GAAG,CAAA,EAAG;AAC5B,UAAA,cAAA,CAAe,GAAA,CAAI,KAAK,GAAG,CAAA;AAC3B,UAAA,IAAI,cAAA,CAAe,QAAQ,OAAA,EAAS;AAAA,QACtC;AAAA,MACF;AAAA,IACF;AAGA,IAAA,MAAM,SAAA,uBAAgB,GAAA,EAAiB;AACvC,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,cAAA,EAAgB;AACvC,MAAA,MAAM,WAA4B,EAAC;AACnC,MAAA,KAAA,MAAW,CAAA,IAAK,IAAI,KAAA,EAAO;AACzB,QAAA,MAAM,CAAA,GAAI,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA;AACrB,QAAA,IAAI,KAAK,GAAA,CAAI,CAAC,KAAK,MAAA,EAAQ,QAAA,CAAS,CAAC,CAAA,GAAI,CAAA;AAAA,MAC3C;AACA,MAAA,IAAI,OAAA;AACJ,MAAA,IAAI,IAAI,IAAA,EAAM;AACZ,QAAA,KAAA,MAAW,CAAA,IAAK,IAAI,IAAA,EAAM;AACxB,UAAA,MAAM,CAAA,GAAI,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA;AACpB,UAAA,IAAI,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA,IAAK,MAAA,EAAQ;AACzB,YAAA,IAAI,CAAC,OAAA,EAAS,OAAA,GAAU,EAAC;AACzB,YAAA,OAAA,CAAQ,CAAC,CAAA,GAAI,CAAA;AAAA,UACf;AAAA,QACF;AAAA,MACF;AACA,MAAA,SAAA,CAAU,GAAA,CAAI,GAAA,EAAK,EAAE,CAAA,EAAG,GAAA,CAAI,GAAG,KAAA,EAAO,QAAA,EAAU,IAAA,EAAM,OAAA,EAAS,CAAA;AAAA,IACjE;AAGA,IAAA,OAAO,IAAI,KAAI,SAAA,EAAW,MAAA,EAAQ,OAAO,CAAA,MAAA,EAAS,IAAA,CAAK,UAAU,CAAA,CAAA,CAAG,CAAA;AAAA,EACtE;AAAA;AAAA,EAGA,IAAI,CAAA,EAAmB;AACrB,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,CAAC,GAAG,CAAA,IAAK,CAAA;AAAA,EAC/B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,cAAA,GAAyB;AACvB,IAAA,OAAO,CAAA,GAAI,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA;AAAA,EACvB;AAAA;AAAA,EAGA,eAAA,GAA0B;AACxB,IAAA,OAAO,IAAA,CAAK,IAAI,CAAC,CAAA;AAAA,EACnB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,MAAM,UAAA,EAAyB;AAC7B,IAAA,IAAI,EAAE,UAAA,GAAa,CAAA,CAAA,EAAI,OAAO,IAAA;AAC9B,IAAA,MAAM,OAAA,GAAU,KAAK,OAAA,EAAQ;AAC7B,IAAA,IAAI,OAAA,CAAQ,MAAA,KAAW,CAAA,EAAG,OAAO,IAAA;AACjC,IAAA,MAAM,GAAA,GAAM,QAAQ,CAAC,CAAA;AACrB,IAAA,MAAM,GAAA,GAAM,OAAA,CAAQ,OAAA,CAAQ,MAAA,GAAS,CAAC,CAAA;AACtC,IAAA,MAAM,QAAQ,GAAA,GAAM,GAAA;AACpB,IAAA,IAAI,KAAA,GAAQ,CAAA,IAAK,UAAA,EAAY,OAAO,IAAA;AACpC,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,IAAA,CAAA,CAAM,KAAA,GAAQ,KAAK,UAAU,CAAA;AAClD,IAAA,OAAO,IAAA,CAAK,SAAA,CAAU,CAAC,CAAA,KAAM,GAAA,GAAM,IAAA,CAAK,KAAA,CAAA,CAAO,CAAA,GAAI,GAAA,IAAO,OAAO,CAAA,GAAI,OAAO,CAAA;AAAA,EAC9E;AAAA;AAAA;AAAA;AAAA,EAKA,YAAA,GAAyB;AACvB,IAAA,MAAM,CAAA,GAAI,KAAK,OAAA,EAAQ;AACvB,IAAA,IAAI,CAAA,CAAE,MAAA,KAAW,CAAA,EAAG,OAAO,EAAC;AAC5B,IAAA,MAAM,EAAA,GAAK,IAAA,CAAK,GAAA,CAAI,GAAG,CAAC,GACtB,EAAA,GAAK,IAAA,CAAK,GAAA,CAAI,GAAG,CAAC,CAAA;AACpB,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,EAAE,MAAA,EAAQ,EAAA,GAAK,EAAA,GAAK,CAAA,EAAE,EAAG,CAAC,CAAA,EAAG,CAAA,KAAM,EAAA,GAAK,CAAC,CAAA,CAAE,IAAA;AAAA,MAC3D,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,GAAI;AAAA,KAChB;AAAA,EACF;AAAA;AAAA,EAGA,MAAM,CAAA,EAAmB;AACvB,IAAA,IAAI,GAAA,GAAM,CAAA;AACV,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAG,CAAA,IAAK,IAAA,CAAK,KAAK,IAAI,GAAA,IAAO,CAAA,EAAG,GAAA,IAAO,GAAA,CAAI,CAAA;AAC5D,IAAA,OAAO,GAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,SAAS,CAAA,EAAmB;AAC1B,IAAA,MAAM,EAAE,MAAA,EAAQ,KAAA,EAAO,KAAA,EAAM,GAAI,KAAK,UAAA,EAAW;AACjD,IAAA,MAAM,IAAI,MAAA,CAAO,MAAA;AACjB,IAAA,IAAI,CAAA,KAAM,GAAG,OAAO,CAAA;AACpB,IAAA,MAAM,KAAA,GAAQ,KAAA,CAAM,CAAA,GAAI,CAAC,CAAA;AACzB,IAAA,IAAI,EAAE,KAAA,GAAQ,CAAA,CAAA,EAAI,OAAO,CAAA;AACzB,IAAA,IAAI,CAAA,IAAK,CAAA,EAAG,OAAO,MAAA,CAAO,CAAC,CAAA;AAC3B,IAAA,IAAI,CAAA,IAAK,CAAA,EAAG,OAAO,MAAA,CAAO,IAAI,CAAC,CAAA;AAE/B,IAAA,MAAM,QAAQ,IAAA,CAAK,GAAA,CAAI,yBAAyB,CAAA,GAAI,CAAA,GAAI,OAAO,OAAO,CAAA;AACtE,IAAA,MAAM,SAAA,GAAY,CAAA,GAAI,KAAA,IAAS,CAAA,GAAI,KAAA,CAAA;AACnC,IAAA,MAAM,UAAA,GAAA,CAAc,CAAA,GAAI,CAAA,IAAK,KAAA,IAAS,CAAA,GAAI,KAAA,CAAA;AAC1C,IAAA,MAAM,UAAU,CAAA,IAAK,GAAA;AAGrB,IAAA,IAAI,EAAA,GAAK,CAAA;AACT,IAAA,IAAI,EAAA,GAAK,CAAA;AACT,IAAA,OAAO,KAAK,EAAA,EAAI;AACd,MAAA,MAAM,GAAA,GAAO,KAAK,EAAA,KAAQ,CAAA;AAC1B,MAAA,MAAM,OAAA,GAAU,UAAU,KAAA,CAAM,GAAG,KAAK,SAAA,GAAY,KAAA,CAAM,GAAG,CAAA,IAAK,UAAA;AAClE,MAAA,IAAI,SAAS,EAAA,GAAK,GAAA;AAAA,gBACR,GAAA,GAAM,CAAA;AAAA,IAClB;AACA,IAAA,OAAO,OAAO,IAAA,CAAK,GAAA,CAAI,EAAA,EAAI,CAAA,GAAI,CAAC,CAAC,CAAA;AAAA,EACnC;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,UAAA,GAAqE;AAC3E,IAAA,IAAI,IAAA,CAAK,gBAAgB,MAAA,EAAW;AAClC,MAAA,MAAM,MAAA,GAAS,KAAK,OAAA,EAAQ;AAC5B,MAAA,MAAM,IAAI,MAAA,CAAO,MAAA;AACjB,MAAA,MAAM,KAAA,GAAQ,IAAI,KAAA,CAAc,CAAC,CAAA;AACjC,MAAA,MAAM,KAAA,GAAQ,IAAI,KAAA,CAAc,CAAC,CAAA;AACjC,MAAA,IAAI,GAAA,GAAM,CAAA;AACV,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,CAAA,EAAG,CAAA,EAAA,EAAK;AAC1B,QAAA,GAAA,IAAQ,KAAK,GAAA,CAAI,GAAA,CAAI,MAAA,CAAO,CAAC,CAAC,CAAA,CAAU,CAAA;AACxC,QAAA,KAAA,CAAM,CAAC,CAAA,GAAI,GAAA;AAAA,MACb;AACA,MAAA,GAAA,GAAM,CAAA;AACN,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,GAAG,CAAA,EAAA,EAAK;AAC/B,QAAA,KAAA,CAAM,CAAC,CAAA,GAAI,GAAA;AACX,QAAA,GAAA,IAAQ,KAAK,GAAA,CAAI,GAAA,CAAI,MAAA,CAAO,CAAC,CAAC,CAAA,CAAU,CAAA;AAAA,MAC1C;AACA,MAAA,IAAA,CAAK,WAAA,GAAc,EAAE,MAAA,EAAQ,KAAA,EAAO,KAAA,EAAM;AAAA,IAC5C;AACA,IAAA,OAAO,IAAA,CAAK,WAAA;AAAA,EACd;AAAA;AAAA,EAGA,SAAA,CAAU,QAAgB,OAAA,EAAyB;AACjD,IAAA,OAAQ,KAAK,GAAA,CAAI,GAAA,CAAI,MAAM,CAAA,EAAG,KAAA,CAAM,OAAO,CAAA,IAAgB,CAAA;AAAA,EAC7D;AAAA;AAAA,EAGA,QAAA,GAAqB;AACnB,IAAA,MAAM,UAAA,uBAAiB,GAAA,EAAY;AACnC,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AAC9B,MAAA,KAAA,MAAW,OAAA,IAAW,IAAI,KAAA,EAAO;AAC/B,QAAA,IAAK,GAAA,CAAI,KAAA,CAAM,OAAO,CAAA,GAAe,CAAA,EAAG;AACtC,UAAA,UAAA,CAAW,IAAI,OAAO,CAAA;AAAA,QACxB;AAAA,MACF;AAAA,IACF;AACA,IAAA,OAAO,KAAA,CAAM,IAAA,CAAK,UAAU,CAAA,CAAE,IAAA,EAAK;AAAA,EACrC;AAAA;AAAA,EAGA,mBAAmB,OAAA,EAAyB;AAC1C,IAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AAC9B,MAAA,KAAA,IAAU,GAAA,CAAI,KAAA,CAAM,OAAO,CAAA,IAAgB,CAAA;AAAA,IAC7C;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA,EAGA,oBAAA,CAAqB,QAAgB,OAAA,EAAyB;AAC5D,IAAA,OAAQ,KAAK,GAAA,CAAI,GAAA,CAAI,MAAM,CAAA,EAAG,IAAA,GAAO,OAAO,CAAA,IAAgB,CAAA;AAAA,EAC9D;AAAA;AAAA,EAGA,MAAM,MAAA,EAIG;AACP,IAAA,MAAM,GAAA,GAAM,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,MAAM,CAAA;AAC/B,IAAA,IAAI,CAAC,KAAK,OAAO,IAAA;AAEjB,IAAA,OAAO;AAAA,MACL,GAAG,GAAA,CAAI,CAAA;AAAA,MACP,KAAA,EAAO,EAAE,GAAG,GAAA,CAAI,KAAA,EAAM;AAAA,MACtB,MAAM,GAAA,CAAI,IAAA,GAAQ,EAAE,GAAG,GAAA,CAAI,MAAK,GAA+B;AAAA,KACjE;AAAA,EACF;AAAA;AAAA,EAGA,WAAW,OAAA,EAA0B;AACnC,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AAC9B,MAAA,IAAA,CAAM,GAAA,CAAI,KAAA,CAAM,OAAO,CAAA,IAAgB,KAAK,CAAA,EAAG;AAC7C,QAAA,OAAO,IAAA;AAAA,MACT;AAAA,IACF;AACA,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAgBA,kBAAA,GAAuD;AACrD,IAAA,MAAM,MAAM,IAAA,CAAK,cAAA,EAAe,GAAI,IAAA,GAAO,KAAK,eAAA,EAAgB;AAChE,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAiC;AAEpD,IAAA,MAAM,GAAA,GAAM,CAAC,KAAA,EAAe,MAAA,EAAgB,IAAA,KAAuB;AACjE,MAAA,IAAI,EAAE,OAAO,CAAA,CAAA,EAAI;AACjB,MAAA,IAAI,MAAA,GAAS,MAAA,CAAO,GAAA,CAAI,KAAK,CAAA;AAC7B,MAAA,IAAI,CAAC,MAAA,EAAQ;AACX,QAAA,MAAA,uBAAa,GAAA,EAAoB;AACjC,QAAA,MAAA,CAAO,GAAA,CAAI,OAAO,MAAM,CAAA;AAAA,MAC1B;AACA,MAAA,MAAA,CAAO,IAAI,MAAA,EAAA,CAAS,MAAA,CAAO,IAAI,MAAM,CAAA,IAAK,KAAK,IAAI,CAAA;AAAA,IACrD,CAAA;AAEA,IAAA,KAAA,MAAW,CAAC,MAAA,EAAQ,GAAG,CAAA,IAAK,IAAI,GAAA,EAAK;AACnC,MAAA,MAAM,CAAA,GAAI,IAAI,CAAA,IAAK,CAAA;AACnB,MAAA,IAAI,KAAK,CAAA,EAAG;AACZ,MAAA,MAAM,YAAY,MAAA,KAAW,CAAA;AAG7B,MAAA,IAAI,SAAA,EAAW;AACb,QAAA,IAAI,UAAA,GAAa,CAAA;AACjB,QAAA,KAAA,MAAW,KAAK,GAAA,CAAI,KAAA,gBAAsB,GAAA,CAAI,KAAA,CAAM,CAAC,CAAA,IAAgB,CAAA;AACrE,QAAA,IAAI,aAAa,CAAA,EAAG;AAClB,UAAA,MAAM,CAAA,GAAK,GAAA,CAAI,KAAA,CAAM,iBAAiB,CAAA,IAAgB,CAAA;AACtD,UAAA,GAAA,CAAI,iBAAA,EAAmB,MAAA,EAAS,CAAA,GAAI,UAAA,GAAc,CAAC,CAAA;AAAA,QACrD;AACA,QAAA;AAAA,MACF;AAGA,MAAA,IAAI,SAAA,GAAY,CAAA;AAChB,MAAA,IAAI,GAAA,CAAI,IAAA,EAAM,KAAA,MAAW,CAAA,IAAK,GAAA,CAAI,MAAM,SAAA,IAAc,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA,IAAgB,CAAA;AAChF,MAAA,IAAI,GAAA,CAAI,IAAA,IAAQ,SAAA,GAAY,CAAA,EAAG;AAC7B,QAAA,KAAA,MAAW,CAAA,IAAK,IAAI,IAAA,EAAM;AACxB,UAAA,IAAI,MAAM,iBAAA,EAAmB;AAC7B,UAAA,GAAA,CAAI,CAAA,EAAG,SAAW,GAAA,CAAI,IAAA,CAAK,CAAC,CAAA,IAAgB,CAAA,IAAK,YAAa,CAAC,CAAA;AAAA,QACjE;AAAA,MACF;AAAA,IACF;AAEA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUQ,sBAAA,GAAoE;AAC1E,IAAA,MAAM,UAAA,GAAa,CAAC,GAAG,IAAA,CAAK,GAAA,CAAI,IAAA,EAAM,CAAA,CAAE,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,IAAI,CAAC,CAAA;AAC5D,IAAA,MAAM,aAAyC,EAAC;AAChD,IAAA,IAAI,WAAA,GAAc,CAAA;AAClB,IAAA,KAAA,IAAS,IAAI,UAAA,CAAW,MAAA,GAAS,CAAA,EAAG,CAAA,IAAK,GAAG,CAAA,EAAA,EAAK;AAC/C,MAAA,MAAM,GAAA,GAAM,WAAW,CAAC,CAAA;AACxB,MAAA,MAAM,GAAA,GAAM,IAAA,CAAK,GAAA,CAAI,GAAA,CAAI,GAAG,CAAA;AAC5B,MAAA,IAAI,CAAC,GAAA,EAAK;AACV,MAAA,WAAA,IAAe,GAAA,CAAI,CAAA;AACnB,MAAA,UAAA,CAAW,QAAQ,EAAE,CAAA,EAAG,KAAK,CAAA,EAAG,WAAA,GAAc,KAAK,CAAA;AAAA,IACrD;AACA,IAAA,MAAM,uBAAA,GAA0B,CAAC,UAAA,KAA+B;AAC9D,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,UAAA,CAAW,QAAQ,CAAA,EAAA,EAAK;AAC1C,QAAA,IAAI,UAAA,CAAW,CAAC,CAAA,CAAE,CAAA,IAAK,UAAA,EAAY;AACjC,UAAA,OAAO,CAAA,GAAI,IAAI,UAAA,CAAW,CAAA,GAAI,CAAC,CAAA,CAAE,CAAA,GAAI,UAAA,CAAW,CAAC,CAAA,CAAE,CAAA;AAAA,QACrD;AAAA,MACF;AACA,MAAA,OAAO,UAAA,CAAW,UAAA,CAAW,MAAA,GAAS,CAAC,CAAA,CAAE,CAAA;AAAA,IAC3C,CAAA;AACA,IAAA,OAAO;AAAA,MACL,GAAA,EAAK,wBAAwB,EAAE,CAAA;AAAA,MAC/B,GAAA,EAAK,wBAAwB,EAAE,CAAA;AAAA,MAC/B,GAAA,EAAK,wBAAwB,EAAE;AAAA,KACjC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBA,2BAAA,CACE,OAAA,GAII,EAAC,EACwB;AAC7B,IAAA,MAAM,EAAE,UAAA,EAAY,UAAA,GAAa,iBAAA,EAAmB,OAAA,GAAU,MAAK,GAAI,OAAA;AAEvE,IAAA,MAAM,KAAA,GAAqC;AAAA,MACzC,QAAQ,EAAC;AAAA,MACT,UAAU,EAAC;AAAA,MACX,MAAA,sBAAY,GAAA,EAAI;AAAA,MAChB,MAAA,sBAAY,GAAA,EAAI;AAAA,MAChB,QAAQ,EAAC;AAAA,MACT,aAAa,EAAE,GAAA,EAAK,GAAG,GAAA,EAAK,CAAA,EAAG,KAAK,CAAA,EAAE;AAAA,MACtC,IAAA,EAAM;AAAA,KACR;AACA,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,IAAA,KAAS,CAAA,EAAG,OAAO,KAAA;AAGhC,IAAA,MAAM,KAAA,GAAQ,KAAK,kBAAA,EAAmB;AAItC,IAAA,MAAM,UAAA,uBAAiB,GAAA,EAAY;AACnC,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AAC9B,MAAA,KAAA,MAAW,CAAA,IAAK,GAAA,CAAI,KAAA,EAAO,UAAA,CAAW,IAAI,CAAC,CAAA;AAC3C,MAAA,IAAI,GAAA,CAAI,MAAM,KAAA,MAAW,CAAA,IAAK,IAAI,IAAA,EAAM,UAAA,CAAW,IAAI,CAAC,CAAA;AAAA,IAC1D;AACA,IAAA,MAAM,WAAW,YAAA,CAAa,CAAC,GAAG,UAAU,GAAG,UAAU,CAAA;AACzD,IAAA,MAAM,cAAA,GAAiB,SAAS,MAAA,GAAS,CAAA;AAIzC,IAAA,IAAI,GAAA,GAAM,QAAA;AACV,IAAA,IAAI,GAAA,GAAM,CAAA,QAAA;AACV,IAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KAAoB;AACjC,MAAA,IAAI,CAAA,GAAI,KAAK,GAAA,GAAM,CAAA;AACnB,MAAA,IAAI,CAAA,GAAI,KAAK,GAAA,GAAM,CAAA;AAAA,IACrB,CAAA;AACA,IAAA,IAAI,cAAA,EAAgB;AAClB,MAAA,KAAA,MAAW,CAAA,IAAK,MAAM,MAAA,EAAO;AAC3B,QAAA,KAAA,MAAW,CAAC,GAAG,CAAC,CAAA,IAAK,GAAG,IAAI,CAAA,GAAI,CAAA,EAAG,KAAA,CAAM,CAAC,CAAA;AAAA,IAC9C,CAAA,MAAO;AACL,MAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,IAAA,CAAK,GAAA,EAAK,IAAA,CAAK,GAAA,CAAI,CAAA,IAAK,CAAA,IAAK,CAAA,EAAG,KAAA,CAAM,CAAC,CAAA;AAAA,IAChE;AACA,IAAA,IAAI,GAAA,GAAM,KAAK,OAAO,KAAA;AACtB,IAAA,MAAM,QAAQ,GAAA,GAAM,GAAA;AAGpB,IAAA,MAAM,MAAA,GACJ,UAAA,KAAe,MAAA,IAAa,UAAA,GAAa,KAAK,KAAA,GAAQ,UAAA;AACxD,IAAA,MAAM,UAAU,MAAA,GAAS,IAAA,CAAK,MAAM,KAAA,GAAQ,CAAA,IAAK,UAAW,CAAA,GAAI,CAAA;AAChE,IAAA,MAAM,OAAA,GAAU,SAAS,IAAA,CAAK,IAAA,CAAA,CAAM,QAAQ,CAAA,IAAK,OAAO,IAAI,KAAA,GAAQ,CAAA;AACpE,IAAA,MAAM,WAAW,CAAC,CAAA,KAAsB,KAAK,KAAA,CAAA,CAAO,CAAA,GAAI,OAAO,OAAO,CAAA;AAEtE,IAAA,MAAM,SAAmB,EAAC;AAC1B,IAAA,MAAM,SAAA,GAA0D,MAAA,GAC5D,EAAC,GACD,MAAA;AACJ,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,OAAA,EAAS,CAAA,EAAA,EAAK;AAChC,MAAA,MAAM,KAAA,GAAQ,MAAM,CAAA,GAAI,OAAA;AACxB,MAAA,MAAA,CAAO,KAAK,KAAK,CAAA;AACjB,MAAA,IAAI,SAAA;AACF,QAAA,SAAA,CAAU,IAAA,CAAK,EAAE,KAAA,EAAO,GAAA,EAAK,IAAA,CAAK,GAAA,CAAI,KAAA,GAAQ,OAAA,GAAU,CAAA,EAAG,GAAG,CAAA,EAAG,CAAA;AAAA,IACrE;AAGA,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAsB;AACzC,IAAA,KAAA,MAAW,WAAW,QAAA,EAAU;AAC9B,MAAA,MAAM,MAAM,IAAI,KAAA,CAAc,OAAO,CAAA,CAAE,KAAK,CAAC,CAAA;AAC7C,MAAA,MAAM,CAAA,GAAI,KAAA,CAAM,GAAA,CAAI,OAAO,CAAA;AAC3B,MAAA,IAAI,CAAA,EAAG;AACL,QAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,CAAA,EAAG;AACtB,UAAA,MAAM,CAAA,GAAI,SAAS,CAAC,CAAA;AACpB,UAAA,IAAI,KAAK,CAAA,IAAK,CAAA,GAAI,OAAA,EAAS,GAAA,CAAI,CAAC,CAAA,IAAK,CAAA;AAAA,QACvC;AAAA,MACF;AACA,MAAA,MAAA,CAAO,GAAA,CAAI,SAAS,GAAG,CAAA;AAAA,IACzB;AAGA,IAAA,MAAM,SAAS,IAAI,KAAA,CAAc,OAAO,CAAA,CAAE,KAAK,CAAC,CAAA;AAChD,IAAA,IAAI,cAAA,EAAgB;AAClB,MAAA,KAAA,MAAW,GAAA,IAAO,OAAO,MAAA,EAAO;AAC9B,QAAA,KAAA,IAAS,CAAA,GAAI,GAAG,CAAA,GAAI,OAAA,EAAS,KAAK,MAAA,CAAO,CAAC,CAAA,IAAK,GAAA,CAAI,CAAC,CAAA;AAAA,IACxD,CAAA,MAAO;AACL,MAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AAC/B,QAAA,MAAM,CAAA,GAAI,IAAI,CAAA,IAAK,CAAA;AACnB,QAAA,IAAI,KAAK,CAAA,EAAG;AACZ,QAAA,MAAM,CAAA,GAAI,SAAS,CAAC,CAAA;AACpB,QAAA,IAAI,KAAK,CAAA,IAAK,CAAA,GAAI,OAAA,EAAS,MAAA,CAAO,CAAC,CAAA,IAAK,CAAA;AAAA,MAC1C;AAAA,IACF;AAGA,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAsB;AACzC,IAAA,KAAA,MAAW,WAAW,QAAA,EAAU;AAC9B,MAAA,MAAM,GAAA,GAAM,MAAA,CAAO,GAAA,CAAI,OAAO,CAAA;AAC9B,MAAA,MAAM,KAAK,IAAI,KAAA,CAAc,OAAO,CAAA,CAAE,KAAK,CAAC,CAAA;AAC5C,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,OAAA,EAAS,CAAA,EAAA,EAAK;AAChC,QAAA,EAAA,CAAG,CAAC,CAAA,GAAI,MAAA,CAAO,CAAC,CAAA,GAAI,OAAA,GAAU,GAAA,CAAI,CAAC,CAAA,GAAI,MAAA,CAAO,CAAC,CAAA,GAAI,CAAA;AAAA,MACrD;AACA,MAAA,MAAA,CAAO,GAAA,CAAI,SAAS,EAAE,CAAA;AAAA,IACxB;AAEA,IAAA,OAAO;AAAA,MACL,MAAA;AAAA,MACA,SAAA;AAAA,MACA,QAAA;AAAA,MACA,MAAA;AAAA,MACA,MAAA;AAAA,MACA,MAAA;AAAA,MACA,WAAA,EAAa,KAAK,sBAAA,EAAuB;AAAA,MACzC,IAAA,EAAM,KAAK,IAAA;AAAK,KAClB;AAAA,EACF;AAAA,EAEA,WAAW,CAAA,EAAmB;AAC5B,IAAA,IAAI,CAAA,GAAI,CAAA;AACR,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,IAAA,EAAM;AAC3B,MAAA,IAAI,IAAI,CAAA,GAAI,CAAA,IAAK,CAAA,IAAK,CAAA,OAAQ,GAAA,CAAI,CAAA;AAAA,IACpC;AACA,IAAA,OAAO,CAAA;AAAA,EACT;AAAA,EAEA,WAAW,CAAA,EAAmB;AAC5B,IAAA,IAAI,CAAA,GAAI,CAAA;AACR,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,IAAA,EAAM;AAC3B,MAAA,IAAI,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,GAAA,CAAI,CAAA;AAAA,IACtB;AACA,IAAA,OAAO,CAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,cAAc,OAAA,EAAsB;AAClC,IAAA,MAAM,WAAA,uBAAkB,GAAA,EAAiB;AAEzC,IAAA,KAAA,MAAW,CAAC,WAAA,EAAa,GAAG,CAAA,IAAK,KAAK,GAAA,EAAK;AACzC,MAAA,MAAM,YAAA,GAAgB,GAAA,CAAI,KAAA,CAAM,OAAO,CAAA,IAAgB,CAAA;AAGvD,MAAA,MAAM,aAAa,MAAA,CAAO,MAAA,CAAO,IAAI,KAAA,IAAS,EAAE,CAAA,CAAE,MAAA;AAAA,QAChD,CAAC,CAAA,EAAG,CAAA,KAAA,CAAO,CAAA,IAAK,MAAO,CAAA,IAAgB,CAAA,CAAA;AAAA,QACvC;AAAA,OACF;AAEA,MAAA,IAAI,YAAA,GAAe,CAAA,IAAK,UAAA,KAAe,MAAA,IAAa,aAAa,CAAA,EAAG;AAElE,QAAA,MAAM,aAAa,YAAA,GAAe,UAAA;AAGlC,QAAA,MAAM,IAAA,GAAO,IAAI,CAAA,GAAI,UAAA;AAErB,QAAA,MAAM,QAAA,GAA4B,EAAE,CAAC,OAAO,GAAG,YAAA,EAAa;AAE5D,QAAA,IAAI,OAAA;AACJ,QAAA,IAAI,IAAI,IAAA,IAAQ,GAAA,CAAI,IAAA,CAAK,OAAO,MAAM,MAAA,EAAW;AAG/C,UAAA,OAAA,GAAU,EAAE,CAAC,OAAO,GAAI,IAAI,IAAA,CAAK,OAAO,IAAe,UAAA,EAAW;AAAA,QACpE;AAEA,QAAA,WAAA,CAAY,IAAI,WAAA,EAAa;AAAA,UAC3B,CAAA,EAAG,IAAA;AAAA,UACH,KAAA,EAAO,QAAA;AAAA,UACP,IAAA,EAAM;AAAA,SACP,CAAA;AAAA,MACH;AAAA,IACF;AAEA,IAAA,OAAO,IAAI,IAAA;AAAA,MACT,WAAA;AAAA,MACA,IAAA,CAAK,OAAA;AAAA,MACL,KAAA;AAAA;AAAA,MACA,CAAA,OAAA,EAAU,IAAA,CAAK,UAAU,CAAA,CAAA,EAAI,OAAO,CAAA,CAAA;AAAA,KACtC;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAcA,OAAc,mBAAA,CACZ,QAAA,EACA,QAAA,EACA,CAAA,EACA;AAIA,IAAA,IACE,CAAC,MAAA,CAAO,QAAA,CAAS,QAAQ,CAAA,IACzB,CAAC,OAAO,QAAA,CAAS,QAAQ,CAAA,IACzB,QAAA,GAAW,KACX,QAAA,GAAW,CAAA,IACX,WAAW,CAAA,IACX,QAAA,GAAW,WAAW,GAAA,EACtB;AACA,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,0EAAA,EAA6E,QAAQ,CAAA,WAAA,EAAc,QAAQ,CAAA,CAAA;AAAA,OAC7G;AAAA,IACF;AAEA,IAAA,MAAM,QAAQ,CAAA,GAAI,QAAA;AAClB,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,GAAA,CAAI,KAAA,EAAO,CAAC,CAAA;AAGlC,IAAA,MAAM,OAAO,CAAA,GAAI,QAAA;AAGjB,IAAA,MAAM,KAAA,GAAQ,QAAA,KAAa,CAAA,GAAI,CAAA,GAAI,QAAA;AAGnC,IAAA,MAAM,gBAAA,GAAoB,WAAW,IAAA,GAAQ,KAAA;AAC7C,IAAA,MAAM,eAAA,GAAA,CAAoB,QAAA,GAAW,QAAA,IAAY,IAAA,GAAQ,KAAA;AAEzD,IAAA,MAAM,KAAA,GAAQ,IAAI,gBAAA,GAAmB,eAAA;AAErC,IAAA,OAAO,EAAE,gBAAA,EAAkB,eAAA,EAAiB,KAAA,EAAO,IAAA,EAAK;AAAA,EAC1D;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAWA,SAAA,CACE,CAAA,EACA,GAAA,GAAc,GAAA,EACd,IAAA,EACK;AACL,IAAA,MAAM,QAAA,GAAW,MAAM,QAAA,IAAY,MAAA;AACnC,IAAA,MAAM,cAAA,GAAiB,MAAM,cAAA,IAAkB,IAAA;AAE/C,IAAA,MAAM,KAAA,GAAQ,CAAC,CAAA,KACb,QAAA,KAAa,UACT,IAAA,CAAK,KAAA,CAAM,CAAC,CAAA,GACZ,QAAA,KAAa,SACb,IAAA,CAAK,IAAA,CAAK,CAAC,CAAA,GACX,QAAA,KAAa,UACb,IAAA,CAAK,KAAA,CAAM,CAAC,CAAA,GACZ,CAAA;AAEN,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAiB;AACpC,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,IAAA,EAAM;AAC3B,MAAA,IAAI,GAAA,CAAI,MAAM,CAAA,EAAG;AACjB,MAAA,MAAM,CAAA,GAAI,KAAA,CAAM,CAAA,CAAE,CAAC,CAAC,CAAA;AACpB,MAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,EAAG;AACxB,QAAA,MAAM,IAAI,KAAA,CAAM,CAAA,WAAA,EAAc,CAAC,CAAA,SAAA,EAAY,CAAC,CAAA,sBAAA,CAAwB,CAAA;AAAA,MACtE;AACA,MAAA,IAAA,CAAI,SAAA,CAAU,QAAQ,CAAA,EAAG;AAAA,QACvB,GAAG,GAAA,CAAI,CAAA;AAAA,QACP,KAAA,EAAO,cAAA,GAAiB,GAAA,CAAI,KAAA,GAAQ;AAAC,OACtC,CAAA;AAAA,IACH;AAEA,IAAA,MAAM,SAAS,IAAI,GAAA,CAAI,CAAC,GAAG,MAAA,CAAO,SAAS,CAAA,CAAE,KAAK,CAAC,CAAA,EAAG,MAAM,CAAA,CAAE,CAAC,IAAI,CAAA,CAAE,CAAC,CAAC,CAAC,CAAA;AACxE,IAAA,OAAO,IAAI,KAAI,MAAA,EAAQ,GAAA,EAAK,KAAK,UAAA,EAAY,CAAA,UAAA,EAAa,IAAA,CAAK,UAAU,CAAA,CAAA,CAAG,CAAA;AAAA,EAC9E;AAAA,EAEA,OAAO,OAAA,CACL,CAAA,EACA,GAAA,GAAc,GAAA,EACd,EAAE,oBAAA,GAAuB,IAAA,EAAK,GAAwC,EAAC,EAClE;AACL,IAAA,MAAM,WAAoC,EAAC;AAC3C,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,CAAA,EAAG;AACtB,MAAA,IAAI,CAAC,OAAO,QAAA,CAAS,CAAC,KAAK,CAAC,MAAA,CAAO,QAAA,CAAS,CAAC,CAAA,EAAG;AAChD,MAAA,IAAI,KAAK,CAAA,IAAK,IAAA,CAAK,GAAA,CAAI,CAAC,IAAI,GAAA,EAAK;AACjC,MAAA,IAAI,oBAAA,IAAwB,CAAC,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,EAAG;AAChD,QAAA,MAAM,IAAI,KAAA,CAAM,CAAA,6BAAA,EAAgC,CAAC,CAAA,CAAE,CAAA;AAAA,MACrD;AACA,MAAA,QAAA,CAAS,IAAA,CAAK,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,IACtB;AAEA,IAAA,IAAI,QAAA,CAAS,WAAW,CAAA,EAAG;AACzB,MAAA,MAAM,IAAI,MAAM,qCAAqC,CAAA;AAAA,IACvD;AAGA,IAAA,IAAI,GAAA,GAAM,CAAA;AACV,IAAA,IAAI,CAAA,GAAI,CAAA;AACR,IAAA,KAAA,MAAW,GAAG,CAAC,CAAA,IAAK,QAAA,EAAU;AAC5B,MAAA,MAAM,IAAI,CAAA,GAAI,CAAA;AACd,MAAA,MAAM,IAAI,GAAA,GAAM,CAAA;AAChB,MAAA,CAAA,GAAI,IAAI,GAAA,GAAM,CAAA;AACd,MAAA,GAAA,GAAM,CAAA;AAAA,IACR;AACA,IAAA,IAAI,GAAA,IAAO,CAAA,EAAG,MAAM,IAAI,MAAM,oCAAoC,CAAA;AAElE,IAAA,QAAA,CAAS,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,EAAE,CAAC,CAAA,GAAI,CAAA,CAAE,CAAC,CAAC,CAAA;AAEnC,IAAA,MAAM,QAAA,uBAAe,GAAA,EAAiB;AACtC,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,QAAA,EAAU;AAC7B,MAAA,QAAA,CAAS,GAAA,CAAI,GAAG,EAAE,CAAA,EAAG,IAAI,GAAA,EAAK,KAAA,EAAO,EAAC,EAAG,CAAA;AAAA,IAC3C;AACA,IAAA,OAAO,IAAI,IAAA,CAAI,QAAA,EAAU,GAAG,CAAA;AAAA,EAC9B;AAAA,EAEA,KAAA,GAAmB;AACjB,IAAA,OAAO,IAAI,UAAU,IAAI,CAAA;AAAA,EAC3B;AACF,CAAA;AAAA;AA1yDa,IAAA,CAEI,eAAA,GAAkB,CAAA;AAF5B,IAAM,GAAA,GAAN;;;AC7DP,IAAM,mBAAA,GAAsB,GAAA;AAsDrB,IAAM,IAAA,GAAN,MAAM,KAAA,CAAK;AAAA,EAUhB,WAAA,CAAY,IAAY,CAAA,EAAG;AAT3B,IAAA,IAAA,CAAiB,QAA4B,EAAC;AAC9C,IAAA,IAAA,CAAO,cAA+B,EAAC;AAIvC;AAAA;AAAA;AAAA,IAAA,IAAA,CAAQ,cAAgE,EAAC;AACzE,IAAA,IAAA,CAAQ,4BAAA,GAA+B,KAAA;AAIrC,IAAA,IAAI,KAAK,CAAA,EAAG;AACZ,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,CAAA,EAAG,CAAA,EAAA,EAAK;AAC3B,MAAA,IAAA,CAAK,KAAA,CAAM,CAAC,CAAA,GAAI,CAAA;AAAA,IAClB;AAAA,EACF;AAAA,EAEA,uBAAuB,GAAA,EAAkD;AACvE,IAAA,IAAI,QAAQ,KAAA,EAAO;AACjB,MAAA,IAAA,CAAK,qBAAA,EAAsB;AAAA,IAC7B;AAEA,IAAA,MAAM,YAAA,GAAe,IAAA,CAAK,WAAA,CAAY,GAAG,CAAA;AACzC,IAAA,IAAI,YAAA,KAAiB,QAAW,OAAO,MAAA;AAEvC,IAAA,OAAO,EAAE,GAAG,YAAA,EAAa;AAAA,EAC3B;AAAA,EAEA,0BAAA,GAEE;AACA,IAAA,OAAO,EAAE,GAAG,IAAA,CAAK,WAAA,EAAY;AAAA,EAC/B;AAAA,EAEA,sBAAA,CACE,KACA,IAAA,EACM;AACN,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,IAAA,CAAK,WAAA,CAAY,GAAG,CAAA,GAAI,IAAA;AAAA,IAC1B,CAAA,MAAO;AACL,MAAA,OAAO,IAAA,CAAK,YAAY,GAAG,CAAA;AAAA,IAC7B;AAAA,EACF;AAAA,EAEA,eAAe,GAAA,EAA2B;AACxC,IAAA,IAAI,QAAQ,KAAA,EAAO;AACjB,MAAA,IAAA,CAAK,qBAAA,EAAsB;AAAA,IAC7B;AACA,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,WAAA,CAAY,GAAG,CAAA;AACjC,IAAA,OAAO,SAAS,MAAA,IAAa,MAAA,CAAO,IAAA,CAAK,IAAI,EAAE,MAAA,GAAS,CAAA;AAAA,EAC1D;AAAA,EAEA,eAAA,CAAgB,KAAkB,IAAA,EAAsB;AACtD,IAAA,OAAO,IAAA,CAAK,WAAA,CAAY,GAAG,CAAA,GAAI,IAAI,CAAA,IAAK,CAAA;AAAA,EAC1C;AAAA,EAEA,WAAW,GAAA,EAA0B;AACnC,IAAA,MAAM,YAAA,GAAe,IAAA,CAAK,sBAAA,CAAuB,GAAG,CAAA;AACpD,IAAA,IAAI,CAAC,cAAc,OAAO,CAAA;AAE1B,IAAA,MAAM,UAAA,GAAa,MAAA,CAAO,MAAA,CAAO,YAAY,CAAA,CAAE,MAAA;AAAA,MAC7C,CAAC,GAAA,EAAK,KAAA,KAAU,GAAA,GAAM,KAAA;AAAA,MACtB;AAAA,KACF;AACA,IAAA,MAAM,cAAA,GAAiB,MAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,CAAE,MAAA;AAAA,MAClD,CAAC,KAAK,CAAC,MAAA,EAAQ,KAAK,CAAA,KAAM,GAAA,GAAM,MAAA,CAAO,MAAM,CAAA,GAAI,KAAA;AAAA,MACjD;AAAA,KACF;AACA,IAAA,IAAI,UAAA,KAAe,GAAG,OAAO,CAAA;AAC7B,IAAA,OAAO,cAAA,GAAiB,UAAA;AAAA,EAC1B;AAAA;AAAA,EAGA,wBAAA,GAA+C;AAC7C,IAAA,MAAM,YAAgC,EAAC;AAOvC,IAAA,MAAM,kBAAA,GAAyD;AAAA,MAC7D,KAAK,WAAA,CAAY,IAAA;AAAA,MACjB,KAAK,WAAA,CAAY,QAAA;AAAA,MACjB,KAAK,WAAA,CAAY,UAAA;AAAA,MACjB,KAAK,WAAA,CAAY,QAAA;AAAA,MACjB,KAAK,WAAA,CAAY,QAAA;AAAA,MACjB,KAAK,WAAA,CAAY;AAAA,KACnB;AAEA,IAAA,KAAA,MAAW,CAAC,MAAM,UAAU,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,EAAG;AAC3D,MAAA,MAAM,OAAA,GAAU,OAAO,IAAI,CAAA;AAC3B,MAAA,IAAI,QAAA,GAAW,UAAA;AAEf,MAAA,KAAA,MAAW,gBAAgB,kBAAA,EAAoB;AAC7C,QAAA,MAAM,YAAA,GAAe,eAAe,OAAO,CAAA;AAC3C,QAAA,IAAI,YAAA,EAAc;AAChB,UAAA,QAAA,IAAY,YAAA;AAAA,QACd;AAAA,MACF;AAIA,MAAA,IAAI,YAAY,CAAA,EAAG;AACjB,QAAA,QAAA,GAAW,IAAA,CAAK,WAAA,CAAY,GAAA,GAAM,CAAC,CAAA,IAAK,CAAA;AAAA,MAC1C;AAIA,MAAA,IAAI,WAAW,CAAA,EAAG;AAChB,QAAA,QAAA,GAAW,CAAA;AAAA,MACb;AACA,MAAA,SAAA,CAAU,OAAO,CAAA,GAAI,QAAA;AAAA,IACvB;AAEA,IAAA,OAAO,SAAA;AAAA,EACT;AAAA,EAEQ,qBAAA,GAA8B;AACpC,IAAA,IAAI,CAAC,KAAK,4BAAA,EAA8B;AACtC,MAAA,MAAM,SAAA,GAAY,KAAK,wBAAA,EAAyB;AAChD,MAAA,IAAA,CAAK,sBAAA,CAAuB,OAAO,SAAS,CAAA;AAC5C,MAAA,IAAA,CAAK,4BAAA,GAA+B,IAAA;AAAA,IACtC;AAAA,EACF;AAAA;AAAA,EAIQ,QAAA,CACN,KAAA,EACA,EAAA,EACA,eAAA,EACM;AACN,IAAA,MAAM,MAAA,GAAS,eAAA,GAAkB,eAAA,EAAgB,GAAI,IAAI,KAAA,EAAK;AAE9D,IAAA,MAAM,QAAA,GAAW,OAAO,KAAA,KAAU,QAAA;AAClC,IAAA,MAAM,KAAA,GAAQ,KAAK,IAAA,EAAK;AAIxB,IAAA,MAAM,KAAA,GAAQ,QAAA,GAAW,EAAC,GAAK,MAAe,IAAA,EAAK;AAInD,IAAA,IAAI,CAAC,QAAA,IAAY,KAAA,CAAM,MAAA,GAAS,KAAA,CAAM,SAAS,mBAAA,EAAqB;AAClE,MAAA,MAAM,IAAI,cAAA;AAAA,QACR,uBAAuB,KAAA,CAAM,MAAM,OAAI,KAAA,CAAM,MAAM,sCAAsC,mBAAmB,CAAA;AAAA,OAC9G;AAAA,IACF;AAEA,IAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,KAAA,CAAM,IAAI,CAAA;AAE9B,MAAA,IAAI,QAAA,EAAU;AACZ,QAAA,MAAM,SAAA,GAAY,EAAA,CAAG,IAAA,EAAM,KAAe,CAAA;AAC1C,QAAA,MAAA,CAAO,SAAA,CAAU,WAAW,MAAM,CAAA;AAAA,MACpC,CAAA,MAAO;AACL,QAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,UAAA,MAAM,MAAA,GAAS,KAAA,CAAM,KAAA,CAAM,IAAI,CAAA;AAC/B,UAAA,MAAM,SAAA,GAAY,EAAA,CAAG,IAAA,EAAM,IAAI,CAAA;AAC/B,UAAA,MAAA,CAAO,SAAA,CAAU,SAAA,EAAW,MAAA,GAAS,MAAM,CAAA;AAAA,QAC7C;AAAA,MACF;AAAA,IACF;AAEA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA,EAIA,cAAA,GAAqC;AACnC,IAAA,OAAO,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,CAAE,IAAI,CAAC,CAAC,CAAA,EAAG,CAAC,MAAM,CAAC,MAAA,CAAO,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,EAClE;AAAA,EAEA,UAAA,GAAiC;AAC/B,IAAA,OAAO,EAAE,GAAG,IAAA,CAAK,KAAA,EAAM;AAAA,EACzB;AAAA,EAEA,IAAI,IAAA,EAAsB;AACxB,IAAA,OAAO,IAAA,CAAK,KAAA,CAAM,IAAI,CAAA,IAAK,CAAA;AAAA,EAC7B;AAAA,EAEA,IAAA,GAAiB;AACf,IAAA,OAAO,OAAO,IAAA,CAAK,IAAA,CAAK,KAAK,CAAA,CAAE,IAAI,MAAM,CAAA;AAAA,EAC3C;AAAA,EAEA,MAAA,GAAmB;AACjB,IAAA,OAAO,MAAA,CAAO,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA;AAAA,EACjC;AAAA,EAEA,KAAA,GAAgB;AACd,IAAA,OAAO,MAAA,CAAO,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA,CAAE,MAAA,CAAO,CAAC,GAAA,EAAK,KAAA,KAAU,GAAA,GAAM,KAAA,EAAO,CAAC,CAAA;AAAA,EACxE;AAAA,EAEO,OAAA,CAAQ,KAAa,KAAA,EAAqB;AAC/C,IAAA,IAAA,CAAK,KAAA,CAAM,GAAG,CAAA,GAAI,KAAA;AAAA,EACpB;AAAA,EAEA,OAAc,OAAO,KAAA,EAAqB;AACxC,IAAA,MAAM,MAAA,GAAS,IAAI,KAAA,EAAK;AACxB,IAAA,MAAA,CAAO,SAAA,CAAU,OAAO,CAAC,CAAA;AACzB,IAAA,OAAO,MAAA;AAAA,EACT;AAAA,EAEO,OAAA,GAAkB;AACvB,IAAA,MAAM,WAAA,GAAc,KAAK,IAAA,EAAK;AAE9B,IAAA,IAAI,WAAA,CAAY,WAAW,CAAA,EAAG;AAC5B,MAAA,MAAM,IAAI,MAAM,wBAAwB,CAAA;AAAA,IAC1C;AAEA,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,GAAG,WAAW,CAAA;AAAA,EAChC;AAAA,EAEO,OAAA,GAAkB;AACvB,IAAA,MAAM,WAAA,GAAc,KAAK,IAAA,EAAK;AAE9B,IAAA,IAAI,WAAA,CAAY,WAAW,CAAA,EAAG;AAC5B,MAAA,MAAM,IAAI,MAAM,wBAAwB,CAAA;AAAA,IAC1C;AAEA,IAAA,OAAO,IAAA,CAAK,GAAA,CAAI,GAAG,WAAW,CAAA;AAAA,EAChC;AAAA,EAEO,SAAA,CAAU,MAAc,KAAA,EAAqB;AAClD,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,KAAA,CAAM,IAAI,CAAA,IAAK,CAAA;AACpC,IAAA,IAAA,CAAK,KAAA,CAAM,IAAI,CAAA,GAAI,OAAA,GAAU,KAAA;AAAA,EAC/B;AAAA;AAAA,EAGO,UAAU,MAAA,EAAsB;AACrC,IAAA,MAAM,MAAA,GAAS,IAAI,KAAA,EAAK;AAExB,IAAA,KAAA,MAAW,CAAC,MAAM,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,EAAG;AACtD,MAAA,MAAA,CAAO,KAAA,CAAM,MAAA,CAAO,IAAI,CAAC,IAAI,KAAA,GAAQ,MAAA;AAAA,IACvC;AAEA,IAAA,MAAA,CAAO,WAAA,GAAc,EAAE,GAAG,IAAA,CAAK,WAAA,EAAY;AAC3C,IAAA,KAAA,MAAW,CAAC,KAAK,YAAY,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,WAAW,CAAA,EAAG;AAClE,MAAA,MAAM,SAA6B,EAAC;AACpC,MAAA,KAAA,MAAW,CAAC,IAAA,EAAM,KAAK,KAAK,MAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,EAAG;AACxD,QAAA,MAAA,CAAO,MAAA,CAAO,IAAI,CAAC,CAAA,GAAI,KAAA,GAAQ,MAAA;AAAA,MACjC;AACA,MAAA,MAAA,CAAO,WAAA,CAAY,GAAkB,CAAA,GAAI,MAAA;AAAA,IAC3C;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA,EAIO,IAAI,KAAA,EAA4B;AACrC,IAAA,OAAO,KAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,CAAA,KAAM,IAAI,CAAC,CAAA;AAAA,EAC7C;AAAA,EAEO,SAAS,KAAA,EAA4B;AAC1C,IAAA,OAAO,KAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,CAAA,KAAM,IAAI,CAAC,CAAA;AAAA,EAC7C;AAAA,EAEO,iBAAiB,KAAA,EAA4B;AAClD,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,OAAO,CAAA,KAAM,CAAA,GAAI,CAAA,GAAI,CAAA,IAAK,CAAC,CAAA;AAAA,EAC7D;AAAA,EAEO,SAAS,KAAA,EAA4B;AAC1C,IAAA,OAAO,KAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,CAAA,KAAM,IAAI,CAAC,CAAA;AAAA,EAC7C;AAAA,EAEO,WAAW,KAAA,EAA4B;AAC5C,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,MAAO,CAAA,KAAM,CAAA,GAAI,CAAA,GAAI,CAAA,GAAI,CAAE,CAAA;AAAA,EAC7D;AAAA,EAEO,GAAG,KAAA,EAA4B;AACpC,IAAA,OAAO,IAAA,CAAK,SAAS,KAAA,EAAO,CAAC,GAAG,CAAA,KAAO,CAAA,KAAM,CAAA,GAAI,CAAA,GAAI,CAAE,CAAA;AAAA,EACzD;AAAA,EAEO,IAAI,KAAA,EAA4B;AACrC,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,MAAM,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,EACtD;AAAA,EAEO,IAAI,KAAA,EAA4B;AACrC,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,MAAM,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,CAAC,CAAC,CAAA;AAAA,EACtD;AAAA,EAEO,SAAA,GAAkB;AACvB,IAAA,OAAO,IAAA,CAAK,IAAI,IAAI,CAAA;AAAA,EACtB;AAAA,EAEO,GAAG,KAAA,EAA4B;AACpC,IAAA,OAAO,IAAA,CAAK,SAAS,KAAA,EAAO,CAAC,GAAG,CAAA,KAAO,CAAA,IAAK,CAAA,GAAI,CAAA,GAAI,CAAE,CAAA;AAAA,EACxD;AAAA,EAEO,OAAO,KAAA,EAA4B;AACxC,IAAA,OAAO,KAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,CAAA,KAAM,IAAI,CAAC,CAAA;AAAA,EAC7C;AAAA,EAEO,cAAc,KAAA,EAA4B;AAC/C,IAAA,IAAA,CAAK,qBAAqB,KAAK,CAAA;AAC/B,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,CAAA,KAAO,CAAA,KAAM,CAAA,GAAI,CAAA,GAAI,IAAA,CAAK,IAAA,CAAK,CAAA,GAAI,CAAC,CAAE,CAAA;AAAA,EACxE;AAAA,EAEO,gBAAgB,KAAA,EAA4B;AACjD,IAAA,IAAA,CAAK,qBAAqB,KAAK,CAAA;AAC/B,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,CAAC,CAAA,EAAG,CAAA,KAAO,CAAA,KAAM,CAAA,GAAI,CAAA,GAAI,IAAA,CAAK,KAAA,CAAM,CAAA,GAAI,CAAC,CAAE,CAAA;AAAA,EACzE;AAAA;AAAA,EAGQ,qBAAqB,KAAA,EAA4B;AACvD,IAAA,IAAI,OAAO,UAAU,QAAA,GAAW,KAAA,KAAU,IAAI,KAAA,CAAM,GAAA,CAAI,CAAC,CAAA,GAAI,CAAA,EAAG;AAC9D,MAAA,MAAM,IAAI,eAAe,wCAAwC,CAAA;AAAA,IACnE;AAAA,EACF;AAAA,EAEO,IAAI,KAAA,EAA4B;AACrC,IAAA,OAAO,IAAA,CAAK,SAAS,KAAA,EAAO,CAAC,GAAG,CAAA,KAAO,CAAA,IAAK,CAAA,GAAI,CAAA,GAAI,CAAE,CAAA;AAAA,EACxD;AAAA,EAEQ,WAAA,CACN,OACA,eAAA,EACM;AACN,IAAA,MAAM,eAAe,MAAM;AACzB,MAAA,MAAM,MAAA,GAAS,IAAI,KAAA,EAAK;AACxB,MAAA,MAAA,CAAO,SAAA,CAAU,GAAG,CAAC,CAAA;AACrB,MAAA,MAAA,CAAO,SAAA,CAAU,GAAG,CAAC,CAAA;AACrB,MAAA,OAAO,MAAA;AAAA,IACT,CAAA;AAEA,IAAA,OAAO,IAAA,CAAK,QAAA,CAAS,KAAA,EAAO,eAAA,EAAiB,YAAY,CAAA;AAAA,EAC3D;AAAA,EAEO,GAAG,KAAA,EAA4B;AACpC,IAAA,MAAM,UAAU,CAAC,CAAA,EAAW,CAAA,KAAe,CAAA,IAAK,IAAI,CAAA,GAAI,CAAA;AACxD,IAAA,MAAM,MAAA,GAAS,IAAA,CAAK,WAAA,CAAY,KAAA,EAAO,OAAO,CAAA;AAE9C,IAAA,MAAA,CAAO,YAAY,SAAA,GAAY,IAAA;AAC/B,IAAA,OAAO,MAAA;AAAA,EACT;AAAA,EAEO,GAAG,KAAA,EAA4B;AACpC,IAAA,MAAM,UAAU,CAAC,CAAA,EAAW,CAAA,KAAe,CAAA,IAAK,IAAI,CAAA,GAAI,CAAA;AACxD,IAAA,OAAO,IAAA,CAAK,WAAA,CAAY,KAAA,EAAO,OAAO,CAAA;AAAA,EACxC;AAAA,EAEO,WAAW,IAAA,EAAoB;AACpC,IAAA,MAAM,MAAA,GAAS,IAAI,KAAA,EAAK;AAExB,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,EAAG;AACrD,MAAA,MAAM,MAAA,GAAS,OAAO,GAAG,CAAA;AACzB,MAAA,IAAI,WAAW,IAAA,EAAM;AACnB,QAAA,MAAA,CAAO,SAAA,CAAU,QAAQ,KAAK,CAAA;AAAA,MAChC;AAAA,IACF;AAEA,IAAA,MAAA,CAAO,WAAA,GAAc,EAAE,GAAG,IAAA,CAAK,WAAA,EAAY;AAC3C,IAAA,MAAA,CAAO,WAAA,GAAc,EAAE,GAAG,IAAA,CAAK,WAAA,EAAY;AAC3C,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOO,OAAO,QAAA,EAA+B;AAC3C,IAAA,MAAM,QAAA,GAAW,IAAI,GAAA,CAAI,OAAO,QAAA,KAAa,QAAA,GAAW,CAAC,QAAQ,CAAA,GAAI,QAAA,CAAS,IAAA,EAAM,CAAA;AACpF,IAAA,MAAM,KAAA,GAAQ,KAAK,KAAA,EAAM;AACzB,IAAA,IAAI,aAAA,GAAgB,CAAA;AACpB,IAAA,KAAA,MAAW,CAAC,IAAA,EAAM,KAAK,CAAA,IAAK,IAAA,CAAK,cAAA,EAAe,EAAG,IAAI,QAAA,CAAS,GAAA,CAAI,IAAI,CAAA,EAAG,aAAA,IAAiB,KAAA;AAE5F,IAAA,MAAM,MAAA,GAAS,IAAI,KAAA,EAAK;AACxB,IAAA,KAAA,MAAW,CAAC,IAAA,EAAM,KAAK,CAAA,IAAK,IAAA,CAAK,gBAAe,EAAG;AACjD,MAAA,MAAA,CAAO,SAAA,CAAU,MAAM,KAAA,IAAA,CAAU,QAAA,CAAS,IAAI,IAAI,CAAA,GAAI,CAAA,GAAI,KAAA,IAAS,aAAA,CAAc,CAAA;AAAA,IACnF;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA;AAAA;AAAA,EAIO,QAAQ,KAAA,EAA4B;AACzC,IAAA,IAAI,OAAO,UAAU,QAAA,EAAU;AAC7B,MAAA,KAAA,GAAQ,KAAA,CAAK,OAAO,KAAK,CAAA;AAAA,IAC3B;AAGA,IAAA,MAAM,MAAA,GAAS,IAAI,KAAA,EAAK;AACxB,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,KAAA,CAAM,KAAK,CAAA,EAAG;AACtD,MAAA,MAAA,CAAO,KAAA,CAAM,MAAA,CAAO,GAAG,CAAC,CAAA,GAAI,KAAA;AAAA,IAC9B;AAGA,IAAA,MAAM,MAAA,GAAS,IAAI,KAAA,EAAK;AACxB,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,EAAG;AACrD,MAAA,MAAM,MAAA,GAAS,OAAO,GAAG,CAAA;AACzB,MAAA,MAAA,CAAO,SAAA,CAAU,QAAQ,KAAK,CAAA;AAG9B,MAAA,IAAI,EAAE,MAAA,IAAU,KAAA,CAAM,KAAA,CAAA,EAAQ;AAC5B,QAAA,MAAA,CAAO,SAAA,CAAU,QAAQ,KAAK,CAAA;AAAA,MAChC;AAAA,IACF;AAEA,IAAA,MAAA,CAAO,cAAc,EAAE,GAAG,IAAA,CAAK,WAAA,EAAa,QAAQ,KAAA,EAAM;AAC1D,IAAA,MAAA,CAAO,WAAA,GAAc,EAAE,GAAG,IAAA,CAAK,WAAA,EAAY;AAC3C,IAAA,OAAO,MAAA;AAAA,EACT;AAAA,EAEO,eAAe,KAAA,EAAmB;AACvC,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,KAAA,CAAM,KAAK,CAAA,EAAG;AACtD,MAAA,MAAM,MAAA,GAAS,OAAO,GAAG,CAAA;AACzB,MAAA,MAAM,OAAA,GAAU,IAAA,CAAK,KAAA,CAAM,MAAM,CAAA,IAAK,CAAA;AACtC,MAAA,IAAA,CAAK,KAAA,CAAM,MAAM,CAAA,GAAI,OAAA,GAAU,KAAA;AAAA,IACjC;AAAA,EACF;AAAA,EAEO,OAAA,GAA8B;AACnC,IAAA,MAAM,KAAA,GAAQ,KAAK,KAAA,EAAM;AACzB,IAAA,MAAM,SAA6B,EAAC;AAEpC,IAAA,KAAA,MAAW,CAAC,MAAM,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,EAAG;AACtD,MAAA,MAAA,CAAO,MAAA,CAAO,IAAI,CAAC,CAAA,GAAI,KAAA,GAAQ,KAAA;AAAA,IACjC;AAEA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA,EAEO,OAAA,GAAkB;AACvB,IAAA,MAAM,KAAA,GAAQ,KAAK,KAAA,EAAM;AACzB,IAAA,IAAI,KAAA,KAAU,GAAG,OAAO,CAAA;AAExB,IAAA,IAAI,GAAA,GAAM,CAAA;AACV,IAAA,KAAA,MAAW,CAAC,KAAK,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,EAAG;AACrD,MAAA,GAAA,IAAO,MAAA,CAAO,GAAG,CAAA,GAAI,KAAA;AAAA,IACvB;AAEA,IAAA,OAAO,GAAA,GAAM,KAAA;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA,EAMO,KAAA,CAAM,aAAqB,GAAA,EAAU;AAC1C,IAAA,MAAM,KAAA,GAAQ,KAAK,KAAA,EAAM;AACzB,IAAA,IAAI,KAAA,KAAU,CAAA,EAAG,OAAO,GAAA,CAAI,MAAM,UAAU,CAAA;AAG5C,IAAA,IAAA,CAAK,qBAAA,EAAsB;AAE3B,IAAA,MAAM,GAAA,uBAAU,GAAA,EAAiB;AAGjC,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,sBAAA,CAAuB,KAAK,KAAK,EAAC;AACzD,IAAA,MAAM,UAAA,GAAa,IAAA,CAAK,sBAAA,CAAuB,MAAM,KAAK,EAAC;AAC3D,IAAA,MAAM,UAAA,GAAa,IAAA,CAAK,sBAAA,CAAuB,YAAY,KAAK,EAAC;AACjE,IAAA,MAAM,UAAA,GAAa,IAAA,CAAK,sBAAA,CAAuB,UAAU,KAAK,EAAC;AAC/D,IAAA,MAAM,cAAA,GAAiB,IAAA,CAAK,sBAAA,CAAuB,UAAU,KAAK,EAAC;AACnE,IAAA,MAAM,QAAA,GAAW,IAAA,CAAK,sBAAA,CAAuB,IAAI,KAAK,EAAC;AAKvD,IAAA,MAAM,UAAA,GAAa,MAAA,CAAO,IAAA,CAAK,UAAU,EAAE,MAAA,GAAS,CAAA;AAEpD,IAAA,MAAM,SAAA,GAAY,IAAA,CAAK,WAAA,CAAY,SAAA,KAAc,IAAA;AAEjD,IAAA,MAAM,cAAc,CAAC,CAAA,KAAe,IAAI,CAAA,IAAK,CAAA,GAAI,SAAS,CAAA,GAAI,CAAA;AAI9D,IAAA,KAAA,MAAW,CAAC,SAAS,YAAY,CAAA,IAAK,OAAO,OAAA,CAAQ,IAAA,CAAK,KAAK,CAAA,EAAG;AAChE,MAAA,MAAM,IAAA,GAAO,OAAO,OAAO,CAAA;AAC3B,MAAA,MAAM,SAAA,GAAY,OAAO,YAAY,CAAA;AAGrC,MAAA,IAAI,aAAa,CAAA,EAAG;AAEpB,MAAA,IAAI,IAAI,SAAA,GAAY,KAAA;AACpB,MAAA,CAAA,GAAI,YAAY,CAAC,CAAA;AAGjB,MAAA,IAAI,EAAE,IAAI,CAAA,CAAA,EAAI;AAGd,MAAA,IAAI,UAAA,IAAc,CAAA,IAAK,CAAA,GAAI,UAAA,EAAY;AAEvC,MAAA,MAAM,QAAyB,EAAC;AAChC,MAAA,MAAM,OAAwB,EAAC;AAG/B,MAAA,IAAI,SAAA,CAAU,IAAI,CAAA,EAAG;AACnB,QAAA,MAAM,CAAA,GAAI,WAAA,CAAY,SAAA,CAAU,IAAI,IAAI,KAAK,CAAA;AAC7C,QAAA,IAAI,IAAI,CAAA,EAAG;AACT,UAAA,IAAI,cAAc,SAAA,EAAW;AAC3B,YAAA,KAAA,CAAM,QAAA,GAAW,CAAA;AACjB,YAAA,IAAA,CAAK,WAAW,WAAA,CAAa,IAAA,GAAO,SAAA,CAAU,IAAI,IAAK,KAAK,CAAA;AAAA,UAC9D,CAAA,MAAO;AACL,YAAA,KAAA,CAAM,GAAA,GAAM,CAAA;AACZ,YAAA,IAAA,CAAK,MAAM,WAAA,CAAa,IAAA,GAAO,SAAA,CAAU,IAAI,IAAK,KAAK,CAAA;AAAA,UACzD;AAAA,QACF;AAAA,MACF;AAEA,MAAA,IAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AACpB,QAAA,MAAM,CAAA,GAAI,WAAA,CAAY,UAAA,CAAW,IAAI,IAAI,KAAK,CAAA;AAC9C,QAAA,IAAI,IAAI,CAAA,EAAG;AACT,UAAA,KAAA,CAAM,IAAA,GAAO,CAAA;AACb,UAAA,IAAA,CAAK,OAAO,WAAA,CAAa,IAAA,GAAO,UAAA,CAAW,IAAI,IAAK,KAAK,CAAA;AAAA,QAC3D;AAAA,MACF;AAEA,MAAA,IAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AACpB,QAAA,MAAM,CAAA,GAAI,WAAA,CAAY,UAAA,CAAW,IAAI,IAAI,KAAK,CAAA;AAC9C,QAAA,IAAI,IAAI,CAAA,EAAG;AACT,UAAA,KAAA,CAAM,UAAA,GAAa,CAAA;AACnB,UAAA,IAAA,CAAK,aAAa,WAAA,CAAa,IAAA,GAAO,UAAA,CAAW,IAAI,IAAK,KAAK,CAAA;AAAA,QACjE;AAAA,MACF;AAEA,MAAA,IAAI,UAAA,CAAW,IAAI,CAAA,EAAG;AACpB,QAAA,MAAM,CAAA,GAAI,WAAA,CAAY,UAAA,CAAW,IAAI,IAAI,KAAK,CAAA;AAC9C,QAAA,IAAI,IAAI,CAAA,EAAG;AACT,UAAA,KAAA,CAAM,QAAA,GAAW,CAAA;AACjB,UAAA,IAAA,CAAK,WAAW,WAAA,CAAa,IAAA,GAAO,UAAA,CAAW,IAAI,IAAK,KAAK,CAAA;AAAA,QAC/D;AAAA,MACF;AAEA,MAAA,IAAI,cAAA,CAAe,IAAI,CAAA,EAAG;AACxB,QAAA,MAAM,CAAA,GAAI,WAAA,CAAY,cAAA,CAAe,IAAI,IAAI,KAAK,CAAA;AAClD,QAAA,IAAI,IAAI,CAAA,EAAG;AACT,UAAA,KAAA,CAAM,QAAA,GAAA,CAAY,KAAA,CAAM,QAAA,IAAY,CAAA,IAAK,CAAA;AACzC,UAAA,IAAA,CAAK,QAAA,GAAW,aAAa,IAAA,CAAK,QAAA,IAAY,KAAM,IAAA,GAAO,cAAA,CAAe,IAAI,CAAA,GAAK,KAAK,CAAA;AAAA,QAC1F;AAAA,MACF;AAEA,MAAA,IAAI,QAAA,CAAS,IAAI,CAAA,EAAG;AAClB,QAAA,MAAM,CAAA,GAAI,WAAA,CAAY,QAAA,CAAS,IAAI,IAAI,KAAK,CAAA;AAC5C,QAAA,IAAI,IAAI,CAAA,EAAG;AACT,UAAA,KAAA,CAAM,EAAA,GAAK,CAAA;AACX,UAAA,IAAA,CAAK,KAAK,WAAA,CAAa,IAAA,GAAO,QAAA,CAAS,IAAI,IAAK,KAAK,CAAA;AAAA,QACvD;AAAA,MACF;AAGA,MAAA,IAAI,CAAC,SAAA,EAAW;AACd,QAAA,MAAM,cAAA,GAAA,CACH,UAAU,IAAI,CAAA,IAAK,MACnB,UAAA,CAAW,IAAI,CAAA,IAAK,CAAA,CAAA,IACpB,UAAA,CAAW,IAAI,KAAK,CAAA,CAAA,IACpB,UAAA,CAAW,IAAI,CAAA,IAAK,CAAA,CAAA,IACpB,cAAA,CAAe,IAAI,CAAA,IAAK,CAAA,CAAA,IACxB,QAAA,CAAS,IAAI,CAAA,IAAK,CAAA,CAAA;AAErB,QAAA,MAAM,gBAAA,GAAmB,WAAA,CAAY,SAAA,GAAY,cAAc,CAAA;AAC/D,QAAA,IAAI,mBAAmB,CAAA,EAAG;AACxB,UAAA,MAAM,IAAA,GAAO,WAAA,CAAY,gBAAA,GAAmB,KAAK,CAAA;AACjD,UAAA,IAAI,OAAO,CAAA,EAAG;AACZ,YAAA,KAAA,CAAM,QAAA,GAAA,CAAY,KAAA,CAAM,QAAA,IAAY,CAAA,IAAK,IAAA;AAAA,UAE3C;AAAA,QACF;AAAA,MACF;AAEA,MAAA,MAAM,GAAA,GAAW,EAAE,CAAA,EAAG,KAAA,EAAM;AAC5B,MAAA,IAAI,MAAA,CAAO,IAAA,CAAK,IAAI,CAAA,CAAE,SAAS,CAAA,EAAG;AAChC,QAAA,GAAA,CAAI,IAAA,GAAO,IAAA;AAAA,MACb;AAEA,MAAA,GAAA,CAAI,GAAA,CAAI,MAAM,GAAG,CAAA;AAAA,IACnB;AAIA,IAAA,MAAM,UAAA,GAAa,KAAK,UAAA,IAAc,OAAA;AAGtC,IAAA,OAAO,IAAI,IAAI,GAAA,EAAK,UAAA,EAAY,MAAM,UAAU,CAAA,CAAE,OAAA,CAAQ,UAAA,EAAY,IAAI,CAAA;AAAA,EAC5E;AACF,CAAA;;;AC9mBA,IAAM,UAAA,GAAa,CAAC,CAAA,KAClB,CAAA,KAAM,WAAe,CAAA,IAAK,GAAA,IAAO,CAAA,IAAK,GAAA,IAAQ,CAAA,KAAM,GAAA,CAAA;AAGtD,IAAM,UAAA,GAAa,CAAC,EAAA,KAClB,EAAA,KAAO,YAAY,EAAA,KAAO,GAAA,IAAO,EAAA,KAAO,GAAA,IAAO,EAAA,KAAO,GAAA;AAGjD,IAAM,2BAAA,GAAN,cAA0C,KAAA,CAAM;AAAC,CAAA;AAQjD,IAAM,0BAAA,GAAN,cAAyC,KAAA,CAAM;AAAC,CAAA;AAGvD,IAAM,iBAAN,MAAqB;AAAA,EAGnB,WAAA,CACmB,GACA,UAAA,EACjB;AAFiB,IAAA,IAAA,CAAA,CAAA,GAAA,CAAA;AACA,IAAA,IAAA,CAAA,UAAA,GAAA,UAAA;AAJnB,IAAA,IAAA,CAAQ,GAAA,GAAM,CAAA;AAAA,EAKX;AAAA,EAEH,IAAA,GAAiB;AACf,IAAA,MAAM,IAAA,GAAO,KAAK,IAAA,EAAK;AACvB,IAAA,IAAI,IAAA,CAAK,GAAA,KAAQ,IAAA,CAAK,CAAA,CAAE,MAAA,EAAQ,IAAA,CAAK,IAAA,CAAK,CAAA,YAAA,EAAe,IAAA,CAAK,CAAA,CAAE,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAG,CAAA;AAC5E,IAAA,OAAO,IAAA;AAAA,EACT;AAAA,EAEQ,KAAK,MAAA,EAAuB;AAClC,IAAA,MAAM,IAAI,2BAAA,CAA4B,CAAA,2BAAA,EAA8B,KAAK,UAAU,CAAA,GAAA,EAAM,MAAM,CAAA,CAAA,CAAG,CAAA;AAAA,EACpG;AAAA,EAEQ,IAAA,GAAiB;AACvB,IAAA,MAAM,KAAA,GAAQ,KAAK,KAAA,EAAM;AACzB,IAAA,MAAM,OAAiB,EAAC;AACxB,IAAA,KAAA,IAAS,EAAA,GAAK,KAAK,SAAA,EAAU,EAAG,OAAO,MAAA,EAAW,EAAA,GAAK,IAAA,CAAK,SAAA,EAAU,EAAG;AACvE,MAAA,IAAI,OAAO,IAAA,EAAM;AACf,QAAA,IAAA,CAAK,KAAK,0FAA0F,CAAA;AAAA,MACtG;AACA,MAAA,IAAI,OAAO,IAAA,EAAM;AACf,QAAA,IAAA,CAAK,KAAK,8FAA8F,CAAA;AAAA,MAC1G;AACA,MAAA,MAAM,GAAA,GAAM,EAAA,KAAO,GAAA,GAAM,MAAA,GAAY,KAAK,KAAA,EAAM;AAChD,MAAA,MAAM,CAAA,GAAI,IAAA,CAAK,CAAA,CAAE,IAAA,CAAK,GAAG,CAAA;AACzB,MAAA,IAAI,CAAA,KAAM,GAAA,IAAO,CAAA,KAAM,GAAA,IAAO,MAAM,GAAA,IAAO,CAAA,KAAM,GAAA,IAAO,IAAA,CAAK,CAAA,CAAE,UAAA,CAAW,IAAA,EAAM,IAAA,CAAK,GAAG,CAAA,EAAG;AACzF,QAAA,IAAA,CAAK,KAAK,0FAA0F,CAAA;AAAA,MACtG;AACA,MAAA,IAAA,CAAK,KAAK,EAAE,EAAA,EAAI,KAAK,GAAA,EAAK,IAAA,CAAK,KAAK,CAAA;AAAA,IACtC;AACA,IAAA,OAAO,EAAE,OAAO,IAAA,EAAK;AAAA,EACvB;AAAA,EAEQ,KAAA,GAAmB;AACzB,IAAA,MAAM,QAAQ,IAAA,CAAK,GAAA;AACnB,IAAA,MAAM,QAAoB,EAAC;AAC3B,IAAA,KAAA,IAAS,IAAA,GAAO,IAAA,CAAK,IAAA,EAAK,EAAG,IAAA,KAAS,MAAA,EAAW,IAAA,GAAO,IAAA,CAAK,IAAA,EAAK,EAAG,KAAA,CAAM,IAAA,CAAK,IAAI,CAAA;AACpF,IAAA,OAAO,EAAE,OAAO,KAAA,EAAM;AAAA,EACxB;AAAA,EAEQ,IAAA,GAA6B;AACnC,IAAA,MAAM,QAAQ,IAAA,CAAK,GAAA;AACnB,IAAA,MAAM,CAAA,GAAI,IAAA,CAAK,CAAA,CAAE,KAAK,CAAA;AACtB,IAAA,IAAI,MAAM,GAAA,EAAK;AACb,MAAA,IAAA,CAAK,GAAA,EAAA;AACL,MAAA,MAAM,IAAA,GAAO,KAAK,IAAA,EAAK;AACvB,MAAA,IAAI,IAAA,CAAK,EAAE,IAAA,CAAK,GAAG,MAAM,GAAA,EAAK,IAAA,CAAK,KAAK,wBAAwB,CAAA;AAChE,MAAA,IAAA,CAAK,GAAA,EAAA;AACL,MAAA,OAAO,EAAE,IAAA,EAAM,OAAA,EAAS,OAAO,GAAA,EAAK,IAAA,CAAK,KAAK,IAAA,EAAK;AAAA,IACrD;AACA,IAAA,IAAI,CAAA,KAAM,GAAA,IAAO,IAAA,CAAK,CAAA,CAAE,QAAQ,CAAC,CAAA,KAAM,GAAA,IAAO,UAAA,CAAW,IAAA,CAAK,CAAA,CAAE,KAAA,GAAQ,CAAC,CAAC,CAAA,EAAG;AAC3E,MAAA,IAAA,CAAK,GAAA,IAAO,CAAA;AACZ,MAAA,IAAA,CAAK,MAAA,EAAO;AACZ,MAAA,OAAO,EAAE,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,GAAA,EAAK,KAAK,GAAA,EAAI;AAAA,IAC7C;AACA,IAAA,IAAI,CAAA,KAAM,OAAO,UAAA,CAAW,IAAA,CAAK,EAAE,KAAA,GAAQ,CAAC,CAAC,CAAA,EAAG;AAC9C,MAAA,IAAA,CAAK,GAAA,IAAO,CAAA;AACZ,MAAA,IAAA,CAAK,MAAA,EAAO;AACZ,MAAA,OAAO,EAAE,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,GAAA,EAAK,KAAK,GAAA,EAAI;AAAA,IAC7C;AACA,IAAA,IAAI,MAAM,GAAA,EAAK;AACb,MAAA,MAAM,IAAA,GAAO,IAAA,CAAK,CAAA,CAAE,KAAA,GAAQ,CAAC,CAAA;AAC7B,MAAA,IAAI,SAAS,GAAA,IAAO,IAAA,KAAS,GAAA,EAAK,IAAA,CAAK,KAAK,oCAAoC,CAAA;AAChF,MAAA,IAAA,CAAK,GAAA,IAAO,CAAA;AACZ,MAAA,MAAM,IAAA,GAAO,KAAK,MAAA,EAAO;AACzB,MAAA,MAAM,KAAA,GAAQ,KAAK,IAAA,EAAK;AACxB,MAAA,IAAI,KAAA,KAAU,MAAA,EAAW,IAAA,CAAK,IAAA,CAAK,4BAA4B,CAAA;AAC/D,MAAA,OAAO,EAAE,MAAM,MAAA,EAAQ,KAAA,EAAO,KAAK,IAAA,CAAK,GAAA,EAAK,KAAA,EAAO,IAAA,EAAM,IAAA,EAAK;AAAA,IACjE;AACA,IAAA,IAAI,UAAA,CAAW,CAAC,CAAA,EAAG;AACjB,MAAA,MAAM,KAAA,GAAQ,KAAK,MAAA,EAAO;AAC1B,MAAA,OAAO,EAAE,IAAA,EAAM,QAAA,EAAU,OAAO,GAAA,EAAK,IAAA,CAAK,KAAK,KAAA,EAAM;AAAA,IACvD;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AAAA,EAEQ,MAAA,GAAiB;AACvB,IAAA,IAAI,MAAA,GAAS,EAAA;AACb,IAAA,OAAO,WAAW,IAAA,CAAK,CAAA,CAAE,IAAA,CAAK,GAAG,CAAC,CAAA,EAAG;AACnC,MAAA,MAAM,EAAA,GAAK,IAAA,CAAK,CAAA,CAAE,IAAA,CAAK,GAAA,EAAK,CAAA;AAC5B,MAAA,MAAA,IAAU,EAAA,KAAO,MAAM,GAAA,GAAM,EAAA;AAAA,IAC/B;AACA,IAAA,IAAI,MAAA,CAAO,MAAA,KAAW,CAAA,EAAG,IAAA,CAAK,IAAA,CAAK,CAAA,sBAAA,EAAyB,IAAA,CAAK,CAAA,CAAE,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAG,CAAA;AAC/E,IAAA,OAAO,QAAA,CAAS,QAAQ,EAAE,CAAA;AAAA,EAC5B;AAAA,EAEQ,SAAA,GAAgC;AACtC,IAAA,MAAM,IAAA,GAAO,IAAA,CAAK,CAAA,CAAE,KAAA,CAAM,KAAK,GAAG,CAAA;AAClC,IAAA,MAAM,KAAK,CAAC,QAAA,EAAU,IAAA,EAAM,IAAA,EAAM,MAAM,IAAA,EAAM,IAAA,EAAM,GAAA,EAAK,GAAA,EAAK,KAAK,GAAA,EAAK,GAAA,EAAK,KAAK,GAAA,EAAK,GAAA,EAAK,GAAG,CAAA,CAAE,IAAA;AAAA,MAC/F,CAAC,KAAA,KAAU,IAAA,CAAK,UAAA,CAAW,KAAK;AAAA,KAClC;AACA,IAAA,IAAI,EAAA,KAAO,MAAA,EAAW,IAAA,CAAK,GAAA,IAAO,EAAA,CAAG,MAAA;AACrC,IAAA,OAAO,EAAA;AAAA,EACT;AACF,CAAA;AAEA,SAAS,YAAY,IAAA,EAAyB;AAC5C,EAAA,QAAQ,KAAK,IAAA;AAAM,IACjB,KAAK,KAAA;AACH,MAAA,OAAO,IAAA;AAAA,IACT,KAAK,QAAA;AACH,MAAA,OAAO,KAAA;AAAA,IACT,KAAK,MAAA;AACH,MAAA,OAAO,WAAA,CAAY,KAAK,KAAK,CAAA;AAAA,IAC/B,KAAK,OAAA;AAEH,MAAA,OACE,YAAA,CAAa,KAAK,IAAA,CAAK,KAAK,KAC5B,IAAA,CAAK,IAAA,CAAK,KAAK,IAAA,CAAK,CAAC,EAAE,EAAA,EAAI,GAAA,OAAU,EAAA,KAAO,QAAA,IAAY,QAAQ,MAAA,IAAa,YAAA,CAAa,GAAG,CAAC,CAAA;AAAA;AAGtG;AAEA,IAAM,eAAe,CAAC,KAAA,KAA8B,KAAA,CAAM,KAAA,CAAM,KAAK,WAAW,CAAA;AAEhF,IAAM,eAAA,GAAkB,CAAC,IAAA,KACvB,IAAA,CAAK,SAAS,KAAA,IAAU,IAAA,CAAK,IAAA,KAAS,OAAA,IAAW,gBAAgB,IAAA,CAAK,IAAA,EAAM,IAAA,CAAK,IAAA,CAAK,KAAK,MAAM,CAAA;AAGnG,SAAS,eAAA,CAAgB,MAAgB,OAAA,EAA0B;AACjE,EAAA,MAAM,QAAA,GAAW,CAAC,IAAA,CAAK,KAAK,CAAA;AAC5B,EAAA,KAAA,MAAW,EAAE,IAAI,GAAA,EAAI,IAAK,KAAK,IAAA,CAAK,KAAA,CAAM,CAAA,EAAG,OAAO,CAAA,EAAG;AACrD,IAAA,IAAI,CAAC,UAAA,CAAW,EAAE,CAAA,EAAG,OAAO,KAAA;AAC5B,IAAA,IAAI,OAAO,QAAA,IAAY,GAAA,KAAQ,MAAA,EAAW,QAAA,CAAS,KAAK,GAAG,CAAA;AAAA,EAC7D;AACA,EAAA,IAAI,IAAA,GAAO,CAAA;AACX,EAAA,KAAA,MAAW,SAAS,QAAA,EAAU;AAC5B,IAAA,IAAI,KAAA,CAAM,MAAM,MAAA,KAAW,CAAA,IAAK,gBAAgB,KAAA,CAAM,KAAA,CAAM,CAAC,CAAC,CAAA,EAAG,IAAA,EAAA;AAAA,SAAA,IACxD,YAAA,CAAa,KAAK,CAAA,EAAG,OAAO,KAAA;AAAA,EACvC;AACA,EAAA,OAAO,IAAA,KAAS,CAAA;AAClB;AAGO,SAAS,eAAA,CAAgB,YAAoB,KAAA,EAAuB;AAGzE,EAAA,IAAI,OAAA,GAAU,EAAA;AACd,EAAA,MAAM,WAAqB,EAAC;AAC5B,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,UAAA,CAAW,QAAQ,CAAA,EAAA,EAAK;AAC1C,IAAA,IAAI,UAAA,CAAW,CAAC,CAAA,KAAM,GAAA,EAAK;AAC3B,IAAA,OAAA,IAAW,UAAA,CAAW,CAAC,CAAA,CAAE,WAAA,EAAY;AACrC,IAAA,QAAA,CAAS,KAAK,CAAC,CAAA;AAAA,EACjB;AACA,EAAA,MAAM,OAAO,IAAI,cAAA,CAAe,OAAA,EAAS,UAAU,EAAE,IAAA,EAAK;AAE1D,EAAA,MAAM,QAAsD,EAAC;AAE7D,EAAA,MAAM,IAAA,GAAO,CAAC,KAAA,EAAe,GAAA,MAAiB,EAAE,IAAA,EAAM,QAAA,CAAS,KAAK,CAAA,EAAG,EAAA,EAAI,QAAA,CAAS,GAAA,GAAM,CAAC,IAAI,CAAA,EAAE,CAAA;AACjG,EAAA,MAAM,IAAA,GAAO,CAAC,KAAA,EAAe,GAAA,EAAa,IAAA,KAAiB;AACzD,IAAA,MAAM,EAAE,IAAA,EAAM,EAAA,EAAG,GAAI,IAAA,CAAK,OAAO,GAAG,CAAA;AACpC,IAAA,KAAA,CAAM,IAAA,CAAK,EAAE,IAAA,EAAM,EAAA,EAAI,MAAM,IAAA,EAAM,IAAA,EAAK,EAAG,EAAE,IAAA,EAAM,EAAA,EAAI,EAAA,EAAI,IAAA,EAAM,KAAK,CAAA;AAAA,EACxE,CAAA;AACA,EAAA,MAAM,MAAA,GAAS,CAAC,KAAA,EAAe,GAAA,KAAgB;AAC7C,IAAA,MAAM,EAAE,IAAA,EAAM,EAAA,EAAG,GAAI,IAAA,CAAK,OAAO,GAAG,CAAA;AACpC,IAAA,OAAO,UAAA,CAAW,KAAA,CAAM,IAAA,EAAM,EAAE,CAAA;AAAA,EAClC,CAAA;AAIA,EAAA,MAAM,YAAsB,EAAC;AAC7B,EAAA,MAAM,WAAA,GACJ,8HAAA;AACF,EAAA,MAAM,QAAA,GAAW,CAAC,IAAA,EAA2C,MAAA,KAA4B;AAEvF,IAAA,IAAK,IAAA,CAAK,IAAA,KAAS,GAAA,IAAO,IAAA,CAAK,IAAA,KAAS,KAAM,CAAC,WAAA,CAAY,IAAA,CAAK,KAAK,CAAA,EAAG;AACxE,IAAA,SAAA,CAAU,KAAK,CAAA,WAAA,EAAc,MAAA,CAAO,MAAA,EAAQ,IAAA,KAAS,WAAW,MAAA,CAAO,KAAA,GAAQ,IAAA,CAAK,KAAA,EAAO,KAAK,KAAA,CAAM,KAAK,CAAC,CAAA,GAAA,EAAM,WAAW,CAAA,CAAE,CAAA;AAAA,EACjI,CAAA;AAIA,EAAA,MAAM,SAAA,GAAY,CAAC,KAAA,KAA0B;AAC3C,IAAA,IAAI,eAAA,CAAgB,KAAK,CAAA,EAAG,IAAA,CAAK,KAAA,CAAM,OAAO,KAAA,CAAM,GAAA,EAAK,CAAA,CAAA,EAAI,KAAK,CAAA,CAAE,CAAA;AAAA,SAAA,IAC3D,KAAA,CAAM,IAAA,KAAS,OAAA,EAAS,SAAA,CAAU,MAAM,IAAI,CAAA;AAAA,SAAA,IAC5C,KAAA,CAAM,SAAS,MAAA,EAAQ;AAC9B,MAAA,QAAA,CAAS,KAAK,CAAA;AACd,MAAA,SAAA,CAAU,MAAM,KAAK,CAAA;AAAA,IACvB;AAAA,EACF,CAAA;AAEA,EAAA,MAAM,UAAA,GAAa,CAAC,KAAA,KAA2B;AAC7C,IAAA,MAAM,EAAE,OAAM,GAAI,KAAA;AAClB,IAAA,IAAI,KAAA,CAAM,WAAW,CAAA,EAAG;AACxB,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,KAAA,CAAM,MAAA,GAAS,CAAC,CAAA;AACnC,IAAA,MAAM,MAAA,GAAS,KAAA,CAAM,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA;AAChC,IAAA,IAAI,MAAA,CAAO,IAAA,CAAK,WAAW,CAAA,EAAG;AAC5B,MAAA,MAAM,IAAI,2BAAA;AAAA,QACR,8BAA8B,UAAU,CAAA,4EAAA;AAAA,OAC1C;AAAA,IACF;AACA,IAAA,IAAI,IAAA,CAAK,SAAS,MAAA,EAAQ;AACxB,MAAA,QAAA,CAAS,IAAA,EAAM,MAAA,CAAO,MAAA,CAAO,MAAA,GAAS,CAAC,CAAC,CAAA;AACxC,MAAA,SAAA,CAAU,KAAK,KAAK,CAAA;AAAA,IACtB,CAAA,MAAA,IAAW,eAAA,CAAgB,IAAI,CAAA,EAAG;AAChC,MAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,MAAA,CAAO,MAAA,GAAS,CAAC,CAAA;AACtC,MAAA,IAAI,KAAA,EAAO,SAAS,QAAA,EAAU;AAC5B,QAAA,KAAA,CAAM,IAAA,CAAK,EAAE,GAAG,IAAA,CAAK,MAAM,KAAA,EAAO,KAAA,CAAM,GAAG,CAAA,EAAG,MAAM,MAAA,CAAO,KAAA,CAAM,KAAA,GAAQ,KAAK,GAAG,CAAA;AAAA,MACnF,CAAA,MAAO;AACL,QAAA,MAAM,EAAA,GAAK,QAAA,CAAS,IAAA,CAAK,KAAK,CAAA;AAC9B,QAAA,KAAA,CAAM,IAAA,CAAK,EAAE,IAAA,EAAM,EAAA,EAAI,EAAA,EAAI,IAAI,IAAA,EAAM,MAAA,CAAO,KAAK,CAAA,EAAG,CAAA;AAAA,MACtD;AAAA,IACF,CAAA,MAAA,IAAW,IAAA,CAAK,IAAA,KAAS,OAAA,EAAS;AAChC,MAAA,SAAA,CAAU,KAAK,IAAI,CAAA;AAAA,IACrB;AAAA,EACF,CAAA;AAEA,EAAA,SAAS,UAAU,IAAA,EAAsB;AAEvC,IAAA,IAAI,OAAA,GAAU,CAAA;AACd,IAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,IAAK,IAAA,CAAK,KAAK,MAAA,IAAU,UAAA,CAAW,IAAA,CAAK,IAAA,CAAK,CAAA,GAAI,CAAC,CAAA,CAAE,EAAE,GAAG,CAAA,EAAA,EAAK;AAC7E,MAAA,IAAI,eAAA,CAAgB,IAAA,EAAM,CAAC,CAAA,EAAG,OAAA,GAAU,CAAA;AAAA,IAC1C;AACA,IAAA,IAAI,OAAA,GAAU,CAAA,EAAG,IAAA,CAAK,IAAA,CAAK,MAAM,KAAA,EAAO,IAAA,CAAK,IAAA,CAAK,OAAA,GAAU,CAAC,CAAA,CAAE,GAAA,EAAK,CAAA,EAAG,KAAK,CAAA,CAAA,CAAG,CAAA;AAAA,SAC1E,UAAA,CAAW,KAAK,KAAK,CAAA;AAC1B,IAAA,IAAI,WAAA,GAAc,OAAA,GAAU,CAAA,IAAK,YAAA,CAAa,KAAK,KAAK,CAAA;AACxD,IAAA,KAAA,MAAW,EAAE,IAAI,GAAA,EAAK,GAAA,MAAS,IAAA,CAAK,IAAA,CAAK,KAAA,CAAM,OAAO,CAAA,EAAG;AACvD,MAAA,IAAI,EAAA,KAAO,QAAA,IAAY,GAAA,KAAQ,MAAA,EAAW;AAC1C,MAAA,MAAM,UAAA,GAAa,aAAa,GAAG,CAAA;AAEnC,MAAA,IAAI,EAAA,KAAO,GAAA,IAAO,WAAA,IAAe,UAAA,EAAY;AAC3C,QAAA,SAAA,CAAU,IAAA,CAAK,CAAA,8BAAA,EAAiC,MAAA,CAAO,IAAA,CAAK,KAAA,CAAM,OAAO,GAAG,CAAC,CAAA,GAAA,EAAM,WAAW,CAAA,CAAE,CAAA;AAAA,MAClG;AAEA,MAAA,IAAI,EAAA,KAAO,GAAA,KAAQ,WAAA,IAAe,UAAA,CAAA,EAAa;AAC7C,QAAA,SAAA,CAAU,IAAA;AAAA,UACR,aAAa,MAAA,CAAO,IAAA,CAAK,KAAA,CAAM,KAAA,EAAO,GAAG,CAAC,CAAA,mJAAA;AAAA,SAE5C;AAAA,MACF;AACA,MAAA,WAAA,KAAA,WAAA,GAAgB,UAAA,CAAA;AAChB,MAAA,UAAA,CAAW,GAAG,CAAA;AAAA,IAChB;AAAA,EACF;AAEA,EAAA,SAAA,CAAU,IAAI,CAAA;AACd,EAAA,IAAI,SAAA,CAAU,SAAS,CAAA,EAAG;AACxB,IAAA,MAAM,IAAI,0BAAA;AAAA,MACR,CAAA,2BAAA,EAA8B,UAAU,CAAA,aAAA,EAAgB,SAAA,CAAU,CAAC,CAAC,CAAA,oGAAA;AAAA,KAEtE;AAAA,EACF;AAEA,EAAA,IAAI,MAAA,GAAS,UAAA;AACb,EAAA,KAAA,MAAW,EAAE,IAAA,EAAM,EAAA,EAAI,IAAA,MAAU,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,IAAA,GAAO,CAAA,CAAE,IAAI,CAAA,EAAG;AACtE,IAAA,MAAA,GAAS,MAAA,CAAO,MAAM,CAAA,EAAG,IAAI,IAAI,IAAA,GAAO,MAAA,CAAO,MAAM,EAAE,CAAA;AAAA,EACzD;AACA,EAAA,OAAO,MAAA;AACT;;;ACzRA,IAAM,aAAA,GAAgB,GAAA;AACtB,IAAM,cAAA,GAAiB,GAAA;AAEvB,IAAM,aAAA,GAAgB,GAAA;AAEtB,IAAM,kBAAkB,MAAA,CAAO,gBAAA;AAM/B,IAAM,UAAA,GAAa,GAAA,CAAI,WAAA,CAAY,GAAI,CAAA;AAGhC,SAAS,gBAAA,GAAyB;AACvC,EAAA,UAAA,CAAW,KAAA,EAAM;AACnB;AAOO,SAAS,KAAA,CAAM,UAAA,EAAoB,CAAA,GAAY,CAAA,EAAQ;AAE5D,EAAA,MAAM,UAAU,UAAA,CAAW,OAAA,CAAQ,IAAA,EAAM,EAAE,EAAE,WAAA,EAAY;AAEzD,EAAA,IAAI,mBAAkB,EAAG;AACvB,IAAA,MAAM,QAAA,GAAW,CAAA,EAAG,OAAO,CAAA,CAAA,EAAI,CAAC,CAAA,CAAA;AAChC,IAAA,MAAM,MAAA,GAAS,UAAA,CAAW,GAAA,CAAI,QAAQ,CAAA;AACtC,IAAA,IAAI,QAAQ,OAAO,MAAA;AAAA,EACrB;AAEA,EAAA,MAAM,KAAA,GAAQ,CAAC,GAAG,OAAO,CAAA;AAEzB,EAAA,IAAI,MAAA;AACJ,EAAA,IAAI;AACF,IAAA,MAAA,GAAS,eAAA,CAAgB,OAAO,CAAC,CAAA;AAAA,EACnC,SAAS,KAAA,EAAO;AACd,IAAA,MAAM,IAAI,cAAA;AAAA,MACR,CAAA,8BAAA,EAAiC,UAAU,CAAA,GAAA,EAAM,KAAK,CAAA,CAAA;AAAA,MACtD,EAAE,UAAA,EAAY,KAAA,EAAO,KAAA;AAAM,KAC7B;AAAA,EACF;AAEA,EAAA,MAAA,CAAO,WAAA,GAAc,MAAA,CAAO,WAAA,IAAe,EAAC;AAC5C,EAAA,MAAA,CAAO,UAAA,GAAa,OAAA;AAEpB,EAAA,IAAI,KAAA,CAAM,SAAS,CAAA,EAAG;AACpB,IAAA,MAAM,IAAI,cAAA;AAAA,MACR,CAAA,mBAAA,EAAsB,KAAA,CAAM,CAAC,CAAC,uBAAuB,UAAU,CAAA,CAAA,CAAA;AAAA,MAC/D,EAAE,UAAA;AAAW,KACf;AAAA,EACF;AAEA,EAAA,MAAM,KAAA,GAAQ,OAAO,KAAA,EAAM;AAC3B,EAAA,IAAI,UAAU,CAAA,EAAG;AACf,IAAA,MAAM,IAAI,cAAA;AAAA,MACR,iCAAiC,UAAU,CAAA,uFAAA,CAAA;AAAA,MAC3C,EAAE,UAAA;AAAW,KACf;AAAA,EACF;AACA,EAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,KAAK,CAAA,EAAG;AAC3B,IAAA,MAAM,IAAI,cAAA;AAAA,MACR,iCAAiC,UAAU,CAAA,wEAAA,CAAA;AAAA,MAC3C,EAAE,UAAA;AAAW,KACf;AAAA,EACF;AAGA,EAAA,MAAM,SAAA,GAAY,MAAA,CAAO,KAAA,CAAM,EAAE,CAAA;AACjC,EAAA,IAAI,mBAAkB,EAAG;AAEvB,IAAA,MAAM,QAAA,GAAW,CAAA,EAAG,OAAO,CAAA,CAAA,EAAI,CAAC,CAAA,CAAA;AAChC,IAAA,UAAA,CAAW,GAAA,CAAI,UAAU,SAAS,CAAA;AAAA,EACpC;AAEA,EAAA,OAAO,SAAA;AACT;AAEA,SAAS,4BAAA,CACP,IAAA,EACA,SAAA,EACA,WAAA,EACA,aACA,WAAA,EAC0C;AAC1C,EAAA,IAAA,GAAO,IAAA,CAAK,UAAU,WAAW,CAAA;AACjC,EAAA,WAAA,GAAc,WAAA,CAAY,UAAU,SAAS,CAAA;AAC7C,EAAA,WAAA,CAAY,sBAAA,CAAuB,WAAA,EAAa,IAAA,CAAK,UAAA,EAAY,CAAA;AACjE,EAAA,WAAA,GAAc,WAAA,CAAY,QAAQ,IAAI,CAAA;AACtC,EAAA,OAAO,EAAE,OAAA,EAAS,WAAA,GAAc,SAAA,EAAW,eAAe,WAAA,EAAY;AACxE;AAOA,SAAS,cAAA,CAAe,GAAS,CAAA,EAAe;AAC9C,EAAA,MAAM,MAAA,GAAS,IAAI,IAAA,EAAK;AACxB,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,CAAA,IAAK,CAAA,CAAE,gBAAe,EAAG,MAAA,CAAO,SAAA,CAAU,GAAA,EAAK,KAAK,CAAA;AAC1E,EAAA,KAAA,MAAW,CAAC,GAAA,EAAK,KAAK,CAAA,IAAK,CAAA,CAAE,cAAA,EAAe,EAAG,MAAA,CAAO,SAAA,CAAU,GAAA,EAAK,CAAC,KAAK,CAAA;AAC3E,EAAA,OAAO,MAAA;AACT;AAOA,IAAM,YAAA,uBAA+C,GAAA,CAAmB;AAAA,EACtE,KAAK,SAAA,CAAU,UAAA;AAAA,EACf,KAAK,SAAA,CAAU,gBAAA;AAAA,EACf,KAAK,SAAA,CAAU,QAAA;AAAA,EACf,KAAK,SAAA,CAAU,aAAA;AAAA,EACf,KAAK,SAAA,CAAU;AACjB,CAAC,CAAA;AAGD,IAAM,QAAA,mBAAuC,IAAI,GAAA,CAAmB,CAAC,IAAA,CAAK,UAAU,EAAA,EAAI,IAAA,CAAK,SAAA,CAAU,EAAE,CAAC,CAAA;AAM1G,SAAS,WAAW,GAAA,EAA4C;AAC9D,EAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,EAAA,IAAI,EAAA;AACJ,EAAA,KAAA,IAAS,IAAI,CAAA,EAAG,CAAA,GAAI,GAAA,CAAI,MAAA,GAAS,GAAG,CAAA,EAAA,EAAK;AACvC,IAAA,MAAM,CAAA,GAAI,IAAI,CAAC,CAAA;AACf,IAAA,IAAI,MAAM,GAAA,EAAK,KAAA,EAAA;AAAA,SAAA,IACN,MAAM,GAAA,EAAK;AAClB,MAAA,IAAI,UAAU,CAAA,EAAG;AACjB,MAAA,KAAA,EAAA;AAAA,IACF,CAAA,MAAA,IAAW,KAAA,KAAU,CAAA,KAAM,CAAA,KAAM,GAAA,IAAO,CAAA,KAAM,GAAA,CAAA,IAAQ,GAAA,CAAI,CAAA,GAAI,CAAC,CAAA,KAAM,GAAA,EAAK;AACxE,MAAA,EAAA,GAAK,IAAI,MAAA,GAAS,CAAA;AAAA,IACpB;AAAA,EACF;AACA,EAAA,OAAO,EAAA;AACT;AAKA,SAAS,eAAA,CAAgB,GAAA,EAAe,CAAA,EAAW,OAAA,GAAU,KAAA,EAAa;AACxE,EAAA,MAAM,IAAA,GAAO,WAAW,GAAG,CAAA;AAC3B,EAAA,MAAM,cAAc,MAAe,OAAA,IAAY,IAAA,KAAS,MAAA,IAAa,IAAI,MAAA,GAAS,IAAA;AAGlF,EAAA,MAAM,gBAAgB,MAAiC;AACrD,IAAA,MAAM,YAAY,WAAA,EAAY;AAC9B,IAAA,MAAM,MAAA,GAAS,eAAe,GAAG,CAAA;AACjC,IAAA,OAAO,WAAW,IAAA,CAAK,SAAA,CAAU,cAAc,SAAA,GAAY,IAAA,CAAK,UAAU,GAAA,GAAM,MAAA;AAAA,EAClF,CAAA;AAEA,EAAA,MAAM,KAAA,GAAQ,aAAA,CAAc,GAAA,EAAK,CAAA,EAAG,aAAa,CAAA;AACjD,EAAA,IAAI,cAAc,OAAO,KAAA,KAAU,WAAW,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA,GAAI,KAAA;AACnE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,EAAU,WAAA,CAAY,YAAY,KAAA,GAAQ,IAAA;AAI/D,EAAA,IAAI,SAAS,WAAA,CAAY,WAAA,CAAY,eAAe,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,GAAI,MAAA;AACnE,EAAA,IAAI,KAAK,aAAA,EAAc;AAEvB,EAAA,OAAO,MAAM,IAAA,EAAM;AAGjB,IAAA,MAAM,OAAA,GACJ,EAAA,KAAO,IAAA,CAAK,SAAA,CAAU,gBAAA,IAAoB,WAAA,CAAY,WAAA,CAAY,SAAA,GAAY,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,GAAI,MAAA;AAC/F,IAAA,MAAM,GAAA,GAAM,CAAC,EAAA,CAAG,KAAA,GAAQ,cAAc,GAAA,EAAK,CAAA,EAAG,WAAA,EAAa,CAAA,GAAI,WAAA;AAC/D,IAAA,MAAM,UAAU,OAAA,EAAS,KAAA,CAAM,GAAG,OAAA,CAAQ,MAAA,GAAS,IAAI,MAAM,CAAA;AAC7D,IAAA,MAAM,WAAW,MAAA,EAAQ,KAAA,CAAM,GAAG,MAAA,CAAO,MAAA,GAAS,IAAI,MAAM,CAAA;AAC5D,IAAA,MAAM,MAAA,GAAS,WAAA;AACf,IAAA,IAAI,OAAO,IAAA,CAAK,SAAA,CAAU,SAAS,aAAA,CAAc,MAAA,EAAQ,KAAK,GAAG,CAAA;AAMjE,IAAA,IAAI,IAAA;AACJ,IAAA,IAAI,QAAA,GAAW,CAAA;AACf,IAAA,MAAM,aAAa,GAAA,CAAI,CAAC,MAAM,GAAA,IAAO,GAAA,CAAI,CAAC,CAAA,KAAM,GAAA;AAChD,IAAA,MAAM,eAAe,CAAC,UAAA,IAAc,YAAY,MAAA,IAAa,CAAC,YAAY,WAAA,CAAY,KAAA;AACtF,IAAA,IAAI,cAAc,YAAA,EAAc;AAC9B,MAAA,IAAI,KAAA,GAAQ,CAAA;AACZ,MAAA,IAAI,UAAA,EAAY;AACd,QAAA,MAAM,OAAA,GAAU,GAAA,CAAI,CAAC,CAAA,KAAM,GAAA;AAC3B,QAAA,IAAI,OAAA,EAAS,WAAA,CAAY,GAAA,EAAK,GAAG,CAAA;AACjC,QAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,QAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,QAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,QAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,QAAA,IAAI,OAAA,EAAS,KAAA,GAAQ,WAAA,CAAY,GAAA,EAAK,CAAC,CAAA;AAAA,MACzC;AAEA,MAAA,IAAI,WAAA,CAAY,YAAY,KAAA,EAAO;AACjC,QAAA,mBAAA,CAAoB,GAAA,EAAK,KAAK,CAAC,CAAA;AAAA,MACjC,CAAA,MAAO;AACL,QAAA,CAAC,EAAE,IAAA,EAAM,IAAA,EAAM,aAAY,GAAI,SAAA,CAAU,aAAa,KAAK,CAAA;AAE3D,QAAA,QAAA,GAAW,KAAK,KAAA,EAAM;AACtB,QAAA,IAAA,GAAO,EAAA,CAAG,IAAA,CAAK,IAAA,EAAM,UAAA,GAAa,mBAAA,CAAoB,GAAA,EAAK,GAAA,EAAK,CAAC,CAAA,GAAI,WAAA,CAAY,OAAA,EAAU,CAAC,CAAC,CAAA;AAE7F,QAAA,QAAA,GAAW,IAAA,IAAQ,QAAA,GAAW,IAAA,CAAK,KAAA,KAAU,QAAA,GAAW,CAAA;AAAA,MAC1D;AAAA,IACF;AAGA,IAAA,IAAI,IAAA;AACJ,IAAA,IAAI,QAAA,GAAW,CAAA;AACf,IAAA,IAAI,GAAA,CAAI,CAAC,CAAA,KAAM,GAAA,EAAK;AAClB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AAEpB,MAAA,IAAA,GAAO,IAAI,IAAA,EAAK;AAChB,MAAA,MAAM,GAAA,GAAM,YAAY,OAAA,EAAQ;AAChC,MAAA,IAAA,CAAK,SAAA,CAAU,MAAM,CAAA,GAAI,GAAA,GAAM,GAAG,WAAA,CAAY,GAAA,CAAI,GAAG,CAAC,CAAA;AAEtD,MAAA,QAAA,GAAW,KAAK,KAAA,EAAM;AACtB,MAAA,WAAA,GAAc,WAAA,CAAY,WAAW,GAAG,CAAA;AACxC,MAAA,IAAA,GAAO,GAAG,IAAA,CAAK,IAAA,EAAM,oBAAoB,GAAA,EAAK,GAAA,EAAK,CAAC,CAAC,CAAA;AACrD,MAAA,QAAA,GAAW,IAAA,IAAQ,QAAA,GAAW,IAAA,CAAK,KAAA,KAAU,QAAA,GAAW,CAAA;AAAA,IAC1D;AAGA,IAAA,IAAI,EAAA;AACJ,IAAA,IAAI,MAAA,GAAS,CAAA;AAEb,IAAA,IAAI,GAAA,CAAI,MAAA,IAAU,CAAA,IAAK,GAAA,CAAI,CAAC,MAAM,GAAA,IAAO,GAAA,CAAI,CAAC,CAAA,KAAM,GAAA,EAAK;AACvD,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AAEpB,MAAA,EAAA,GAAK,IAAI,IAAA,EAAK;AACd,MAAA,MAAM,GAAA,GAAM,YAAY,OAAA,EAAQ;AAChC,MAAA,EAAA,CAAG,SAAA,CAAU,MAAM,CAAA,GAAI,GAAA,GAAM,GAAG,WAAA,CAAY,GAAA,CAAI,GAAG,CAAC,CAAA;AAEpD,MAAA,MAAM,UAAA,GAAa,GAAG,KAAA,EAAM;AAC5B,MAAA,WAAA,GAAc,WAAA,CAAY,WAAW,GAAG,CAAA;AAExC,MAAA,EAAA,GAAK,EAAA,CAAG,IAAA,CAAK,EAAA,EAAI,mBAAA,CAAoB,GAAA,EAAK,KAAK,CAAC,CAAC,CAAA,CAAE,eAAA,CAAgB,CAAC,CAAA;AAEpE,MAAA,MAAM,SAAA,GAAY,EAAA,GAAK,EAAA,CAAG,KAAA,EAAM,GAAI,CAAA;AACpC,MAAA,MAAA,GAAS,UAAA,GAAa,YAAY,UAAA,GAAa,CAAA;AAAA,IACjD;AAGA,IAAA,IAAI,IAAA;AACJ,IAAA,IAAI,QAAA,GAAW,CAAA;AAEf,IAAA,IAAI,GAAA,CAAI,CAAC,CAAA,KAAM,GAAA,EAAK;AAClB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AACpB,MAAA,WAAA,CAAY,KAAK,GAAG,CAAA;AAEpB,MAAA,IAAA,GAAO,IAAI,IAAA,EAAK;AAChB,MAAA,MAAM,GAAA,GAAM,YAAY,OAAA,EAAQ;AAChC,MAAA,IAAA,CAAK,SAAA,CAAU,MAAM,CAAA,GAAI,GAAA,GAAM,GAAG,WAAA,CAAY,GAAA,CAAI,GAAG,CAAC,CAAA;AAEtD,MAAA,QAAA,GAAW,KAAK,KAAA,EAAM;AACtB,MAAA,WAAA,GAAc,WAAA,CAAY,WAAW,GAAG,CAAA;AAExC,MAAA,IAAA,GAAO,GAAG,IAAA,CAAK,IAAA,EAAM,oBAAoB,GAAA,EAAK,GAAA,EAAK,CAAC,CAAC,CAAA;AACrD,MAAA,QAAA,GAAW,IAAA,IAAQ,QAAA,GAAW,IAAA,CAAK,KAAA,KAAU,QAAA,GAAW,CAAA;AAAA,IAC1D;AAEA,IAAA,IAAI,IAAA,GAAO,YAAY,KAAA,EAAM;AAE7B,IAAA,MAAM,SAAS,IAAA,KAAS,MAAA,IAAa,SAAS,MAAA,IAAa,EAAA,KAAO,UAAa,IAAA,KAAS,MAAA;AACxF,IAAA,MAAM,QAAA,GAAW,iBAAiB,WAAW,CAAA;AAC7C,IAAA,MAAM,OAAA,GAAU,WAAA;AAChB,IAAA,IAAI,CAAC,MAAA,IAAU,QAAA,IAAY,YAAA,CAAa,GAAA,CAAI,EAAE,CAAA,EAAG;AAC/C,MAAA,WAAA,GAAc,cAAA,CAAe,WAAA,EAAa,EAAA,EAAI,GAAA,EAAK,UAAU,CAAC,CAAA;AAAA,IAChE,CAAA,MAAO;AACL,MAAA,WAAA,GAAc,EAAA,CAAG,IAAA,CAAK,WAAA,EAAa,GAAG,CAAA;AAAA,IACxC;AAEA,IAAA,IAAI,QAAQ,WAAA,CAAY,SAAA,IAAa,YAAA,CAAa,GAAA,CAAI,EAAE,CAAA,EAAG;AACzD,MAAA,WAAA,CAAY,sBAAA,CAAuB,UAAA,EAAY,EAAA,CAAG,IAAA,CAAK,OAAA,CAAQ,UAAA,CAAW,CAAC,CAAA,EAAG,GAAG,CAAA,CAAE,UAAA,EAAY,CAAA;AAAA,IACjG;AAGA,IAAA,IAAI,CAAC,OAAA,CAAQ,WAAA,CAAY,SAAA,IAAa,YAAA,CAAa,GAAA,CAAI,EAAE,CAAA,KAAM,OAAA,KAAY,MAAA,IAAa,OAAA,CAAQ,WAAA,CAAY,aAAA,CAAA,EAAgB;AAC1H,MAAA,WAAA,CAAY,YAAY,aAAA,GAAgB,IAAA;AACxC,MAAA,MAAM,MAAA,GAAS,gBAAA,CAAiB,OAAA,EAAS,EAAA,EAAI,GAAG,CAAA;AAChD,MAAA,IAAI,MAAA,GAAS,GAAG,WAAA,CAAY,sBAAA,CAAuB,OAAO,EAAE,CAAA,EAAG,QAAQ,CAAA;AAAA,IACzE,CAAA,MAAA,IAAW,EAAA,KAAO,IAAA,CAAK,SAAA,CAAU,OAAA,IAAW,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,CAAI,WAAA,CAAY,aAAA,EAAe;AAEpG,MAAA,WAAA,CAAY,YAAY,aAAA,GAAgB,IAAA;AACxC,MAAA,MAAM,MAAA,GAAS,QAAQ,eAAA,CAAgB,KAAA,EAAO,CAAC,CAAA,GAAI,GAAA,CAAI,eAAA,CAAgB,KAAA,EAAO,CAAC,CAAA;AAC/E,MAAA,IAAI,MAAA,GAAS,GAAG,WAAA,CAAY,sBAAA,CAAuB,OAAO,EAAE,CAAA,EAAG,QAAQ,CAAA;AAAA,IACzE;AAEA,IAAA,MAAM,KAAA,GAAQ,OAAO,IAAA,CAAK,SAAA,CAAU,WAAW,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,CAAI,WAAA,CAAY,SAAA;AAC1F,IAAA,IAAI,OAAO,IAAA,CAAK,SAAA,CAAU,MAAM,KAAA,EAAO,WAAA,CAAY,YAAY,SAAA,GAAY,IAAA;AAC3E,IAAA,iBAAA,CAAkB,MAAA,EAAQ,EAAA,EAAI,GAAA,EAAK,WAAA,EAAa,MAAM,CAAA;AACtD,IAAA,IAAA,GAAO,IAAA,GAAO,WAAA,CAAY,KAAA,EAAM,GAAI,IAAA,GAAO,CAAA;AAG3C,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,MAAM,MAAA,GAAS,4BAAA;AAAA,QACb,IAAA;AAAA,QACA,QAAA;AAAA,QACA,MAAA;AAAA,QACA,IAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,IAAA,GAAO,MAAA,CAAO,OAAA;AACd,MAAA,WAAA,GAAc,MAAA,CAAO,aAAA;AAAA,IACvB;AAEA,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,MAAM,MAAA,GAAS,4BAAA;AAAA,QACb,IAAA;AAAA,QACA,QAAA;AAAA,QACA,UAAA;AAAA,QACA,IAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,IAAA,GAAO,MAAA,CAAO,OAAA;AACd,MAAA,WAAA,GAAc,MAAA,CAAO,aAAA;AAAA,IACvB;AAEA,IAAA,IAAI,IAAA,EAAM;AACR,MAAA,MAAM,MAAA,GAAS,4BAAA;AAAA,QACb,IAAA;AAAA,QACA,QAAA;AAAA,QACA,YAAA;AAAA,QACA,IAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,IAAA,GAAO,MAAA,CAAO,OAAA;AACd,MAAA,WAAA,GAAc,MAAA,CAAO,aAAA;AAAA,IACvB;AAEA,IAAA,IAAI,EAAA,EAAI;AACN,MAAA,MAAM,MAAA,GAAS,4BAAA;AAAA,QACb,EAAA;AAAA,QACA,MAAA;AAAA,QACA,IAAA;AAAA,QACA,IAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,IAAA,GAAO,MAAA,CAAO,OAAA;AACd,MAAA,WAAA,GAAc,MAAA,CAAO,aAAA;AAAA,IACvB;AAEA,IAAA,IAAI,cAAc,WAAA,CAAY,WAAA,CAAY,YAAA,GAAe,EAAE,SAAS,OAAA,EAAS;AAC7E,IAAA,MAAA,GAAS,YAAY,WAAA,CAAY,YAAA,GAAe,GAAA,CAAI,IAAA,CAAK,EAAE,CAAA,GAAI,MAAA;AAC/D,IAAA,EAAA,GAAK,aAAA,EAAc;AAAA,EACrB;AAEA,EAAA,OAAO,WAAA;AACT;AAGA,SAAS,aAAa,KAAA,EAA8B;AAClD,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,EAAU,OAAO,CAAA;AACtC,EAAA,MAAM,EAAE,SAAA,EAAW,cAAA,EAAe,GAAI,KAAA,CAAM,WAAA;AAC5C,EAAA,OAAO,SAAA,GAAY,SAAA,CAAU,KAAA,GAAS,cAAA,IAAkB,CAAA;AAC1D;AAOA,SAAS,QAAA,CAAS,OAAe,KAAA,EAAwB;AACvD,EAAA,IAAI,KAAA,KAAU,OAAO,OAAO,KAAA;AAC5B,EAAA,IAAI,KAAA,KAAU,EAAA,IAAM,KAAA,KAAU,EAAA,SAAW,KAAA,KAAU,EAAA;AACnD,EAAA,OAAO,KAAA,GAAQ,KAAA;AACjB;AAGA,SAAS,UAAU,GAAA,EAAsB;AACvC,EAAA,OAAO;AAAA,IACL,KAAA,EAAO,IAAI,OAAA,EAAQ;AAAA,IACnB,IAAA,EAAM,IAAA;AAAA,IACN,KAAA,EAAO,CAAC,IAAA,KAAS;AACf,MAAA,MAAM,KAAA,GAAQ,IAAI,IAAA,EAAK;AACvB,MAAA,MAAM,MAAA,GAAS,GAAA,CAAI,GAAA,CAAI,IAAI,CAAA;AAC3B,MAAA,IAAI,MAAA,EAAQ,KAAA,CAAM,OAAA,CAAQ,IAAA,EAAM,MAAM,CAAA;AACtC,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,GACF;AACF;AAGA,SAAS,QAAQ,KAAA,EAA4B;AAC3C,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,EAAU,OAAO,KAAA;AACtC,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA;AAChC,EAAA,MAAA,CAAO,YAAY,KAAA,GAAQ,IAAA;AAC3B,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,WAAW,KAAA,EAAuC;AACzD,EAAA,OAAO,OAAO,KAAA,KAAU,QAAA,GAAW,CAAC,OAAA,CAAQ,KAAK,CAAC,CAAA,GAAK,KAAA,CAAM,WAAA,CAAY,QAAA,IAAY,CAAC,KAAK,CAAA;AAC7F;AAEA,IAAM,mBAAmB,CAAC,KAAA,KACxB,OAAO,KAAA,KAAU,YAAY,MAAA,CAAO,IAAA,CAAK,KAAA,CAAM,0BAAA,EAA4B,CAAA,CAAE,IAAA,CAAK,CAAC,KAAA,KAAU,UAAU,KAAK,CAAA;AAE9G,IAAM,MAAA,GAAS,CAAC,KAAA,KAAkC,OAAO,UAAU,QAAA,IAAY,KAAA,CAAM,YAAY,SAAA,KAAc,IAAA;AAS/G,SAAS,aAAA,CAAc,IAAA,EAAY,KAAA,EAAsB,IAAA,EAA+B;AACtF,EAAA,IAAI,gBAAA,CAAiB,IAAI,CAAA,IAAK,gBAAA,CAAiB,KAAK,CAAA,EAAG;AACrD,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KAEF;AAAA,EACF;AACA,EAAA,IAAI,MAAA,CAAO,IAAI,CAAA,KAAM,MAAA,CAAO,KAAK,CAAA,EAAG;AAClC,IAAA,MAAM,IAAI,MAAM,wGAAwG,CAAA;AAAA,EAC1H;AACA,EAAA,MAAM,CAAC,IAAA,EAAM,KAAK,CAAA,GAAI,IAAA;AACtB,EAAA,IAAI,IAAA,KAAS,GAAA,IAAO,IAAA,KAAS,GAAA,IAAO,IAAA,KAAS,GAAA,IAAO,IAAA,KAAS,GAAA,IAAQ,IAAA,KAAS,GAAA,IAAO,KAAA,KAAU,GAAA,EAAM;AACnG,IAAA,MAAM,IAAI,MAAM,qGAAqG,CAAA;AAAA,EACvH;AACF;AAoBA,SAAS,iBAAA,CAAkB,MAAA,EAAc,EAAA,EAAmB,GAAA,EAAoB,OAAa,MAAA,EAAuB;AAClH,EAAA,MAAM,OAAO,KAAA,CAAM,WAAA;AACnB,EAAA,OAAO,IAAA,CAAK,SAAA;AACZ,EAAA,OAAO,IAAA,CAAK,cAAA;AACZ,EAAA,OAAO,IAAA,CAAK,KAAA;AACZ,EAAA,OAAO,IAAA,CAAK,QAAA;AACZ,EAAA,MAAM,IAAA,GAAO,QAAA,CAAS,GAAA,CAAI,EAAE,CAAA;AAC5B,EAAA,IAAI,CAAC,MAAA,IAAU,MAAA,CAAO,WAAA,CAAY,KAAA,KAAU,IAAA,IAAQ,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,CAAI,WAAA,CAAY,KAAA,CAAA,EAAQ;AACrG,IAAA,IAAA,CAAK,KAAA,GAAQ,IAAA;AAAA,EACf;AAEA,EAAA,MAAM,KAAA,GACJ,MAAA,CAAO,WAAA,CAAY,QAAA,KAAa,MAAA,IAC/B,CAAC,IAAA,IAAQ,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,CAAI,WAAA,CAAY,QAAA,KAAa,MAAA;AACpE,EAAA,IAAI,CAAC,MAAA,IAAU,EAAA,KAAO,IAAA,CAAK,UAAU,OAAA,EAAS;AAC5C,IAAA,IAAA,CAAK,QAAA,GAAW,CAAC,GAAG,UAAA,CAAW,MAAM,CAAA,EAAG,GAAG,UAAA,CAAW,GAAG,CAAC,CAAA;AAAA,EAC5D,WAAW,CAAC,MAAA,IAAU,SAAS,EAAA,KAAO,IAAA,CAAK,UAAU,MAAA,EAAQ;AAE3D,IAAA,MAAM,SAAA,GAAY,EAAA,KAAO,IAAA,CAAK,SAAA,CAAU,SAAA;AACxC,IAAA,MAAM,MAAA,GAAS,SAAA,GAAY,IAAA,CAAK,SAAA,CAAU,GAAA,GAAM,EAAA;AAChD,IAAA,MAAM,KAAA,GAAQ,WAAW,MAAM,CAAA;AAC/B,IAAA,MAAM,MAAA,GAAS,SAAA,GAAY,KAAA,GAAQ,IAAA,GAAO,CAAC,QAAQ,GAAG,CAAC,CAAA,GAAI,UAAA,CAAW,GAAG,CAAA;AACzE,IAAA,IAAA,CAAK,WAAW,KAAA,CAAM,OAAA;AAAA,MAAQ,CAAC,IAAA,KAC7B,MAAA,CAAO,GAAA,CAAI,CAAC,KAAA,KAAU;AACpB,QAAA,MAAM,IAAA,GAAO,MAAA,CAAO,IAAA,CAAK,IAAA,EAAM,KAAK,CAAA;AACpC,QAAA,iBAAA,CAAkB,IAAA,EAAM,MAAA,EAAQ,KAAA,EAAO,IAAA,EAAM,KAAK,CAAA;AAClD,QAAA,OAAO,IAAA;AAAA,MACT,CAAC;AAAA,KACH;AAAA,EACF;AACA,EAAA,IAAI,KAAK,QAAA,EAAU;AACjB,IAAA,eAAA,CAAgB,KAAA,EAAO,KAAK,QAAQ,CAAA;AACpC,IAAA;AAAA,EACF;AAEA,EAAA,MAAM,KAAA,GAAQ,OAAO,WAAA,CAAY,SAAA;AACjC,EAAA,MAAM,WAAW,OAAO,GAAA,KAAQ,YAAY,IAAA,GAAO,MAAA,GAAY,IAAI,WAAA,CAAY,SAAA;AAC/E,EAAA,MAAM,KAAA,GAAQ,aAAa,MAAM,CAAA;AACjC,EAAA,MAAM,QAAA,GAAW,IAAA,GAAO,CAAA,GAAI,YAAA,CAAa,GAAG,CAAA;AAC5C,EAAA,MAAM,WAAW,EAAA,KAAO,IAAA,CAAK,UAAU,GAAA,IAAO,EAAA,KAAO,KAAK,SAAA,CAAU,GAAA;AACpE,EAAA,MAAM,GAAA,GAAM,KAAA,KAAU,MAAA,IAAa,QAAA,CAAS,OAAO,QAAQ,CAAA;AAC3D,EAAA,MAAM,QAAA,GAAW,MAAM,KAAA,GAAQ,QAAA,IAAY,SAAS,QAAA,EAAU,KAAK,IAAI,QAAA,GAAW,MAAA;AAElF,EAAA,IAAI,MAAA,EAAQ,CAEZ,MAAA,IAAW,OAAO,IAAA,CAAK,SAAA,CAAU,aAAa,EAAA,KAAO,IAAA,CAAK,UAAU,MAAA,EAAQ;AAC1E,IAAA,IAAI,KAAA,EAAO,IAAA,EAAM,IAAA,CAAK,SAAA,GAAY,UAAU,KAAK,CAAA;AAAA,EACnD,WAAW,QAAA,IAAY,KAAA,EAAO,QAAQ,QAAA,EAAU,IAAA,IAAQ,UAAU,QAAA,EAAU;AAC1E,IAAA,IAAA,CAAK,SAAA,GAAY,UAAU,KAAK,CAAA;AAAA,EAClC,WAAW,QAAA,EAAU;AACnB,IAAA,MAAM,KAAA,GAAQ,GAAA,GAAM,CAAC,KAAA,KAAgB,GAAG,IAAA,CAAK,KAAA,EAAO,GAAG,CAAA,GAAI,CAAC,KAAA,KAAgB,EAAA,CAAG,IAAA,CAAK,QAAQ,KAAK,CAAA;AACjG,IAAA,MAAM,OAAO,QAAA,GAAW,CAAC,UAAgB,QAAA,CAAS,KAAA,EAAO,KAAK,CAAA,GAAI,KAAA;AAClE,IAAA,IAAA,CAAK,SAAA,GAAY,EAAE,KAAA,EAAO,QAAA,CAAS,OAAO,IAAA,EAAM,KAAA,EAAO,KAAA,EAAO,CAAC,SAAS,IAAA,CAAK,QAAA,CAAS,KAAA,CAAM,IAAI,CAAC,CAAA,EAAE;AAAA,EACrG;AACA,EAAA,IAAI,CAAC,KAAK,SAAA,EAAW;AACnB,IAAA,MAAM,GAAA,GAAM,QAAA,CAAS,QAAA,EAAU,KAAK,IAAI,QAAA,GAAW,KAAA;AACnD,IAAA,IAAI,GAAA,GAAM,CAAA,EAAG,IAAA,CAAK,cAAA,GAAiB,GAAA;AAAA,EACrC;AACF;AAOA,SAAS,eAAA,CAAgB,OAAa,QAAA,EAAiC;AACrE,EAAA,MAAM,QAAQ,QAAA,CAAS,MAAA,CAAO,CAAC,GAAA,EAAK,WAAY,QAAA,CAAS,YAAA,CAAa,MAAM,CAAA,EAAG,GAAG,CAAA,GAAI,YAAA,CAAa,MAAM,CAAA,GAAI,KAAM,CAAC,CAAA;AACpH,EAAA,IAAI,UAAU,CAAA,EAAG;AACjB,EAAA,MAAM,SAAsB,EAAC;AAC7B,EAAA,KAAA,MAAW,UAAU,QAAA,EAAU;AAC7B,IAAA,IAAI,YAAA,CAAa,MAAM,CAAA,KAAM,KAAA,EAAO;AACpC,IAAA,MAAM,KAAA,GAAQ,OAAO,WAAA,CAAY,SAAA;AACjC,IAAA,IAAI,CAAC,KAAA,EAAO;AACV,MAAA,KAAA,CAAM,YAAY,cAAA,GAAiB,KAAA;AACnC,MAAA;AAAA,IACF;AACA,IAAA,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,EACnB;AACA,EAAA,KAAA,CAAM,YAAY,SAAA,GAAY;AAAA,IAC5B,KAAA;AAAA,IACA,IAAA,EAAM,MAAA,CAAO,MAAA,KAAW,QAAA,CAAS,MAAA,IAAU,OAAO,KAAA,CAAM,CAAC,KAAA,KAAU,KAAA,CAAM,IAAI,CAAA;AAAA,IAC7E,KAAA,EAAO,CAAC,IAAA,KAAS;AACf,MAAA,MAAM,KAAA,GAAQ,IAAI,IAAA,EAAK;AACvB,MAAA,KAAA,MAAW,SAAS,MAAA,EAAQ,KAAA,CAAM,eAAe,KAAA,CAAM,KAAA,CAAM,IAAI,CAAC,CAAA;AAClE,MAAA,OAAO,KAAA;AAAA,IACT;AAAA,GACF;AACF;AAMA,SAAS,QAAA,CAAS,OAAa,KAAA,EAAmC;AAChE,EAAA,MAAM,MAAA,GAAS,IAAI,IAAA,EAAK;AACxB,EAAA,KAAA,MAAW,CAAC,KAAA,EAAO,KAAK,CAAA,IAAK,KAAA,CAAM,gBAAe,EAAG;AACnD,IAAA,MAAM,IAAA,GAAO,IAAI,IAAA,EAAK;AACtB,IAAA,IAAA,CAAK,OAAA,CAAQ,OAAO,KAAK,CAAA;AACzB,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,IAAI,CAAA,CAAE,IAAI,KAAK,CAAA;AAClC,IAAA,IAAI,IAAA,EAAM,MAAA,CAAO,SAAA,CAAU,KAAA,EAAO,IAAI,CAAA;AAAA,EACxC;AACA,EAAA,OAAO,MAAA;AACT;AAYA,SAAS,SAAA,CAAU,OAAa,KAAA,EAA2C;AACzE,EAAA,IAAI,UAAU,CAAA,EAAG;AACf,IAAA,MAAM,IAAA,GAAO,IAAI,IAAA,EAAK;AACtB,IAAA,OAAO,EAAE,IAAA,EAAM,IAAA,EAAM,MAAM,cAAA,CAAe,KAAA,EAAO,IAAI,CAAA,EAAE;AAAA,EACzD;AACA,EAAA,MAAM,KAAA,GAAQ,MAAM,WAAA,CAAY,SAAA;AAChC,EAAA,IAAI,CAAC,KAAA,EAAO;AACV,IAAA,MAAM,IAAI,KAAA;AAAA,MACR;AAAA,KAGF;AAAA,EACF;AACA,EAAA,MAAM,EAAE,OAAM,GAAI,KAAA;AAClB,EAAA,IAAI,QAAQ,KAAA,EAAO;AAEjB,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,KAAA,EAAQ,KAAK,CAAA,oBAAA,EAAuB,KAAK,CAAA,+BAAA,CAAiC,CAAA;AAAA,EAC5F;AACA,EAAA,IAAI,IAAA,GAAO,IAAI,IAAA,EAAK;AACpB,EAAA,KAAA,IAAS,IAAA,GAAO,KAAA,EAAO,IAAA,GAAO,KAAA,GAAQ,KAAA,EAAO,IAAA,EAAA,EAAQ,IAAA,CAAK,cAAA,CAAe,KAAA,CAAM,KAAA,CAAM,IAAI,CAAC,CAAA;AAC1F,EAAA,MAAM,IAAA,GAAO,cAAA,CAAe,KAAA,EAAO,IAAI,CAAA;AACvC,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,GAAA,CAAI,CAAC,CAAA;AACzB,EAAA,IAAI,MAAA,EAAQ;AACV,IAAA,IAAA,GAAO,IAAA,CAAK,WAAW,CAAC,CAAA;AACxB,IAAA,IAAA,CAAK,SAAA,CAAU,GAAG,MAAM,CAAA;AAAA,EAC1B;AACA,EAAA,OAAO,EAAE,MAAM,IAAA,EAAK;AACtB;AASA,SAAS,WAAA,CAAY,MAAc,CAAA,EAAiB;AAClD,EAAA,IAAI,OAAA,GAAU,IAAA;AACd,EAAA,IAAI;AAEF,IAAA,OAAA,GAAU,eAAA,CAAgB,KAAK,OAAA,CAAQ,IAAA,EAAM,OAAO,CAAC,CAAC,GAAG,CAAC,CAAA;AAAA,EAC5D,SAAS,KAAA,EAAO;AACd,IAAA,IAAI,EAAE,KAAA,YAAiB,2BAAA,CAAA,EAA8B,MAAM,KAAA;AAAA,EAC7D;AACA,EAAA,MAAM,KAAA,GAAQ,CAAC,GAAG,OAAO,CAAA;AACzB,EAAA,MAAM,OAAA,GAAU,eAAA,CAAgB,KAAA,EAAO,CAAC,CAAA;AACxC,EAAA,IAAI,KAAA,CAAM,SAAS,CAAA,EAAG;AACpB,IAAA,MAAM,IAAI,MAAM,CAAA,kBAAA,EAAqB,KAAA,CAAM,CAAC,CAAC,CAAA,uBAAA,EAA0B,OAAO,CAAA,CAAA,CAAG,CAAA;AAAA,EACnF;AACA,EAAA,OAAO,OAAA;AACT;AAQA,SAAS,cAAA,CACP,QAAA,EACA,EAAA,EACA,GAAA,EACA,UACA,CAAA,EACM;AACN,EAAA,MAAM,QAAA,GAAW,SAAS,WAAA,CAAY,YAAA;AACtC,EAAA,MAAM,WAAW,OAAO,GAAA,KAAQ,QAAA,GAAW,CAAA,GAAI,IAAI,KAAA,EAAM;AACzD,EAAA,MAAM,MAAA,GAAS,IAAI,IAAA,EAAK;AACxB,EAAA,IAAI,IAAA,GAAO,QAAA;AACX,EAAA,IAAI,OAAA;AACJ,EAAA,KAAA,MAAW,CAAC,OAAO,YAAY,CAAA,IAAK,OAAO,OAAA,CAAQ,QAAA,CAAS,0BAAA,EAA4B,CAAA,EAAG;AACzF,IAAA,IAAI,KAAA,KAAU,KAAA,IAAS,YAAA,KAAiB,MAAA,EAAW;AACnD,IAAA,MAAM,IAAA,GAAO,IAAI,IAAA,EAAK;AACtB,IAAA,KAAA,MAAW,CAAC,IAAA,EAAM,KAAK,CAAA,IAAK,MAAA,CAAO,OAAA,CAAQ,YAAY,CAAA,EAAG,IAAA,CAAK,SAAA,CAAU,MAAA,CAAO,IAAI,GAAG,KAAK,CAAA;AAC5F,IAAA,IAAA,GAAO,cAAA,CAAe,MAAM,IAAI,CAAA;AAChC,IAAA,IAAI,OAAA;AACJ,IAAA,IAAI,KAAA,KAAU,MAAA,IAAU,QAAA,IAAY,QAAA,KAAa,MAAA,EAAW;AAC1D,MAAA,OAAA,GAAU,SAAS,OAAA,GAAU,QAAA;AAC7B,MAAA,MAAM,OAAA,GAAU,WAAA,CAAY,OAAA,EAAS,CAAC,CAAA;AAEtC,MAAA,OAAA,GAAU,OAAA,CAAQ,UAAW,IAAA,CAAK,KAAA,KAAU,QAAA,GAAY,OAAA,CAAQ,OAAO,CAAA;AAAA,IACzE,CAAA,MAAO;AACL,MAAA,OAAA,GAAU,EAAA,CAAG,IAAA,CAAK,IAAA,EAAM,GAAG,CAAA;AAAA,IAC7B;AACA,IAAA,MAAA,CAAO,eAAe,OAAO,CAAA;AAC7B,IAAA,MAAA,CAAO,sBAAA,CAAuB,KAAA,EAAsB,OAAA,CAAQ,UAAA,EAAY,CAAA;AAAA,EAC1E;AACA,EAAA,MAAA,CAAO,cAAA,CAAe,EAAA,CAAG,IAAA,CAAK,IAAA,EAAM,GAAG,CAAC,CAAA;AACxC,EAAA,IAAI,QAAA,CAAS,WAAA,CAAY,SAAA,EAAW,MAAA,CAAO,YAAY,SAAA,GAAY,IAAA;AACnE,EAAA,IAAI,YAAY,MAAA,EAAW,MAAA,CAAO,WAAA,CAAY,YAAA,GAAe,EAAE,OAAA,EAAQ;AACvE,EAAA,OAAO,MAAA;AACT;AAMA,SAAS,gBAAA,CAAiB,OAAA,EAAe,EAAA,EAAmB,GAAA,EAA4B;AACtF,EAAA,IAAI,MAAA,GAAS,CAAA;AACb,EAAA,KAAA,MAAW,CAAC,MAAM,KAAK,CAAA,IAAK,OAAO,OAAA,CAAQ,OAAA,CAAQ,wBAAA,EAA0B,CAAA,EAAG;AAC9E,IAAA,IAAI,EAAE,QAAQ,CAAA,CAAA,EAAI;AAClB,IAAA,MAAM,GAAA,GAAM,IAAI,IAAA,EAAK;AACrB,IAAA,GAAA,CAAI,OAAA,CAAQ,MAAA,CAAO,IAAI,CAAA,EAAG,KAAK,CAAA;AAC/B,IAAA,MAAA,IAAU,GAAG,IAAA,CAAK,GAAA,EAAK,GAAG,CAAA,CAAE,IAAI,CAAC,CAAA;AAAA,EACnC;AACA,EAAA,OAAO,MAAA;AACT;AAMA,SAAS,aAAA,CAAc,CAAA,EAAa,CAAA,EAAW,OAAA,GAAU,KAAA,EAAsB;AAC7E,EAAA,IAAI,CAAA,CAAE,CAAC,CAAA,KAAM,GAAA,EAAK;AAChB,IAAA,CAAA,CAAE,KAAA,EAAM;AACR,IAAA,MAAM,OAAA,GAAU,aAAA,CAAc,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA;AAC3C,IAAA,IAAI,OAAO,OAAA,KAAY,QAAA,EAAU,OAAO,CAAA,GAAI,OAAA;AAC5C,IAAA,MAAM,IAAA,GAAO,QAAQ,CAAC,CAAA;AACtB,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,QAAA,CAAS,OAAO,CAAA;AACrC,IAAA,iBAAA,CAAkB,MAAM,IAAA,CAAK,SAAA,CAAU,QAAA,EAAU,OAAA,EAAS,SAAS,KAAK,CAAA;AACxE,IAAA,OAAO,OAAA;AAAA,EACT;AAEA,EAAA,IAAI,MAAA,GAAS,qBAAA,CAAsB,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA;AAChD,EAAA,IAAI,WAAW,MAAA,EAAW;AACxB,IAAA,MAAM,EAAA,GAAK,CAAA,CAAE,MAAA,KAAW,CAAA,GAAI,2BAAA,GAA8B,CAAA,CAAA,EAAI,CAAA,CAAE,KAAA,CAAM,CAAA,EAAG,EAAE,CAAA,CAAE,IAAA,CAAK,EAAE,CAAC,CAAA,CAAA,CAAA;AACrF,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,2CAAA,EAA8C,EAAE,CAAA,CAAE,CAAA;AAAA,EACpE;AAEA,EAAA,KAAA,IAAS,IAAA,GAAO,qBAAA,CAAsB,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA,EAAG,IAAA,KAAS,MAAA,EAAW,IAAA,GAAO,qBAAA,CAAsB,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA,EAAG;AACrH,IAAA,MAAA,GAAS,kBAAA,CAAmB,QAAQ,IAAI,CAAA;AAAA,EAC1C;AAEA,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,kBAAA,CAAmB,IAAmB,EAAA,EAAyB;AAEtE,EAAA,MAAM,KAAA,GAAA,CACH,OAAO,EAAA,KAAO,QAAA,IAAY,EAAA,CAAG,WAAA,CAAY,KAAA,MAAW,OAAO,EAAA,KAAO,QAAA,IAAY,EAAA,CAAG,WAAA,CAAY,KAAA,CAAA;AAChG,EAAA,IAAI,OAAO,EAAA,KAAO,QAAA,EAAU,EAAA,GAAK,IAAA,CAAK,OAAO,EAAE,CAAA;AAC/C,EAAA,IAAI,OAAO,EAAA,KAAO,QAAA,EAAU,EAAA,GAAK,IAAA,CAAK,OAAO,EAAE,CAAA;AAE/C,EAAA,MAAM,MAAA,GAAS,IAAI,IAAA,EAAK;AAIxB,EAAA,MAAM,KAAA,uBAAY,GAAA,EAAkB;AACpC,EAAA,IAAI,MAAA,GAAS,CAAA;AAEb,EAAA,MAAM,EAAE,IAAA,EAAK,GAAI,EAAA,CAAG,WAAA;AACpB,EAAA,KAAA,MAAW,GAAA,IAAO,EAAA,CAAG,IAAA,EAAK,EAAG;AAC3B,IAAA,MAAM,IAAA,GAAO,OAAO,QAAA,CAAS,EAAA,EAAI,KAAK,IAAI,CAAA,GAAI,YAAA,CAAa,GAAA,EAAK,EAAE,CAAA;AAElE,IAAA,MAAA,IAAU,KAAK,KAAA,EAAM;AACrB,IAAA,KAAA,CAAM,GAAA,CAAI,KAAK,IAAI,CAAA;AAAA,EACrB;AAIA,EAAA,MAAM,QAAQ,MAAA,IAAU,eAAA;AACxB,EAAA,KAAA,MAAW,CAAC,CAAA,EAAG,IAAI,CAAA,IAAK,KAAA,EAAO;AAC7B,IAAA,MAAM,KAAA,GAAQ,EAAA,CAAG,GAAA,CAAI,CAAC,CAAA;AACtB,IAAA,MAAA,CAAO,cAAA,CAAe,IAAA,CAAK,SAAA,CAAA,CAAY,KAAA,GAAQ,MAAA,GAAS,KAAK,KAAA,GAAS,IAAA,CAAK,KAAA,EAAO,CAAC,CAAA;AAAA,EACrF;AAEA,EAAA,MAAA,CAAO,WAAA,CAAY,SAAS,EAAC;AAI7B,EAAA,MAAM,CAAC,IAAA,EAAM,GAAG,IAAI,CAAA,GAAI,GAAG,IAAA,EAAK;AAChC,EAAA,MAAM,EAAE,SAAA,EAAU,GAAI,EAAA,CAAG,WAAA;AACzB,EAAA,MAAM,KAAA,GAAQ,SAAS,MAAA,GAAY,IAAA,GAAO,KAAK,GAAA,CAAI,IAAA,EAAM,KAAK,IAAI,CAAA;AAClE,EAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,YAAA,CAAa,EAAE,CAAA,EAAG,YAAA,CAAa,EAAE,CAAC,CAAA,GAAI,YAAA,CAAa,EAAE,CAAA,GAAI,aAAa,EAAE,CAAA;AAC/F,EAAA,IAAI,UAAU,CAAA,IAAK,IAAA,CAAK,MAAA,KAAW,CAAA,IAAK,WAAW,IAAA,EAAM;AACvD,IAAA,MAAA,CAAO,WAAA,CAAY,SAAA,GAAY,SAAA,CAAU,MAAM,CAAA;AAAA,EACjD,CAAA,MAAA,IAAW,QAAQ,CAAA,EAAG;AACpB,IAAA,MAAA,CAAO,YAAY,cAAA,GAAiB,KAAA;AAAA,EACtC;AACA,EAAA,IAAI,KAAA,EAAO,MAAA,CAAO,WAAA,CAAY,KAAA,GAAQ,IAAA;AACtC,EAAA,OAAO,MAAA;AACT;AAGA,SAAS,kBAAkB,CAAA,EAAiB;AAC1C,EAAA,IAAI,CAAC,MAAA,CAAO,SAAA,CAAU,CAAC,CAAA,IAAK,IAAI,CAAA,EAAG;AACjC,IAAA,MAAM,IAAI,cAAA,CAAe,CAAA,oEAAA,EAAuE,CAAC,CAAA,CAAE,CAAA;AAAA,EACrG;AACA,EAAA,IAAI,IAAI,cAAA,EAAgB;AACtB,IAAA,MAAM,IAAI,cAAA;AAAA,MACR,CAAA,WAAA,EAAc,CAAC,CAAA,wBAAA,EAA2B,cAAc,CAAA;AAAA,KAC1D;AAAA,EACF;AACF;AAEA,SAAS,YAAA,CAAa,GAAW,CAAA,EAAe;AAC9C,EAAA,iBAAA,CAAkB,CAAC,CAAA;AACnB,EAAA,IAAI,CAAA,KAAM,CAAA,EAAG,OAAO,IAAA,CAAK,OAAO,CAAC,CAAA;AACjC,EAAA,IAAI,CAAA,KAAM,GAAG,OAAO,CAAA;AAEpB,EAAA,MAAM,IAAA,GAAO,IAAA,CAAK,KAAA,CAAM,CAAA,GAAI,CAAC,CAAA;AAC7B,EAAA,IAAI,MAAA,GAAS,YAAA,CAAa,IAAA,EAAM,CAAC,CAAA;AACjC,EAAA,MAAA,GAAS,MAAA,CAAO,IAAI,MAAM,CAAA;AAE1B,EAAA,IAAI,CAAA,GAAI,MAAM,CAAA,EAAG;AACf,IAAA,MAAA,GAAS,MAAA,CAAO,IAAI,CAAC,CAAA;AAAA,EACvB;AAIA,EAAA,MAAM,KAAA,GAAQ,OAAO,KAAA,EAAM;AAC3B,EAAA,OAAO,QAAQ,eAAA,GAAkB,MAAA,CAAO,SAAA,CAAU,CAAA,GAAI,KAAK,CAAA,GAAI,MAAA;AACjE;AASA,SAAS,SAAS,GAAA,EAAW,KAAA,EAAe,EAAE,IAAA,EAAM,QAAO,EAA4C;AACrG,EAAA,iBAAA,CAAkB,KAAK,CAAA;AACvB,EAAA,IAAI,IAAA,IAAQ,KAAA,EAAO,OAAO,YAAA,CAAa,OAAO,GAAG,CAAA;AACjD,EAAA,IAAI,IAAA,IAAQ,CAAA,EAAG,OAAO,IAAA,CAAK,OAAO,CAAC,CAAA;AAEnC,EAAA,MAAM,KAAA,GAAQ,GAAA,CACX,cAAA,EAAe,CACf,MAAA,CAAO,CAAC,GAAG,MAAM,CAAA,KAAM,MAAA,GAAS,CAAC,EACjC,IAAA,CAAK,CAAC,CAAC,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA,KAAO,MAAA,GAAS,CAAA,GAAI,CAAA,GAAI,CAAA,GAAI,CAAE,CAAA;AAC9C,EAAA,IAAI,KAAA,CAAM,MAAA,KAAW,CAAA,EAAG,OAAO,IAAI,IAAA,EAAK;AACxC,EAAA,MAAM,IAAA,GAAO,IAAA,CAAK,GAAA,CAAI,KAAA,CAAM,MAAM,MAAA,GAAS,CAAC,CAAA,CAAE,CAAC,CAAA,GAAI,KAAA,CAAM,CAAC,CAAA,CAAE,CAAC,CAAC,CAAA;AAC9D,EAAA,MAAM,OAAO,KAAA,CAAM,MAAA,GAAS,IAAA,GAAO,IAAA,IAAQ,OAAO,IAAA,GAAO,CAAA,CAAA;AACzD,EAAA,IAAI,OAAO,aAAA,EAAe;AACxB,IAAA,MAAM,IAAI,cAAA;AAAA,MACR,CAAA,QAAA,EAAW,IAAI,CAAA,IAAA,EAAO,KAAK,gBAAgB,KAAA,CAAM,MAAM,0CAA0C,aAAa,CAAA;AAAA,KAChH;AAAA,EACF;AAGA,EAAA,MAAM,KAAA,GAAkB,IAAI,KAAA,CAAM,KAAA,CAAM,MAAM,CAAA;AAC9C,EAAA,KAAA,IAAS,IAAI,KAAA,CAAM,MAAA,GAAS,CAAA,EAAG,IAAA,GAAO,GAAG,CAAA,IAAK,CAAA,EAAG,CAAA,EAAA,EAAK,KAAA,CAAM,CAAC,CAAA,GAAI,IAAA,IAAQ,KAAA,CAAM,CAAC,EAAE,CAAC,CAAA;AAEnF,EAAA,MAAM,KAAA,GAAQ,CAAC,GAAA,EAA0B,GAAA,EAAa,CAAA,KAAoB;AACxE,IAAA,GAAA,CAAI,IAAI,GAAA,EAAA,CAAM,GAAA,CAAI,IAAI,GAAG,CAAA,IAAK,KAAK,CAAC,CAAA;AAAA,EACtC,CAAA;AAEA,EAAA,IAAI,MAAA,GAAS,KAAA,CAAM,IAAA,CAAK,EAAE,MAAA,EAAQ,MAAK,EAAG,sBAAM,IAAI,GAAA,EAAqB,CAAA;AACzE,EAAA,MAAA,CAAO,CAAC,CAAA,CAAE,GAAA,CAAI,CAAA,EAAG,CAAC,CAAA;AAClB,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAoB;AAErC,EAAA,KAAA,CAAM,QAAQ,CAAC,CAAC,KAAA,EAAO,MAAM,GAAG,CAAA,KAAM;AACpC,IAAA,MAAM,CAAA,GAAI,MAAA,GAAS,KAAA,CAAM,CAAC,CAAA;AAC1B,IAAA,MAAM,IAAA,GAAO,KAAA,CAAM,IAAA,CAAK,EAAE,MAAA,EAAQ,MAAK,EAAG,sBAAM,IAAI,GAAA,EAAqB,CAAA;AACzE,IAAA,MAAA,CAAO,OAAA,CAAQ,CAAC,IAAA,EAAM,MAAA,KAAW;AAC/B,MAAA,IAAI,IAAA,CAAK,SAAS,CAAA,EAAG;AACrB,MAAA,MAAM,OAAO,KAAA,GAAQ,MAAA;AACrB,MAAA,MAAM,OAAO,IAAA,GAAO,MAAA;AAEpB,MAAA,MAAM,MAAgB,EAAC;AACvB,MAAA,IAAI,SAAA,GAAY,CAAA;AAChB,MAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,IAAA,EAAM,CAAA,EAAA,EAAK;AAC7B,QAAA,IAAI,CAAA,GAAI,GAAG,SAAA,IAAa,IAAA,CAAK,KAAK,IAAA,GAAO,CAAA,GAAI,KAAK,CAAC,CAAA;AACnD,QAAA,GAAA,CAAI,KAAK,CAAA,IAAK,CAAA,GAAI,IAAI,IAAA,CAAK,GAAA,CAAI,YAAY,CAAA,GAAI,IAAA,CAAK,IAAI,CAAC,CAAA,GAAA,CAAK,OAAO,CAAA,IAAK,IAAA,CAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;AAAA,MAC3F;AACA,MAAA,MAAM,MAAA,GAAS,IAAA,CAAK,GAAA,CAAI,CAAA,EAAG,CAAA,GAAI,GAAA,CAAI,MAAA,CAAO,CAAC,KAAA,EAAO,CAAA,KAAM,KAAA,GAAQ,CAAA,EAAG,CAAC,CAAC,CAAA;AACrE,MAAA,KAAA,MAAW,CAAC,GAAA,EAAK,CAAC,CAAA,IAAK,IAAA,EAAM;AAC3B,QAAA,GAAA,CAAI,OAAA,CAAQ,CAAC,EAAA,EAAI,CAAA,KAAM;AACrB,UAAA,IAAI,EAAA,GAAK,CAAA,EAAG,KAAA,CAAM,IAAA,CAAK,MAAA,GAAS,CAAC,CAAA,EAAG,GAAA,GAAM,CAAA,GAAI,KAAA,EAAO,CAAA,GAAI,EAAE,CAAA;AAAA,QAC7D,CAAC,CAAA;AACD,QAAA,IAAI,MAAA,GAAS,GAAG,KAAA,CAAM,IAAA,EAAM,MAAM,IAAA,GAAO,KAAA,EAAO,IAAI,MAAM,CAAA;AAAA,MAC5D;AAAA,IACF,CAAC,CAAA;AACD,IAAA,MAAA,GAAS,IAAA;AAAA,EACX,CAAC,CAAA;AAED,EAAA,MAAM,MAAA,GAAS,IAAI,IAAA,EAAK;AACxB,EAAA,KAAA,MAAW,CAAC,KAAK,CAAC,CAAA,IAAK,MAAM,MAAA,CAAO,SAAA,CAAU,KAAK,CAAC,CAAA;AACpD,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,qBAAA,CACP,CAAA,EACA,CAAA,EACA,OAAA,GAAU,KAAA,EACiB;AAC3B,EAAA,IAAI,CAAA,CAAE,WAAW,CAAA,EAAG;AAEpB,EAAA,MAAM,CAAA,GAAI,EAAE,CAAC,CAAA;AAEb,EAAA,QAAQ,CAAA;AAAG,IACT,KAAK,GAAA;AACH,MAAA,CAAA,CAAE,KAAA,EAAM;AACR,MAAA,OAAO,YAAY,CAAA,EAAG,GAAA,EAAK,gBAAgB,CAAA,EAAG,CAAA,EAAG,OAAO,CAAC,CAAA;AAAA,IAE3D,KAAK,GAAA;AAAA,IACL,KAAK,GAAA;AACH,MAAA,OAAO,SAAA,CAAU,GAAG,CAAC,CAAA;AAAA,IAEvB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,SAAA,CAAU,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA;AAAA,IAEhC,KAAK,GAAA;AACH,MAAA,OAAO,WAAA,CAAY,GAAG,CAAC,CAAA;AAAA,IAEzB;AACE,MAAA,IAAI,QAAQ,CAAC,CAAA,EAAG,OAAO,WAAA,CAAY,GAAG,CAAC,CAAA;AACvC,MAAA;AAAA;AAEN;AAEA,SAAS,mBAAA,CACP,GAAA,EACA,GAAA,EACA,CAAA,EACM;AACN,EAAA,IAAI,GAAA,CAAI,MAAA,IAAU,CAAA,IAAK,GAAA,CAAI,CAAC,MAAM,GAAA,IAAO,IAAA,CAAK,GAAA,EAAK,MAAM,CAAA,EAAG;AAC1D,IAAA,WAAA,CAAY,KAAK,MAAM,CAAA;AAEvB,IAAA,MAAM,UAAU,OAAO,GAAA,KAAQ,WAAW,IAAA,CAAK,MAAA,CAAO,GAAG,CAAA,GAAI,GAAA;AAC7D,IAAA,OAAO,OAAA,CAAQ,gBAAgB,CAAC,CAAA;AAAA,EAClC;AAEA,EAAA,MAAM,MAAA,GAAS,aAAA,CAAc,GAAA,EAAK,CAAC,CAAA;AACnC,EAAA,OAAO,OAAO,MAAA,KAAW,QAAA,GAAW,IAAA,CAAK,MAAA,CAAO,MAAM,CAAA,GAAI,MAAA;AAC5D;AAEA,SAAS,WAAA,CAAe,CAAA,EAAa,QAAA,EAAkB,GAAA,EAAwB;AAC7E,EAAA,KAAA,MAAW,MAAM,QAAA,EAAU;AACzB,IAAA,MAAM,KAAA,GAAQ,EAAE,KAAA,EAAM;AACtB,IAAA,IAAI,UAAU,EAAA,EAAI;AAChB,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,oBAAA,EAAuB,EAAE,CAAA,UAAA,EAAa,KAAK,CAAA,CAAA,CAAG,CAAA;AAAA,IAChE;AAAA,EACF;AACA,EAAA,OAAO,GAAA;AACT;AAEA,SAAS,SAAA,CAAU,GAAa,CAAA,EAA6B;AAC3D,EAAA,IAAI,SAAA,GAAY,KAAA;AAEhB,EAAA,IAAI,KAAK,CAAA,EAAG,IAAI,KAAK,YAAA,CAAa,CAAA,EAAG,CAAC,CAAA,EAAG;AACvC,IAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,IAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,IAAA,SAAA,GAAY,IAAA;AAAA,EACd,CAAA,MAAA,IAAW,KAAK,CAAA,EAAG,GAAG,KAAK,YAAA,CAAa,CAAA,EAAG,CAAC,CAAA,EAAG;AAC7C,IAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAAA,EACpB,CAAA,MAAO;AACL,IAAA;AAAA,EACF;AAEA,EAAA,MAAM,KAAA,GAAQ,WAAA,CAAY,CAAA,EAAG,CAAC,CAAA;AAC9B,EAAA,IAAI,QAAQ,aAAA,EAAe;AACzB,IAAA,MAAM,IAAI,cAAA;AAAA,MACR,CAAA,SAAA,EAAY,KAAK,CAAA,wBAAA,EAA2B,aAAa,CAAA;AAAA,KAC3D;AAAA,EACF;AACA,EAAA,IAAI,MAAA,GAAS,IAAI,IAAA,CAAK,KAAK,CAAA;AAE3B,EAAA,IAAI,KAAA,KAAU,GAAG,OAAO,MAAA;AAExB,EAAA,IAAI,SAAA,EAAW;AAKb,IAAA,MAAA,GAAS,MAAA,CAAO,OAAO,CAAC,CAAA;AAAA,EAC1B;AAEA,EAAA,MAAA,CAAO,WAAA,CAAY,SAAA,GAAY,SAAA,CAAU,MAAM,CAAA;AAC/C,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,IAAA,CAAK,KAAe,QAAA,EAA2B;AACtD,EAAA,IAAI,QAAA,CAAS,MAAA,GAAS,GAAA,CAAI,MAAA,EAAQ,OAAO,KAAA;AAEzC,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,QAAA,CAAS,QAAQ,CAAA,EAAA,EAAK;AACxC,IAAA,IAAI,IAAI,CAAC,CAAA,KAAM,SAAS,MAAA,CAAO,CAAC,GAAG,OAAO,KAAA;AAAA,EAC5C;AAEA,EAAA,OAAO,IAAA;AACT;AAEA,SAAS,YAAA,CAAa,KAAe,KAAA,EAAwB;AAC3D,EAAA,IAAI,KAAA,IAAS,GAAA,CAAI,MAAA,EAAQ,OAAO,KAAA;AAChC,EAAA,OAAO,QAAQ,GAAA,CAAI,KAAK,CAAC,CAAA,IAAK,GAAA,CAAI,KAAK,CAAA,KAAM,GAAA;AAC/C;AAEA,SAAS,WAAA,CAAY,GAAa,CAAA,EAAmB;AACnD,EAAA,IAAI,GAAA,GAAM,EAAA;AAEV,EAAA,OAAO,CAAA,CAAE,MAAA,GAAS,CAAA,KAAM,OAAA,CAAQ,CAAA,CAAE,CAAC,CAAC,CAAA,IAAK,CAAA,CAAE,CAAC,CAAA,KAAM,GAAA,CAAA,EAAM;AACtD,IAAA,MAAM,EAAA,GAAK,EAAE,KAAA,EAAM;AACnB,IAAA,GAAA,IAAO,EAAA,KAAO,GAAA,GAAM,CAAA,CAAE,QAAA,EAAS,GAAI,EAAA;AAAA,EACrC;AAEA,EAAA,IAAI,GAAA,CAAI,WAAW,CAAA,EAAG;AACpB,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,yBAAA,EAA4B,CAAA,CAAE,CAAC,CAAC,CAAA,CAAA,CAAG,CAAA;AAAA,EACrD;AAEA,EAAA,OAAO,QAAA,CAAS,KAAK,EAAE,CAAA;AACzB;AAEA,SAAS,QAAQ,CAAA,EAAoB;AACnC,EAAA,OAAO,CAAA,IAAK,OAAO,CAAA,IAAK,GAAA;AAC1B;AAEA,SAAS,SAAA,CAAU,CAAA,EAAa,CAAA,EAAW,OAAA,EAAoC;AAC7E,EAAA,IAAI,MAAA,GAAS,KAAA;AAEb,EAAA,IAAI,IAAA,CAAK,CAAA,EAAG,GAAG,CAAA,EAAG;AAChB,IAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,IAAA,MAAA,GAAS,IAAA;AAAA,EACX,CAAA,MAAA,IAAW,IAAA,CAAK,CAAA,EAAG,GAAG,CAAA,EAAG;AACvB,IAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAAA,EACpB,CAAA,MAAO;AACL,IAAA;AAAA,EACF;AAEA,EAAA,MAAM,IAAA,GAAO,WAAA,CAAY,CAAA,EAAG,CAAC,CAAA;AAC7B,EAAA,MAAM,MAAA,GAAS,qBAAA,CAAsB,CAAA,EAAG,CAAA,EAAG,OAAO,CAAA;AAElD,EAAA,IAAI,kBAAkB,IAAA,EAAM;AAC1B,IAAA,MAAA,CAAO,WAAA,CAAY,IAAA,GAAO,EAAE,IAAA,EAAM,MAAA,EAAO;AACzC,IAAA,OAAO,MAAA;AAAA,EACT;AAEA,EAAA,MAAM,IAAI,MAAM,mCAAmC,CAAA;AACrD;AAEA,SAAS,eAAe,CAAA,EAAwC;AAC9D,EAAA,QAAQ,CAAA,CAAE,CAAC,CAAA;AAAG,IACZ,KAAK,GAAA;AACH,MAAA;AAAA,IAEF,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,IAAI,CAAA;AACnB,MAAA,OAAO,KAAK,SAAA,CAAU,EAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,IAAI,CAAA;AACnB,MAAA,OAAO,KAAK,SAAA,CAAU,EAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,MAAM,GAAA,GAAM,KAAK,SAAA,CAAU,SAAA;AAC3B,MAAA,GAAA,CAAI,KAAA,GAAQ,IAAA;AACZ,MAAA,OAAO,GAAA;AAAA,IAET,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,KAAK,SAAA,CAAU,GAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,KAAK,SAAA,CAAU,GAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,KAAK,SAAA,CAAU,UAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,KAAK,SAAA,CAAU,GAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,KAAK,SAAA,CAAU,QAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,KAAK,SAAA,CAAU,OAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,QAAQ,CAAA;AACvB,MAAA,OAAO,KAAK,SAAA,CAAU,MAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAElB,MAAA,IAAI,IAAA,CAAK,CAAA,EAAG,GAAG,CAAA,EAAG;AAChB,QAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,QAAA,OAAO,KAAK,SAAA,CAAU,QAAA;AAAA,MACxB;AAEA,MAAA,OAAO,KAAK,SAAA,CAAU,gBAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,IAAI,CAAA,CAAE,CAAC,CAAA,KAAM,GAAA,EAAK;AAChB,QAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,QAAA,OAAO,KAAK,SAAA,CAAU,eAAA;AAAA,MACxB;AACA,MAAA,OAAO,KAAK,SAAA,CAAU,aAAA;AAAA,IAExB,KAAK,GAAA;AACH,MAAA,WAAA,CAAY,GAAG,GAAG,CAAA;AAClB,MAAA,OAAO,KAAK,SAAA,CAAU,EAAA;AAAA;AAG1B,EAAA;AACF;;;ACtjCA,IAAM,eAAA,GAAkB,kBAAA;AAyBjB,SAAS,SAAS,UAAA,EAAyB;AAIhD,EAAA,IAAI,eAAA,CAAgB,IAAA,CAAK,UAAU,CAAA,EAAG;AACpC,IAAA,MAAM,KAAA,GAAQ,OAAO,UAAU,CAAA;AAC/B,IAAA,OAAO,MAAA,CAAO,cAAc,KAAK,CAAA,GAAI,IAAI,KAAA,CAAM,KAAK,CAAA,GAAI,GAAA,CAAI,KAAA,EAAM;AAAA,EACpE;AAEA,EAAA,IAAI;AACF,IAAA,OAAO,MAAM,UAAU,CAAA;AAAA,EACzB,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,IAAI,KAAA,EAAM;AAAA,EACnB;AACF;AAGA,IAAM,WAAA,GAAc,cAAA;AAGpB,IAAM,OAAA,GAAU,8BAAA;AAEhB,IAAM,iBAAA,GAA8C;AAAA,EAClD,IAAA,EAAM,KAAA;AAAA,EACN,SAAA,EAAW,WAAA;AAAA,EACX,YAAA,EAAc,WAAA;AAAA,EACd,gBAAA,EAAkB;AACpB,CAAA;AAgCO,SAAS,YAAA,CAAa,YAAoB,QAAA,EAA4B;AAC3E,EAAA,MAAM,MAAA,GAAS,gBAAgB,UAAU,CAAA;AACzC,EAAA,IAAI,SAAA,GAAY,EAAA;AAChB,EAAA,IAAI,UAAA,GAAa,CAAA;AAEjB,EAAA,KAAA,MAAW,GAAA,IAAO,WAAW,QAAA,CAAS,IAAI,OAAO,OAAA,EAAS,IAAI,CAAC,CAAA,EAAG;AAChE,IAAA,MAAM,KAAK,GAAA,CAAI,KAAA;AACf,IAAA,IAAI,CAAC,YAAA,CAAa,UAAA,EAAY,MAAA,EAAQ,EAAE,CAAA,EAAG;AAE3C,IAAA,MAAM,WAAA,GAAc,GAAA,CAAI,CAAC,CAAA,CAAE,aAAY,CAAE,UAAA,CAAW,GAAG,CAAA,GACnD,IAAI,iBAAA,CAAkB,QAAQ,CAAC,CAAA,CAAA,GAC/B,kBAAkB,QAAQ,CAAA;AAE9B,IAAA,SAAA,IAAa,UAAA,CAAW,KAAA,CAAM,UAAA,EAAY,EAAE,CAAA,GAAI,WAAA;AAChD,IAAA,UAAA,GAAa,EAAA,GAAK,GAAA,CAAI,CAAC,CAAA,CAAE,MAAA;AAAA,EAC3B;AAEA,EAAA,OAAO,SAAA,GAAY,UAAA,CAAW,KAAA,CAAM,UAAU,CAAA;AAChD;AAOA,SAAS,gBACP,UAAA,EAC2C;AAC3C,EAAA,MAAM,OAAiB,EAAC;AACxB,EAAA,MAAM,SAA2C,EAAC;AAElD,EAAA,KAAA,IAAS,CAAA,GAAI,CAAA,EAAG,CAAA,GAAI,UAAA,CAAW,QAAQ,CAAA,EAAA,EAAK;AAC1C,IAAA,IAAI,WAAW,CAAC,CAAA,KAAM,GAAA,EAAK,IAAA,CAAK,KAAK,CAAC,CAAA;AAAA,SAAA,IAC7B,UAAA,CAAW,CAAC,CAAA,KAAM,GAAA,EAAK;AAC9B,MAAA,MAAM,KAAA,GAAQ,KAAK,GAAA,EAAI;AACvB,MAAA,IAAI,KAAA,KAAU,QAAW,MAAA,CAAO,IAAA,CAAK,EAAE,KAAA,EAAO,GAAA,EAAK,CAAA,GAAI,CAAA,EAAG,CAAA;AAAA,IAC5D;AAAA,EACF;AAIA,EAAA,OAAO,MAAA,CAAO,IAAA,CAAK,CAAC,CAAA,EAAG,CAAA,KAAM,CAAA,CAAE,GAAA,GAAM,CAAA,CAAE,KAAA,IAAS,CAAA,CAAE,GAAA,GAAM,CAAA,CAAE,KAAA,CAAM,CAAA;AAClE;AAaA,SAAS,YAAA,CACP,UAAA,EACA,MAAA,EACA,EAAA,EACS;AACT,EAAA,IAAI,MAAA,GAAS,KAAA;AAEb,EAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,IAAA,IAAI,EAAA,GAAK,KAAA,CAAM,KAAA,IAAS,EAAA,IAAM,MAAM,GAAA,EAAK;AACzC,IAAA,MAAA,GAAS,IAAA;AACT,IAAA,MAAMC,MAAAA,GAAQ,YAAY,IAAA,CAAK,UAAA,CAAW,MAAM,KAAA,CAAM,KAAA,EAAO,KAAA,CAAM,GAAG,CAAC,CAAA;AACvE,IAAA,IAAIA,QAAO,OAAOA,MAAAA,CAAM,CAAC,CAAA,CAAE,aAAY,KAAM,IAAA;AAAA,EAC/C;AAEA,EAAA,IAAI,QAAQ,OAAO,KAAA;AAEnB,EAAA,MAAM,KAAA,GAAQ,WAAA,CAAY,IAAA,CAAK,UAAU,CAAA;AACzC,EAAA,OAAO,UAAU,IAAA,IAAQ,KAAA,CAAM,CAAC,CAAA,CAAE,aAAY,KAAM,IAAA;AACtD;;;ACvJO,IAAM,OAAA,GAAN,MAAM,QAAA,CAAmC;AAAA,EAK9C,WAAA,CAAY,MAAc,GAAA,EAAK;AAJ/B,IAAA,IAAA,CAAiB,MAAA,uBAAa,GAAA,EAAoB;AAClD;AAAA,IAAA,IAAA,CAAiB,SAAA,uBAAgB,GAAA,EAA+B;AAI9D,IAAA,IAAA,CAAK,GAAA,GAAM,MAAA,CAAO,QAAA,CAAS,GAAG,IAAI,GAAA,GAAM,GAAA;AAAA,EAC1C;AAAA;AAAA,EAGA,KAAA,GAAc;AACZ,IAAA,IAAA,CAAK,OAAO,KAAA,EAAM;AAClB,IAAA,IAAA,CAAK,UAAU,KAAA,EAAM;AACrB,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA,EAGA,IAAA,GAAe;AACb,IAAA,OAAO,KAAK,MAAA,CAAO,IAAA;AAAA,EACrB;AAAA;AAAA,EAGA,SAAS,KAAA,EAAmB;AAC1B,IAAA,KAAA,MAAW,GAAA,IAAO,KAAK,SAAA,CAAU,MAAA,IAAU,IAAI,GAAA,CAAI,KAAK,CAAA,EAAG,OAAO,IAAA;AAClE,IAAA,OAAO,KAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,GAAA,CAAI,KAAA,EAAU,GAAA,EAAU,MAAA,GAAS,CAAA,EAAS;AACxC,IAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,MAAM,CAAA,IAAK,MAAA,IAAU,GAAG,OAAO,IAAA;AAGpD,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,GAAA,EAAK;AAC1B,MAAA,MAAM,IAAI,GAAA,CAAI,CAAA;AACd,MAAA,IAAI,KAAK,CAAA,EAAG;AAEZ,MAAA,MAAM,MAAM,MAAA,GAAS,CAAA;AACrB,MAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,GAAG,CAAA,IAAK,OAAO,CAAA,EAAG;AAEvC,MAAA,IAAA,CAAK,MAAA,CAAO,IAAI,CAAA,EAAA,CAAI,IAAA,CAAK,OAAO,GAAA,CAAI,CAAC,CAAA,IAAK,CAAA,IAAK,GAAG,CAAA;AAClD,MAAA,MAAM,MAAM,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,CAAC,KAAM,EAAC;AACvC,MAAA,GAAA,CAAI,KAAK,CAAA,GAAA,CAAK,GAAA,CAAI,KAAK,KAAK,CAAA,IAAK,GAAA;AACjC,MAAA,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,CAAA,EAAG,GAAG,CAAA;AAAA,IAC3B;AAEA,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,QAAA,CAAS,MAAc,GAAA,EAAU;AAC/B,IAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,IAAA,CAAK,MAAA,CAAO,QAAQ,CAAA;AAC3C,IAAA,IAAI,EAAE,KAAA,GAAQ,CAAA,CAAA,EAAI,MAAM,IAAI,MAAM,0BAA0B,CAAA;AAE5D,IAAA,MAAM,SAAA,GAAY,KAAK,GAAA,GAAM,KAAA;AAC7B,IAAA,MAAM,IAAA,GAAO,CAAC,GAAG,IAAA,CAAK,MAAM,CAAA,CAAE,MAAA,CAAO,CAAC,GAAG,CAAC,CAAA,KAAM,CAAA,GAAI,CAAA,IAAK,KAAK,SAAS,CAAA;AACvE,IAAA,IAAI,IAAA,CAAK,WAAW,CAAA,EAAG;AACrB,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,wBAAA,EAA2B,IAAA,CAAK,GAAG,CAAA,sBAAA,CAAwB,CAAA;AAAA,IAC7E;AACA,IAAA,MAAM,YACJ,IAAA,CAAK,MAAA,KAAW,IAAA,CAAK,MAAA,CAAO,OAAO,KAAA,GAAQ,QAAA,CAAS,IAAA,CAAK,GAAA,CAAI,CAAC,GAAG,CAAC,CAAA,KAAM,CAAC,CAAC,CAAA;AAE5E,IAAA,MAAM,QAAA,uBAAe,GAAA,EAAiB;AACtC,IAAA,KAAA,MAAW,CAAC,CAAA,EAAG,CAAC,CAAA,IAAK,IAAA,EAAM;AACzB,MAAA,MAAM,QAAgC,EAAC;AACvC,MAAA,MAAM,MAAM,IAAA,CAAK,SAAA,CAAU,GAAA,CAAI,CAAC,KAAM,EAAC;AACvC,MAAA,KAAA,MAAW,SAAS,GAAA,EAAK,KAAA,CAAM,KAAK,CAAA,GAAI,GAAA,CAAI,KAAK,CAAA,GAAI,SAAA;AACrD,MAAA,QAAA,CAAS,IAAI,CAAA,EAAG,EAAE,GAAG,CAAA,GAAI,SAAA,EAAW,OAAO,CAAA;AAAA,IAC7C;AACA,IAAA,OAAO,IAAI,GAAA,CAAI,QAAA,EAAU,GAAG,CAAA;AAAA,EAC9B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,SAAA,GAA4B;AAE1B,IAAA,MAAM,MAAA,uBAAa,GAAA,EAAO;AAC1B,IAAA,KAAA,MAAW,GAAA,IAAO,IAAA,CAAK,SAAA,CAAU,MAAA,EAAO,EAAG;AACzC,MAAA,KAAA,MAAW,KAAK,MAAA,CAAO,IAAA,CAAK,GAAG,CAAA,EAAU,MAAA,CAAO,IAAI,CAAC,CAAA;AAAA,IACvD;AAEA,IAAA,MAAM,MAAM,EAAC;AACb,IAAA,KAAA,MAAW,SAAS,MAAA,EAAQ;AAC1B,MAAA,MAAM,UAAA,GAAa,QAAA;AAAA,QACjB,CAAC,GAAG,IAAA,CAAK,SAAA,CAAU,MAAA,EAAQ,CAAA,CAAE,GAAA,CAAI,CAAC,GAAA,KAAQ,GAAA,CAAI,KAAK,KAAK,CAAC;AAAA,OAC3D;AACA,MAAA,IAAI,EAAE,aAAa,CAAA,CAAA,EAAI;AACvB,MAAA,MAAM,CAAA,uBAAQ,GAAA,EAAoB;AAClC,MAAA,KAAA,MAAW,CAAC,CAAA,EAAG,GAAG,CAAA,IAAK,KAAK,SAAA,EAAW;AACrC,QAAA,MAAM,CAAA,GAAI,IAAI,KAAK,CAAA;AACnB,QAAA,IAAI,CAAA,EAAG,CAAA,CAAE,GAAA,CAAI,CAAA,EAAG,IAAI,UAAU,CAAA;AAAA,MAChC;AACA,MAAA,GAAA,CAAI,KAAK,CAAA,GAAI,GAAA,CAAI,OAAA,CAAQ,CAAA,EAAG,KAAK,GAAG,CAAA;AAAA,IACtC;AACA,IAAA,OAAO,GAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,OAAA,GAA6B;AAC3B,IAAA,MAAM,MAAM,EAAC;AACb,IAAA,KAAA,MAAW,GAAG,GAAG,CAAA,IAAK,KAAK,SAAA,EAAW;AACpC,MAAA,KAAA,MAAW,CAAC,GAAA,EAAK,CAAC,KAAK,MAAA,CAAO,OAAA,CAAQ,GAAG,CAAA,EAAoB;AAC3D,QAAA,IAAI,CAAC,MAAA,CAAO,QAAA,CAAS,CAAC,CAAA,IAAK,KAAK,CAAA,EAAG;AACnC,QAAA,GAAA,CAAI,GAAG,CAAA,GAAA,CAAK,GAAA,CAAI,GAAG,KAAK,CAAA,IAAK,CAAA;AAAA,MAC/B;AAAA,IACF;AACA,IAAA,MAAM,KAAA,GAAQ,QAAA,CAAS,MAAA,CAAO,MAAA,CAAO,GAAG,CAAa,CAAA;AACrD,IAAA,IAAI,QAAQ,CAAA,EAAG;AACb,MAAA,KAAA,MAAW,KAAK,GAAA,EAAK,GAAA,CAAI,CAAM,CAAA,GAAI,GAAA,CAAI,CAAM,CAAA,GAAI,KAAA;AAAA,IACnD;AACA,IAAA,OAAO,GAAA;AAAA,EACT;AAAA,EAEA,MAAA,GAIE;AACA,IAAA,OAAO;AAAA,MACL,QAAQ,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,MAAA,CAAO,SAAS,CAAA,CAAE,IAAA,CAAK,CAAC,GAAG,CAAA,KAAM,CAAA,CAAE,CAAC,CAAA,GAAI,CAAA,CAAE,CAAC,CAAC,CAAA;AAAA,MACpE,QAAQ,KAAA,CAAM,IAAA,CAAK,IAAA,CAAK,SAAA,CAAU,SAAS,CAAA,CAAE,IAAA,CAAK,CAAC,GAAG,CAAA,KAAM,CAAA,CAAE,CAAC,CAAA,GAAI,CAAA,CAAE,CAAC,CAAC,CAAA;AAAA,MACvE,KAAK,IAAA,CAAK;AAAA,KACZ;AAAA,EACF;AAAA,EAEA,OAAO,GAAA,CACL,KAAA,EACA,GAAA,GAAc,GAAA,EACT;AACL,IAAA,MAAM,GAAA,GAAM,IAAI,QAAA,CAAW,GAAG,CAAA;AAC9B,IAAA,KAAA,MAAW,CAAC,GAAA,EAAK,GAAA,EAAK,CAAC,CAAA,IAAK,OAAO,GAAA,CAAI,GAAA,CAAI,GAAA,EAAK,GAAA,EAAK,CAAC,CAAA;AACtD,IAAA,OAAO,GAAA,CAAI,SAAS,GAAG,CAAA;AAAA,EACzB;AACF;AAGA,SAAS,SAAS,MAAA,EAAkC;AAClD,EAAA,IAAI,GAAA,GAAM,CAAA;AACV,EAAA,IAAI,CAAA,GAAI,CAAA;AACR,EAAA,KAAA,MAAW,KAAK,MAAA,EAAQ;AACtB,IAAA,MAAM,IAAI,CAAA,GAAI,CAAA;AACd,IAAA,MAAM,IAAI,GAAA,GAAM,CAAA;AAChB,IAAA,CAAA,GAAI,IAAI,GAAA,GAAM,CAAA;AACd,IAAA,GAAA,GAAM,CAAA;AAAA,EACR;AACA,EAAA,OAAO,GAAA;AACT","file":"index.cjs","sourcesContent":["/**\n * Bounce odds — the \"birthday problem\" for bouncing damage dice (e.g. Chromatic\n * Orb): the probability that at least two of K dice with S faces show the same\n * value, which is what lets the spell jump to another target.\n *\n * Accounts for two modifiers:\n * - **Elemental Adept** (`minimumDieRoll >= 2`): rolls below the minimum are\n * bumped up to it, collapsing the low faces onto a single heavier value.\n * - **Empowered Spell** (`rerollDamageDice > 0`): up to that many dice may be\n * rerolled once, giving a second chance at a match.\n *\n * Every case is exact. With Empowered Spell, a roll that already matched stands;\n * otherwise the caster rerolls the dice — which ones and how many, up to the\n * limit — that maximise the chance of a match. The rerolled dice match when they\n * collide among themselves or with a kept die.\n */\n\n/** Options that modify bounce odds via metamagic / feats. */\nexport interface BounceOddsOptions {\n /** Minimum die roll — e.g. 2 for Elemental Adept, 3 for Great Weapon Fighting 2024. */\n minimumDieRoll?: number;\n /**\n * How many dice may be rerolled once — e.g. CHA modifier for Empowered Spell. \"Up to\":\n * the odds assume the best choice of which dice, and how many, to reroll.\n */\n rerollDamageDice?: number;\n}\n\n/**\n * Exact per-face probability marginal for a single die, honoring threshold `reroll(k)` and\n * `minimum(v)` — the SAME two transforms `resolveSingleDie` (`builder/ast.ts`) applies, in the\n * same order (reroll, then minimum-floor), so a caller building `weights` for\n * `jointSumAndMatch`/`explodingPoolMatchProbability` gets face weights consistent with the pool's\n * actual resolved PMF. Returns a 1-indexed array (`weights[v - 1] = P(shows v)`, `1 <= v <= faces`);\n * a face collapsed onto by `minimum` carries its collapsed neighbors' mass, and a face below\n * `minimum` carries zero.\n */\nexport function faceWeights(faces: number, minimum = 0, reroll = 0): number[] {\n const f = Math.max(0, Math.floor(faces));\n if (f <= 0) return [];\n\n let weights = new Array<number>(f).fill(1 / f);\n\n const r = Math.max(0, Math.min(Math.floor(reroll), f));\n if (r > 0) {\n const rerollMass = r / f;\n const uniformReroll = rerollMass / f;\n weights = weights.map((_, i) => (i < r ? 0 : 1 / f) + uniformReroll);\n }\n\n const minV = Math.max(0, Math.floor(minimum));\n if (minV > 1) {\n const collapsed = new Array<number>(f).fill(0);\n for (let v = 1; v <= f; v++) {\n const target = Math.min(f, Math.max(v, minV));\n collapsed[target - 1] += weights[v - 1];\n }\n weights = collapsed;\n }\n\n return weights;\n}\n\n/** Binomial coefficient C(n, k), 0 for out-of-range k. */\nfunction binom(n: number, k: number): number {\n if (k < 0 || k > n) return 0;\n let result = 1;\n for (let i = 0; i < k; i++) result = (result * (n - i)) / (i + 1);\n return result;\n}\n\n/**\n * Exact P(all K dice show distinct values) for a die with `uniformCount`\n * ordinary faces (each probability `1/faces`) plus one optional heavy face whose\n * probability is `heavyWeight` (used for the Elemental-Adept collapse; pass 0\n * for a plain die). Uses the elementary symmetric polynomial e_K over the face\n * probabilities: P(all distinct) = K! · e_K.\n */\nfunction pAllDistinct(\n dice: number,\n faces: number,\n uniformCount: number,\n heavyWeight: number\n): number {\n const light = 1 / faces;\n // e_K = (choose K distinct light faces) + (heavy face + K-1 light faces).\n const eK =\n binom(uniformCount, dice) * Math.pow(light, dice) +\n heavyWeight * binom(uniformCount, dice - 1) * Math.pow(light, dice - 1);\n let kFactorial = 1;\n for (let i = 2; i <= dice; i++) kFactorial *= i;\n return kFactorial * eK;\n}\n\n/** Exact P(at least one duplicate) among `dice` dice, honoring Elemental Adept. */\nfunction pMatch(dice: number, faces: number, minimumDieRoll: number): number {\n if (dice <= 1) return 0;\n if (dice > faces) return 1;\n\n if (minimumDieRoll >= 2) {\n // Rolls 1..minimumDieRoll collapse onto the value `minimumDieRoll`, giving it\n // weight minimumDieRoll/faces; the faces above it stay uniform at 1/faces.\n const uniformCount = faces - minimumDieRoll; // values minimumDieRoll+1 .. faces\n const effectiveValues = uniformCount + 1; // + the collapsed value\n if (dice > effectiveValues) return 1;\n const heavyWeight = minimumDieRoll / faces;\n const distinct = pAllDistinct(dice, faces, uniformCount, heavyWeight);\n return Math.min(1, Math.max(0, 1 - distinct));\n }\n\n // Plain die: P(all distinct) = falling_factorial(faces, dice) / faces^dice.\n let pDistinct = 1;\n for (let i = 0; i < dice; i++) pDistinct *= (faces - i) / faces;\n return 1 - pDistinct;\n}\n\n/**\n * P(at least two of `diceCount` dice with `dieFaces` faces match), honoring\n * Elemental Adept and Empowered Spell. Returns a probability in [0, 1].\n *\n * With `rerollDamageDice`, a roll that matched stands; otherwise up to that many\n * dice are rerolled once, choosing which and how many to maximise the chance of a\n * match (rerolling fewer can be better: a kept Elemental Adept face is a likely\n * target). The fresh dice match when they collide among themselves or with a kept die.\n *\n * @param diceCount Number of dice rolled.\n * @param dieFaces Faces per die (e.g. 8 for d8).\n * @param options Optional metamagic / feat modifiers.\n */\nexport function calculateBounceOdds(\n diceCount: number,\n dieFaces: number,\n options?: BounceOddsOptions\n): number {\n if (diceCount <= 1) return 0;\n if (diceCount > dieFaces) return 1; // pigeonhole\n\n const minimumDieRoll = options?.minimumDieRoll ?? 0;\n const rerollDamageDice = options?.rerollDamageDice ?? 0;\n\n const pMatchFirst = pMatch(diceCount, dieFaces, minimumDieRoll);\n\n // Without Empowered Spell we're done.\n const rerollLimit = Math.min(Math.floor(rerollDamageDice), diceCount);\n if (rerollLimit <= 0 || pMatchFirst >= 1) return pMatchFirst;\n\n // A roll with no match shows distinct faces. Elemental Adept gives the die two kinds of\n // face: the collapsed minimum (the heavy face, weight minimumDieRoll/dieFaces) and the\n // `lightCount` faces above it (1/dieFaces each); a plain die has only light faces. After\n // rerolling k dice, no match means the k fresh dice are distinct and avoid every kept\n // face: k!·e_k over the faces not kept, which `pAllDistinct` computes.\n const collapsed = minimumDieRoll >= 2;\n const lightCount = collapsed ? dieFaces - minimumDieRoll : dieFaces;\n const heavyWeight = collapsed ? minimumDieRoll / dieFaces : 0;\n const pMissAfter = (rerolled: number, keptLight: number, heavyKept: boolean): number =>\n pAllDistinct(rerolled, dieFaces, lightCount - keptLight, heavyKept ? 0 : heavyWeight);\n\n // The best reroll for each kind of first roll. Without the heavy face every kept face is\n // light; with it, the caster either keeps it or rerolls it along with k − 1 light dice.\n let missLightOnly = 1;\n let missWithHeavy = 1;\n for (let rerolled = 1; rerolled <= rerollLimit; rerolled++) {\n const allLightKept = pMissAfter(rerolled, diceCount - rerolled, false);\n missLightOnly = Math.min(missLightOnly, allLightKept);\n missWithHeavy = Math.min(missWithHeavy, allLightKept);\n if (rerolled < diceCount) {\n missWithHeavy = Math.min(missWithHeavy, pMissAfter(rerolled, diceCount - 1 - rerolled, true));\n }\n }\n\n // P(distinct, light faces only) = n!·C(L, n)·l^n; P(distinct, one heavy) = n·H·(n−1)!·C(L, n−1)·l^(n−1).\n const pLightOnly = pAllDistinct(diceCount, dieFaces, lightCount, 0);\n const pWithHeavy = diceCount * heavyWeight * pAllDistinct(diceCount - 1, dieFaces, lightCount, 0);\n\n return Math.min(\n 1,\n pMatchFirst + pLightOnly * (1 - missLightOnly) + pWithHeavy * (1 - missWithHeavy)\n );\n}\n\n/**\n * Exact joint P(sum ∧ match), K = 2 hardcoded (per design: every shipped 5e bounce mechanic is\n * \"two or more\" — see `CHROMATIC_ORB.md`). `K > 2` (a face with multiplicity ≥ K) is a harder\n * combinatorial problem with no consumer; a `match` parameter whose only legal value is 2 would\n * advertise a generality this DP does not have, so it is not offered.\n *\n * `weights` is the resolved single-die marginal's per-face probabilities, 1-indexed\n * (`weights[v - 1] = P(one die shows v)`) — NOT assumed uniform, so `minimum`/threshold `reroll`\n * (which collapse or reweight faces) compose correctly. Dice are i.i.d. and homogeneous (same\n * `weights` for all of them): a mixed-face-size pool (e.g. 2d6 + 1d4) is a genuinely different,\n * harder problem (dice are no longer exchangeable) with no consumer here.\n */\n\n/** Exact P(sum = s) for `dice` i.i.d. dice sharing `weights`, as a sum -> mass map. */\nexport function diceSumDistribution(dice: number, weights: readonly number[]): Map<number, number> {\n let dist = new Map<number, number>([[0, 1]]);\n for (let die = 0; die < dice; die++) {\n const next = new Map<number, number>();\n for (const [sum, mass] of dist) {\n for (let face = 1; face <= weights.length; face++) {\n const w = weights[face - 1] ?? 0;\n if (w <= 0) continue;\n const s = sum + face;\n next.set(s, (next.get(s) ?? 0) + mass * w);\n }\n }\n dist = next;\n }\n return dist;\n}\n\n/**\n * Exact P(sum = s ∧ all `dice` values distinct), via the elementary-symmetric DP over faces:\n * `dp[c+1][s+f] += dp[c][s] · w_f`, each face used at most once (0/1 knapsack over faces, tracking\n * both count and sum). `P(sum = s ∧ all distinct) = dice! · dp[dice][s]` — `dp[dice][s]` sums over\n * unordered subsets of `dice` distinct faces; multiplying by `dice!` accounts for every way to\n * assign that subset to the `dice` labeled dice.\n */\nfunction sumAllDistinctDistribution(dice: number, weights: readonly number[]): Map<number, number> {\n const faceCount = weights.length;\n let dp = new Map<number, Map<number, number>>([[0, new Map([[0, 1]])]]);\n\n for (let face = 1; face <= faceCount; face++) {\n const w = weights[face - 1] ?? 0;\n const next = new Map<number, Map<number, number>>();\n for (const [count, sumMap] of dp) next.set(count, new Map(sumMap));\n\n if (w > 0) {\n for (const [count, sumMap] of dp) {\n const nextCount = count + 1;\n if (nextCount > dice) continue;\n const target = next.get(nextCount) ?? new Map<number, number>();\n for (const [sum, mass] of sumMap) {\n const s = sum + face;\n target.set(s, (target.get(s) ?? 0) + mass * w);\n }\n next.set(nextCount, target);\n }\n }\n dp = next;\n }\n\n let factorial = 1;\n for (let i = 2; i <= dice; i++) factorial *= i;\n\n const chosen = dp.get(dice) ?? new Map<number, number>();\n const result = new Map<number, number>();\n for (const [sum, mass] of chosen) result.set(sum, mass * factorial);\n return result;\n}\n\n/**\n * Exact joint P(sum = s ∧ match) for `dice` i.i.d. dice sharing `weights`\n * (`P(sum ∧ match) = P(sum) − P(sum ∧ all distinct)`). Returns a sum -> mass map; sums with zero\n * match mass are omitted. `dice <= 1` returns an empty map (no match possible).\n */\nexport function jointSumAndMatch(dice: number, weights: readonly number[]): Map<number, number> {\n if (dice <= 1) return new Map();\n\n const total = diceSumDistribution(dice, weights);\n const distinct = sumAllDistinctDistribution(dice, weights);\n\n // A sum carries match mass only if a roll with a repeated face reaches it: twice one face\n // plus any `dice − 2` faces. At every other sum the difference below is exactly 0, and\n // float residue must not turn it into a bin.\n const rest = diceSumDistribution(dice - 2, weights);\n const matchable = new Set<number>();\n weights.forEach((weight, index) => {\n if (weight <= 0) return;\n for (const sum of rest.keys()) matchable.add(2 * (index + 1) + sum);\n });\n\n const result = new Map<number, number>();\n for (const [sum, mass] of total) {\n if (!matchable.has(sum)) continue;\n const matchMass = Math.max(0, mass - (distinct.get(sum) ?? 0));\n if (matchMass > 0) result.set(sum, matchMass);\n }\n return result;\n}\n\n/**\n * The joint distribution over `(m, k)` — `m` dice landing on the pool's max face, `k` on anything\n * else — realized by the SAME `(pending, budget)` walk as the pool-wide exploding-dice DP\n * (`resolveExplodingPool` in `builder/ast.ts`): one traversal serves both the sum (there) and this\n * match composition (here), rather than each needing its own. `pMax` is the max face's probability\n * under the single die's resolved marginal.\n */\nfunction explodingPoolMkDistribution(\n pMax: number,\n count: number,\n budget: number\n): Map<string, number> {\n const binomial = (n: number, p: number): number[] => {\n const result = new Array<number>(n + 1).fill(0);\n result[0] = 1;\n for (let trial = 0; trial < n; trial++) {\n const next = new Array<number>(n + 1).fill(0);\n for (let successes = 0; successes <= trial; successes++) {\n const mass = result[successes];\n if (mass <= 0) continue;\n next[successes] += mass * (1 - p);\n next[successes + 1] += mass * p;\n }\n for (let i = 0; i <= n; i++) result[i] = next[i];\n }\n return result;\n };\n\n const memo = new Map<string, Map<string, number>>();\n const f = (pending: number, remainingBudget: number): Map<string, number> => {\n if (pending === 0) return new Map([[\"0,0\", 1]]);\n if (remainingBudget === 0) {\n const binom = binomial(pending, pMax);\n const result = new Map<string, number>();\n for (let m = 0; m <= pending; m++) {\n const mass = binom[m];\n if (mass > 0) result.set(`${m},${pending - m}`, mass);\n }\n return result;\n }\n\n const key = `${pending},${remainingBudget}`;\n const cached = memo.get(key);\n if (cached) return cached;\n\n const result = new Map<string, number>();\n const accumulate = (mk: string, mass: number): void => {\n result.set(mk, (result.get(mk) ?? 0) + mass);\n };\n\n for (const [mk, mass] of f(pending, remainingBudget - 1)) {\n const [m, k] = mk.split(\",\").map(Number);\n accumulate(`${m + 1},${k}`, mass * pMax);\n }\n for (const [mk, mass] of f(pending - 1, remainingBudget)) {\n const [m, k] = mk.split(\",\").map(Number);\n accumulate(`${m},${k + 1}`, mass * (1 - pMax));\n }\n\n memo.set(key, result);\n return result;\n };\n\n return f(count, budget);\n}\n\n/** Exact P(`count` i.i.d. dice with face probabilities `weights` all differ): `count! · e_count(weights)`. */\nfunction allDistinctProbability(count: number, weights: readonly number[]): number {\n const symmetric = new Array<number>(count + 1).fill(0);\n symmetric[0] = 1;\n for (const weight of weights) {\n if (weight <= 0) continue;\n for (let chosen = count; chosen >= 1; chosen--) symmetric[chosen] += symmetric[chosen - 1] * weight;\n }\n let factorial = 1;\n for (let i = 2; i <= count; i++) factorial *= i;\n return factorial * symmetric[count];\n}\n\n/**\n * P(match) for a pool sharing ONE pool-wide exploding-dice budget (see\n * `RollBuilder.explodePool()`). The plain `jointSumAndMatch`/`calculateBounceOdds` formulas assume\n * `dice` i.i.d. dice — false for an exploded pool, since conditioning on a realized size already\n * reveals some die rolled max. Exploiting that max is the only exploding face: condition on `m`\n * (dice showing max, the exploded ones included) and `k` (dice showing anything else) —\n *\n * `m ≥ 2` → match is certain (two dice already share the max face).\n * `m ≤ 1` → match iff the `k` non-max dice collide among themselves. Each shows face `v` with\n * the conditional weight `w_v / (1 − pMax)`, and they cannot collide with the max face,\n * so the two parts separate.\n *\n * So a single die can match its own explosion: a lone d8 with budget ≥ 1 matches when it rolls\n * 8 and then 8 again (1/64).\n *\n * `weights` is the single (non-exploding-budget) die's resolved marginal, 1-indexed with the\n * max face last, as {@link faceWeights} returns it.\n */\nexport function explodingPoolMatchProbability(\n weights: readonly number[],\n count: number,\n budget: number\n): number {\n if (count <= 0 || weights.length === 0) return 0;\n\n const pMax = weights[weights.length - 1];\n const nonMax = pMax < 1 ? weights.slice(0, -1).map((weight) => weight / (1 - pMax)) : [];\n\n let pMatchTotal = 0;\n for (const [mk, weight] of explodingPoolMkDistribution(pMax, count, budget)) {\n const [m, k] = mk.split(\",\").map(Number);\n if (m >= 2) pMatchTotal += weight;\n // Fewer than two non-max dice cannot collide: skip the sum that is 1 only up to rounding.\n else if (k >= 2) pMatchTotal += weight * (1 - allDistinctProbability(k, nonMax));\n }\n return Math.min(1, Math.max(0, pMatchTotal));\n}\n","/**\n * Error thrown when a dice expression cannot be parsed.\n *\n * Extends the built-in {@link Error}, so existing `catch (e)` / message checks\n * continue to work, while callers can now narrow with `instanceof DiceParseError`.\n *\n * @example\n * try {\n * parse(\"d6@3\");\n * } catch (e) {\n * if (e instanceof DiceParseError) {\n * // e.expression === \"d6@3\"\n * }\n * }\n */\nexport class DiceParseError extends Error {\n /** The original expression that failed to parse, when available. */\n readonly expression?: string;\n\n /** The underlying error that triggered this one, when available. */\n readonly cause?: unknown;\n\n constructor(\n message: string,\n options?: { expression?: string; cause?: unknown }\n ) {\n super(message);\n this.name = \"DiceParseError\";\n this.expression = options?.expression;\n this.cause = options?.cause;\n // Restore the prototype chain for reliable `instanceof` across targets.\n Object.setPrototypeOf(this, DiceParseError.prototype);\n }\n}\n","/**\n * Simple LRU cache implementation\n */\n\nlet cachingEnabled = true;\n\n/**\n * Bumped each time caching is turned off. A cache created with `followsCachingToggle` empties\n * itself the next time it is touched after a bump, so no registry holds the caches alive.\n */\nlet cacheGeneration = 0;\n\n/**\n * Enable or disable the library's internal caches: the parse cache, the PMF convolution/power\n * cache, and the builder, die, roll, attack, save and check caches. While disabled those caches\n * store nothing and every lookup misses, and disabling empties them. Caches you construct\n * yourself are unaffected unless created with `followsCachingToggle`.\n */\nexport function setCachingEnabled(enabled: boolean): void {\n cachingEnabled = enabled;\n if (!enabled) cacheGeneration++;\n}\n\n/** Returns whether the library's internal caches are currently enabled. */\nexport function getCachingEnabled(): boolean {\n return cachingEnabled;\n}\n\nexport interface LRUCacheOptions<V> {\n /** Called with every value as it is stored, e.g. to freeze a shared result. */\n onInsert?: (value: V) => void;\n /**\n * Store and return nothing while {@link setCachingEnabled} has turned caching off, and empty\n * this cache when it does.\n */\n followsCachingToggle?: boolean;\n}\n\nexport class LRUCache<K, V> {\n private cache = new Map<K, V>();\n private readonly onInsert?: (value: V) => void;\n private readonly followsCachingToggle: boolean;\n private generation = cacheGeneration;\n\n /**\n * @param maxSize Entries kept before the least recently used is evicted. A capacity of 0 or\n * less (or NaN) makes the cache store nothing.\n */\n constructor(\n private readonly maxSize = 1000,\n options: LRUCacheOptions<V> = {}\n ) {\n this.onInsert = options.onInsert;\n this.followsCachingToggle = options.followsCachingToggle ?? false;\n }\n\n /** Drops the entries of a toggle-following cache when caching was turned off since last use. */\n private sync(): void {\n if (this.followsCachingToggle && this.generation !== cacheGeneration) {\n this.cache.clear();\n this.generation = cacheGeneration;\n }\n }\n\n private get storing(): boolean {\n this.sync();\n return this.maxSize > 0 && (cachingEnabled || !this.followsCachingToggle);\n }\n\n get(key: K): V | undefined {\n if (!this.storing) return undefined;\n const value = this.cache.get(key);\n if (value === undefined) return undefined;\n\n this.cache.delete(key);\n this.cache.set(key, value);\n return value;\n }\n\n delete(key: K): void {\n this.cache.delete(key);\n }\n\n set(key: K, value: V): this {\n if (!this.storing) return this;\n this.onInsert?.(value);\n this.cache.delete(key);\n if (this.cache.size >= this.maxSize) {\n const oldestKey = this.cache.keys().next().value;\n this.cache.delete(oldestKey as K);\n }\n this.cache.set(key, value);\n return this;\n }\n\n clear(): void {\n this.cache.clear();\n }\n\n get size(): number {\n this.sync();\n return this.cache.size;\n }\n\n has(key: K): boolean {\n return this.storing && this.cache.has(key);\n }\n\n keys(): IterableIterator<K> {\n this.sync();\n return this.cache.keys();\n }\n\n values(): IterableIterator<V> {\n this.sync();\n return this.cache.values();\n }\n}\n","/** Mapping from outcome label to probability mass or damage attribution. */\nexport type OutcomeLabelMap = Partial<Record<string, number>>;\n\n/** Computational epsilon for pruning negligible probabilities. */\nexport const EPS = 1e-12;\n\n/** A probability bin for a specific damage value. */\nexport interface Bin {\n /** Total probability mass at this damage value. */\n p: number;\n /** Per-outcome probability mass contributions at this damage. */\n count: OutcomeLabelMap;\n /** Optional per-outcome damage attribution at this damage. */\n attr?: OutcomeLabelMap;\n}\n\n/**\n * One homogeneous die-type's resolved shape within a damage pool — count of dice, faces per die,\n * and the per-die `minimum`/threshold-`reroll` that shape its resolved marginal (see\n * `RollBuilder.getSubRollConfigs()`). The raw material for `dice-match` trigger slicing.\n */\nexport interface DicePoolDescriptor {\n readonly count: number;\n readonly faces: number;\n readonly minimum: number;\n readonly reroll: number;\n}\n\n/**\n * Exact P(match | this branch's own final damage value = d) for a resolved hit/crit branch,\n * keyed by the SAME damage values the branch's PMF uses (post flat `modifier`, post crit\n * doubling) — so a consumer splits a PMF bin-by-bin with no sum/modifier bookkeeping of its own.\n */\nexport interface DiceMatchInfo {\n readonly matchProbabilityByDamage: ReadonlyMap<number, number>;\n}\n\n/**\n * Optional capability of a `dice-match`-eligible damage source (implemented by `AttackBuilder`):\n * exposes the exact per-branch match-probability breakdown needed to slice its hit/crit PMF into\n * matched / did-not-match halves. Absence (a bare `PMF`, a plain non-attack `RollBuilder`, or a\n * `null` branch — `noCrit()`, a parsed/pooled/`keep` source) is a defined \"no match slice\n * available\" state, not a crash: naming such a source in a `dice-match` trigger is a\n * `TurnSpecError`, not a silent zero.\n */\nexport interface HasDiceMatchInfo {\n diceMatchInfo(eps?: number): { hit: DiceMatchInfo | null; crit: DiceMatchInfo | null };\n}\n\nexport interface CritConfig {\n critThreshold: number;\n}\n\n/** Simple mapping from damage value to probability. */\nexport type DamageDistribution = Record<number, number>;\n/** Canonical outcome labels supported by the query helpers. */\nexport type OutcomeType =\n | \"crit\"\n | \"hit\"\n | \"missNone\"\n | \"missDamage\"\n | \"saveHalf\"\n | \"saveFail\"\n | \"pc\";\n\nexport type Rounding = \"none\" | \"floor\" | \"round\" | \"ceil\";\n\n/** How a d20 attack roll resolves: single die, keep-highest of 2/3, or keep-lowest of 2. */\nexport type RollType = \"flat\" | \"advantage\" | \"disadvantage\" | \"elven accuracy\";\n\n/**\n * P(critical hit) for the given crit window and d20 {@link RollType}.\n *\n * `critRange` is the number of top faces that crit (1 for a natural 20, 2 for\n * 19–20, …), so a single die crits with probability `critRange / 20`. Advantage\n * rolls two d20s / elven accuracy three, keeping the best; disadvantage keeps\n * the worst of two.\n */\nexport function critProbability(critRange: number, rollType: RollType = \"flat\"): number {\n const base = critRange / 20;\n switch (rollType) {\n case \"advantage\":\n return 1 - (1 - base) ** 2;\n case \"elven accuracy\":\n return 1 - (1 - base) ** 3;\n case \"disadvantage\":\n return base ** 2;\n case \"flat\":\n default:\n return base;\n }\n}\n\n/**\n * The canonical \"clean miss\" outcome — a point of zero damage with no rider.\n * This is the {@link OutcomeType} that attribution charts and outcome stats key\n * on, and is distinct from the builder's attack-resolution `miss` weight label.\n */\nexport const MISS_NONE_OUTCOME: OutcomeType = \"missNone\";\n\n/**\n * All outcome types in canonical severity order — clean miss → crit. This is\n * also the natural stacking order for attribution charts (least- to\n * most-impactful, bottom → top). Enumerates every {@link OutcomeType} exactly\n * once; use it instead of hand-maintained per-consumer outcome tables.\n */\nexport const ALL_OUTCOME_TYPES: OutcomeType[] = [\n \"missNone\",\n \"missDamage\",\n \"saveFail\",\n \"saveHalf\",\n \"pc\",\n \"hit\",\n \"crit\",\n];\n\n/**\n * Outcome types in display order for stats / breakdown rows — most prominent\n * first (crit, hit, …) down to the clean miss.\n */\nexport const OUTCOME_DISPLAY_ORDER: OutcomeType[] = [\n \"crit\",\n \"hit\",\n \"missDamage\",\n \"saveHalf\",\n \"saveFail\",\n \"pc\",\n \"missNone\",\n];\n\n/**\n * Sort outcome labels by a canonical order (defaults to {@link ALL_OUTCOME_TYPES}).\n * Labels not present in `order` sort after known ones, alphabetically — so\n * ad-hoc/test labels outside the {@link OutcomeType} union stay stable.\n */\nexport function sortOutcomes<T extends string>(\n outcomes: Iterable<T>,\n order: readonly string[] = ALL_OUTCOME_TYPES\n): T[] {\n const rank = new Map(order.map((o, i) => [o, i]));\n return [...outcomes].sort((a, b) => {\n const ra = rank.get(a);\n const rb = rank.get(b);\n if (ra !== undefined && rb !== undefined) return ra - rb;\n if (ra !== undefined) return -1;\n if (rb !== undefined) return 1;\n return a.localeCompare(b);\n });\n}\n\nexport const onAnyHit: OutcomeType[] = [\"hit\", \"crit\"];\nexport const onCritOnly: OutcomeType[] = [\"crit\"];\nexport const onHitOnly: OutcomeType[] = [\"hit\"];\nexport const onMissOnly: OutcomeType[] = [\"missNone\", \"missDamage\"];\nexport const onMissDamageOnly: OutcomeType[] = [\"missDamage\"];\nexport const onSaveHalfOnly: OutcomeType[] = [\"saveHalf\"];\nexport const onSaveFailOnly: OutcomeType[] = [\"saveFail\"];\nexport const onPotentCantripOnly: OutcomeType[] = [\"pc\"];\n","import type { OutcomeType } from \"../common/types\";\nimport { ALL_OUTCOME_TYPES, EPS } from \"../common/types\";\nimport { PMF } from \"./pmf\";\nimport type { DamageAttributionChartModel } from \"./pmf\";\n\n/**\n * Query interface for analyzing dice roll probability distributions.\n *\n * Combines multiple attack PMFs and provides statistical analysis methods for:\n * - Basic statistics (mean, variance, min/max, percentiles)\n * - Probability queries (hit chances, success rates, exact counts)\n * - Damage analysis (ranges by outcome type, expected values)\n * - Data export (charts, tables, visualizations)\n *\n */\n\nexport class DiceQuery {\n public readonly singles: PMF[];\n private readonly _eps: number;\n private readonly _combinedProvided: boolean;\n private _combined?: PMF;\n private _combinedWithAttr?: PMF;\n\n constructor(singles: PMF | PMF[], combined?: PMF, eps = EPS) {\n this.singles = Array.isArray(singles) ? singles : [singles];\n if (this.singles.some((s) => s === undefined)) {\n throw new Error(\"DiceQuery contains undefined singles\");\n }\n this._eps = eps;\n // When the caller supplies an explicit combined distribution that may not\n // equal convolve(singles), the additive closed-form moments would describe\n // a different distribution than cdf/percentiles. Track this so mean()/\n // variance() can fall back to the provided combined and stay consistent.\n this._combinedProvided = combined !== undefined;\n if (combined !== undefined) {\n this._combined =\n Math.abs(combined.mass() - 1) <= eps ? combined : combined.normalize();\n }\n }\n\n /**\n * The combined damage distribution of all single PMFs (their convolution),\n * normalized to total probability 1.\n *\n * Computed lazily on first access and cached. Queries that only need\n * additive statistics — {@link DiceQuery.mean}, {@link DiceQuery.variance},\n * {@link DiceQuery.stddev} — never trigger this convolution.\n */\n get combined(): PMF {\n if (this._combined === undefined) {\n const c = PMF.convolveMany(this.singles);\n this._combined =\n Math.abs(c.mass() - 1) <= this._eps ? c : c.normalize();\n }\n return this._combined;\n }\n\n private static readonly DEFAULT_OUTCOMES: readonly OutcomeType[] = [\n \"hit\",\n \"crit\",\n \"missNone\",\n ] as const;\n\n /**\n * Returns a new PMF with damage attribution metadata populated.\n *\n * This method computes attribution on-demand for builder-generated PMFs,\n * enabling them to work with damage attribution charts. The `attr` field\n * tracks how much damage each outcome type contributes at each damage value.\n *\n * For each bin at damage D: sum(attr.values()) ≈ D × P(damage = D)\n *\n * Performance: Cached after first call. Adds minimal overhead vs `combined`.\n *\n * @returns PMF with attr field populated for damage attribution charts\n *\n * @example\n * const attack = d20.plus(5).ac(15).onHit(d(2,6).plus(3)).onCrit(d(2,6))\n * const query = attack.toQuery()\n * const pmf = query.combinedWithAttribution()\n * // Now pmf can be used with attributionByValue() / damageAttributionChartModel()\n */\n combinedWithAttribution(): PMF {\n if (this._combinedWithAttr) {\n return this._combinedWithAttr;\n }\n\n // An explicitly provided `combined` is NOT the convolution of `singles` —\n // a Turn's exact joint distribution, for instance, is narrower than the\n // independent product because riders correlate with their sources.\n // Re-convolving would silently discard it (and drop the riders' damage\n // entirely), so attribute the provided distribution itself.\n if (this._combinedProvided) {\n this._combinedWithAttr = this.combined.withAttribution();\n return this._combinedWithAttr;\n }\n\n // Fast path: if every single already carries attribution (as parser-\n // generated PMFs do), the attributed convolution is bit-for-bit identical\n // to `combined` — reuse it instead of convolving a second time.\n if (this.singles.every((pmf) => pmf.hasAttribution())) {\n this._combinedWithAttr = this.combined;\n return this._combinedWithAttr;\n }\n\n // Otherwise (e.g. builder-generated PMFs that only carry `count`), add\n // attribution to each single PMF, then convolve.\n const singlesWithAttr = this.singles.map((pmf) => pmf.withAttribution());\n const combined = PMF.convolveMany(singlesWithAttr, this.combined.epsilon);\n\n // Normalize if needed\n const normalized =\n Math.abs(combined.mass() - 1) <= this.combined.epsilon\n ? combined\n : combined.normalize();\n\n this._combinedWithAttr = normalized;\n return normalized;\n }\n\n /**\n * Per-label `damage value → probability mass` series for the combined,\n * attribution-carrying distribution — the provenance core of the stacked\n * damage-attribution chart. Convenience for\n * `combinedWithAttribution().attributionByValue()`; see\n * {@link PMF.attributionByValue}.\n */\n attributionByValue(): Map<string, Map<number, number>> {\n return this.combinedWithAttribution().attributionByValue();\n }\n\n /**\n * Full numeric model for the stacked damage-attribution chart. Convenience for\n * `combinedWithAttribution().damageAttributionChartModel(options)`; see\n * {@link PMF.damageAttributionChartModel}.\n */\n damageAttributionChartModel(options?: {\n maxBuckets?: number;\n stackOrder?: readonly string[];\n epsilon?: number;\n }): DamageAttributionChartModel {\n return this.combinedWithAttribution().damageAttributionChartModel(options);\n }\n\n /**\n * How many of the independent single PMFs can produce the given outcome\n * label. Useful for \"all of them succeeded\" style probabilities where the\n * exponent is the number of contributing attacks (see\n * {@link DiceQuery.probExactlyK}).\n */\n countSinglesWith(label: string): number {\n let count = 0;\n for (const single of this.singles) {\n if (single.hasOutcome(label)) count++;\n }\n return count;\n }\n\n /**\n * Returns the expected damage across all possible outcomes.\n *\n * Example: `query.mean()` → 12.5\n * Use case: \"What's my average damage per round?\"\n */\n mean(): number {\n // If the caller supplied a combined distribution that may diverge from\n // convolve(singles), report its mean so mean() stays consistent with\n // cdf/percentiles/min/max (which all read `combined`).\n if (this._combinedProvided) {\n let m = 0;\n for (const [damageValue, bin] of this.combined) m += damageValue * bin.p;\n return m;\n }\n // Expectation is additive over independent attacks: E[Σ Xᵢ] = Σ E[Xᵢ].\n // Computing it directly from the singles avoids building `combined`.\n let totalMean = 0;\n for (const single of this.singles) {\n const mass = single.mass();\n if (mass <= 0) continue;\n // Match `combined`'s semantics: only divide by mass when it is not\n // already 1 (within eps), so an already-normalized single is bit-exact.\n totalMean +=\n Math.abs(mass - 1) <= this._eps ? single.mean() : single.mean() / mass;\n }\n return totalMean;\n }\n\n /**\n * Returns the variance of the damage distribution.\n *\n * Example: `query.variance()` → 45.2\n * Use case: \"How much does my damage vary from the average?\"\n * High variance means higher risk/reward. Lower variance means more consistent damage.\n */\n variance(): number {\n // Consistent with mean(): if a (possibly divergent) combined was provided,\n // compute the variance of that distribution directly.\n if (this._combinedProvided) {\n const mu = this.mean();\n let v = 0;\n for (const [damageValue, bin] of this.combined) {\n const dev = damageValue - mu;\n v += dev * dev * bin.p;\n }\n return v;\n }\n // Variance is additive over independent attacks: Var[Σ Xᵢ] = Σ Var[Xᵢ].\n // Use the centered form per single (E[(X−μ)²]) rather than E[X²]−μ², which\n // suffers catastrophic cancellation when damage has a large constant offset.\n let totalVariance = 0;\n for (const single of this.singles) {\n const mass = single.mass();\n if (mass <= 0) continue;\n if (Math.abs(mass - 1) <= this._eps) {\n // PMF.variance() is the centered, cached, mass-1 variance.\n totalVariance += single.variance();\n } else {\n // Normalized centered variance of a non-unit-mass single.\n let mu = 0;\n for (const [d, b] of single) mu += d * (b.p / mass);\n let v = 0;\n for (const [d, b] of single) {\n const dev = d - mu;\n v += dev * dev * (b.p / mass);\n }\n totalVariance += v;\n }\n }\n return totalVariance;\n }\n\n /**\n * Returns the standard deviation of the damage distribution.\n *\n * Example: `query.stdev()` → 6.7\n * Use case: \"What's the typical spread around my average damage?\"\n * Used to determine how consistent the damage is.\n */\n stddev(): number {\n return Math.sqrt(this.variance());\n }\n\n /** Alias of {@link DiceQuery.stddev}, matching {@link PMF.stdev}. */\n stdev(): number {\n return this.stddev();\n }\n\n /**\n * Returns the Cumulative Distribution Function.\n */\n cdf(x: number): number {\n return this.probTotalAtMost(x);\n }\n\n /**\n * Returns the probability of dealing X damage or less.\n * In statistics, this is called the cumulative distribution function (CDF).\n * Example: `query.cdf(20)` → 0.75\n * Use case: \"What's the chance I deal 20 damage or less?\"\n */\n probTotalAtMost(x: number): number {\n let cumulativeProbability = 0;\n for (const [damageValue, probabilityBin] of this.combined) {\n if (damageValue <= x) {\n cumulativeProbability += probabilityBin.p;\n }\n }\n return cumulativeProbability;\n }\n\n /**\n * Returns the Complementary Cumulative Distribution Function.\n */\n ccdf(x: number): number {\n return this.probTotalAtLeast(x);\n }\n\n /**\n * Returns the probability of dealing at least X damage.\n *\n * Example: `query.probTotalAtLeast(25)` → 0.35\n * Use case: \"What's the chance I deal at least 25 damage to finish the enemy?\"\n */\n probTotalAtLeast(threshold: number): number {\n let probabilitySum = 0;\n for (const [damageValue, probabilityBin] of this.combined) {\n if (damageValue >= threshold) {\n probabilitySum += probabilityBin.p;\n }\n }\n return probabilitySum;\n }\n\n /**\n * Returns damage values at specific percentiles: for each p, the smallest damage x with\n * P(total ≤ x) ≥ p, exact at CDF boundaries (see {@link PMF.quantile}).\n *\n * Example: `query.percentiles([0.25, 0.5, 0.75])` → [8, 12, 18]\n * Use case: \"What are my 25th, 50th, and 75th percentile damage values?\"\n */\n percentiles(percentileValues: number[]): number[] {\n return percentileValues.map((p) => this.combined.quantile(p));\n }\n\n /**\n * Returns the minimum possible damage.\n *\n * Example: `query.min()` → 0\n * Use case: \"What's the worst-case damage if everything misses?\"\n */\n min(): number {\n return this.combined.min();\n }\n\n /**\n * Returns the maximum possible damage.\n *\n * Example: `query.max()` → 56\n * Use case: \"What's the best-case damage if everything crits and rolls max?\"\n */\n max(): number {\n return this.combined.max();\n }\n\n private singleProb(diceIndex: number, label: OutcomeType): number {\n const single = this.singles[diceIndex];\n let probabilitySum = 0;\n for (const [, probabilityBin] of single) {\n probabilitySum += probabilityBin.count[label] || 0;\n }\n // Return the conditional per-event probability. Dividing by the single's\n // mass keeps the result in [0,1] for a non-normalized single (e.g. one that\n // has been scaled), so probAtLeastOne / the binomial DP stay mass-invariant.\n const mass = single.mass();\n return mass > 0 ? probabilitySum / mass : 0;\n }\n\n /**\n * Full count distribution [P(0), P(1), …, P(n)] for \"an attack succeeds if it\n * carries ANY of `labels`\", over the n independent singles.\n *\n * Each single's per-event success probability is the Poisson-binomial\n * marginal P(≥1 of labels) from {@link probabilityOf} (i.e. probAtLeastOne),\n * computed exactly once. The binomial DP then runs once to produce the whole\n * distribution, so the array-label paths of probExactlyK / probAtLeastK /\n * probAtMostK can slice or sum from it instead of rebuilding a DiceQuery and\n * re-running the DP per requested k.\n */\n private countDistribution(labels: OutcomeType[]): number[] {\n const n = this.singles.length;\n const successProbabilities = this.singles.map((single) =>\n new DiceQuery([single]).probabilityOf(labels)\n );\n\n const dist = new Array(n + 1).fill(0);\n dist[0] = 1;\n for (const successProb of successProbabilities) {\n for (let outcomeCount = n; outcomeCount >= 1; outcomeCount--) {\n dist[outcomeCount] =\n dist[outcomeCount] * (1 - successProb) +\n dist[outcomeCount - 1] * successProb;\n }\n dist[0] *= 1 - successProb;\n }\n return dist;\n }\n\n probAtLeastK(labels: OutcomeType | OutcomeType[], k: number): number {\n const L = Array.isArray(labels) ? [...new Set(labels)] : [labels];\n const n = this.singles.length;\n\n if (k <= 0) return 1;\n if (k > n) return 0;\n\n // Sum the upper tail of the single, shared count distribution rather than\n // calling probExactlyK (which rebuilt the distribution) once per i.\n const dist = this.countDistribution(L);\n let tail = 0;\n for (let i = k; i <= n; i++) {\n tail += dist[i];\n }\n\n if (tail < 0) return 0;\n if (tail > 1) return 1;\n return tail;\n }\n\n /**\n * Returns the probability that at least one attack has the specified outcome(s).\n * - This is the complement of probAtMostK(labels, 0)\n *\n * Examples:\n * - `query.probAtLeastOne('hit')` → 0.88 (88% chance at least one attack hits)\n * - `query.probAtLeastOne(['hit', 'crit'])` → 0.96 (96% chance at least one succeeds)\n *\n * Use cases:\n * - \"What's the chance at least one of my attacks connects?\"\n *\n * Note:\n *\n * - You have to pass in an array of labels to avoid double-counting if you are\n * using multiple labels. You cannot just add them. A label listed twice counts once.\n */\n probAtLeastOne(labels: OutcomeType | OutcomeType[]): number {\n const distinctLabels = typeof labels === \"string\" ? [labels] : [...new Set(labels)];\n\n let productOfNonOccurrence = 1;\n for (let diceIndex = 0; diceIndex < this.singles.length; diceIndex++) {\n // Calculate total probability of any of the specified labels occurring.\n // Clamp to [0,1] so floating-point drift in the per-attack sum cannot push\n // the complement out of range.\n let combinedProbability = 0;\n for (const label of distinctLabels) {\n combinedProbability += this.singleProb(diceIndex, label);\n }\n if (combinedProbability < 0) combinedProbability = 0;\n else if (combinedProbability > 1) combinedProbability = 1;\n productOfNonOccurrence *= 1 - combinedProbability;\n }\n const result = 1 - productOfNonOccurrence;\n return result < 0 ? 0 : result > 1 ? 1 : result;\n }\n\n /**\n * Computes binomial probabilities for exactly 0, 1, 2, ..., maxK occurrences of a label.\n *\n * Uses dynamic programming to efficiently calculate the probability distribution\n * of how many attacks will have the specified outcome, accounting for different\n * success probabilities across individual attacks.\n *\n * Example: For 3 attacks with 50% hit chance each, returns:\n * [0.125, 0.375, 0.375, 0.125] = [P(0 hits), P(1 hit), P(2 hits), P(3 hits)]\n *\n * @param label - The outcome type to count\n * @param maxK - Maximum number of occurrences to calculate (usually number of attacks)\n * @returns Array where index K contains P(exactly K attacks have the label)\n */\n private computeBinomialProbabilities(\n label: OutcomeType,\n maxK: number\n ): number[] {\n const individualProbabilities = this.singles.map((_, diceIndex) =>\n this.singleProb(diceIndex, label)\n );\n const binomialProbs = new Array(maxK + 1).fill(0);\n binomialProbs[0] = 1;\n\n for (const singleProbability of individualProbabilities) {\n for (let outcomeCount = maxK; outcomeCount >= 1; outcomeCount--) {\n binomialProbs[outcomeCount] =\n binomialProbs[outcomeCount] * (1 - singleProbability) +\n binomialProbs[outcomeCount - 1] * singleProbability;\n }\n binomialProbs[0] *= 1 - singleProbability;\n }\n\n return binomialProbs;\n }\n\n /**\n * Returns the probability that exactly K attacks result in the specified outcome(s).\n *\n * Single label examples:\n * - probExactlyK('hit', 2) = probability exactly 2 attacks hit\n * - probExactlyK('crit', 1) = probability exactly 1 attack crits\n * - probExactlyK('crit', 0) = probability no attacks crit\n *\n * Array examples:\n * - probExactlyK(['hit', 'crit'], 2) = probability exactly 2 attacks succeed\n * - probExactlyK(['hit', 'crit'], 1) = probability exactly 1 attack succeeds\n * - probExactlyK(['missDamage', 'missNone'], 0) = probability no attacks miss\n *\n * Use cases:\n * - \"What's the chance exactly one of my attacks hits?\"\n * - \"How likely am I to get exactly 2 successes out of 3 attacks?\"\n * - \"What's the probability that exactly half my attacks succeed?\"\n *\n * Note: For arrays, an attack counts as a \"success\" if it has any of the specified labels,\n * as in probAtLeastK and probAtMostK. A negative k has probability 0.\n */\n probExactlyK(labels: OutcomeType | OutcomeType[], k: number): number {\n if (k < 0) return 0;\n // Handle single label case (backward compatibility)\n if (typeof labels === \"string\") {\n const probabilityArray = this.computeBinomialProbabilities(labels, k);\n return probabilityArray[k];\n }\n\n // For multiple labels, derive P(exactly k) from the single shared count\n // distribution. (k > n is impossible, so index out of range reads as 0.)\n const dist = this.countDistribution(labels);\n return k >= 0 && k < dist.length ? dist[k] : 0;\n }\n\n /**\n * Returns the probability that AT MOST K attacks result in the specified outcome(s).\n *\n * Single label examples:\n * - probAtMostK('hit', 1) = probability 0 or 1 attacks hit (at most 1)\n * - probAtMostK('crit', 0) = probability no attacks crit\n * - probAtMostK('missDamage', 2) = probability at most 2 attacks miss\n *\n * Array examples:\n * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds\n * - probAtMostK(['hit', 'crit'], 0) = probability no attacks succeed (all miss)\n *\n * Use cases:\n * - \"What's the chance that at most one attack hits?\" (rest miss)\n * - \"How likely am I to have mostly failures?\" (at most 1 success)\n * - \"What's the probability of a really bad turn?\" (at most 0 successes)\n *\n */\n probAtMostK(labels: OutcomeType | OutcomeType[], k: number): number {\n // Handle single label case (backward compatibility)\n if (typeof labels === \"string\") {\n const probabilityArray = this.computeBinomialProbabilities(labels, k);\n let cumulativeSum = 0;\n for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {\n cumulativeSum += probabilityArray[outcomeCount];\n }\n return cumulativeSum;\n }\n\n // For multiple labels, sum the lower tail of the single shared count\n // distribution rather than recomputing it per outcomeCount.\n const dist = this.countDistribution(labels);\n const upper = Math.min(k, dist.length - 1);\n let cumulativeSum = 0;\n for (let outcomeCount = 0; outcomeCount <= upper; outcomeCount++) {\n cumulativeSum += dist[outcomeCount];\n }\n return cumulativeSum;\n }\n\n /**\n * Returns the expected damage attributed to specific outcome types.\n *\n * Single label examples:\n * - expectedDamageFrom('hit') = expected damage from hit components\n * - expectedDamageFrom('crit') = expected damage from crit components\n *\n * Array examples:\n * - expectedDamageFrom(['hit', 'crit']) = expected damage from any success\n * - expectedDamageFrom(['missDamage', 'missNone']) = expected damage from misses\n *\n * Use cases:\n * - \"How much damage do I expect from successful attacks?\"\n * - \"What's the damage contribution from critical hits specifically?\"\n * - \"How much damage comes from miss effects (like save-for-half spells)?\"\n *\n * A single whose mass is not 1 is normalized exactly as {@link mean} normalizes it, so the\n * contributions of labels that cover every outcome add up to `mean()`. A label listed twice\n * counts once.\n */\n expectedDamageFrom(labels: OutcomeType | OutcomeType[]): number {\n const wanted = Array.isArray(labels) ? [...new Set(labels)] : [labels];\n\n let total = 0;\n // By linearity of expectation, sum the wanted-label damage over each single PMF directly,\n // avoiding the `count` aggregation issues a merged PMF would introduce.\n for (const single of this.singles) {\n const mass = single.mass();\n if (mass <= 0) continue;\n let contribution = 0;\n for (const [dmg, bin] of single) {\n let p = 0;\n for (const label of wanted) p += bin.count[label] ?? 0;\n contribution += dmg * p;\n }\n total += Math.abs(mass - 1) <= this._eps ? contribution : contribution / mass;\n }\n return total;\n }\n\n /**\n * Returns damage statistics for scenarios where AT LEAST ONE attack results in\n * the specified outcome(s).\n *\n * This method answers \"What happens when things go reasonably well?\" rather than\n * \"What's the theoretical maximum?\" It includes mixed scenarios which are more\n * common and tactically relevant than pure scenarios.\n *\n * Single label examples:\n * - damageStatsFrom('hit') = damage range when at least one attack hits\n * - damageStatsFrom('crit') = damage range when at least one attack crits\n *\n * Array examples:\n * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds\n * - damageStatsFrom(['missDamage', 'missNone']) = damage range when at least one attack misses\n *\n * Tactical Use Cases:\n * - \"Given that I don't completely whiff (99% of turns), what damage should I expect?\"\n * - \"When planning to kill a 60 HP enemy, what's my damage range on successful turns?\"\n * - \"Should I use this risky spell if it has good damage when it works?\"\n * - \"What's my damage potential when something goes right?\" (vs pure failure)\n *\n * Combat Planning Examples:\n * - 4 attacks with 90% hit chance: \"96% of the time you'll do 25-150 damage, avg 52\"\n * (Much more useful than \"You average 50 damage including complete misses\")\n * - Risk assessment: \"80% of successful turns do 40-80 damage, but 20% do 80-150\"\n * - Resource management: \"If I hit anything, I'll likely finish this enemy\"\n *\n * Statistical Note:\n * This includes mixed scenarios (2 hits + 1 crit, 3 hits + 1 miss, etc.) which\n * occur far more frequently than pure scenarios. For pure scenarios, use combinedDamageStats.\n *\n * KNOWN LIMITATION (multi-attack, single label): the returned `count` is an\n * EXPECTED COUNT (E[#label], so > 1 for N≥2 attacks, not a probability), and\n * `avg` is the size-biased conditional mean E[dmg·#label]/E[#label] rather than\n * E[dmg | the label occurs]. For a single attack both are the plain\n * conditional figures. Use {@link probAtLeastOne} for the scenario probability.\n *\n * @example\n * // High-level tactical planning\n * const successStats = query.damageStatsFrom('hit')\n * const successChance = query.probAtLeastOne('hit')\n * console.log(`${(successChance*100).toFixed(1)}% chance to do ${successStats.min}-${successStats.max} damage`)\n */\n damageStatsFrom(labels: OutcomeType | OutcomeType[]): {\n min: number;\n max: number;\n avg: number;\n count: number;\n } {\n // Normalize input to array for uniform handling\n const labelArray = typeof labels === \"string\" ? [labels] : labels;\n\n let minDamage = Infinity;\n let maxDamage = -Infinity;\n let totalDamage = 0;\n let totalCount = 0;\n\n for (const [damage, probabilityBin] of this.combined) {\n // Check if this bin has any of the specified labels\n let binHasAnyLabel = false;\n let binContribution = 0;\n\n for (const label of labelArray) {\n const count = probabilityBin.count[label] as number;\n if (count && count > 0) {\n binHasAnyLabel = true;\n binContribution += count;\n }\n }\n\n if (damage > 0 && binHasAnyLabel) {\n minDamage = Math.min(minDamage, damage);\n maxDamage = Math.max(maxDamage, damage);\n\n // For single labels, use the specific count; for multiple labels, use total probability\n const weightToUse =\n labelArray.length === 1 ? binContribution : probabilityBin.p;\n totalDamage += damage * weightToUse;\n totalCount += weightToUse;\n }\n }\n\n return {\n min: minDamage === Infinity ? 0 : minDamage,\n max: maxDamage === -Infinity ? 0 : maxDamage,\n avg: totalCount > 0 ? totalDamage / totalCount : 0,\n count: totalCount,\n };\n }\n\n /**\n * Returns damage statistics for scenarios where ALL attacks result in the specified\n * outcome, calculated by leveraging the pure partition of singles.\n *\n * This method answers \"What's the theoretical best/worst case?\" and \"What are the\n * clean mathematical boundaries?\" It provides pure scenarios without mixing outcomes.\n *\n * Examples:\n * - combinedDamageStats('hit') = damage range when all attacks hit (none crit, none miss)\n * - combinedDamageStats('crit') = damage range when all attacks crit (none just hit)\n *\n * UI and Display Use Cases:\n * - Statistics panels showing \"MAX Hit Damage\" (users expect pure hits, not mixed)\n * - \"Best case scenario\" vs \"worst case scenario\" analysis\n * - Mathematical verification: \"Does our hit damage calculation match manual math?\"\n * - Clean damage type attribution: \"How much comes from base hits vs crits?\"\n *\n * Design and Balance Use Cases:\n * - Game designers: \"What's the damage ceiling if someone gets lucky?\"\n * - Character optimization: \"What's my absolute maximum potential?\"\n * - Ability comparison: \"Which build has higher crit ceiling?\"\n * - Minimum guaranteed damage: \"What's the worst I can do if everything hits?\"\n *\n * Mathematical Use Cases:\n * - Validating complex calculations against simple manual math\n * - Understanding damage component contributions in isolation\n * - Separating luck (crit variance) from consistency (hit variance)\n * - Building intuition about damage sources\n *\n * When to Use This vs damageStatsFrom():\n * - Use THIS for: UI max/min displays, theoretical limits, clean comparisons\n * - Use damageStatsFrom() for: tactical planning, realistic expectations, mixed scenarios\n *\n * Statistical Note:\n * Pure scenarios (all hits, all crits) are rare but represent clear mathematical\n * boundaries. These stats help understand the \"shape\" of your damage potential.\n *\n * @example\n * // UI display logic\n * const pureHitMax = query.combinedDamageStats('hit').max // Clean \"MAX Hit Damage: 90\"\n * const pureCritMax = query.combinedDamageStats('crit').max // Clean \"MAX Crit Damage: 168\"\n *\n * // vs tactical planning (use damageStatsFrom instead)\n * const realisticRange = query.damageStatsFrom('hit') // Includes mixed scenarios\n */\n combinedDamageStats(targetLabel: OutcomeType): {\n min: number;\n max: number;\n avg: number;\n count: number;\n } {\n // Get pure statistics from each single attack (singles are already pure partitions)\n const singleStats = this.singles.map((single) =>\n new DiceQuery([single]).damageStatsFrom(targetLabel)\n );\n\n // If any single attack has no outcomes of this type, return zeros\n if (singleStats.some((stats) => stats.count === 0)) {\n return { min: 0, max: 0, avg: 0, count: 0 };\n }\n\n // Calculate combined statistics for N attacks all of target type\n const combinedMin = singleStats.reduce((sum, stats) => sum + stats.min, 0);\n const combinedMax = singleStats.reduce((sum, stats) => sum + stats.max, 0);\n const combinedAvg = singleStats.reduce((sum, stats) => sum + stats.avg, 0);\n const combinedProb = singleStats.reduce(\n (product, stats) => product * stats.count,\n 1\n );\n\n return {\n min: combinedMin,\n max: combinedMax,\n avg: combinedAvg,\n count: combinedProb,\n };\n }\n\n /**\n * Returns the probability that at least one attack carries ANY of the\n * specified labels (the marginal P(≥1) across the independent attacks).\n *\n * Examples:\n * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)\n * - `query.probabilityOf(['hit', 'crit'])` → 0.96 (probability of any success)\n *\n * Use cases:\n * - \"What's the chance my resolution includes a success label?\"\n * - \"How likely am I to get any hits or crits across all attacks?\"\n *\n * Note: this must NOT be computed by summing `combined` bin probabilities. A\n * single combined damage total is reachable by many outcome combinations and\n * a bin can hold several labels at once, so summing `bin.p` over bins that\n * contain a label over-counts. The correct marginal is the Poisson-binomial\n * complement over the per-attack probabilities, i.e. {@link probAtLeastOne}.\n */\n probabilityOf(labels: OutcomeType | OutcomeType[]): number {\n return this.probAtLeastOne(labels);\n }\n\n /**\n * Returns the probability that at least one attack misses (either kind of miss:\n * `missNone` or `missDamage`). For a single attack this is its miss chance.\n *\n * Example: `query.missChance()` → 0.45\n * Use case: \"What's the chance I miss at least once this turn?\"\n *\n * For the chance that every attack misses, use\n * `probExactlyK([\"missNone\", \"missDamage\"], n)` with n attacks, or\n * `probAtMostK([\"hit\", \"crit\"], 0)`.\n */\n missChance(): number {\n // Miss can be either explicit misses with damage or zero-damage misses\n return this.probabilityOf([\"missDamage\", \"missNone\"]);\n }\n\n /**\n * Returns data formatted for plotting damage probability distribution.\n *\n * Example: `query.toChartSeries()` → [{x: 0, y: 0.04}, {x: 6, y: 0.1}, ...]\n * Use case: \"I want to visualize my damage distribution in a chart.\"\n */\n toChartSeries(): Array<{ x: number; y: number }> {\n return this.combined.support().map((damageValue) => ({\n x: damageValue,\n y: this.combined.map.get(damageValue)!.p,\n }));\n }\n\n /**\n * Returns tabular data showing damage values and their probability breakdowns.\n *\n * Example: `query.toLabeledTable(['hit', 'crit'])` →\n * [{damage: 6, total: 0.01, hit: 0.008, crit: 0}, ...]\n *\n * Use case: \"I want to see exactly how hit/crit probabilities contribute to each damage value.\"\n */\n toLabeledTable(\n labels: OutcomeType[] = []\n ): Array<{ damage: number; total: number } & Record<string, number>> {\n return this.combined.support().map((damageValue) => {\n const probabilityBin = this.combined.map.get(damageValue)!;\n const tableRow: { damage: number; total: number } & Record<\n string,\n number\n > = {\n damage: damageValue,\n total: probabilityBin.p,\n };\n for (const outcomeLabel of labels) {\n tableRow[outcomeLabel] = probabilityBin.count[outcomeLabel] || 0;\n }\n return tableRow;\n });\n }\n\n /**\n * Returns data for stacked charts with unconditional per-label probability mass per damage.\n *\n * - Each dataset value equals the unconditional probability mass for that label at that damage\n * (i.e., `bin.count[label]`).\n * - Column sums may be less than the total probability `bin.p` when you omit labels or when\n * there is unlabeled mass. Include all relevant outcome labels if you need the sum to match.\n * - This behavior matches tests that expect raw per-label mass (not proportional scaling).\n * - NOTE: This implementation may break dprcalc.com chart binning at large n, need to test it more.\n *\n * @example\n * query.toStackedChartData(['hit', 'crit'])\n * // → {labels: [0, 6, 12, ...], datasets: [{label: 'hit', data: [0, 0.03, ...]}, ...]}\n */\n toStackedChartData(\n labels: OutcomeType[] = [],\n epsilon = EPS\n ): { labels: number[]; datasets: Array<{ label: string; data: number[] }> } {\n const damageValues = this.combined.support();\n\n const datasets = labels.map((outcomeLabel) => ({\n label: outcomeLabel,\n data: damageValues.map((dmg) => {\n const bin = this.combined.map.get(dmg);\n const v = bin ? (bin.count[outcomeLabel] as number) || 0 : 0;\n return v <= epsilon ? 0 : v;\n }),\n }));\n\n return { labels: damageValues, datasets };\n }\n\n /**\n * Returns pure mathematical data for cumulative distribution function (CDF).\n * Shows P(X ≤ x) - the probability of getting at most x damage.\n *\n * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)\n * @returns Pure data structure with support and cumulative probabilities\n *\n * @example\n * query.toCDFSeries()\n * // → {support: [0, 6, 12], data: [5.2, 18.3, 45.1]}\n */\n toCDFSeries(asPercentages: boolean = true): {\n support: number[];\n data: number[];\n } {\n const originalSupport = this.combined.support();\n if (originalSupport.length === 0) {\n return { support: [], data: [] };\n }\n\n // Create complete integer range from min to max\n const minDamage = Math.min(...originalSupport);\n const maxDamage = Math.max(...originalSupport);\n const support = Array.from(\n { length: maxDamage - minDamage + 1 },\n (_, i) => minDamage + i\n );\n\n let cumulativeProbability = 0;\n const cdfData: number[] = [];\n\n for (const damage of support) {\n const bin = this.combined.map.get(damage);\n if (bin) {\n cumulativeProbability += bin.p;\n }\n cdfData.push(\n asPercentages ? cumulativeProbability * 100 : cumulativeProbability\n );\n }\n\n return {\n support,\n data: cdfData,\n };\n }\n\n /**\n * Returns pure mathematical data for complementary cumulative distribution function (CCDF).\n * Shows P(X ≥ x) - the probability of getting at least x damage.\n *\n * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)\n * @returns Pure data structure with support and complementary cumulative probabilities\n *\n * @example\n * query.toCCDFSeries()\n * // → {support: [0, 6, 12], data: [100, 94.8, 81.7]}\n */\n toCCDFSeries(asPercentages: boolean = true): {\n support: number[];\n data: number[];\n } {\n const originalSupport = this.combined.support();\n if (originalSupport.length === 0) {\n return { support: [], data: [] };\n }\n\n // Create complete integer range from min to max\n const minDamage = Math.min(...originalSupport);\n const maxDamage = Math.max(...originalSupport);\n const support = Array.from(\n { length: maxDamage - minDamage + 1 },\n (_, i) => minDamage + i\n );\n\n // Calculate CCDF: P(X ≥ x) = 1 - P(X < x)\n let cumulativeProbability = 0;\n const ccdfData: number[] = [];\n\n for (const damage of support) {\n // P(X ≥ x) is the total mass minus the cumulative up to (not including) x.\n const ccdf = 1 - cumulativeProbability;\n ccdfData.push(asPercentages ? ccdf * 100 : ccdf);\n\n // Now add current probability for next iteration\n const bin = this.combined.map.get(damage);\n if (bin) {\n cumulativeProbability += bin.p;\n }\n }\n\n return {\n support,\n data: ccdfData,\n };\n }\n\n /** Probability of doing strictly more than threshold damage (default >0). */\n probDamageGreaterThan(threshold = 0): number {\n let acc = 0;\n for (const [x, bin] of this.combined.map) if (x > threshold) acc += bin.p;\n return acc;\n }\n\n /** All outcome keys present in the PMF, ordered by `order` when given. */\n outcomeKeys(order?: OutcomeType[]): OutcomeType[] {\n const found = new Set<string>();\n for (const [, bin] of this.combined.map) {\n for (const k in bin.count)\n if (bin.count[k] && (bin.count[k] as number) > 0) found.add(k);\n }\n if (found.size === 0)\n [\"hit\", \"crit\", \"missNone\"].forEach((k) => found.add(k));\n const keys = Array.from(found).filter(\n (k) => order?.includes(k as OutcomeType) ?? true\n ) as OutcomeType[];\n if (order && order.length)\n keys.sort((a, b) => order.indexOf(a) + 999 - (order.indexOf(b) + 999));\n return keys;\n }\n\n /** Total probability per outcome across the PMF. */\n outcomeTotals(\n outcomes: OutcomeType[] = this.outcomeKeys()\n ): Map<OutcomeType, number> {\n const totals = new Map<OutcomeType, number>();\n outcomes.forEach((o) => totals.set(o, 0));\n for (const [, row] of this.combined.map) {\n for (const o of outcomes) {\n const p = (row.count[o] as number) || 0; // if your bins store per-outcome p; else derive via toLabeledTable\n totals.set(o, (totals.get(o) || 0) + p);\n }\n }\n return totals;\n }\n\n /** Conditional damage range per outcome (min/avg/max of X | outcome). */\n outcomeDamageRanges(\n outcomes: OutcomeType[] = this.outcomeKeys()\n ): Map<OutcomeType, { min: number; avg: number; max: number }> {\n // Use toLabeledTable to stay consistent with your existing attribution\n const table = this.toLabeledTable(outcomes);\n const ranges = new Map<\n OutcomeType,\n { min?: number; max?: number; sum: number; mass: number }\n >();\n outcomes.forEach((o) => ranges.set(o, { sum: 0, mass: 0 }));\n\n for (const row of table) {\n const dmg = row.damage as number;\n for (const o of outcomes) {\n const p = (row[o] as number) || 0; // joint mass at (damage, outcome)\n if (p > 0) {\n const r = ranges.get(o)!;\n r.sum += dmg * p;\n r.mass += p;\n if (r.min === undefined || dmg < r.min) r.min = dmg;\n if (r.max === undefined || dmg > r.max) r.max = dmg;\n }\n }\n }\n\n const out = new Map<\n OutcomeType,\n { min: number; avg: number; max: number }\n >();\n for (const o of outcomes) {\n const r = ranges.get(o)!;\n const avg = r.mass > 0 ? r.sum / r.mass : 0;\n out.set(o, { min: r.min ?? 0, avg, max: r.max ?? 0 });\n }\n return out;\n }\n\n /**\n * Per-outcome probabilities and damage ranges, aggregated over the individual\n * singles rather than read off the combined distribution.\n *\n * `damageRange` is the sum, over every single that can produce the outcome, of\n * that single's own conditional damage range: \"what this outcome contributes\n * across the whole turn when every attack that can produce it does\". Linear in\n * the number of attacks by construction.\n *\n * Prefer this over {@link DiceQuery.snapshot} for a multi-attack query.\n * `snapshot` reads `damageRange` off the combined PMF's `count`, which the\n * convolution accumulates as an expected count, so its `avg` is size-biased\n * for N≥2 (its own doc comment says so). The two agree for a single attack.\n *\n * Only outcomes that actually occur appear in the result.\n *\n * Like every `singles`-based helper on this class, it describes the singles\n * and not an explicitly provided `combined`. `Turn.toQuery()` supplies one whose\n * distribution also contains rider attacks that are absent from `singles`\n * (an `otherwise([unarmed, unarmed])` flurry, say), so those attacks do not\n * appear here. For rider-inclusive figures read the combined distribution\n * directly: {@link DiceQuery.outcomeTotals}, {@link DiceQuery.outcomeDamageRanges}.\n *\n * @param outcomes Which outcomes to consider; defaults to every canonical one.\n */\n outcomeStats(\n outcomes: readonly OutcomeType[] = ALL_OUTCOME_TYPES\n ): Map<OutcomeType, OutcomeSnapshot> {\n const stats = new Map<OutcomeType, OutcomeSnapshot>();\n const perSingle = this.singles.map((pmf) => new DiceQuery([pmf], undefined, this._eps));\n\n for (const outcome of outcomes) {\n const atLeastOneProbability = this.probAtLeastOne(outcome);\n if (atLeastOneProbability <= 0) continue;\n\n const damageRange = { min: 0, avg: 0, max: 0 };\n let contributors = 0;\n for (const single of perSingle) {\n if (single.probAtLeastOne(outcome) <= 0) continue;\n contributors++;\n const stat = single.damageStatsFrom(outcome);\n damageRange.min += stat.min;\n damageRange.avg += stat.avg;\n damageRange.max += stat.max;\n }\n\n stats.set(outcome, {\n atLeastOneProbability,\n allProbability:\n contributors > 0 ? this.probExactlyK(outcome, contributors) : 0,\n damageRange,\n });\n }\n\n return stats;\n }\n\n /**\n * Snapshot of the distribution in the exact shape the UI consumes.\n * - outcome probabilities are \"at least one\" (and equal to \"all\" for a single PMF)\n * - damageRange is conditional on the outcome occurring\n *\n * The outcome probabilities use the correct Poisson-binomial marginals\n * (`atLeastOneProbability` = P(≥1 attack has it), `allProbability` = P(all do)),\n * so they are always valid probabilities in [0,1].\n *\n * KNOWN LIMITATION (multi-attack): `damageRange.avg` is still aggregated from\n * the combined PMF's `count`, which the convolution accumulates as an EXPECTED\n * COUNT, so for N≥2 attacks it is the size-biased mean E[dmg·#label]/E[#label]\n * rather than a clean conditional expectation. It is correct for a single\n * attack.\n */\n snapshot(order?: readonly OutcomeType[]): Snapshot {\n // 1) Discover which outcomes actually appear in this PMF\n const discovered = new Set<string>();\n for (const [, bin] of this.combined.map) {\n for (const k in bin.count) {\n if (bin.count[k] && (bin.count[k] as number) > 0) discovered.add(k);\n }\n }\n if (discovered.size === 0) {\n for (const k of DiceQuery.DEFAULT_OUTCOMES) discovered.add(k);\n }\n\n let outcomes = Array.from(discovered);\n\n // Optional filtering + ordering if a preferred order was provided\n if (order && order.length) {\n const inOrder = new Set(order);\n outcomes = outcomes.filter((k) => inOrder.has(k as OutcomeType));\n const rank = new Map(order.map((k, i) => [k, i]));\n outcomes.sort(\n (a, b) =>\n (rank.get(a as OutcomeType) ?? 999) -\n (rank.get(b as OutcomeType) ?? 999)\n );\n }\n\n // 2) Aggregate per-outcome mass and conditional damage ranges via labeled table\n const rows = this.toLabeledTable(outcomes as OutcomeType[]);\n\n const rangeAcc = new Map<\n OutcomeType,\n { min?: number; max?: number; sum: number; mass: number }\n >();\n for (const ot of outcomes) {\n rangeAcc.set(ot as OutcomeType, { sum: 0, mass: 0 });\n }\n\n for (const row of rows) {\n const dmg = row.damage as number;\n for (const ot of outcomes) {\n const p = (row[ot] as number) || 0;\n if (p <= 0) continue;\n\n const r = rangeAcc.get(ot as OutcomeType)!;\n r.sum += dmg * p;\n r.mass += p;\n if (r.min === undefined || dmg < r.min) r.min = dmg;\n if (r.max === undefined || dmg > r.max) r.max = dmg;\n }\n }\n\n const n = this.singles.length;\n const outcomeMap = new Map<OutcomeType, OutcomeSnapshot>();\n for (const ot of outcomes) {\n const r = rangeAcc.get(ot as OutcomeType)!;\n const avg = r.mass > 0 ? r.sum / r.mass : 0;\n // Use the correct per-attack marginals (Poisson-binomial) so these are\n // always valid probabilities in [0,1]. For a single attack both reduce to\n // P(outcome); the previous `total` was an expected count and could exceed 1.\n outcomeMap.set(ot as OutcomeType, {\n atLeastOneProbability: this.probAtLeastOne(ot as OutcomeType),\n allProbability: this.probAtLeastK(ot as OutcomeType, n),\n damageRange: { min: r.min ?? 0, avg, max: r.max ?? 0 },\n });\n }\n\n // 3) Scalars: mean, damageChance, and percentiles\n const averageDPR = this.mean();\n\n let damageChance = 0; // P(total damage > 0)\n for (const [x, bin] of this.combined.map) if (x > 0) damageChance += bin.p;\n\n const percentiles = {\n p25: this.combined.quantile(0.25),\n p50: this.combined.quantile(0.5),\n p75: this.combined.quantile(0.75),\n };\n\n return { averageDPR, damageChance, percentiles, outcomes: outcomeMap };\n }\n\n /**\n * PMF Transformation Methods\n *\n * These methods provide a fluent API for transforming dice queries by wrapping\n * the underlying PMF transformation methods. All operations work on the combined\n * PMF and return new DiceQuery instances.\n */\n\n /**\n * Returns a new DiceQuery with normalized probabilities (ensuring they sum to 1.0).\n *\n * @returns New DiceQuery with normalized combined PMF\n */\n normalize(): DiceQuery {\n return new DiceQuery([this.combined.normalize()]);\n }\n\n /**\n * Returns a new DiceQuery with low-probability outcomes removed.\n *\n * @param eps Minimum probability threshold (defaults to PMF epsilon)\n * @param keepFinalBin Whether to keep the highest damage bin regardless of probability\n * @returns New DiceQuery with compacted combined PMF\n */\n compact(eps?: number, keepFinalBin?: boolean): DiceQuery {\n return new DiceQuery([this.combined.compact(eps, keepFinalBin)]);\n }\n\n /**\n * Returns a new DiceQuery with an additional scaled branch added.\n * Useful for conditional outcomes like \"30% chance of opportunity attack\".\n *\n * @param branch DiceQuery to add as a scaled branch\n * @param probability Probability of the branch occurring (0-1)\n * @returns New DiceQuery combining this query with the scaled branch\n *\n * @example\n * const baseAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n * const opportunityAttack = parse(\"(d20 + 5 AC 15) * (1d8 + 3)\");\n * const withOpportunity = baseAttack.addScaled(opportunityAttack, 0.3);\n */\n addScaled(branch: DiceQuery, probability: number): DiceQuery {\n return new DiceQuery([\n this.combined.addScaled(branch.combined, probability),\n ]);\n }\n\n /**\n * Returns a new DiceQuery with all probabilities scaled by a factor.\n * Used for conditional scenarios where the entire outcome has reduced probability.\n *\n * @param factor Scaling factor for probabilities\n * @returns New DiceQuery with scaled probabilities\n *\n * @example\n * const fullAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n * const conditionalAttack = fullAttack.scaleMass(0.3); // 30% chance scenario\n */\n scaleMass(factor: number): DiceQuery {\n return new DiceQuery([this.combined.scaleMass(factor)]);\n }\n\n totalMass(): number {\n return this.combined.mass();\n }\n\n /**\n * Returns a new DiceQuery with damage values transformed by a function.\n * Useful for applying modifiers, resistances, or other damage transformations.\n *\n * @param damageTransformFunction Function to transform each damage value\n * @returns New DiceQuery with transformed damage values\n *\n * @example\n * const baseAttack = parse(\"2d6 + 3\");\n * const withResistance = baseAttack.mapDamage(dmg => Math.floor(dmg / 2)); // Half damage\n * const withBonus = baseAttack.mapDamage(dmg => dmg + 5); // +5 damage\n */\n mapDamage(\n damageTransformFunction: (damageValue: number) => number\n ): DiceQuery {\n return new DiceQuery([this.combined.mapDamage(damageTransformFunction)]);\n }\n\n /**\n * Returns a new DiceQuery with damage values scaled by `factor / denominator`.\n * Convenient wrapper around mapDamage for multiplicative scaling; see\n * {@link PMF.scaleDamage} for the rounding rules.\n *\n * @param factor Scaling factor for damage values (the numerator of a ratio)\n * @param rounding Rounding method: \"floor\" (default), \"round\", or \"ceil\"\n * @param denominator Divisor; integer `factor` and `denominator` round exactly\n * @returns New DiceQuery with scaled damage values\n *\n * @example\n * const baseAttack = parse(\"2d6 + 3\");\n * const doubled = baseAttack.scaleDamage(2); // Double damage\n * const halfDamage = baseAttack.scaleDamage(0.5, \"round\"); // Half damage, rounded\n * const sevenTenths = baseAttack.scaleDamage(7, \"floor\", 10); // floor(7v/10), exactly\n */\n scaleDamage(\n factor: number,\n rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\",\n denominator = 1\n ): DiceQuery {\n return new DiceQuery([this.combined.scaleDamage(factor, rounding, denominator)]);\n }\n\n /**\n * Returns a new DiceQuery combining this query with another via convolution.\n * Equivalent to rolling both queries independently and adding results.\n * It is important to use this rather than combing()ing the PMFs directly!\n * This method maintains the provenance of the PMFs which is needed for damage attribution.\n * Combining the .combined PMFs directly is still valid for DPR calculations but\n * is not statistically sound for queries.\n *\n * @param other DiceQuery to combine with\n * @param eps Optional epsilon for precision control\n * @returns New DiceQuery representing the combined outcome\n *\n * @example\n * const mainAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n * const bonusAttack = parse(\"(d20 + 3 AC 15) * (1d6 + 1)\");\n * const bothAttacks = mainAttack.convolve(bonusAttack);\n */\n convolve(other: DiceQuery): DiceQuery {\n const singles = [...this.singles, ...other.singles];\n return new DiceQuery(singles);\n }\n\n /**\n * First-success split over an ordered list of DISTINCT single-swing PMFs.\n * Each PMF may have different success/subset probabilities (from labels).\n *\n * successOutcome: e.g., [\"success\"] or [\"hit\", \"crit\"]\n * subsetOutcome: e.g., [\"subset\"] or [\"crit\"] where subset ⊆ success\n *\n * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]\n */\n public firstSuccessSplit(\n successOutcome: OutcomeType | OutcomeType[],\n subsetOutcome: OutcomeType | OutcomeType[],\n eps = EPS\n ): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number] {\n const pmfs = this.singles;\n if (!pmfs.length) {\n throw new Error(\"firstSuccessSplitFromPMFs: pmfs must be non-empty\");\n }\n\n const toArr = (x: OutcomeType | OutcomeType[]): OutcomeType[] =>\n Array.isArray(x) ? x : [x];\n const clamp01 = (x: number) => Math.max(0, Math.min(1, x));\n const tol = Math.max(eps, 8 * Number.EPSILON);\n\n // Per-event probabilities from each PMF via DiceQuery([pmf])\n const per = pmfs.map((pmf) => {\n const dq = new DiceQuery([pmf]);\n const pS = dq.probAtLeastOne(toArr(successOutcome));\n const pB = dq.probAtLeastOne(toArr(subsetOutcome));\n if (pB - pS > eps) {\n throw new Error(\n \"firstSuccessSplitFromPMFs: P(subset) > P(success) for an event. Ensure subset ⊆ success.\"\n );\n }\n return { pS, pB };\n });\n\n // Aggregate with running miss prefix\n let missSoFar = 1;\n let pFirstSubset = 0;\n let pFirstNonSubset = 0;\n let pNone = 1;\n\n for (const { pS, pB } of per) {\n pFirstSubset += missSoFar * pB;\n pFirstNonSubset += missSoFar * (pS - pB);\n const miss = 1 - pS;\n missSoFar *= miss;\n pNone *= miss;\n }\n\n const pAny = 1 - pNone;\n\n // Clamp and sanity check\n const a = clamp01(pFirstNonSubset);\n const b = clamp01(pFirstSubset);\n const any = clamp01(pAny);\n const none = clamp01(pNone);\n\n if (Math.abs(a + b - any) > tol * Math.max(1, any)) {\n throw new Error(\n `firstSuccessSplitFromPMFs: parts do not sum to pAny. got a+b=${\n a + b\n }, pAny=${any}`\n );\n }\n\n return [a, b, any, none] as const;\n }\n}\n// Make sure these types are exported in your public index, or inline them here.\nexport type OutcomeSnapshot = {\n atLeastOneProbability: number; // P(outcome occurs at least once)\n allProbability: number; // equal to atLeastOneProbability for a single aggregated PMF\n damageRange: { min: number; avg: number; max: number }; // conditional on the outcome occurring\n};\n\nexport type Snapshot = {\n averageDPR: number;\n damageChance: number; // P(total damage > 0)\n percentiles: { p25: number; p50: number; p75: number };\n outcomes: Map<OutcomeType, OutcomeSnapshot>;\n};\n","import { LRUCache } from \"../common/lru-cache\";\nimport type { LRUCacheOptions } from \"../common/lru-cache\";\nimport type { Bin, OutcomeLabelMap, Rounding } from \"../common/types\";\nimport {\n ALL_OUTCOME_TYPES,\n EPS,\n MISS_NONE_OUTCOME,\n sortOutcomes,\n} from \"../common/types\";\nimport { DiceQuery } from \"./query\";\n\n/** Library caches hand the same PMF to every caller, so entries are frozen as they are stored. */\nconst sharedPMFCacheOptions: LRUCacheOptions<PMF> = {\n onInsert: (pmf) => pmf.freeze(),\n followsCachingToggle: true,\n};\n\nexport const pmfCache = new LRUCache<string, PMF>(1000, sharedPMFCacheOptions);\n\n/**\n * Relative slack when comparing a float-summed CDF with a target probability. Float running\n * sums drift by a few ulps; a target within this fraction of the CDF counts as reached.\n */\nconst QUANTILE_RELATIVE_SLACK = 1e-12;\n\n/**\n * The map of a frozen PMF: a copy of the map it was built with that reads like any `Map` but whose\n * `set`, `delete` and `clear` throw a `TypeError`, so a PMF shared through a cache cannot be\n * changed through it. Only frozen PMFs pay for the copy; the unfrozen hot paths keep their own map.\n */\nclass FrozenBinMap extends Map<number, Bin> {\n constructor(source: ReadonlyMap<number, Bin>) {\n super();\n for (const [value, bin] of source) super.set(value, bin);\n }\n\n override set(value: number): never {\n throw new TypeError(`Cannot set damage value ${value}: this PMF is frozen (shared through a cache)`);\n }\n\n override delete(value: number): never {\n throw new TypeError(`Cannot delete damage value ${value}: this PMF is frozen (shared through a cache)`);\n }\n\n override clear(): never {\n throw new TypeError(\"Cannot clear the map: this PMF is frozen (shared through a cache)\");\n }\n}\n\n/**\n * Complete numeric model for the stacked damage-attribution chart, produced by\n * {@link PMF.damageAttributionChartModel}. Carries every dice-and-probability\n * value the chart needs; a renderer only maps these numbers into its own format\n * (colors, human labels, axis units, dataset objects).\n */\nexport interface DamageAttributionChartModel {\n /** Bucket-start value for each column. Numeric; the caller stringifies for labels. */\n labels: number[];\n /** Present only when the distribution was coarsened; [start,end] inclusive, per bucket. */\n binRanges?: { start: number; end: number }[];\n /** Discovered outcome labels in stack order. Empty for pure (unattributed) distributions. */\n outcomes: string[];\n /** outcome → per-bucket probability mass (fraction 0..1). Bar heights. Σ over outcomes ≈ totals[i]. */\n series: Map<string, number[]>;\n /**\n * outcome → per-bucket conditional share (fraction 0..1) of that bucket's total.\n * Tooltip signal. 0 where the bucket total is below `epsilon`; otherwise Σ over\n * outcomes ≈ 1.\n */\n shares: Map<string, number[]>;\n /** Per-bucket total probability mass (fraction 0..1). The only signal for pure distributions. */\n totals: number[];\n /** Reversed-convention CCDF markers: damage at which P(X ≥ x) crosses 80/50/20%. */\n percentiles: { p80: number; p50: number; p20: number };\n /** Distribution mean, `this.mean()`. */\n mean: number;\n}\n\n/**\n * Probability Mass Function for discrete damage distributions.\n */\nexport class PMF {\n // Unique ID generator for anonymous PMFs to avoid cache key collisions\n private static __anonIdCounter = 1;\n\n // Cached computed values\n private _support?: number[];\n private _min?: number;\n private _max?: number;\n private _totalMass?: number;\n private _mean?: number;\n private _variance?: number;\n private _stdev?: number;\n private _fingerprint?: string;\n private _cumulative?: { values: number[]; below: number[]; above: number[] };\n private _frozen = false;\n\n /**\n * @param map Damage value → bin. Typed read-only: a PMF is immutable once built. A PMF returned\n * from the library's caches is frozen: its bins, its map and the `map` property itself reject\n * writes (see {@link freeze}).\n */\n constructor(\n public readonly map: ReadonlyMap<number, Bin> = new Map(),\n public readonly epsilon = EPS,\n public readonly normalized = false,\n public readonly identifier: string = `anon#${PMF.__anonIdCounter++}`,\n private readonly _preservedProvenance = true\n ) {}\n\n /**\n * A PMF cache that freezes every stored PMF and follows `setCachingEnabled`. The library's\n * own caches are built with this.\n */\n static createCache(maxSize: number): LRUCache<string, PMF> {\n return new LRUCache<string, PMF>(maxSize, sharedPMFCacheOptions);\n }\n\n /**\n * Freezes this PMF so it can be shared through a cache. Every bin is deep-frozen, including its\n * `count` and `attr` maps, so writing to one throws a `TypeError`. The map is replaced by a copy\n * whose `set`/`delete`/`clear` throw a `TypeError` (the map this PMF was built with stays the\n * caller's), and the `map` property becomes read-only, so assigning it throws too.\n * Returns this PMF.\n */\n freeze(): this {\n if (this._frozen) return this;\n const map = new FrozenBinMap(this.map);\n for (const bin of map.values()) {\n Object.freeze(bin.count);\n if (bin.attr) Object.freeze(bin.attr);\n Object.freeze(bin);\n }\n // Frozen too, so no own `set`/`delete`/`clear` can be installed over the throwing ones.\n Object.freeze(map);\n // `as object`: `defineProperty` returns its target, which is not a derived PMF to keep.\n Object.defineProperty(this as object, \"map\", { value: map, writable: false, enumerable: true, configurable: false });\n this._frozen = true;\n return this;\n }\n\n static empty(epsilon = EPS, identifier = \"empty\") {\n return new PMF(new Map(), epsilon, false, identifier);\n }\n\n // This has a single bin at value 0, mass of 1\n static zero(epsilon = EPS): PMF {\n const m = new Map();\n m.set(0, { p: 1, count: { miss: 1 }, attr: {} });\n return new PMF(m, epsilon, false, \"zero\");\n }\n\n static delta(value: number, epsilon = EPS): PMF {\n return PMF.fromMap(new Map([[value, 1]]), epsilon);\n }\n\n /**\n * Point mass at damage 0 tagged with the canonical `missNone` outcome.\n *\n * Differs from {@link PMF.zero}, which labels its zero bin `miss` — the\n * builder's attack-resolution vocabulary. This uses the `missNone`\n * {@link OutcomeType} that the attribution charts and outcome stats key on,\n * so it is the correct \"clean miss / no damage\" delta for provenance-aware\n * mixtures feeding those consumers.\n */\n static missNone(epsilon = EPS): PMF {\n const m = new Map<number, Bin>();\n m.set(0, { p: 1, count: { [MISS_NONE_OUTCOME]: 1 }, attr: {} });\n return new PMF(m, epsilon, false, \"missNone\");\n }\n\n // This creates a single bin at value 0, but with weight 0.\n static emptyMass(): PMF {\n return PMF.zero().scaleMass(0);\n }\n\n // Makes PMF iterable over [damage, bin] pairs.\n [Symbol.iterator](): IterableIterator<[number, Bin]> {\n return this.map[Symbol.iterator]();\n }\n\n static clearCache() {\n pmfCache.clear();\n }\n\n /**\n * Creates a conditional PMF from two branches (success and failure) and a probability.\n * This is the core logic for modeling any probabilistic event where there are two\n * distinct outcomes.\n */\n static branch(\n successPMF: PMF,\n failurePMF: PMF,\n successProbability: number\n ): PMF {\n let p = successProbability;\n if (!Number.isFinite(p)) p = 0;\n if (p < 0) p = 0;\n if (p > 1) p = 1;\n\n const q = 1 - p;\n\n // Fast paths. scaleMass(1) returns the same instance, so these hand back the\n // branch PMF unchanged. That is safe because PMFs are treated as immutable\n // (compact() and the other transforms now clone bins rather than mutate).\n if (p === 0) return failurePMF.scaleMass(1);\n if (p === 1) return successPMF.scaleMass(1);\n\n // Choose epsilon. You can also pick Math.min for a tighter threshold.\n const eps = successPMF.epsilon ?? failurePMF.epsilon;\n const id = `branch(${failurePMF.identifier}*${q.toFixed(6)} + ${\n successPMF.identifier\n }*${p.toFixed(6)})`;\n\n // Proper Bernoulli mixture: q·failure ⊕ p·success, assembled in a single\n // pass. The previous `empty().addScaled(failure,q).addScaled(success,p)`\n // chain copied failurePMF's bins twice (into the intermediate, then again\n // when the intermediate was copied by the second addScaled). Merging both\n // scaled branches directly into one fresh map keeps the same accumulation\n // order — q·failure first, then p·success — so the result is bit-identical.\n const resultMap = new Map<number, Bin>();\n for (const [damageValue, bin] of failurePMF.map) {\n PMF.mergeInto(resultMap, damageValue, PMF.scaleBin(bin, q));\n }\n for (const [damageValue, bin] of successPMF.map) {\n PMF.mergeInto(resultMap, damageValue, PMF.scaleBin(bin, p));\n }\n\n return new PMF(resultMap, eps, false, id);\n }\n\n /**\n * withProbability()\n *\n * A convenience wrapper around branch() for the common case where the \"failure\" branch is always zero().\n *\n * Think of this as a shortcut for:\n * pmf.gate(p, PMF.zero())\n *\n * Use this to model a *single* Bernoulli event — an outcome that either happens or doesn't,\n * like an opportunity attack that occurs with probability p, or a single attack that either hits or misses.\n *\n * This is **not** for combining multiple independent attacks or mutually exclusive multi-outcome scenarios.\n * - For multiple independent swings, use DiceQuery with separate PMFs for each attack.\n * - For modeling \"first success\" logic across multiple attacks (like Sneak Attack or Smite)\n * use query.firstSuccessSplit() to get the exact probabilities.\n * - For scenarios with several mutually exclusive outcomes (like crit vs hit vs none), use PMF.exclusive().\n *\n */\n static withProbability(successPMF: PMF, probability: number): PMF {\n return PMF.branch(successPMF, PMF.zero(), probability);\n }\n\n /**\n * gate()\n *\n * A conditional wrapper around branch() that applies this PMF with probability `p`,\n * and applies a provided fallback PMF otherwise.\n *\n * This is useful for modeling a binary choice between two outcomes:\n * - The \"success\" outcome (this PMF) happens with probability `p`.\n * - The \"failure\" outcome (fallback PMF) happens with probability `1 - p`.\n *\n * Examples:\n * - 25% chance to include an opportunity attack, otherwise nothing:\n * attackPMF.gate(0.25, PMF.zero())\n *\n * - 50% chance to deal fireball damage, otherwise cone of cold damage:\n * fireballPMF.gate(0.5, coneOfColdPMF)\n *\n * Relationship to other helpers:\n * - **withProbability()** is a shortcut for the common case where the fallback is `PMF.zero()`.\n * - **exclusive()** is for three or more mutually exclusive outcomes (e.g., crit vs hit vs none).\n *\n * @param p Probability of applying this PMF (between 0 and 1).\n * @param fallback PMF to apply when this PMF is *not* selected.\n * @returns A new PMF representing the weighted mixture of this PMF and the fallback.\n */\n gate(p: number, fallback: PMF) {\n return PMF.branch(this, fallback, p);\n }\n\n /**\n * PMF.exclusive()\n *\n * Builds a single PMF from a set of mutually exclusive weighted outcomes.\n * Exactly one of the provided options will occur.\n *\n * Each option has:\n * - A PMF representing its outcome (e.g., damage dice).\n * - A weight representing its probability of being selected.\n *\n * Notes:\n * - If total weight < 1 (within eps), leftover mass is assumed to be PMF.zero()\n *\n * @param options Array of `{ pmf, weight }` or `[PMF, number]`.\n * @param eps Optional tolerance for floating point rounding.\n */\n static exclusive(\n options: Array<{ pmf: PMF; weight: number } | [PMF, number]>,\n eps = EPS\n ): PMF {\n const items = options.map((o) =>\n Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o\n );\n\n // Validate weights\n for (const { weight } of items) {\n if (!Number.isFinite(weight) || weight < -eps) {\n throw new Error(`PMF.exclusive: invalid weight ${weight}.`);\n }\n }\n\n // Sum and check\n let totalWeight = items.reduce((s, { weight }) => s + weight, 0);\n\n // Normalize tiny negatives to 0 and tiny overshoot to 1 when within eps\n if (Math.abs(totalWeight) <= eps) totalWeight = 0;\n if (Math.abs(1 - totalWeight) <= eps) totalWeight = 1;\n\n if (totalWeight > 1 + EPS) {\n throw new Error(\n `PMF.exclusive: total weight ${totalWeight} exceeds 1. (epsilon: ${eps})`\n );\n }\n\n // Accumulate scaled components, skipping near-zero weights\n let out = PMF.empty(eps);\n for (const { pmf, weight } of items) {\n if (weight > eps) out = out.addScaled(pmf, weight);\n }\n\n // Add leftover mass at zero outcome\n const leftover = Math.max(0, 1 - totalWeight);\n if (leftover > eps) {\n out = out.addScaled(PMF.zero(), leftover);\n }\n\n return out;\n }\n\n /**\n * PMF.mix()\n *\n * Builds a PMF as a linear combination of input PMFs with the given weights.\n * Unlike `exclusive`, this does NOT:\n * - enforce that weights sum to 1\n * - add leftover probability to δ0 (PMF.zero())\n *\n * Use when outcomes are not mutually exclusive, or for interpolation/blending.\n *\n * @param options Array of `{ pmf, weight }` or `[PMF, number]`.\n * @param eps Optional tolerance for skipping tiny weights.\n */\n static mix(\n options: Array<{ pmf: PMF; weight: number } | [PMF, number]>,\n eps = EPS\n ): PMF {\n const items = options.map((o) =>\n Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o\n );\n\n // Validate weights, but do not constrain their sum.\n for (const { weight } of items) {\n if (!Number.isFinite(weight)) {\n throw new Error(`PMF.mix: invalid weight ${weight}.`);\n }\n }\n\n let out = PMF.empty(eps);\n for (const { pmf, weight } of items) {\n if (Math.abs(weight) <= eps) continue; // ignore crumbs\n out = out.addScaled(pmf, weight);\n }\n return out;\n }\n /**\n * Adds damage attribution metadata to this PMF based on existing count metadata.\n * For each bin, sets attr[outcome] = damage × count[outcome].\n *\n * This enables damage attribution charts to work with builder-generated PMFs.\n * The parser generates attr automatically, but builder PMFs only have count.\n *\n * @returns New PMF with attr field populated in each bin\n */\n /**\n * Returns true if this PMF already carries damage attribution metadata.\n *\n * Only the first positive-damage bin is inspected (parser-generated PMFs\n * populate `attr` uniformly), so this is O(1) in practice.\n */\n hasAttribution(): boolean {\n for (const [damage, bin] of this.map) {\n if (damage !== 0 && bin.attr && Object.keys(bin.attr).length > 0) {\n return true;\n }\n // Only check the first non-zero bin for performance\n if (damage > 0) break;\n }\n return false;\n }\n\n withAttribution(): PMF {\n // Fast path: if attr already exists, return this PMF unchanged\n if (this.hasAttribution()) return this;\n\n const newMap = new Map<number, Bin>();\n\n for (const [damage, bin] of this.map) {\n const attr: OutcomeLabelMap = {};\n\n // For each outcome type in count, compute its damage contribution\n for (const outcome in bin.count) {\n const probability = bin.count[outcome] as number;\n if (probability > 0) {\n attr[outcome] = damage * probability;\n }\n }\n\n // Create new bin with attribution\n newMap.set(damage, {\n p: bin.p,\n count: { ...bin.count },\n attr: Object.keys(attr).length > 0 ? attr : undefined,\n });\n }\n\n // Use a different identifier to avoid cache collisions with non-attributed version\n return new PMF(\n newMap,\n this.epsilon,\n this.normalized,\n `${this.identifier}~attr`\n );\n }\n\n /**\n * General-purpose N-way mixture.\n * weights: Array of [weight, PMF].\n *\n * Example: PMF.mixN([\n * [pMiss, zero],\n * [pHit, hitPMF],\n * [pCrit, critPMF],\n * ]);\n */\n static mixN(weights: [number, PMF][], eps = EPS): PMF {\n // Treat tiny/negative as zero; keep performance clean\n const filtered = weights.filter(([w]) => w > eps);\n\n if (filtered.length === 0) {\n return PMF.emptyMass(); // not PMF.zero(): we want \"no mass\" mixture\n }\n\n // No need to normalize up front; accumulation blends by relative weight\n let acc: PMF | null = null;\n let sum = 0;\n\n for (const [w, pmf] of filtered) {\n if (acc === null) {\n acc = pmf;\n sum = w;\n } else {\n const q = w / (sum + w); // relative weight of the new component\n acc = PMF.branch(pmf, acc, q); // success=new pmf, failure=acc\n sum += w;\n }\n }\n\n // If everything got filtered out (all ~0), return empty mass\n return acc ?? PMF.emptyMass();\n }\n\n /**\n * False for a PMF produced by {@link power}, which folds independent attacks into one\n * distribution and cannot say which attack produced which label.\n */\n public preservedProvenance(): boolean {\n return this._preservedProvenance;\n }\n\n private getPowerCacheKey(n: number, eps: number): string {\n // Includes fingerprint() (per-bin probability/count/attr content), matching convolve()'s\n // cache key: the identifier alone is not content-unique. `mapDamage`/`scaleDamage`,\n // `normalize()`, and `compact()` all keep the PARENT's identifier while producing a\n // numerically different PMF\n // (e.g. `X.mapDamage(f).power(2)` and `X.mapDamage(g).power(2)` would otherwise collide on\n // the same key `map(X)+map(X)@eps` and silently return each other's cached result).\n const id = this.identifier;\n let key = `${id}`;\n for (let i = 1; i < n; i++) key += `+${id}`;\n return `${key}@${eps}|${this.fingerprint()}`;\n }\n\n /**\n * Convolves this PMF with itself `n` times, by exponentiation by squaring. `n` must be a\n * positive integer.\n *\n * NOTE: this folds `n` independent, identical attacks into one PMF, so it loses data\n * provenance. It is only safe when computing masses; for `atLeast`-style queries use a\n * `DiceQuery` instead of `power()`.\n */\n power(n: number, eps = this.epsilon): PMF {\n if (!Number.isInteger(n) || n <= 0) {\n throw new Error(\"power(n): n must be a positive integer\");\n }\n if (n === 1) return this;\n\n const epsilon = eps ?? this.epsilon;\n\n const key = this.getPowerCacheKey(n, epsilon);\n const cached = pmfCache.get(key);\n if (cached) return cached;\n\n // Start from the base PMF and accumulate n-1 additional powers\n let base: PMF = this.normalized ? this : this.normalize();\n let result: PMF = base;\n let exp = n - 1;\n\n while (exp > 0) {\n if (exp & 1) {\n result = result.convolve(base, epsilon);\n }\n exp >>= 1;\n if (exp > 0) {\n base = base.convolve(base, epsilon);\n }\n }\n\n // A copy carries the flag: `result` may be a convolution shared through the cache.\n const folded = new PMF(\n result.map,\n result.epsilon,\n result.normalized,\n result.identifier,\n false\n );\n pmfCache.set(key, folded);\n return folded;\n }\n\n /*\n * Helper for chaining multiple identical attacks\n */\n replicate(n: number): PMF[] {\n if (!Number.isInteger(n) || n <= 0) {\n throw new Error(\"replicate(n): n must be a positive integer\");\n }\n if (n === 1) return [this];\n return Array.from({ length: n }, () => this);\n }\n\n mass(): number {\n if (this._totalMass === undefined) {\n let totalProbabilityMass = 0;\n for (const { p } of this.map.values()) {\n totalProbabilityMass += p;\n }\n this._totalMass = totalProbabilityMass;\n }\n return this._totalMass;\n }\n\n outcomeMass(outcome: string): number {\n let totalProbabilityMass = 0;\n for (const { p, count } of this.map.values()) {\n totalProbabilityMass += p * ((count[outcome] as number) ?? 0);\n }\n return totalProbabilityMass;\n }\n\n // Helper for testing\n faceTotal(): number {\n return [...this.map.keys()].reduce((sum, key) => sum + key, 0);\n }\n\n normalize(): PMF {\n if (this.normalized) return this;\n const normalizationFactor = this.mass();\n if (normalizationFactor === 0) return this;\n\n // Note: this divides by normalizationFactor rather than multiplying by its\n // reciprocal, to keep results bit-identical to direct division.\n const normalizedMap = new Map<number, Bin>();\n for (const [damageValue, probabilityBin] of this.map) {\n const normalizedCount: OutcomeLabelMap = {};\n for (const labelKey in probabilityBin.count) {\n normalizedCount[labelKey] =\n (probabilityBin.count[labelKey] as number) / normalizationFactor;\n }\n\n let normalizedAttributes: OutcomeLabelMap | undefined;\n if (probabilityBin.attr) {\n normalizedAttributes = {};\n for (const labelKey in probabilityBin.attr) {\n normalizedAttributes[labelKey] =\n (probabilityBin.attr[labelKey] as number) / normalizationFactor;\n }\n }\n\n normalizedMap.set(damageValue, {\n p: probabilityBin.p / normalizationFactor,\n count: normalizedCount,\n attr: normalizedAttributes,\n });\n }\n return new PMF(normalizedMap, this.epsilon, true, this.identifier);\n }\n\n /**\n * Returns a copy with negligible probabilities removed (p < eps).\n * If keepFinalBin is true, the bin with the largest key is always kept,\n * even if its probability is below eps. count/attr submaps are still cleaned.\n */\n compact(eps = this.epsilon, keepFinalBin = false): PMF {\n let maxKey = -Infinity;\n if (keepFinalBin) {\n for (const key of this.map.keys()) {\n if (key > maxKey) maxKey = key;\n }\n }\n\n const compactedMap = new Map<number, Bin>();\n\n for (const [damageValue, probabilityBin] of this.map) {\n const shouldKeep =\n probabilityBin.p >= eps || (keepFinalBin && damageValue === maxKey);\n\n if (!shouldKeep) continue;\n\n // Build a fresh Bin rather than mutating the source. Bins are shared by\n // reference across PMFs (e.g. branch()/addScaled()/scaleMass() fast paths\n // can carry another PMF's bin objects), so deleting sub-eps entries in\n // place would silently corrupt the source PMF's count/attr.\n const cleanedBin = PMF.cloneBin(probabilityBin);\n\n for (const labelKey in cleanedBin.count) {\n if (Math.abs(cleanedBin.count[labelKey] || 0) < eps) {\n delete cleanedBin.count[labelKey];\n }\n }\n\n if (cleanedBin.attr) {\n for (const labelKey in cleanedBin.attr) {\n if (Math.abs(cleanedBin.attr[labelKey] || 0) < eps) {\n delete cleanedBin.attr[labelKey];\n }\n }\n if (Object.keys(cleanedBin.attr).length === 0) {\n cleanedBin.attr = undefined;\n }\n }\n\n compactedMap.set(damageValue, cleanedBin);\n }\n\n return new PMF(compactedMap, eps, this.normalized, this.identifier);\n }\n\n // Note: The \"support\" of a PMF is the set of all non-zero probability outcomes.\n // This returns all damage values with non-zero probability, sorted ascending.\n support(): number[] {\n if (this._support === undefined) {\n this._support = [...this.map.keys()].sort((a, b) => a - b);\n }\n return this._support!;\n }\n\n // Minimum possible damage value.\n min(): number {\n if (this._min === undefined) {\n const support = this.support();\n this._min = support.length > 0 ? support[0] : 0;\n }\n return this._min;\n }\n\n // Maximum possible damage value.\n max(): number {\n if (this._max === undefined) {\n const support = this.support();\n this._max = support.length > 0 ? support[support.length - 1] : 0;\n }\n return this._max;\n }\n\n /**\n * Returns the expected (mean) damage value, Σ v·p. Cached.\n *\n * On a PMF whose mass is not 1 this is the partial expectation (the slice's contribution to\n * the whole distribution's mean), not the conditional mean; `DiceQuery.mean()` divides by the\n * mass instead.\n */\n mean(): number {\n if (this._mean === undefined) {\n let totalSum = 0;\n for (const [damageValue, probabilityBin] of this.map) {\n totalSum += damageValue * probabilityBin.p;\n }\n this._mean = totalSum;\n }\n return this._mean;\n }\n\n /**\n * Returns the variance of the damage distribution. Cached.\n *\n * On a PMF whose mass is not 1 (a slice such as {@link filterOutcome}'s output) this is the\n * variance of the distribution conditioned on the slice, Σ (v − μ)²·p / m with μ = Σ v·p / m\n * and m = {@link mass}, the same quantity `DiceQuery.variance()` reports for that PMF. Note\n * that {@link mean} is not conditioned: it stays the partial expectation Σ v·p, so slices add\n * up. Within 1e-12 of unit mass (or at zero or negative mass) no conditioning is applied.\n */\n variance(): number {\n if (this._variance === undefined) {\n const mass = this.mass();\n const conditional = mass > 0 && Math.abs(mass - 1) > EPS;\n const meanValue = conditional ? this.mean() / mass : this.mean();\n let varianceSum = 0;\n for (const [damageValue, probabilityBin] of this.map) {\n const deviationFromMean = damageValue - meanValue;\n varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;\n }\n this._variance = conditional ? varianceSum / mass : varianceSum;\n }\n return this._variance;\n }\n\n /**\n * Returns the standard deviation of the damage distribution.\n */\n stdev(): number {\n if (this._stdev === undefined) {\n this._stdev = Math.sqrt(this.variance());\n }\n return this._stdev;\n }\n\n /** Deep-copies a Bin, cloning its count and (optional) attr maps. */\n private static cloneBin(bin: Bin): Bin {\n return {\n p: bin.p,\n count: { ...bin.count },\n attr: bin.attr ? { ...bin.attr } : undefined,\n };\n }\n\n /** Returns a new Bin with p, count, and attr all multiplied by `factor`. */\n private static scaleBin(bin: Bin, factor: number): Bin {\n const count: OutcomeLabelMap = {};\n for (const k in bin.count) {\n count[k] = (bin.count[k] as number) * factor;\n }\n\n let attr: OutcomeLabelMap | undefined;\n if (bin.attr) {\n attr = {};\n for (const k in bin.attr) {\n attr[k] = (bin.attr[k] as number) * factor;\n }\n }\n\n return { p: bin.p * factor, count, attr };\n }\n\n private static mergeInto(\n destinationMap: Map<number, Bin>,\n damageValue: number,\n binToAdd: Bin\n ) {\n const existingBin = destinationMap.get(damageValue);\n if (!existingBin) {\n destinationMap.set(damageValue, PMF.cloneBin(binToAdd));\n return;\n }\n\n existingBin.p += binToAdd.p;\n\n for (const labelKey in binToAdd.count) {\n existingBin.count[labelKey] =\n (existingBin.count[labelKey] || 0) +\n (binToAdd.count[labelKey] as number);\n }\n\n if (binToAdd.attr) {\n if (!existingBin.attr) {\n existingBin.attr = {};\n }\n for (const labelKey in binToAdd.attr) {\n existingBin.attr[labelKey] =\n (existingBin.attr[labelKey] || 0) +\n (binToAdd.attr[labelKey] as number);\n }\n }\n }\n\n // Convenience method\n add(other: PMF): PMF {\n return this.addScaled(other, 1);\n }\n\n /**\n * Returns a new PMF with `branch` added to this one, scaled by `probability` before merging —\n * the primitive for conditional effects. Example: `pmf.addScaled(critBranch, 0.05)` → a PMF\n * including a 5% crit slice.\n */\n addScaled(branch: PMF, probability: number): PMF {\n if (probability === 0) return this;\n\n const resultMap = new Map<number, Bin>();\n for (const [dmg, bin] of this.map) {\n resultMap.set(dmg, PMF.cloneBin(bin));\n }\n\n for (const [damageValue, probabilityBin] of branch.map) {\n PMF.mergeInto(\n resultMap,\n damageValue,\n PMF.scaleBin(probabilityBin, probability)\n );\n }\n\n return new PMF(\n resultMap,\n this.epsilon,\n false,\n `${this.identifier}+scaled(${branch.identifier},${probability})`\n );\n }\n\n /**\n * Bernoulli thinning: the effect this PMF describes happens with probability\n * `frequency` and otherwise deals nothing — a conditional attack, an on-hit\n * rider, or a sub-one AoE target fraction. The result is\n * `frequency · X + (1 − frequency) · δ0`.\n *\n * Every bin (negative damage included) keeps `frequency` of its probability\n * mass, per-label `count` and per-label `attr`; the zero bin keeps its labels\n * at that share too. The freed mass, `(1 − frequency) · mass()`, is added to\n * the damage-0 bin under the canonical `missNone` outcome, so the total mass\n * is unchanged, also for a slice whose mass is not 1.\n *\n * Unlike a bare {@link scaleMass} or {@link mapDamage}, this keeps damage\n * attribution (`attr`) intact, so a frequency-scaled PMF still renders\n * correctly in the damage-attribution charts.\n *\n * `frequency >= 1` (or non-finite) returns this PMF unchanged; `frequency <= 0`\n * leaves only the damage-0 bin, holding all of the mass as `missNone`.\n *\n * @param frequency Probability in [0, 1] that the effect occurs.\n */\n applyHitFrequency(frequency: number): PMF {\n if (!Number.isFinite(frequency) || frequency >= 1) return this;\n const freq = Math.max(0, frequency);\n const freedMass = (1 - freq) * this.mass();\n\n const newMap = new Map<number, Bin>();\n if (freq > 0) {\n for (const [damage, bin] of this.map) {\n newMap.set(damage, PMF.scaleBin(bin, freq));\n }\n }\n if (freedMass > 0) {\n PMF.mergeInto(newMap, 0, {\n p: freedMass,\n count: { [MISS_NONE_OUTCOME]: freedMass },\n attr: {},\n });\n }\n\n return new PMF(\n newMap,\n this.epsilon,\n false,\n `freq(${this.identifier},${freq})`\n );\n }\n\n /**\n * Splits this PMF into two complementary PMFs by an arbitrary per-damage-value factor in\n * `[0, 1]` — bin `d`'s mass, `count`, and `attr` split `factor(d)` / `1 - factor(d)` between the\n * two results (via the same proportional scaling {@link applyHitFrequency} uses, `scaleBin`), so\n * `a.add(b)` recovers this PMF exactly and both halves stay chart-attributable. Unlike\n * {@link applyHitFrequency}, mass is NOT redistributed to a miss bin at 0 — each bin stays at its\n * own damage value in whichever half it lands in. `factor` outside `[0, 1]` is clamped.\n *\n * Built for `dice-match` trigger slicing: splitting a hit/crit sub-PMF into \"matched\" and\n * \"did not match\" halves by the exact per-damage-value match probability.\n */\n splitByFactor(factor: (damage: number) => number): [PMF, PMF] {\n const a = new Map<number, Bin>();\n const b = new Map<number, Bin>();\n for (const [damage, bin] of this.map) {\n const f = Math.min(1, Math.max(0, factor(damage)));\n if (f > 0) a.set(damage, PMF.scaleBin(bin, f));\n if (f < 1) b.set(damage, PMF.scaleBin(bin, 1 - f));\n }\n return [\n new PMF(a, this.epsilon, false, `split+(${this.identifier})`),\n new PMF(b, this.epsilon, false, `split-(${this.identifier})`),\n ];\n }\n\n /**\n * Max of two i.i.d. copies of this PMF's distribution: normalize, square\n * the CDF, then restore the original mass. The engine's damage-reroll\n * substitution (`onFirstHit(keepBestDamage())`) applies this to a landing\n * attack's base payload slice — \"roll it again, keep the better total\".\n *\n * PRESERVES outcome labels and attribution. A max, unlike a sum, is\n * literally one of the two draws: the value that wins was drawn from this\n * same distribution, so its `count`/`attr` composition is unchanged in\n * *proportion* — only that bin's total mass is recomputed (via the\n * squared-CDF step) and every label is rescaled by the same factor. This\n * is why {@link power}'s documented provenance loss does not apply here:\n * for a sum, one output value arises from many `(x1, x2)` pairs with\n * different attribution mixes, so provenance is genuinely ambiguous; for a\n * max, there is exactly one realized draw per bin. A naive rebuild through\n * {@link fromMap} would silently discard both `count` and `attr`.\n *\n * Works on a non-unit-mass slice (e.g. {@link filterOutcome}'s output):\n * the CDF is squared on the NORMALIZED distribution, then the result is\n * rescaled back to this PMF's original total mass, not to 1.\n */\n maxOfTwo(): PMF {\n const totalMass = this.mass();\n if (totalMass <= 0) return this;\n\n const resultMap = new Map<number, Bin>();\n let cdf = 0; // running NORMALIZED cdf through the previous support value\n\n for (const damage of this.support()) {\n const bin = this.map.get(damage)!;\n const normalizedP = bin.p / totalMass;\n if (normalizedP <= 0) continue;\n\n const prevCdf = cdf;\n cdf += normalizedP;\n\n // P(max = damage), normalized: F(damage)² − F(damage⁻)², factored as\n // p·(F(damage) + F(damage⁻)). The difference of squares near 1 would\n // cancel the tail bins away; the factored form keeps full precision.\n // It also is the scale factor from the original bin to the new one:\n // reusing the bin's count/attr via scaleBin (rather than rebuilding from\n // a bare number) is what keeps every label's proportion intact.\n resultMap.set(damage, PMF.scaleBin(bin, cdf + prevCdf));\n }\n\n return new PMF(\n resultMap,\n this.epsilon,\n this.normalized,\n `maxOfTwo(${this.identifier})`\n );\n }\n\n scaleMass(factor: number): PMF {\n if (factor === 1) return this;\n\n const scaledMap = new Map<number, Bin>();\n for (const [damageValue, probabilityBin] of this.map) {\n scaledMap.set(damageValue, PMF.scaleBin(probabilityBin, factor));\n }\n return new PMF(\n scaledMap,\n this.epsilon,\n false,\n `scale(${this.identifier},${factor})`\n );\n }\n\n mapDamage(damageTransformFunction: (damageValue: number) => number): PMF {\n const transformedMap = new Map<number, Bin>();\n for (const [originalDamage, probabilityBin] of this.map) {\n const transformedDamage = damageTransformFunction(originalDamage);\n PMF.mergeInto(\n transformedMap,\n transformedDamage,\n PMF.cloneBin(probabilityBin)\n );\n }\n return new PMF(\n transformedMap,\n this.epsilon,\n this.normalized,\n `map(${this.identifier})`\n );\n }\n\n /**\n * Multiplies every damage value by `factor / denominator` and rounds: `floor`\n * (toward −∞, the default), `ceil` (toward +∞) or `round` (to nearest, halves\n * toward +∞). Values that land on the same result merge, labels included.\n *\n * With an integer `factor` and `denominator` the rounding is exact: `v·factor`\n * is an exact integer, and one division of two integers below 2^53 lands on\n * the correct side of every integer. Pass a ratio that way, e.g.\n * `scaleDamage(9, \"ceil\", 7)`; `scaleDamage(9 / 7, \"ceil\")` rounds the factor\n * to a double first, so 21·(9/7) = 27.000000000000004 would round up to 28.\n */\n scaleDamage(\n factor: number,\n rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\",\n denominator = 1\n ): PMF {\n if (!Number.isFinite(factor)) {\n throw new RangeError(`scaleDamage() factor must be finite, got ${factor}`);\n }\n if (!Number.isFinite(denominator) || denominator === 0) {\n throw new RangeError(`scaleDamage() denominator must be finite and non-zero, got ${denominator}`);\n }\n const exact = Number.isInteger(factor) && Number.isInteger(denominator);\n return this.mapDamage((damageValue) => {\n if (exact && Number.isInteger(damageValue)) {\n const numerator = damageValue * factor;\n if (rounding === \"round\") {\n return Math.floor((2 * numerator + denominator) / (2 * denominator));\n }\n const quotient = numerator / denominator;\n return rounding === \"ceil\" ? Math.ceil(quotient) : Math.floor(quotient);\n }\n const scaled = (damageValue * factor) / denominator;\n return rounding === \"round\"\n ? Math.round(scaled)\n : rounding === \"ceil\"\n ? Math.ceil(scaled)\n : Math.floor(scaled);\n });\n }\n\n private getPMFCombineCacheKey(\n p1: PMF,\n p2: PMF,\n eps: number,\n raw: boolean\n ): string {\n const [id1, id2] = [p1.identifier, p2.identifier].sort();\n\n return `v4:${raw ? \"RAW\" : \"N\"}:${id1}+${id2}@${eps}|${p1.fingerprint()}|${p2.fingerprint()}`;\n }\n\n /**\n * A content fingerprint of every bin (probability, per-label `count`, per-label `attr`) plus\n * the `normalized` flag, so convolution/power cache keys change whenever the underlying\n * numbers do. Mass/bin-count/face-sum alone are not content-unique: `mapDamage` variants can\n * keep the same identifier, support, mass, and face sum while differing in per-bin\n * probabilities or in the `count`/`attr` channels `convolve()`/`power()` actually propagate --\n * that previously let `power()` return one PMF's cached result for a different PMF. Memoized\n * because a PMF is immutable once constructed -- this avoids re-deriving the key on every\n * convolve()/power() call (including cache hits). Bin order is sorted by damage value (and\n * label keys sorted within each bin) so two equal-content PMFs built via different code paths\n * fingerprint identically regardless of Map insertion order. Label keys are JSON-encoded, so a\n * label containing the separators cannot make two different bins read the same.\n */\n fingerprint(): string {\n if (this._fingerprint === undefined) {\n const labels = (m: OutcomeLabelMap | undefined): string =>\n m === undefined\n ? \"\"\n : Object.keys(m)\n .sort()\n .map((k) => `${JSON.stringify(k)}:${m[k]}`)\n .join(\",\");\n const bins = [...this.map.entries()].sort((a, b) => a[0] - b[0]);\n const parts: string[] = [];\n for (const [damageValue, bin] of bins) {\n parts.push(`${damageValue}:${bin.p}[${labels(bin.count)}]{${labels(bin.attr)}}`);\n }\n this._fingerprint = `${this.normalized ? 1 : 0}|${parts.join(\";\")}`;\n }\n return this._fingerprint;\n }\n\n convolve(other: PMF, eps?: number, raw = false): PMF {\n const epsilon = eps ?? this.epsilon;\n\n // Normalize-by-value on non-raw path\n const norm = (x: PMF) =>\n raw ? x : Math.abs(x.mass() - 1) <= epsilon ? x : x.normalize();\n const A0 = norm(this);\n const B0 = norm(other);\n\n const [A, B] = A0.identifier <= B0.identifier ? [A0, B0] : [B0, A0];\n const cacheKey = this.getPMFCombineCacheKey(A, B, epsilon, raw);\n const cached = pmfCache.get(cacheKey);\n if (cached) return cached;\n\n // Accumulate directly into each destination bin instead of building a\n // temporary Bin per (a,b) pair and merging it. The probability channel\n // (`dest.p += ap*bp`) accumulates in the same order as before, so it is\n // bit-identical; only the per-label `count`/`attr` sums re-associate, which\n // shifts them by at most a few ULP (far below the eps pruning threshold).\n // Label entries are listed once per bin, outside the pair loop: enumerating\n // the keys of a (frozen, cached) bin per pair costs more than the arithmetic.\n const labelEntries = (m: OutcomeLabelMap | undefined): [string, number][] | undefined =>\n m === undefined ? undefined : (Object.entries(m) as [string, number][]);\n const bEntries = [...B.map].map(([bVal, bBin]) => ({\n bVal,\n bp: bBin.p,\n count: labelEntries(bBin.count) as [string, number][],\n attr: labelEntries(bBin.attr),\n }));\n const combinedMap = new Map<number, Bin>();\n for (const [aVal, aBin] of A.map) {\n const ap = aBin.p;\n const aCount = labelEntries(aBin.count) as [string, number][];\n const aAttr = labelEntries(aBin.attr);\n for (const { bVal, bp, count: bCount, attr: bAttr } of bEntries) {\n const dmg = aVal + bVal;\n\n let dest = combinedMap.get(dmg);\n if (dest === undefined) {\n dest = { p: 0, count: {} };\n combinedMap.set(dmg, dest);\n }\n\n dest.p += ap * bp;\n\n const dc = dest.count;\n for (const [k, v] of aCount) dc[k] = (dc[k] || 0) + v * bp;\n for (const [k, v] of bCount) dc[k] = (dc[k] || 0) + v * ap;\n\n if (aAttr || bAttr) {\n let da = dest.attr;\n if (da === undefined) {\n da = {};\n dest.attr = da;\n }\n if (aAttr) for (const [k, v] of aAttr) da[k] = (da[k] || 0) + v * bp;\n if (bAttr) for (const [k, v] of bAttr) da[k] = (da[k] || 0) + v * ap;\n }\n }\n }\n\n let result = new PMF(\n combinedMap,\n epsilon,\n !raw,\n `${A.identifier}${raw ? \"*\" : \"+\"}${B.identifier}`\n );\n\n // Enforce mass invariant: mass(out) = (raw? A.mass():1) * (raw? B.mass():1)\n const mExp = (raw ? A.mass() : 1) * (raw ? B.mass() : 1);\n const mGot = result.mass();\n // Guard mGot !== 0: a zero-mass operand convolves to the zero measure\n // (mass 0). Without this guard the non-raw path would scaleMass(mExp/0) =\n // scaleMass(Infinity), poisoning every bin to 0*Infinity = NaN.\n if (mExp !== 0 && mGot !== 0 && Math.abs(mGot - mExp) > epsilon) {\n result = result.scaleMass(mExp / mGot);\n }\n if (!raw && mGot !== 0 && Math.abs(result.mass() - 1) > epsilon)\n result = result.normalize();\n\n pmfCache.set(cacheKey, result);\n return result;\n }\n\n // Convolve without renormalizing (raw = true), for callers that combine raw counts.\n combineRaw(other: PMF, eps?: number): PMF {\n return this.convolve(other, eps, true);\n }\n\n // Reduce a list of PMFs by left-folding convolve() with the given eps\n private static reduceConvolveLeft(pmfList: PMF[], eps: number): PMF {\n let result = pmfList[0];\n for (let i = 1; i < pmfList.length; i++) {\n result = result.convolve(pmfList[i], eps);\n }\n return result;\n }\n\n /**\n * Convolves multiple PMFs using linear convolution with automatic caching.\n * Uses a left-to-right accumulation approach for maximum cache reuse.\n * Each convolve() call automatically uses the convolution cache for performance.\n *\n * This linear approach provides better cache hits than pairwise because:\n * - Intermediate results are more predictable and stable\n * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)\n * - Order-independent cache keys work better with consistent build patterns\n */\n static convolveMany(pmfList: PMF[], eps = EPS): PMF {\n if (pmfList.length === 0) return PMF.empty(eps);\n if (pmfList.length === 1) return pmfList[0];\n\n // Linear combination with automatic intermediate caching: each prefix\n // (A+B, (A+B)+C, ...) is a stable cache key, maximizing reuse.\n return PMF.reduceConvolveLeft(pmfList, eps);\n }\n\n /**\n * Returns a plain, JSON-serializable representation of this PMF.\n *\n * Follows the standard `toJSON` contract, so `JSON.stringify(pmf)` produces\n * the expected output (no double-encoding). Use {@link PMF.fromJSON} to\n * reconstruct, or {@link PMF.toJSONString} if you need the string directly.\n */\n toJSON(): {\n bins: Array<[number, Bin]>;\n normalized: boolean;\n identifier: string;\n } {\n return {\n bins: [...this.map.entries()],\n normalized: this.normalized,\n identifier: this.identifier,\n };\n }\n\n /** Serializes this PMF to a JSON string (equivalent to `JSON.stringify(pmf)`). */\n toJSONString(): string {\n return JSON.stringify(this);\n }\n\n static fromJSON(jsonData: {\n bins: Array<[number, Bin]>;\n normalized?: boolean;\n identifier?: string;\n }) {\n return new PMF(\n new Map(jsonData.bins),\n EPS,\n !!jsonData.normalized,\n jsonData.identifier || \"fromJSON\"\n );\n }\n\n /**\n * Relative pruning with optional top-K floor.\n * Keeps bins with p >= epsRel * peak, always keeps min and max damage,\n * optionally guarantees at least `minBins` survivors by adding top-K.\n * Returns a new, non-normalized PMF.\n */\n prune(epsRel: number, minBins = 0): PMF {\n const size = this.map.size;\n if (size === 0) return this;\n\n // One pass: peak, min, max\n let peak = 0;\n let minDamage = Number.POSITIVE_INFINITY;\n let maxDamage = Number.NEGATIVE_INFINITY;\n for (const [dmg, bin] of this.map) {\n if (bin.p > peak) peak = bin.p;\n if (dmg < minDamage) minDamage = dmg;\n if (dmg > maxDamage) maxDamage = dmg;\n }\n if (peak === 0)\n return new PMF(new Map(this.map), epsRel, false, this.identifier);\n\n const thresh = epsRel * peak;\n const entries = [...this.map.entries()];\n\n // Protect endpoints\n const survivorsByDmg = new Map<number, Bin>();\n const protect = (d: number) => {\n const b = this.map.get(d);\n if (b) survivorsByDmg.set(d, b);\n };\n protect(minDamage);\n if (maxDamage !== minDamage) protect(maxDamage);\n\n // Relative survivors\n for (const [dmg, bin] of entries) {\n if (bin.p >= thresh) survivorsByDmg.set(dmg, bin);\n }\n\n // Enforce minBins via top-K if requested\n if (minBins > 0 && survivorsByDmg.size < minBins) {\n // Sort all entries by probability desc (or replace with Quickselect for O(n))\n entries.sort((a, b) => b[1].p - a[1].p);\n for (const [dmg, bin] of entries) {\n if (!survivorsByDmg.has(dmg)) {\n survivorsByDmg.set(dmg, bin);\n if (survivorsByDmg.size >= minBins) break;\n }\n }\n }\n\n // Rebuild map, pruning tiny count/attr entries with the same threshold\n const prunedMap = new Map<number, Bin>();\n for (const [dmg, bin] of survivorsByDmg) {\n const newCount: OutcomeLabelMap = {};\n for (const k in bin.count) {\n const v = bin.count[k] as number;\n if (Math.abs(v) >= thresh) newCount[k] = v;\n }\n let newAttr: OutcomeLabelMap | undefined;\n if (bin.attr) {\n for (const k in bin.attr) {\n const v = bin.attr[k] as number;\n if (Math.abs(v) >= thresh) {\n if (!newAttr) newAttr = {};\n newAttr[k] = v;\n }\n }\n }\n prunedMap.set(dmg, { p: bin.p, count: newCount, attr: newAttr });\n }\n\n // Return non-normalized PMF\n return new PMF(prunedMap, epsRel, false, `prune(${this.identifier})`);\n }\n\n /** Probability mass at exactly x. */\n pAt(x: number): number {\n return this.map.get(x)?.p ?? 0;\n }\n\n /**\n * P(any damage) — the mass on all non-zero outcomes, i.e. `1 - P(0)`.\n * Assumes a miss is encoded as the damage-0 bin (the convention used across\n * attack/save PMFs). The dual of {@link missProbability}.\n */\n hitProbability(): number {\n return 1 - this.pAt(0);\n }\n\n /** P(no damage) — the mass at damage 0. The dual of {@link hitProbability}. */\n missProbability(): number {\n return this.pAt(0);\n }\n\n /**\n * Coarsen the distribution into at most `maxBuckets` contiguous, equal-width\n * damage buckets, aggregating probability mass (and `count`/`attr`\n * provenance) into each bucket's start value. Returns this PMF unchanged when\n * its integer support already fits within `maxBuckets`.\n *\n * This is a lossy display/downsampling transform (bucket start replaces the\n * exact damage value) — use it for charting wide distributions, not for DPR\n * math.\n */\n rebin(maxBuckets: number): PMF {\n if (!(maxBuckets > 0)) return this;\n const support = this.support();\n if (support.length === 0) return this;\n const min = support[0];\n const max = support[support.length - 1];\n const range = max - min;\n if (range + 1 <= maxBuckets) return this;\n const binSize = Math.ceil((range + 1) / maxBuckets);\n return this.mapDamage((d) => min + Math.floor((d - min) / binSize) * binSize);\n }\n\n /** Dense integer support from min..max (inclusive).\n * Useful for showing empty bars in charts.\n */\n denseSupport(): number[] {\n const s = this.support();\n if (s.length === 0) return [];\n const lo = Math.min(...s),\n hi = Math.max(...s);\n return Array.from({ length: hi - lo + 1 }, (_, i) => lo + i).sort(\n (a, b) => a - b\n );\n }\n\n /** CDF at x: P(X ≤ x). */\n cdfAt(x: number): number {\n let acc = 0;\n for (const [val, bin] of this.map) if (val <= x) acc += bin.p;\n return acc;\n }\n\n /**\n * Quantile / inverse CDF: the smallest support value x with P(X ≤ x) ≥ p·mass().\n * `p <= 0` gives the smallest support value; `p >= 1` or NaN gives the largest.\n *\n * A float running sum can land an ulp short of a CDF that is exactly p (a d20's CDF(10) sums\n * to 0.49999999999999994), so the comparison allows a relative slack of a few ulps per bin.\n * Below the median it compares the CDF summed from the low end; above it, the mass strictly\n * above x summed from the high end. A sum of non-negative terms is accurate relative to its\n * own size, so the tail that decides the answer is never swamped by the rest of the mass.\n */\n quantile(p: number): number {\n const { values, below, above } = this.cumulative();\n const n = values.length;\n if (n === 0) return 0;\n const total = below[n - 1];\n if (!(total > 0)) return 0;\n if (p <= 0) return values[0];\n if (p >= 1) return values[n - 1];\n\n const slack = Math.max(QUANTILE_RELATIVE_SLACK, 4 * n * Number.EPSILON);\n const lowTarget = p * total * (1 - slack);\n const highTarget = (1 - p) * total * (1 + slack);\n const lowSide = p <= 0.5;\n\n // Smallest index whose CDF reaches p; the test is monotone in the index.\n let lo = 0;\n let hi = n;\n while (lo < hi) {\n const mid = (lo + hi) >>> 1;\n const reached = lowSide ? below[mid] >= lowTarget : above[mid] <= highTarget;\n if (reached) hi = mid;\n else lo = mid + 1;\n }\n return values[Math.min(lo, n - 1)];\n }\n\n /**\n * Sorted support with `below[i]` = Σ p over values ≤ values[i], summed from the low end,\n * and `above[i]` = Σ p over values > values[i], summed from the high end. Cached.\n */\n private cumulative(): { values: number[]; below: number[]; above: number[] } {\n if (this._cumulative === undefined) {\n const values = this.support();\n const n = values.length;\n const below = new Array<number>(n);\n const above = new Array<number>(n);\n let sum = 0;\n for (let i = 0; i < n; i++) {\n sum += (this.map.get(values[i]) as Bin).p;\n below[i] = sum;\n }\n sum = 0;\n for (let i = n - 1; i >= 0; i--) {\n above[i] = sum;\n sum += (this.map.get(values[i]) as Bin).p;\n }\n this._cumulative = { values, below, above };\n }\n return this._cumulative;\n }\n\n /** Get outcome probability at specific damage value. */\n outcomeAt(damage: number, outcome: string): number {\n return (this.map.get(damage)?.count[outcome] as number) ?? 0;\n }\n\n /** Get all outcome types present in this PMF. */\n outcomes(): string[] {\n const outcomeSet = new Set<string>();\n for (const [, bin] of this.map) {\n for (const outcome in bin.count) {\n if ((bin.count[outcome] as number) > 0) {\n outcomeSet.add(outcome);\n }\n }\n }\n return Array.from(outcomeSet).sort();\n }\n\n /** Get total probability of an outcome across all damage values. */\n outcomeProbability(outcome: string): number {\n let total = 0;\n for (const [, bin] of this.map) {\n total += (bin.count[outcome] as number) ?? 0;\n }\n return total;\n }\n\n /** Get damage attribution for an outcome at specific damage value. */\n outcomeAttributionAt(damage: number, outcome: string): number {\n return (this.map.get(damage)?.attr?.[outcome] as number) ?? 0;\n }\n\n /** Get all outcome data at specific damage value. */\n binAt(damage: number): {\n p: number;\n count: Record<string, number>;\n attr?: Record<string, number>;\n } | null {\n const bin = this.map.get(damage);\n if (!bin) return null;\n\n return {\n p: bin.p,\n count: { ...bin.count } as Record<string, number>,\n attr: bin.attr ? ({ ...bin.attr } as Record<string, number>) : undefined,\n };\n }\n\n /** Check if outcome exists in this PMF. */\n hasOutcome(outcome: string): boolean {\n for (const [, bin] of this.map) {\n if (((bin.count[outcome] as number) ?? 0) > 0) {\n return true;\n }\n }\n return false;\n }\n\n /**\n * Split each damage value's probability mass across outcome labels, returning\n * per-label maps of `damage value → probability mass attributable to that\n * label`. Summing over labels at a given value recovers that value's `p`.\n *\n * Damage-bearing bins are split by `attr` weight (the share of damage each\n * outcome contributed); the clean-miss bin at 0 is split by `count` weight\n * (there is no damage to attribute). Attribution is computed on demand via\n * {@link withAttribution} when absent, so builder-generated PMFs work too.\n *\n * This is the provenance core of the stacked damage-attribution chart — the\n * caller only maps these series into its rendering format (colors, binning,\n * axis labels).\n */\n attributionByValue(): Map<string, Map<number, number>> {\n const src = this.hasAttribution() ? this : this.withAttribution();\n const result = new Map<string, Map<number, number>>();\n\n const add = (label: string, damage: number, mass: number): void => {\n if (!(mass > 0)) return;\n let series = result.get(label);\n if (!series) {\n series = new Map<number, number>();\n result.set(label, series);\n }\n series.set(damage, (series.get(damage) ?? 0) + mass);\n };\n\n for (const [damage, bin] of src.map) {\n const p = bin.p || 0;\n if (p <= 0) continue;\n const isMissBin = damage === 0;\n\n // Damage-0 (clean miss): split by count, crediting the missNone label.\n if (isMissBin) {\n let totalCount = 0;\n for (const k in bin.count) totalCount += (bin.count[k] as number) || 0;\n if (totalCount > 0) {\n const c = (bin.count[MISS_NONE_OUTCOME] as number) || 0;\n add(MISS_NONE_OUTCOME, damage, (c / totalCount) * p);\n }\n continue;\n }\n\n // Damage-bearing bin: split by attribution weight.\n let totalAttr = 0;\n if (bin.attr) for (const k in bin.attr) totalAttr += (bin.attr[k] as number) || 0;\n if (bin.attr && totalAttr > 0) {\n for (const k in bin.attr) {\n if (k === MISS_NONE_OUTCOME) continue;\n add(k, damage, (((bin.attr[k] as number) || 0) / totalAttr) * p);\n }\n }\n }\n\n return result;\n }\n\n /**\n * Reversed-convention CCDF percentile markers used by the attribution chart:\n * for each target probability t, the largest damage x still reached with\n * P(X ≥ x) > t%, falling back to the smallest/largest support value at the\n * edges. Ported verbatim from the app so `p80/p50/p20` keep their intentional\n * reversed meaning (p80 is the low-damage end). Computed on the full, un-binned\n * support. Assumes a non-empty map.\n */\n private attributionPercentiles(): { p80: number; p50: number; p20: number } {\n const sortedKeys = [...this.map.keys()].sort((a, b) => a - b);\n const sparseCCDF: { x: number; y: number }[] = [];\n let cumulativeP = 0;\n for (let i = sortedKeys.length - 1; i >= 0; i--) {\n const key = sortedKeys[i];\n const bin = this.map.get(key);\n if (!bin) continue;\n cumulativeP += bin.p;\n sparseCCDF.unshift({ x: key, y: cumulativeP * 100 });\n }\n const findDamageAtProbability = (targetProb: number): number => {\n for (let i = 0; i < sparseCCDF.length; i++) {\n if (sparseCCDF[i].y <= targetProb) {\n return i > 0 ? sparseCCDF[i - 1].x : sparseCCDF[i].x;\n }\n }\n return sparseCCDF[sparseCCDF.length - 1].x;\n };\n return {\n p80: findDamageAtProbability(80),\n p50: findDamageAtProbability(50),\n p20: findDamageAtProbability(20),\n };\n }\n\n /**\n * Full numeric model for the stacked damage-attribution chart — bar-height\n * masses, tooltip shares, bucket labels/ranges, percentile markers, and the\n * mean. The caller only maps these into a rendering format (colors, labels,\n * axis units); all of the dice-and-probability logic lives here.\n *\n * Built split-first-then-bin: the attribution split ({@link attributionByValue})\n * runs on the un-binned distribution, then the resulting series are coarsened.\n * {@link rebin} is deliberately *not* used — rebinning first would fold any\n * sub-`binSize` damage into the damage-0 bucket, which the split then mistakes\n * for a clean miss and drops.\n *\n * @param options.maxBuckets Coarsen to at most this many equal-width buckets\n * when the integer support is wider (`range > maxBuckets`); omit for a dense,\n * per-integer model.\n * @param options.stackOrder Preferred outcome order (defaults to\n * {@link ALL_OUTCOME_TYPES}); labels outside it sort alphabetically after.\n * @param options.epsilon Bucket-total floor below which a `shares` entry is 0\n * (divide-by-~0 guard). Defaults to 1e-9.\n */\n damageAttributionChartModel(\n options: {\n maxBuckets?: number;\n stackOrder?: readonly string[];\n epsilon?: number;\n } = {}\n ): DamageAttributionChartModel {\n const { maxBuckets, stackOrder = ALL_OUTCOME_TYPES, epsilon = 1e-9 } = options;\n\n const empty: DamageAttributionChartModel = {\n labels: [],\n outcomes: [],\n series: new Map(),\n shares: new Map(),\n totals: [],\n percentiles: { p80: 0, p50: 0, p20: 0 },\n mean: 0,\n };\n if (this.map.size === 0) return empty;\n\n // Split on the un-binned distribution: outcome → (damage → probability mass).\n const split = this.attributionByValue();\n\n // Discover outcomes across BOTH count and attr keys so any all-zero legend\n // entries survive (matches the app's discovery), then order for stacking.\n const discovered = new Set<string>();\n for (const [, bin] of this.map) {\n for (const k in bin.count) discovered.add(k);\n if (bin.attr) for (const k in bin.attr) discovered.add(k);\n }\n const outcomes = sortOutcomes([...discovered], stackOrder);\n const hasAttribution = outcomes.length > 0;\n\n // Support window over values carrying positive mass (the app's allDamageValues):\n // from the split for attributed PMFs, from positive-p bins for pure ones.\n let min = Infinity;\n let max = -Infinity;\n const widen = (d: number): void => {\n if (d < min) min = d;\n if (d > max) max = d;\n };\n if (hasAttribution) {\n for (const s of split.values())\n for (const [d, m] of s) if (m > 0) widen(d);\n } else {\n for (const [d, bin] of this.map) if ((bin.p || 0) > 0) widen(d);\n }\n if (max < min) return empty; // nothing carried positive mass\n const range = max - min;\n\n // Binning geometry — dense (per-integer) unless range > maxBuckets.\n const binned =\n maxBuckets !== undefined && maxBuckets > 0 && range > maxBuckets;\n const binSize = binned ? Math.ceil((range + 1) / maxBuckets!) : 1;\n const numBins = binned ? Math.ceil((range + 1) / binSize) : range + 1;\n const bucketOf = (d: number): number => Math.floor((d - min) / binSize);\n\n const labels: number[] = [];\n const binRanges: { start: number; end: number }[] | undefined = binned\n ? []\n : undefined;\n for (let i = 0; i < numBins; i++) {\n const start = min + i * binSize;\n labels.push(start);\n if (binRanges)\n binRanges.push({ start, end: Math.min(start + binSize - 1, max) });\n }\n\n // Aggregate per-outcome masses into buckets.\n const series = new Map<string, number[]>();\n for (const outcome of outcomes) {\n const arr = new Array<number>(numBins).fill(0);\n const s = split.get(outcome);\n if (s) {\n for (const [d, m] of s) {\n const b = bucketOf(d);\n if (b >= 0 && b < numBins) arr[b] += m;\n }\n }\n series.set(outcome, arr);\n }\n\n // Per-bucket totals: sum of the attributed series, or (pure) of raw p.\n const totals = new Array<number>(numBins).fill(0);\n if (hasAttribution) {\n for (const arr of series.values())\n for (let i = 0; i < numBins; i++) totals[i] += arr[i];\n } else {\n for (const [d, bin] of this.map) {\n const p = bin.p || 0;\n if (p <= 0) continue;\n const b = bucketOf(d);\n if (b >= 0 && b < numBins) totals[b] += p;\n }\n }\n\n // Conditional shares for tooltips (guarded against a ~zero bucket total).\n const shares = new Map<string, number[]>();\n for (const outcome of outcomes) {\n const arr = series.get(outcome)!;\n const sh = new Array<number>(numBins).fill(0);\n for (let i = 0; i < numBins; i++) {\n sh[i] = totals[i] > epsilon ? arr[i] / totals[i] : 0;\n }\n shares.set(outcome, sh);\n }\n\n return {\n labels,\n binRanges,\n outcomes,\n series,\n shares,\n totals,\n percentiles: this.attributionPercentiles(),\n mean: this.mean(),\n };\n }\n\n tailProbGE(t: number): number {\n let s = 0;\n for (const [x, bin] of this) {\n if (bin.p > 0 && x >= t) s += bin.p;\n }\n return s;\n }\n\n tailProbGT(t: number): number {\n let s = 0;\n for (const [x, rec] of this) {\n if (x > t) s += rec.p;\n }\n return s;\n }\n\n /**\n * Returns a new PMF containing only bins where the specified outcome has non-zero probability.\n * This creates a marginal distribution for the given outcome type, with probabilities\n * scaled to represent the unconditional mass attributable to that outcome.\n */\n filterOutcome(outcome: string): PMF {\n const filteredMap = new Map<number, Bin>();\n\n for (const [damageValue, bin] of this.map) {\n const outcomeCount = (bin.count[outcome] as number) ?? 0;\n\n // total paths that reached this bin (sum across labels)\n const totalCount = Object.values(bin.count ?? {}).reduce(\n (a, b) => (a ?? 0) + ((b as number) ?? 0),\n 0\n );\n\n if (outcomeCount > 0 && totalCount !== undefined && totalCount > 0) {\n // proportion of this bin's mass attributable to the outcome\n const proportion = outcomeCount / totalCount;\n\n // downweight p to the unconditional mass from the outcome only\n const newP = bin.p * proportion;\n\n const newCount: OutcomeLabelMap = { [outcome]: outcomeCount };\n\n let newAttr: OutcomeLabelMap | undefined;\n if (bin.attr && bin.attr[outcome] !== undefined) {\n // A count-like attr accumulator is scaled by the same proportion; a per-outcome-only\n // attr carries over as-is.\n newAttr = { [outcome]: (bin.attr[outcome] as number) * proportion };\n }\n\n filteredMap.set(damageValue, {\n p: newP,\n count: newCount,\n attr: newAttr,\n });\n }\n }\n\n return new PMF(\n filteredMap,\n this.epsilon,\n false, // don't normalize by default\n `filter(${this.identifier},${outcome})`\n );\n }\n /**\n * Calculates probabilities for first-success outcomes across n independent attempts.\n *\n * @param pSuccess - Total probability of any success on a single attempt.\n * @param pSpecial - Probability of a specific subset of successes (e.g., critical success).\n * @param n - Number of independent attempts.\n *\n * Returns:\n * - pSpecificSuccess: Probability that the first success was of the \"special\" type\n * - pGeneralSuccess: Probability that the first success was of the non-special type\n * - pNone: Probability that no successes occurred\n * - pAny: Probability that at least one success occurred\n */\n public static firstSuccessWeights(\n pSuccess: number,\n pSpecial: number,\n n: number\n ) {\n // Preconditions: the \"special\" successes are a subset of all successes, so\n // 0 <= pSpecial <= pSuccess <= 1. Without this guard, violating inputs\n // silently produce probabilities outside [0,1].\n if (\n !Number.isFinite(pSuccess) ||\n !Number.isFinite(pSpecial) ||\n pSuccess < 0 ||\n pSuccess > 1 ||\n pSpecial < 0 ||\n pSpecial - pSuccess > EPS\n ) {\n throw new Error(\n `firstSuccessWeights: require 0 <= pSpecial <= pSuccess <= 1 (got pSuccess=${pSuccess}, pSpecial=${pSpecial})`\n );\n }\n\n const pFail = 1 - pSuccess;\n const pFailAll = Math.pow(pFail, n);\n\n // Probability of at least one success\n const pAny = 1 - pFailAll;\n\n // Avoid divide-by-zero if pSuccess is 0\n const denom = pSuccess === 0 ? 1 : pSuccess;\n\n // Breakdown of first success type\n const pSpecificSuccess = (pSpecial * pAny) / denom;\n const pGeneralSuccess = ((pSuccess - pSpecial) * pAny) / denom;\n\n const pNone = 1 - pSpecificSuccess - pGeneralSuccess; // Should equal pFailAll\n\n return { pSpecificSuccess, pGeneralSuccess, pNone, pAny };\n }\n\n /**\n * Maps every damage value through `f`, then optionally rounds it (`rounding`, default\n * `\"none\"`). Values that land on the same result merge their probability and, unless\n * `preserveCounts` is false, their per-label `count`. Damage attribution (`attr`) is dropped,\n * because it is tied to the old values. Nothing is pruned and the mass is unchanged.\n *\n * @param eps Epsilon carried by the result.\n * @throws Error when a mapped value is not a finite integer.\n */\n mapValues(\n f: (v: number) => number,\n eps: number = EPS,\n opts?: { rounding?: Rounding; preserveCounts?: boolean }\n ): PMF {\n const rounding = opts?.rounding ?? \"none\";\n const preserveCounts = opts?.preserveCounts ?? true;\n\n const round = (x: number) =>\n rounding === \"floor\"\n ? Math.floor(x)\n : rounding === \"ceil\"\n ? Math.ceil(x)\n : rounding === \"round\"\n ? Math.round(x)\n : x;\n\n const merged = new Map<number, Bin>();\n for (const [v, bin] of this) {\n if (bin.p === 0) continue;\n const u = round(f(v));\n if (!Number.isInteger(u)) {\n throw new Error(`mapValues: ${v} maps to ${u}, not a finite integer`);\n }\n PMF.mergeInto(merged, u, {\n p: bin.p,\n count: preserveCounts ? bin.count : {},\n });\n }\n\n const sorted = new Map([...merged.entries()].sort((a, b) => a[0] - b[0]));\n return new PMF(sorted, eps, this.normalized, `mapValues(${this.identifier})`);\n }\n\n static fromMap(\n m: Map<number, number>,\n eps: number = EPS,\n { requireIntegerValues = true }: { requireIntegerValues?: boolean } = {}\n ): PMF {\n const filtered: Array<[number, number]> = [];\n for (const [v, p] of m) {\n if (!Number.isFinite(v) || !Number.isFinite(p)) continue;\n if (p <= 0 || Math.abs(p) < eps) continue;\n if (requireIntegerValues && !Number.isInteger(v)) {\n throw new Error(`fromMap: non-integer outcome ${v}`);\n }\n filtered.push([v, p]);\n }\n\n if (filtered.length === 0) {\n throw new Error(\"fromMap: empty or invalid input map\");\n }\n\n // Kahan sum for stability\n let sum = 0;\n let c = 0;\n for (const [, p] of filtered) {\n const y = p - c;\n const t = sum + y;\n c = t - sum - y;\n sum = t;\n }\n if (sum <= 0) throw new Error(\"pmfFromMap: probabilities sum to 0\");\n\n filtered.sort((a, b) => a[0] - b[0]);\n\n const internal = new Map<number, Bin>();\n for (const [v, p] of filtered) {\n internal.set(v, { p: p / sum, count: {} }); // keep count object present for consistency\n }\n return new PMF(internal, eps);\n }\n\n query(): DiceQuery {\n return new DiceQuery(this);\n }\n}\n","// dice.ts (internal)\n\nimport { DiceParseError } from \"../common/errors\";\nimport type {\n Bin,\n DamageDistribution,\n OutcomeLabelMap,\n OutcomeType,\n} from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\n\n/**\n * Work budget for a single dice×dice operation. binaryOp is O(faces₁ × faces₂),\n * so two individually-legal large dice (e.g. `d100000 + d100000`) would otherwise\n * enumerate ~10^10 face pairs and hang. The parser's per-die / per-count caps\n * bound each operand but not their product, so this bounds the operation itself.\n * Generous enough for any realistic expression; only pathological blow-ups trip\n * it. (Chosen so expressions well beyond normal use still parse; tune if needed.)\n */\nconst MAX_BINARY_OUTCOMES = 100_000_000;\n\n/** Internal bookkeeping attached to a {@link Dice} during parsing. */\nexport interface DicePrivateData {\n /** Marks a DC (saving-throw) check so outcomes are attributed correctly. */\n isDCCheck?: boolean;\n /** The \"other\" distribution recorded by {@link Dice.combine}. */\n except?: Dice | Record<string, never>;\n /** Set by a keep (`4kh3`, `2kl1`) on the dice it keeps from: how many of the repeated copies are\n * kept, and whether the lowest or the highest. A keep of one (`2kh1d20`) keeps a single natural roll. */\n keep?: { kept: number; lowest: boolean };\n /** The natural roll of an attack check, followed through every op applied to it, so a crit is the\n * natural-max event (or an `xcrit` range of natural faces) at any bonus roll. It is the check's one\n * d20 wherever it sits in the sum, or with no d20 its largest die; other dice are bonus dice. Read\n * and written by {@link parseExpression} in parser.ts; set on every freshly parsed `dN`/`hdN` atom. */\n critTrack?: CritTrack;\n /** Set instead of {@link critTrack} on a value whose natural die has no single natural roll to\n * follow (`2d20`, `d20 + d20`, `(d20 + 1d4)!`, a bonus pool like `2d4`): that die's size, so a\n * die it outranks never passes for the natural roll. Read and written by parser.ts. */\n untrackedSides?: number;\n /** Set on a value built from numbers alone, with no die anywhere in it but an AC or DC target. As an\n * attack check it has no natural roll, so its crit mass is exactly 0. Read and written by parser.ts. */\n noDie?: true;\n /** The operands of an `&` mix, each carried through every op since with its own natural roll, so the\n * mix crits where a branch does, at that branch's share. Read and written by parser.ts. */\n branches?: readonly Dice[];\n /** Set on the result of an `AC` gate: a following `*` is an attack's hit payload, which crits\n * even with no crit clause. Read by {@link parseExpression} in parser.ts. */\n isACCheck?: boolean;\n /** Set on an attack whose crit is its hit payload doubled (no crit clause): the payload's\n * text, so a trailing hit-only term joins the payload and doubles with it. See parser.ts. */\n implicitCrit?: { payload: string };\n /** Set on an attack's payload: the result of an AC check's `*`, and of each hit-only term after it.\n * A landed hit that deals 0 there is recorded under `hit` at 0, where the misses also sit, and a\n * later hit-only term keeps it (see {@link Dice.calculateHitDistribution}). Read and written by parser.ts. */\n attackPayload?: true;\n}\n\n/**\n * An attack check's natural roll. `slice(f)` is the check's share where the kept natural roll is f,\n * in the check's own counts: every op after the natural die acts face by face, so replaying the\n * ops on face f's weight gives exactly that share, and a mix of checks adds its branches' shares.\n */\nexport interface CritTrack {\n /** The natural die's size. */\n readonly sides: number;\n /** The check is its natural roll itself, with no op since (`d20`, `2kh1d20`, `d20 > d20`, `d20 & d20`). */\n readonly bare: boolean;\n readonly slice: (face: number) => Dice;\n}\n\n/**\n * @internal\n */\nexport class Dice {\n private readonly faces: DamageDistribution = {};\n public privateData: DicePrivateData = {};\n // Partial: the object starts empty and gains keys as outcomes are recorded,\n // so the type must not claim every OutcomeType is present. (Previously typed\n // as a full Record via an `as` cast, which lied about missing keys.)\n private outcomeData: Partial<Record<OutcomeType, DamageDistribution>> = {};\n private hasHitDistributionCalculated = false;\n public identifier?: string;\n\n constructor(x: number = 0) {\n if (x <= 0) return;\n for (let i = 1; i <= x; i++) {\n this.faces[i] = 1;\n }\n }\n\n getOutcomeDistribution(key: OutcomeType): DamageDistribution | undefined {\n if (key === \"hit\") {\n this.ensureHitDistribution();\n }\n\n const distribution = this.outcomeData[key];\n if (distribution === undefined) return undefined;\n\n return { ...distribution };\n }\n\n getFullOutcomeDistribution(): Partial<\n Record<OutcomeType, DamageDistribution>\n > {\n return { ...this.outcomeData };\n }\n\n setOutcomeDistribution(\n key: OutcomeType,\n data: DamageDistribution | undefined\n ): void {\n if (data) {\n this.outcomeData[key] = data;\n } else {\n delete this.outcomeData[key];\n }\n }\n\n hasOutcomeData(key: OutcomeType): boolean {\n if (key === \"hit\") {\n this.ensureHitDistribution();\n }\n const data = this.outcomeData[key];\n return data !== undefined && Object.keys(data).length > 0;\n }\n\n getOutcomeCount(key: OutcomeType, face: number): number {\n return this.outcomeData[key]?.[face] ?? 0;\n }\n\n getAverage(key: OutcomeType): number {\n const distribution = this.getOutcomeDistribution(key);\n if (!distribution) return 0;\n\n const totalCount = Object.values(distribution).reduce(\n (sum, count) => sum + count,\n 0\n );\n const expectedDamage = Object.entries(distribution).reduce(\n (sum, [damage, count]) => sum + Number(damage) * count,\n 0\n );\n if (totalCount === 0) return 0;\n return expectedDamage / totalCount;\n }\n\n // Public (no modifier) for direct test access.\n calculateHitDistribution(): DamageDistribution {\n const hitValues: DamageDistribution = {};\n\n // Hoist the per-outcome distributions out of the face loop: they are\n // constant across faces, so fetching (and previously cloning) them once is\n // O(faces + outcomes) instead of O(faces × outcomes). The stored maps are\n // only read here, never mutated, so reading them directly is safe and\n // produces identical counts.\n const subtractedOutcomes: (DamageDistribution | undefined)[] = [\n this.outcomeData.crit,\n this.outcomeData.missNone,\n this.outcomeData.missDamage,\n this.outcomeData.saveHalf,\n this.outcomeData.saveFail,\n this.outcomeData.pc,\n ];\n\n for (const [face, totalCount] of Object.entries(this.faces)) {\n const numFace = Number(face);\n let hitCount = totalCount;\n\n for (const distribution of subtractedOutcomes) {\n const outcomeCount = distribution?.[numFace];\n if (outcomeCount) {\n hitCount -= outcomeCount;\n }\n }\n\n // At 0 a miss and a hit that deals nothing coincide: only the landed hits recorded there are\n // hits (an attack payload's, see `attackPayload`); everything else at 0 is a miss.\n if (numFace === 0) {\n hitCount = this.outcomeData.hit?.[0] ?? 0;\n }\n\n // Defensive clamp: guards against negative hit counts from older\n // inclusion-exclusion logic. Should never trigger in practice.\n if (hitCount < 0) {\n hitCount = 0;\n }\n hitValues[numFace] = hitCount;\n }\n\n return hitValues;\n }\n\n private ensureHitDistribution(): void {\n if (!this.hasHitDistributionCalculated) {\n const hitValues = this.calculateHitDistribution();\n this.setOutcomeDistribution(\"hit\", hitValues);\n this.hasHitDistributionCalculated = true;\n }\n }\n\n // PRIVATE FUNCTIONS\n\n private binaryOp(\n other: Dice | number,\n op: (a: number, b: number) => number,\n diceConstructor?: () => Dice\n ): Dice {\n const result = diceConstructor ? diceConstructor() : new Dice();\n\n const isScalar = typeof other === \"number\";\n const keys1 = this.keys();\n // Hoist the inner die's faces out of the outer loop: they are constant\n // across key1, so computing them once avoids re-allocating the array on\n // every outer iteration.\n const keys2 = isScalar ? [] : (other as Dice).keys();\n\n // Guard the O(faces₁ × faces₂) work before running it: a binary op between\n // two large (but individually legal) dice would otherwise blow up.\n if (!isScalar && keys1.length * keys2.length > MAX_BINARY_OUTCOMES) {\n throw new DiceParseError(\n `Dice operation over ${keys1.length}×${keys2.length} face pairs exceeds the maximum of ${MAX_BINARY_OUTCOMES}`\n );\n }\n\n for (const key1 of keys1) {\n const value1 = this.faces[key1]!;\n\n if (isScalar) {\n const resultKey = op(key1, other as number);\n result.increment(resultKey, value1);\n } else {\n for (const key2 of keys2) {\n const value2 = other.faces[key2]!;\n const resultKey = op(key1, key2);\n result.increment(resultKey, value1 * value2);\n }\n }\n }\n\n return result;\n }\n\n // PUBLIC FUNCTIONS\n\n getFaceEntries(): [number, number][] {\n return Object.entries(this.faces).map(([k, v]) => [Number(k), v]);\n }\n\n getFaceMap(): DamageDistribution {\n return { ...this.faces };\n }\n\n get(face: number): number {\n return this.faces[face] ?? 0;\n }\n\n keys(): number[] {\n return Object.keys(this.faces).map(Number);\n }\n\n values(): number[] {\n return Object.values(this.faces);\n }\n\n total(): number {\n return Object.values(this.faces).reduce((sum, value) => sum + value, 0);\n }\n\n public setFace(key: number, value: number): void {\n this.faces[key] = value;\n }\n\n public static scalar(value: number): Dice {\n const result = new Dice();\n result.increment(value, 1);\n return result;\n }\n\n public maxFace(): number {\n const numericKeys = this.keys();\n\n if (numericKeys.length === 0) {\n throw new Error(\"No numeric faces found\");\n }\n\n return Math.max(...numericKeys);\n }\n\n public minFace(): number {\n const numericKeys = this.keys();\n\n if (numericKeys.length === 0) {\n throw new Error(\"No numeric faces found\");\n }\n\n return Math.min(...numericKeys);\n }\n\n public increment(face: number, count: number): void {\n const current = this.faces[face] || 0;\n this.faces[face] = current + count;\n }\n\n /** Scales every face count, and every outcome's counts with it, so each outcome keeps its share. */\n public normalize(scalar: number): Dice {\n const result = new Dice();\n\n for (const [face, count] of Object.entries(this.faces)) {\n result.faces[Number(face)] = count * scalar;\n }\n\n result.privateData = { ...this.privateData };\n for (const [key, distribution] of Object.entries(this.outcomeData)) {\n const scaled: DamageDistribution = {};\n for (const [face, count] of Object.entries(distribution)) {\n scaled[Number(face)] = count * scalar;\n }\n result.outcomeData[key as OutcomeType] = scaled;\n }\n return result;\n }\n\n // OPERATIONS\n\n public add(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a + b);\n }\n\n public subtract(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a - b);\n }\n\n public conditionalApply(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a === 0 ? 0 : 1) * b);\n }\n\n public multiply(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a * b);\n }\n\n public addNonZero(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a !== 0 ? a + b : a));\n }\n\n public eq(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a === b ? 1 : 0));\n }\n\n public max(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => Math.max(a, b));\n }\n\n public min(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => Math.min(a, b));\n }\n\n public advantage(): Dice {\n return this.max(this);\n }\n\n public ge(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a >= b ? 0 : 1));\n }\n\n public divide(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a / b);\n }\n\n public divideRoundUp(other: Dice | number): Dice {\n this.assertNonZeroDivisor(other);\n return this.binaryOp(other, (a, b) => (b === 0 ? 0 : Math.ceil(a / b)));\n }\n\n public divideRoundDown(other: Dice | number): Dice {\n this.assertNonZeroDivisor(other);\n return this.binaryOp(other, (a, b) => (b === 0 ? 0 : Math.floor(a / b)));\n }\n\n /** A divisor that can be 0 has no quotient there. A 0 face with no weight is never rolled, so it passes. */\n private assertNonZeroDivisor(other: Dice | number): void {\n if (typeof other === \"number\" ? other === 0 : other.get(0) > 0) {\n throw new DiceParseError(\"Division by zero: the divisor can be 0\");\n }\n }\n\n public and(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a && b ? 1 : 0));\n }\n\n private checkTarget(\n other: Dice | number,\n comparisonLogic: (roll: number, target: number) => number\n ): Dice {\n const createResult = () => {\n const result = new Dice();\n result.increment(0, 0); // Success\n result.increment(1, 0); // Failure\n return result;\n };\n\n return this.binaryOp(other, comparisonLogic, createResult);\n }\n\n public dc(other: Dice | number): Dice {\n const dcCheck = (a: number, b: number) => (a >= b ? 0 : 1);\n const result = this.checkTarget(other, dcCheck);\n // Mark this as a DC check (save mechanic) for proper attribute assignment\n result.privateData.isDCCheck = true;\n return result;\n }\n\n public ac(other: Dice | number): Dice {\n const acCheck = (a: number, b: number) => (a >= b ? a : 0);\n return this.checkTarget(other, acCheck);\n }\n\n public deleteFace(face: number): Dice {\n const result = new Dice();\n\n for (const [key, value] of Object.entries(this.faces)) {\n const numKey = Number(key);\n if (numKey !== face) {\n result.increment(numKey, value);\n }\n }\n\n result.privateData = { ...this.privateData };\n result.outcomeData = { ...this.outcomeData };\n return result;\n }\n\n /**\n * Roll once and, on a result in `toReroll`'s faces, roll again and keep the second roll. Each\n * result keeps its own weight: with T the total count and c_R the count on the rerolled faces,\n * face v's new count is c_v·(T·[v∉R] + c_R), i.e. p′(v) = p(v)·[v∉R] + P(R)·p(v).\n */\n public reroll(toReroll: Dice | number): Dice {\n const rerolled = new Set(typeof toReroll === \"number\" ? [toReroll] : toReroll.keys());\n const total = this.total();\n let rerolledCount = 0;\n for (const [face, count] of this.getFaceEntries()) if (rerolled.has(face)) rerolledCount += count;\n\n const result = new Dice();\n for (const [face, count] of this.getFaceEntries()) {\n result.increment(face, count * ((rerolled.has(face) ? 0 : total) + rerolledCount));\n }\n return result;\n }\n\n // This is not addition and not rolling two dice at once.\n // Instead, it’s mixing two distributions into a single weighted die.\n public combine(other: Dice | number): Dice {\n if (typeof other === \"number\") {\n other = Dice.scalar(other);\n }\n\n // Start by copying \"other\" into a new Dice object\n const result = new Dice();\n for (const [key, value] of Object.entries(other.faces)) {\n result.faces[Number(key)] = value;\n }\n\n // Build the \"except\" dice and add faces from `this` to result\n const except = new Dice();\n for (const [key, value] of Object.entries(this.faces)) {\n const numKey = Number(key);\n result.increment(numKey, value);\n\n // A key absent from `other` is still tracked in `except`.\n if (!(numKey in other.faces)) {\n except.increment(numKey, value); // still tracked in except\n }\n }\n\n result.privateData = { ...this.privateData, except: other };\n result.outcomeData = { ...this.outcomeData };\n return result;\n }\n\n public combineInPlace(other: Dice): void {\n for (const [key, value] of Object.entries(other.faces)) {\n const numKey = Number(key);\n const current = this.faces[numKey] || 0;\n this.faces[numKey] = current + value;\n }\n }\n\n public percent(): DamageDistribution {\n const total = this.total();\n const result: DamageDistribution = {};\n\n for (const [face, count] of Object.entries(this.faces)) {\n result[Number(face)] = count / total;\n }\n\n return result;\n }\n\n public average(): number {\n const total = this.total();\n if (total === 0) return 0;\n\n let sum = 0;\n for (const [key, value] of Object.entries(this.faces)) {\n sum += Number(key) * value;\n }\n\n return sum / total;\n }\n\n /*\n * Convert dice to PMF using OutcomeType labels directly from damage distribution.\n * This is much cleaner than the original complex distribution conversion.\n */\n public toPMF(numEpsilon: number = EPS): PMF {\n const total = this.total();\n if (total === 0) return PMF.empty(numEpsilon);\n\n // Ensure hit distribution is calculated before using it\n this.ensureHitDistribution();\n\n const map = new Map<number, Bin>();\n\n // Outcome distributions (counts, not probabilities)\n const hitDistro = this.getOutcomeDistribution(\"hit\") || {};\n const critDistro = this.getOutcomeDistribution(\"crit\") || {};\n const missDistro = this.getOutcomeDistribution(\"missDamage\") || {};\n const saveDistro = this.getOutcomeDistribution(\"saveHalf\") || {};\n const saveFailDistro = this.getOutcomeDistribution(\"saveFail\") || {};\n const pcDistro = this.getOutcomeDistribution(\"pc\") || {};\n\n // A save string records its failed saves as `saveFail` and its halved successes as\n // `saveHalf`, a failed save that rolls 0 damage included. What is left of a save-half string\n // is full damage on a failed save too; a bare DC check (no payload) is 1 on a failed save.\n const isSaveHalf = Object.keys(saveDistro).length > 0;\n\n const isDCCheck = this.privateData.isDCCheck === true;\n\n const clampNonNeg = (x: number) => (x < 0 && x > -1e-15 ? 0 : x);\n\n // Process each face value (iterate the internal map directly; this loop\n // only reads it, so the defensive clone from getFaceMap() is unnecessary)\n for (const [faceStr, faceCountRaw] of Object.entries(this.faces)) {\n const face = Number(faceStr);\n const faceCount = Number(faceCountRaw);\n\n // Skip structurally present but empty bins early\n if (faceCount <= 0) continue;\n\n let p = faceCount / total;\n p = clampNonNeg(p);\n\n // Always drop exact zeros to keep PMF semantics clean\n if (!(p > 0)) continue;\n\n // Optional pruning only when epsilon is enabled\n if (numEpsilon >= 0 && p < numEpsilon) continue;\n\n const count: OutcomeLabelMap = {};\n const attr: OutcomeLabelMap = {};\n\n // Add distribution counts and attributions\n if (hitDistro[face]) {\n const c = clampNonNeg(hitDistro[face] / total);\n if (c > 0) {\n if (isSaveHalf || isDCCheck) {\n count.saveFail = c; // full damage on failed save\n attr.saveFail = clampNonNeg((face * hitDistro[face]) / total);\n } else {\n count.hit = c;\n attr.hit = clampNonNeg((face * hitDistro[face]) / total);\n }\n }\n }\n\n if (critDistro[face]) {\n const c = clampNonNeg(critDistro[face] / total);\n if (c > 0) {\n count.crit = c;\n attr.crit = clampNonNeg((face * critDistro[face]) / total);\n }\n }\n\n if (missDistro[face]) {\n const c = clampNonNeg(missDistro[face] / total);\n if (c > 0) {\n count.missDamage = c;\n attr.missDamage = clampNonNeg((face * missDistro[face]) / total);\n }\n }\n\n if (saveDistro[face]) {\n const c = clampNonNeg(saveDistro[face] / total);\n if (c > 0) {\n count.saveHalf = c; // half damage on successful save\n attr.saveHalf = clampNonNeg((face * saveDistro[face]) / total);\n }\n }\n\n if (saveFailDistro[face]) {\n const c = clampNonNeg(saveFailDistro[face] / total);\n if (c > 0) {\n count.saveFail = (count.saveFail ?? 0) + c;\n attr.saveFail = clampNonNeg((attr.saveFail ?? 0) + (face * saveFailDistro[face]) / total);\n }\n }\n\n if (pcDistro[face]) {\n const c = clampNonNeg(pcDistro[face] / total);\n if (c > 0) {\n count.pc = c;\n attr.pc = clampNonNeg((face * pcDistro[face]) / total);\n }\n }\n\n // What no outcome claims deals no damage (missNone); a bare DC check's successes stay unlabelled.\n if (!isDCCheck) {\n const distroCountRaw =\n (hitDistro[face] || 0) +\n (critDistro[face] || 0) +\n (missDistro[face] || 0) +\n (saveDistro[face] || 0) +\n (saveFailDistro[face] || 0) +\n (pcDistro[face] || 0);\n\n const unaccountedCount = clampNonNeg(faceCount - distroCountRaw);\n if (unaccountedCount > 0) {\n const frac = clampNonNeg(unaccountedCount / total);\n if (frac > 0) {\n count.missNone = (count.missNone ?? 0) + frac;\n // missNone does 0 damage, so no attr contribution\n }\n }\n }\n\n const bin: Bin = { p, count };\n if (Object.keys(attr).length > 0) {\n bin.attr = attr;\n }\n\n map.set(face, bin);\n }\n\n // Fall back to a sentinel identifier if none was assigned. This indicates\n // a Dice constructed outside the normal parse/build flow.\n const identifier = this.identifier || \"ERROR\";\n\n // Normalize, drop zeros again if any snuck in, then compaction and pruning\n return new PMF(map, numEpsilon, true, identifier).compact(numEpsilon, true);\n }\n}\n\nexport type _DiceInternal = never;\n","/**\n * Crit doubling for parsed damage strings: scale every dice term's count, keep every\n * operator and flat. A dice term is a die together with its per-die modifiers, so the rewrite\n * reads the string with the same grammar `parse()` uses:\n *\n * - `2d6 + 5` → `4d6 + 5`; `2d6 // 2` → `4d6 // 2` (the division applies to the doubled total).\n * - `d6 reroll 1 + 3` → `2(d6 reroll 1) + 3` and `3>d6` → `2(3>d6)`: a lone die with `reroll`,\n * `>`, `<` or `!` applied to it is one die term; a `reroll`'s argument is a face set, never dice.\n * - `2(d6 reroll 1)` → `4(d6 reroll 1)`; `3(1d6 + 2)` → `3(2d6 + 2)` (copies of a group whose\n * flats must not double are doubled inside).\n * - `2kh1(2d6 + 3)` → `2kh1(4d6 + 3)`: a pool doubles inside, then pools; its trial count stays.\n * Only keep-highest-of-1 (\"roll it N times, keep the best\") does: any other keep (`4kh3d6`,\n * `3kl1(1d6)`), a min of two dice terms (`d6 < d6`) and an `&` mix with dice on either side\n * (`1d6 & 3`: doubling its dice also changes each side's share of the mix) have no single doubled\n * meaning, so they throw {@link AmbiguousCritDoublingError} and the caller must give the crit\n * explicitly.\n *\n * An attack or save check (`AC`/`DC`, or a crit/save/pc/miss clause) is not a damage expression —\n * doubling it would double the d20 — so it throws, as does a dice-valued repeat count (`d4d6`).\n */\ntype DiceAtom =\n | { kind: \"number\"; start: number; end: number; value: number }\n | { kind: \"die\"; start: number; end: number }\n | { kind: \"group\"; start: number; end: number; expr: DiceExpr }\n | { kind: \"keep\"; start: number; end: number; inner: DiceAtom; mode: \"h\" | \"l\"; kept: number };\ntype DiceChain = { start: number; atoms: DiceAtom[] };\ntype DiceOp = { op: string; arg: DiceChain | undefined; end: number };\ntype DiceExpr = { first: DiceChain; rest: DiceOp[] };\n\nconst isDigitOrN = (c: string | undefined): boolean =>\n c !== undefined && ((c >= \"0\" && c <= \"9\") || c === \"n\");\n\n/** Operators that, applied to a lone die, modify that die rather than a total. */\nconst isPerDieOp = (op: string): boolean =>\n op === \"reroll\" || op === \">\" || op === \"<\" || op === \"!\";\n\n/** Why a parsed string's dice cannot double: it is not a damage expression `scaleParsedDice` can rewrite. */\nexport class UndoubleableExpressionError extends Error {}\n\n/**\n * Why a damage payload's dice cannot double on a crit: it is damage, but \"double the dice\"\n * has more than one reading for it (a keep other than keep-highest-of-1, a `bestOf()`, a die rolled\n * with advantage, an `&` mix with dice). Never caught as {@link UndoubleableExpressionError}: no\n * crit is approximated.\n */\nexport class AmbiguousCritDoublingError extends Error {}\n\n/** A recursive-descent reader over `parse()`'s cleaned grammar (see `parser.ts`). */\nclass DiceTermReader {\n private pos = 0;\n\n constructor(\n private readonly s: string,\n private readonly expression: string\n ) {}\n\n read(): DiceExpr {\n const expr = this.expr();\n if (this.pos !== this.s.length) this.fail(`unexpected '${this.s[this.pos]}'`);\n return expr;\n }\n\n private fail(reason: string): never {\n throw new UndoubleableExpressionError(`Cannot double the dice of \"${this.expression}\": ${reason}.`);\n }\n\n private expr(): DiceExpr {\n const first = this.chain();\n const rest: DiceOp[] = [];\n for (let op = this.operation(); op !== undefined; op = this.operation()) {\n if (op === \"ac\") {\n this.fail(\"it contains an attack check (a d20 roll against an AC), so it is not a damage expression\");\n }\n if (op === \"dc\") {\n this.fail(\"it contains a saving throw check (a d20 roll against a DC), so it is not a damage expression\");\n }\n const arg = op === \"!\" ? undefined : this.chain();\n const c = this.s[this.pos];\n if (c === \"x\" || c === \"c\" || c === \"s\" || c === \"m\" || this.s.startsWith(\"pc\", this.pos)) {\n this.fail(\"it contains a check-outcome clause (crit/save/pc/miss), so it is not a damage expression\");\n }\n rest.push({ op, arg, end: this.pos });\n }\n return { first, rest };\n }\n\n private chain(): DiceChain {\n const start = this.pos;\n const atoms: DiceAtom[] = [];\n for (let atom = this.atom(); atom !== undefined; atom = this.atom()) atoms.push(atom);\n return { start, atoms };\n }\n\n private atom(): DiceAtom | undefined {\n const start = this.pos;\n const c = this.s[start];\n if (c === \"(\") {\n this.pos++;\n const expr = this.expr();\n if (this.s[this.pos] !== \")\") this.fail(\"unbalanced parentheses\");\n this.pos++;\n return { kind: \"group\", start, end: this.pos, expr };\n }\n if (c === \"h\" && this.s[start + 1] === \"d\" && isDigitOrN(this.s[start + 2])) {\n this.pos += 2;\n this.number();\n return { kind: \"die\", start, end: this.pos };\n }\n if (c === \"d\" && isDigitOrN(this.s[start + 1])) {\n this.pos += 1;\n this.number();\n return { kind: \"die\", start, end: this.pos };\n }\n if (c === \"k\") {\n const mode = this.s[start + 1];\n if (mode !== \"h\" && mode !== \"l\") this.fail(\"'k' must be followed by 'h' or 'l'\");\n this.pos += 2;\n const kept = this.number();\n const inner = this.atom();\n if (inner === undefined) this.fail(\"a keep needs dice after it\");\n return { kind: \"keep\", start, end: this.pos, inner, mode, kept };\n }\n if (isDigitOrN(c)) {\n const value = this.number();\n return { kind: \"number\", start, end: this.pos, value };\n }\n return undefined;\n }\n\n private number(): number {\n let digits = \"\";\n while (isDigitOrN(this.s[this.pos])) {\n const ch = this.s[this.pos++];\n digits += ch === \"n\" ? \"0\" : ch; // ParsedRollBuilder always parses with n = 0\n }\n if (digits.length === 0) this.fail(`expected a number at '${this.s[this.pos]}'`);\n return parseInt(digits, 10);\n }\n\n private operation(): string | undefined {\n const rest = this.s.slice(this.pos);\n const op = [\"reroll\", \"**\", \"//\", \"~+\", \"ac\", \"dc\", \"!\", \">\", \"<\", \"+\", \"-\", \"&\", \"*\", \"/\", \"=\"].find(\n (token) => rest.startsWith(token)\n );\n if (op !== undefined) this.pos += op.length;\n return op;\n }\n}\n\nfunction atomHasDice(atom: DiceAtom): boolean {\n switch (atom.kind) {\n case \"die\":\n return true;\n case \"number\":\n return false;\n case \"keep\":\n return atomHasDice(atom.inner);\n case \"group\":\n // A `reroll`'s argument is a face set (`reroll d2` = faces 1–2), never damage dice.\n return (\n chainHasDice(atom.expr.first) ||\n atom.expr.rest.some(({ op, arg }) => op !== \"reroll\" && arg !== undefined && chainHasDice(arg))\n );\n }\n}\n\nconst chainHasDice = (chain: DiceChain): boolean => chain.atoms.some(atomHasDice);\n\nconst isSingleDieAtom = (atom: DiceAtom): boolean =>\n atom.kind === \"die\" || (atom.kind === \"group\" && isSingleDieExpr(atom.expr, atom.expr.rest.length));\n\n/** Is `expr`'s first `opCount` operations one die term: one lone die, per-die operators, and flats? */\nfunction isSingleDieExpr(expr: DiceExpr, opCount: number): boolean {\n const operands = [expr.first];\n for (const { op, arg } of expr.rest.slice(0, opCount)) {\n if (!isPerDieOp(op)) return false;\n if (op !== \"reroll\" && arg !== undefined) operands.push(arg);\n }\n let dice = 0;\n for (const chain of operands) {\n if (chain.atoms.length === 1 && isSingleDieAtom(chain.atoms[0])) dice++;\n else if (chainHasDice(chain)) return false;\n }\n return dice === 1;\n}\n\n/** Rewrites every dice term's count in a parsed damage expression by `scale`. */\nexport function scaleParsedDice(expression: string, scale: number): string {\n // `parse()` drops every space and lowercases; keep a map back to the original characters so\n // the rewrite leaves the caller's spacing and casing alone.\n let cleaned = \"\";\n const original: number[] = [];\n for (let i = 0; i < expression.length; i++) {\n if (expression[i] === \" \") continue;\n cleaned += expression[i].toLowerCase();\n original.push(i);\n }\n const root = new DiceTermReader(cleaned, expression).read();\n\n const edits: { from: number; to: number; text: string }[] = [];\n /** The original characters behind cleaned `[start, end)`, spaces inside included. */\n const span = (start: number, end: number) => ({ from: original[start], to: original[end - 1] + 1 });\n const wrap = (start: number, end: number, open: string) => {\n const { from, to } = span(start, end);\n edits.push({ from, to: from, text: open }, { from: to, to, text: \")\" });\n };\n const source = (start: number, end: number) => {\n const { from, to } = span(start, end);\n return expression.slice(from, to);\n };\n\n // Shapes whose doubling has no single meaning, each with why. They are refused after the whole\n // walk, so a string that is not damage at all still reports that (UndoubleableExpressionError).\n const ambiguous: string[] = [];\n const keepReading =\n 'has no single doubled meaning (only keep-highest-of-1, \"roll it N times, keep the best\", doubles its dice inside each trial)';\n const noteKeep = (keep: Extract<DiceAtom, { kind: \"keep\" }>, trials?: DiceAtom): void => {\n // A keep of numbers alone is a constant: it has no dice to double, so one meaning.\n if ((keep.mode === \"h\" && keep.kept === 1) || !atomHasDice(keep.inner)) return;\n ambiguous.push(`the keep \\`${source(trials?.kind === \"number\" ? trials.start : keep.start, keep.inner.start)}\\` ${keepReading}`);\n };\n\n // After a keep's count a bare prefix would merge into that number (`4kh3d6` → `4kh32d6`), so a\n // kept lone die takes its count inside new parentheses: `4kh3(2d6)`.\n const scaleKept = (inner: DiceAtom): void => {\n if (isSingleDieAtom(inner)) wrap(inner.start, inner.end, `(${scale}`);\n else if (inner.kind === \"group\") scaleExpr(inner.expr);\n else if (inner.kind === \"keep\") {\n noteKeep(inner);\n scaleKept(inner.inner);\n }\n };\n\n const scaleChain = (chain: DiceChain): void => {\n const { atoms } = chain;\n if (atoms.length === 0) return;\n const last = atoms[atoms.length - 1];\n const counts = atoms.slice(0, -1);\n if (counts.some(atomHasDice)) {\n throw new UndoubleableExpressionError(\n `Cannot double the dice of \"${expression}\": a dice-valued repeat count (like d4d6) has no single dice term to double.`\n );\n }\n if (last.kind === \"keep\") {\n noteKeep(last, counts[counts.length - 1]);\n scaleKept(last.inner); // the pool's trial count stays; its dice double inside\n } else if (isSingleDieAtom(last)) {\n const count = counts[counts.length - 1];\n if (count?.kind === \"number\") {\n edits.push({ ...span(count.start, count.end), text: String(count.value * scale) });\n } else {\n const at = original[last.start];\n edits.push({ from: at, to: at, text: String(scale) });\n }\n } else if (last.kind === \"group\") {\n scaleExpr(last.expr); // copies of a group: double inside so its flats stay single\n }\n };\n\n function scaleExpr(expr: DiceExpr): void {\n // Operators bind left to right, so a leading lone die with per-die operators is one term.\n let unitOps = 0;\n for (let i = 1; i <= expr.rest.length && isPerDieOp(expr.rest[i - 1].op); i++) {\n if (isSingleDieExpr(expr, i)) unitOps = i;\n }\n if (unitOps > 0) wrap(expr.first.start, expr.rest[unitOps - 1].end, `${scale}(`);\n else scaleChain(expr.first);\n let leftHasDice = unitOps > 0 || chainHasDice(expr.first);\n for (const { op, arg, end } of expr.rest.slice(unitOps)) {\n if (op === \"reroll\" || arg === undefined) continue;\n const argHasDice = chainHasDice(arg);\n // `a < b` is min(a, b): with dice on both sides it keeps the lower of two dice terms.\n if (op === \"<\" && leftHasDice && argHasDice) {\n ambiguous.push(`the lower of two dice terms \\`${source(expr.first.start, end)}\\` ${keepReading}`);\n }\n // `a & b` mixes by count: doubling a side's dice multiplies its count, so its share moves.\n if (op === \"&\" && (leftHasDice || argHasDice)) {\n ambiguous.push(\n `the mix \\`${source(expr.first.start, end)}\\` has no single doubled meaning (an \\`&\\` weights each side ` +\n `by its count of outcomes, so doubling a side's dice also changes its share of the mix)`\n );\n }\n leftHasDice ||= argHasDice;\n scaleChain(arg);\n }\n }\n\n scaleExpr(root);\n if (ambiguous.length > 0) {\n throw new AmbiguousCritDoublingError(\n `Cannot double the dice of \"${expression}\" on a crit: ${ambiguous[0]}. ` +\n `Give the crit explicitly: onCrit(...) on an attack, critDamage on a rider, or a crit (...) clause.`\n );\n }\n\n let result = expression;\n for (const { from, to, text } of edits.sort((a, b) => b.from - a.from)) {\n result = result.slice(0, from) + text + result.slice(to);\n }\n return result;\n}\n","import { DiceParseError } from \"../common/errors\";\nimport { getCachingEnabled } from \"../common/lru-cache\";\nimport type { OutcomeType } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\nimport { Dice } from \"./dice\";\nimport type { CritTrack } from \"./dice\";\nimport { scaleParsedDice, UndoubleableExpressionError } from \"./scaleDice\";\n\ntype DiceOperation = ((this: Dice, other: Dice | number) => Dice) & {\n unary?: boolean;\n};\n\n/**\n * Resource-exhaustion guards. Adversarial expressions (a huge die, a huge dice\n * count, or a keep over a huge pool) can otherwise blow up memory and CPU.\n * These caps are deliberately generous so every legitimate expression the suite\n * exercises (e.g. d100000) still parses.\n */\n// Must stay >= 100000: the suite asserts d100000 (100k faces) parses.\nconst MAX_DIE_SIDES = 1_000_000;\nconst MAX_DICE_COUNT = 10_000;\n// Bound on keepDice's work, faces · kept² · (kept · face span + 1): its states times its steps.\nconst MAX_KEEP_WORK = 100_000_000;\n// Face counts are whole numbers up to here; a repeat whose counts would pass it keeps probabilities.\nconst MAX_EXACT_COUNT = Number.MAX_SAFE_INTEGER;\n\n/**\n * Internal parse cache for PMFs produced from string expressions.\n * Keyed by cleaned expression (spaces stripped, lowercased) and optional `n` value.\n */\nconst parseCache = PMF.createCache(1000);\n\n/** Clears the internal parse cache. */\nexport function clearParserCache(): void {\n parseCache.clear();\n}\n\n/**\n * Parse a dice expression into a PMF.\n *\n * - Expression is case-insensitive and ignores spaces.\n */\nexport function parse(expression: string, n: number = 0): PMF {\n // Check cache first if enabled\n const cleaned = expression.replace(/ /g, \"\").toLowerCase();\n\n if (getCachingEnabled()) {\n const cacheKey = `${cleaned}:${n}`;\n const cached = parseCache.get(cacheKey);\n if (cached) return cached;\n }\n\n const chars = [...cleaned];\n\n let result: Dice;\n try {\n result = parseExpression(chars, n);\n } catch (error) {\n throw new DiceParseError(\n `Cannot parse dice expression [${expression}]: ${error}`,\n { expression, cause: error }\n );\n }\n\n result.privateData = result.privateData || {};\n result.identifier = cleaned;\n\n if (chars.length > 0) {\n throw new DiceParseError(\n `Unexpected token: '${chars[0]}' from expression: '${expression}'`,\n { expression }\n );\n }\n\n const total = result.total();\n if (total === 0) {\n throw new DiceParseError(\n `Cannot parse dice expression [${expression}]: it has no outcomes (a d0 has no faces; it is only a reroll set, as in \\`reroll d0\\`)`,\n { expression }\n );\n }\n if (!Number.isFinite(total)) {\n throw new DiceParseError(\n `Cannot parse dice expression [${expression}]: its outcome counts overflow (too many dice combined to count exactly)`,\n { expression }\n );\n }\n\n // When creating the PMF, do not epsilon prune\n const resultPMF = result.toPMF(-1);\n if (getCachingEnabled()) {\n // Store under the same cleaned key used for the lookup above.\n const cacheKey = `${cleaned}:${n}`;\n parseCache.set(cacheKey, resultPMF);\n }\n\n return resultPMF;\n}\n\nfunction combineDiceWithNormalization(\n dice: Dice,\n normValue: number,\n outcomeType: OutcomeType,\n currentNorm: number,\n finalResult: Dice\n): { newNorm: number; updatedResult: Dice } {\n dice = dice.normalize(currentNorm);\n finalResult = finalResult.normalize(normValue);\n finalResult.setOutcomeDistribution(outcomeType, dice.getFaceMap());\n finalResult = finalResult.combine(dice);\n return { newNorm: currentNorm * normValue, updatedResult: finalResult };\n}\n\n/**\n * Face-wise histogram difference. NOT the same as {@link Dice.subtract}, which convolves VALUES\n * (`a - b` as numbers); this subtracts raw face COUNTS, used to take a sub-distribution (a crit\n * slice, one outcome's share) back out of the distribution it is part of.\n */\nfunction subtractCounts(a: Dice, b: Dice): Dice {\n const result = new Dice();\n for (const [key, value] of a.getFaceEntries()) result.increment(key, value);\n for (const [key, value] of b.getFaceEntries()) result.increment(key, -value);\n return result;\n}\n\n/**\n * Ops that leave a 0 (a miss) at 0 whatever their argument. A term joined to an attack by one of\n * these applies only where the attack deals damage, so it is part of that damage: `(check) *\n * (1d8) + 1d6` is `(check) * ((1d8) + 1d6)`, since the grammar reads left to right.\n */\nconst HIT_ONLY_OPS: ReadonlySet<DiceOperation> = new Set<DiceOperation>([\n Dice.prototype.addNonZero,\n Dice.prototype.conditionalApply,\n Dice.prototype.multiply,\n Dice.prototype.divideRoundUp,\n Dice.prototype.divideRoundDown,\n]);\n\n/** An AC or DC gate: its target, on the right, is never the check's natural roll. */\nconst GATE_OPS: ReadonlySet<DiceOperation> = new Set<DiceOperation>([Dice.prototype.ac, Dice.prototype.dc]);\n\n/**\n * The count of tokens left in `arr` where the last `AC`/`DC` gate at this nesting level starts, or\n * undefined with none. Every term read while more tokens are left builds that check's total.\n */\nfunction lastGateAt(arr: readonly string[]): number | undefined {\n let depth = 0;\n let at: number | undefined;\n for (let i = 0; i < arr.length - 1; i++) {\n const c = arr[i];\n if (c === \"(\") depth++;\n else if (c === \")\") {\n if (depth === 0) break;\n depth--;\n } else if (depth === 0 && (c === \"a\" || c === \"d\") && arr[i + 1] === \"c\") {\n at = arr.length - i;\n }\n }\n return at;\n}\n\n/**\n * `inCheck`: `arr` is part of a check total (a group left of an `AC`/`DC`), so its `+` always adds.\n */\nfunction parseExpression(arr: string[], n: number, inCheck = false): Dice {\n const gate = lastGateAt(arr);\n const buildsCheck = (): boolean => inCheck || (gate !== undefined && arr.length > gate);\n // `+` adds only to a non-zero total, so a miss (0) stays 0 -- except in a check total, where a\n // running total of exactly 0 (`d20 - 5` on a natural 5) is a roll like any other.\n const readOperation = (): DiceOperation | undefined => {\n const checkTerm = buildsCheck();\n const parsed = parseOperation(arr);\n return parsed === Dice.prototype.addNonZero && checkTerm ? Dice.prototype.add : parsed;\n };\n\n const first = parseArgument(arr, n, buildsCheck());\n let finalResult = typeof first === \"number\" ? Dice.scalar(first) : first;\n if (typeof first === \"number\") finalResult.privateData.noDie = true;\n\n // While `finalResult` crits with its doubled hit payload, the text of each op and its argument,\n // so a trailing hit-only term joins the payload it is part of. Joined only for that case.\n let opText = finalResult.privateData.implicitCrit ? arr.join(\"\") : undefined;\n let op = readOperation();\n\n while (op != null) {\n // An AC check times a payload is an attack's hit: keep the payload's text, so its crit can\n // double the dice when the string has no crit clause. Joined only for that case.\n const pending =\n op === Dice.prototype.conditionalApply && finalResult.privateData.isACCheck ? arr.join(\"\") : undefined;\n const arg = !op.unary ? parseArgument(arr, n, buildsCheck()) : finalResult;\n const hitText = pending?.slice(0, pending.length - arr.length);\n const termText = opText?.slice(0, opText.length - arr.length);\n const before = finalResult;\n if (op === Dice.prototype.combine) assertMixable(before, arg, arr);\n\n // Handle crit (e.g. xcrit, crit). With no clause, an attack's crit is its hit payload with\n // every dice term doubled, at the check's natural-max rate, like the builder's. A check\n // with no die in it has no natural roll: its crit mass is exactly 0, so it takes no crit, and a\n // crit clause on it can never fire -- it is read and ignored, and the hit payload applies.\n let crit: Dice | undefined;\n let critNorm = 1;\n const critClause = arr[0] === \"x\" || arr[0] === \"c\";\n const implicitCrit = !critClause && hitText !== undefined && !finalResult.privateData.noDie;\n if (critClause || implicitCrit) {\n let count = 1;\n if (critClause) {\n const isXcrit = arr[0] === \"x\";\n if (isXcrit) assertToken(arr, \"x\");\n assertToken(arr, \"c\");\n assertToken(arr, \"r\");\n assertToken(arr, \"i\");\n assertToken(arr, \"t\");\n if (isXcrit) count = parseNumber(arr, n);\n }\n\n if (finalResult.privateData.noDie) {\n parseBinaryArgument(arg, arr, n);\n } else {\n ({ crit, rest: finalResult } = splitCrit(finalResult, count));\n\n critNorm = crit.total();\n crit = op.call(crit, critClause ? parseBinaryArgument(arg, arr, n) : critPayload(hitText!, n));\n\n critNorm = crit && critNorm ? crit.total() / critNorm : 1;\n }\n }\n\n // Handle save\n let save: Dice | undefined;\n let saveNorm = 1;\n if (arr[0] === \"s\") {\n assertToken(arr, \"s\");\n assertToken(arr, \"a\");\n assertToken(arr, \"v\");\n assertToken(arr, \"e\");\n\n save = new Dice();\n const min = finalResult.minFace();\n save.increment(min > 0 ? min : 1, finalResult.get(min));\n\n saveNorm = save.total();\n finalResult = finalResult.deleteFace(min);\n save = op.call(save, parseBinaryArgument(arg, arr, n));\n saveNorm = save && saveNorm ? save.total() / saveNorm : 1;\n }\n\n // Handle half damage on hit (potent cantrip)\n let pc: Dice | undefined;\n let pcNorm = 1;\n\n if (arr.length >= 2 && arr[0] === \"p\" && arr[1] === \"c\") {\n assertToken(arr, \"p\");\n assertToken(arr, \"c\");\n\n pc = new Dice();\n const min = finalResult.minFace();\n pc.increment(min > 0 ? min : 1, finalResult.get(min));\n\n const missBefore = pc.total();\n finalResult = finalResult.deleteFace(min);\n\n pc = op.call(pc, parseBinaryArgument(arg, arr, n)).divideRoundDown(2); // parse the damage\n\n const missAfter = pc ? pc.total() : 0;\n pcNorm = missBefore ? missAfter / missBefore : 1;\n }\n\n // Handle miss\n let miss: Dice | undefined;\n let missNorm = 1;\n\n if (arr[0] === \"m\") {\n assertToken(arr, \"m\");\n assertToken(arr, \"i\");\n assertToken(arr, \"s\");\n assertToken(arr, \"s\");\n\n miss = new Dice();\n const min = finalResult.minFace();\n miss.increment(min > 0 ? min : 1, finalResult.get(min));\n\n missNorm = miss.total();\n finalResult = finalResult.deleteFace(min);\n\n miss = op.call(miss, parseBinaryArgument(arg, arr, n));\n missNorm = miss && missNorm ? miss.total() / missNorm : 1;\n }\n\n let norm = finalResult.total();\n\n const clause = crit !== undefined || save !== undefined || pc !== undefined || miss !== undefined;\n const labelled = hasOutcomeLabels(finalResult);\n const operand = finalResult;\n if (!clause && labelled && HIT_ONLY_OPS.has(op)) {\n finalResult = applyByOutcome(finalResult, op, arg, termText, n);\n } else {\n finalResult = op.call(finalResult, arg);\n }\n // A save's payload: every failed save (a 1) is `saveFail`, whatever the payload rolls there.\n if (operand.privateData.isDCCheck && HIT_ONLY_OPS.has(op)) {\n finalResult.setOutcomeDistribution(\"saveFail\", op.call(operand.deleteFace(0), arg).getFaceMap());\n }\n // A landed hit that deals 0 is still a hit: record it at 0, where the misses also sit, from the\n // AC check's `*` on through every hit-only term after it.\n if (!operand.privateData.isDCCheck && HIT_ONLY_OPS.has(op) && (hitText !== undefined || operand.privateData.attackPayload)) {\n finalResult.privateData.attackPayload = true;\n const landed = landedHitsAtZero(operand, op, arg);\n if (landed > 0) finalResult.setOutcomeDistribution(\"hit\", { 0: landed });\n } else if (op === Dice.prototype.combine && typeof arg !== \"number\" && arg.privateData.attackPayload) {\n // `combine` keeps the left side's data; an `&` mix lands the hits of both sides.\n finalResult.privateData.attackPayload = true;\n const landed = operand.getOutcomeCount(\"hit\", 0) + arg.getOutcomeCount(\"hit\", 0);\n if (landed > 0) finalResult.setOutcomeDistribution(\"hit\", { 0: landed });\n }\n // An `&` mix is an attack check whichever side the gate is on: `combine` copies the left's data.\n const gated = op === Dice.prototype.combine && typeof arg !== \"number\" && arg.privateData.isACCheck;\n if (op === Dice.prototype.ac || gated) finalResult.privateData.isACCheck = true;\n followNaturalRoll(before, op, arg, finalResult, clause);\n norm = norm ? finalResult.total() / norm : 1;\n\n // Combine dice with normalization\n if (crit) {\n const result = combineDiceWithNormalization(\n crit,\n critNorm,\n \"crit\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (save) {\n const result = combineDiceWithNormalization(\n save,\n saveNorm,\n \"saveHalf\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (miss) {\n const result = combineDiceWithNormalization(\n miss,\n missNorm,\n \"missDamage\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (pc) {\n const result = combineDiceWithNormalization(\n pc,\n pcNorm,\n \"pc\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (implicitCrit) finalResult.privateData.implicitCrit = { payload: hitText! };\n opText = finalResult.privateData.implicitCrit ? arr.join(\"\") : undefined;\n op = readOperation();\n }\n\n return finalResult;\n}\n\n/** The size of `value`'s natural die, whether or not its natural roll is tracked; 0 with no die. */\nfunction naturalSides(value: Dice | number): number {\n if (typeof value === \"number\") return 0;\n const { critTrack, untrackedSides } = value.privateData;\n return critTrack ? critTrack.sides : (untrackedSides ?? 0);\n}\n\n/**\n * Whether a die of `sides` takes the natural roll from one of `other` sides (0: no die): a d20\n * outranks every other die, and with no d20 the larger die does. A d30 or d100 beside the d20 is a\n * bonus die.\n */\nfunction outranks(sides: number, other: number): boolean {\n if (sides === other) return false;\n if (sides === 20 || other === 20) return sides === 20;\n return sides > other;\n}\n\n/** A check that is its natural roll itself: face f's share is its own count at f. */\nfunction bareTrack(die: Dice): CritTrack {\n return {\n sides: die.maxFace(),\n bare: true,\n slice: (face) => {\n const slice = new Dice();\n const weight = die.get(face);\n if (weight) slice.setFace(face, weight);\n return slice;\n },\n };\n}\n\n/** A number operand as a value: a die-less branch of an `&` mix. */\nfunction asValue(value: Dice | number): Dice {\n if (typeof value !== \"number\") return value;\n const scalar = Dice.scalar(value);\n scalar.privateData.noDie = true;\n return scalar;\n}\n\nfunction branchesOf(value: Dice | number): readonly Dice[] {\n return typeof value === \"number\" ? [asValue(value)] : (value.privateData.branches ?? [value]);\n}\n\nconst hasOutcomeLabels = (value: Dice | number): boolean =>\n typeof value !== \"number\" && Object.keys(value.getFullOutcomeDistribution()).some((label) => label !== \"hit\");\n\nconst isSave = (value: Dice | number): boolean => typeof value !== \"number\" && value.privateData.isDCCheck === true;\n\n/**\n * An `&` mix weights each side by its count of outcomes and keeps the left side's labels. An attack\n * already split into crit, miss or save outcomes has no count to weight by (the split renormalises\n * it), a save beside a non-save has no one set of labels, and a crit, save, pc or miss clause after\n * the mix would split the left side alone. Each reading would depend on operand order, so all three\n * are refused. `rest` is the text after the mix's right side.\n */\nfunction assertMixable(left: Dice, right: Dice | number, rest: readonly string[]): void {\n if (hasOutcomeLabels(left) || hasOutcomeLabels(right)) {\n throw new Error(\n \"an `&` mix of an attack already split into crit, miss or save outcomes has no single reading: \" +\n \"mix the checks before the payload, like `((d20 AC 10) & (d20 AC 15)) * (1d6)`\"\n );\n }\n if (isSave(left) !== isSave(right)) {\n throw new Error(\"an `&` mix of a saving throw (DC) with anything but another saving throw has no single set of outcomes\");\n }\n const [next, after] = rest;\n if (next === \"x\" || next === \"c\" || next === \"s\" || next === \"m\" || (next === \"p\" && after === \"c\")) {\n throw new Error(\"a crit, save, pc or miss clause on an `&` mix has no single reading: put it after the payload's `*`\");\n }\n}\n\n/**\n * Record on `after = op(before, arg)` the natural roll a crit is read from, or the size of the die\n * whose natural roll it lost, replacing whatever `op` copied from `before`. The natural roll is the\n * check's one d20 wherever it sits in the sum, or with no d20 its largest die: other dice are bonus\n * dice, and an AC or DC target is never the roll. Two dice of that size have no single natural roll\n * (`d20 + d20`, like `2d20`), except as advantage or disadvantage between two natural rolls\n * (`d20 > d20`), whose result is the new kept roll. Advantage and rerolls choose which natural roll\n * is kept, so they apply only to a bare die (no op since it). A max or min against anything else\n * follows the natural roll only where its value is the one kept: `d20 > d4` crits on every natural\n * 20, `d20 < 15` never. Every other op acts face by face, so replaying it on one natural face's\n * slice follows that face exactly. A clause splits the check's outcomes off by face, so its natural\n * roll no longer maps onto them.\n *\n * An `&` mix adds its operands' counts, so it keeps them as branches, and every later op but a\n * reroll (which draws again from the whole mix) is replayed on each branch, or each pair of branches:\n * `(d20 & d4) > d20` is `(d20 > d20) & (d4 > d20)`. The mix crits where a branch rolls the natural\n * roll's top faces, at that branch's share: `d4 & d20` crits on the d20 branch's 20, 1 in 24.\n */\nfunction followNaturalRoll(before: Dice, op: DiceOperation, arg: Dice | number, after: Dice, clause: boolean): void {\n const data = after.privateData;\n delete data.critTrack;\n delete data.untrackedSides;\n delete data.noDie;\n delete data.branches;\n const gate = GATE_OPS.has(op);\n if (!clause && before.privateData.noDie && (gate || typeof arg === \"number\" || arg.privateData.noDie)) {\n data.noDie = true;\n }\n\n const mixed =\n before.privateData.branches !== undefined ||\n (!gate && typeof arg !== \"number\" && arg.privateData.branches !== undefined);\n if (!clause && op === Dice.prototype.combine) {\n data.branches = [...branchesOf(before), ...branchesOf(arg)];\n } else if (!clause && mixed && op !== Dice.prototype.reroll) {\n // Advantage is a max of two independent rolls of the mix: every pair of its branches.\n const advantage = op === Dice.prototype.advantage;\n const pairOp = advantage ? Dice.prototype.max : op;\n const lefts = branchesOf(before);\n const rights = advantage ? lefts : gate ? [asValue(arg)] : branchesOf(arg);\n data.branches = lefts.flatMap((left) =>\n rights.map((right) => {\n const part = pairOp.call(left, right);\n followNaturalRoll(left, pairOp, right, part, false);\n return part;\n })\n );\n }\n if (data.branches) {\n mixNaturalRolls(after, data.branches);\n return;\n }\n\n const track = before.privateData.critTrack;\n const argTrack = typeof arg === \"number\" || gate ? undefined : arg.privateData.critTrack;\n const sides = naturalSides(before);\n const argSides = gate ? 0 : naturalSides(arg);\n const extremum = op === Dice.prototype.max || op === Dice.prototype.min;\n const own = track !== undefined && outranks(sides, argSides);\n const followed = own ? track : argTrack && outranks(argSides, sides) ? argTrack : undefined;\n\n if (clause) {\n // A clause leaves no natural roll: untracked below.\n } else if (op === Dice.prototype.advantage || op === Dice.prototype.reroll) {\n if (track?.bare) data.critTrack = bareTrack(after);\n } else if (extremum && track?.bare && argTrack?.bare && sides === argSides) {\n data.critTrack = bareTrack(after);\n } else if (followed) {\n const apply = own ? (value: Dice) => op.call(value, arg) : (value: Dice) => op.call(before, value);\n const step = extremum ? (slice: Dice) => keptPart(slice, apply) : apply;\n data.critTrack = { sides: followed.sides, bare: false, slice: (face) => step(followed.slice(face)) };\n }\n if (!data.critTrack) {\n const top = outranks(argSides, sides) ? argSides : sides;\n if (top > 0) data.untrackedSides = top;\n }\n}\n\n/**\n * The natural roll of an `&` mix `after` of `branches`: the top-ranked natural die among them. A\n * branch without that die never crits; one that has it but not as one natural roll (`d20 + d20`)\n * leaves the mix without one.\n */\nfunction mixNaturalRolls(after: Dice, branches: readonly Dice[]): void {\n const sides = branches.reduce((top, branch) => (outranks(naturalSides(branch), top) ? naturalSides(branch) : top), 0);\n if (sides === 0) return;\n const tracks: CritTrack[] = [];\n for (const branch of branches) {\n if (naturalSides(branch) !== sides) continue;\n const track = branch.privateData.critTrack;\n if (!track) {\n after.privateData.untrackedSides = sides;\n return;\n }\n tracks.push(track);\n }\n after.privateData.critTrack = {\n sides,\n bare: tracks.length === branches.length && tracks.every((track) => track.bare),\n slice: (face) => {\n const slice = new Dice();\n for (const track of tracks) slice.combineInPlace(track.slice(face));\n return slice;\n },\n };\n}\n\n/**\n * The share of a max or min, `apply(face)` per face of `slice`, whose result is that face's own\n * value: where the natural roll is the value kept (ties included), not the other side's.\n */\nfunction keptPart(slice: Dice, apply: (face: Dice) => Dice): Dice {\n const result = new Dice();\n for (const [value, count] of slice.getFaceEntries()) {\n const face = new Dice();\n face.setFace(value, count);\n const kept = apply(face).get(value);\n if (kept) result.increment(value, kept);\n }\n return result;\n}\n\n/**\n * Split an attack check's crit mass off `check`: the slices of its `count` highest natural faces\n * (`count` is 1 for a natural max, N for `xcrit N`), each replayed through every op since the die --\n * bonus dice, modifiers, the AC gate -- so a crit is a natural roll in range at any bonus roll, the\n * builder's rule. A check whose natural roll is not one die throws rather than guessing from its\n * highest totals, which smear a natural roll across several totals once bonus dice are added.\n *\n * A crit face the AC gate turned into 0 missed (parse() has no natural-20 auto-hit): it stays\n * miss mass and is never labelled a crit. `xcrit0` crits on no face, so it needs no natural roll.\n */\nfunction splitCrit(check: Dice, count: number): { crit: Dice; rest: Dice } {\n if (count === 0) {\n const none = new Dice();\n return { crit: none, rest: subtractCounts(check, none) };\n }\n const track = check.privateData.critTrack;\n if (!track) {\n throw new Error(\n \"crit rate cannot be computed exactly for this attack check: its natural roll is not one die \" +\n \"(a dice-valued check like 2d20 or 2kh2d20, two d20s like d20 + d20, or advantage \" +\n \"over a total). Build the attack with the builder API instead.\"\n );\n }\n const { sides } = track;\n if (count > sides) {\n // Usually a count run into the next number: `xcrit2 1d6` reads as `xcrit21 d6`.\n throw new Error(`xcrit${count} is wider than the d${sides} it reads its natural roll from`);\n }\n let crit = new Dice();\n for (let face = sides; face > sides - count; face--) crit.combineInPlace(track.slice(face));\n const rest = subtractCounts(check, crit);\n const missed = crit.get(0);\n if (missed) {\n crit = crit.deleteFace(0);\n rest.increment(0, missed);\n }\n return { crit, rest };\n}\n\n/**\n * The crit payload of an attack string with no crit clause is its hit payload `text` with\n * every dice term doubled and its flats kept -- the rewrite the parsed builder's `doubleDice()`\n * uses, so `(d20 + 5 AC 12) * (1d8 + 3)` crits as `(2d8 + 3)`, exactly like the builder. A payload\n * that rewrite cannot double (a dice-valued count like `d4d6`, a nested check) is added as-is,\n * like a bare PMF.\n */\nfunction critPayload(text: string, n: number): Dice {\n let doubled = text;\n try {\n // The rewrite reads `n` as a digit; substitute it first so a count of `n` doubles by value.\n doubled = scaleParsedDice(text.replace(/n/g, String(n)), 2);\n } catch (error) {\n if (!(error instanceof UndoubleableExpressionError)) throw error;\n }\n const chars = [...doubled];\n const payload = parseExpression(chars, n);\n if (chars.length > 0) {\n throw new Error(`Unexpected token '${chars[0]}' in the crit payload '${doubled}'`);\n }\n return payload;\n}\n\n/**\n * `op(labelled, arg)` for a hit-only op, outcome by outcome, so an attack's labels survive a\n * trailing term. A doubled crit (no crit clause) takes the term into its payload and doubles the\n * whole payload again, exactly as if the term were written inside it; every other outcome,\n * an explicit crit clause's included, takes the term as written.\n */\nfunction applyByOutcome(\n labelled: Dice,\n op: DiceOperation,\n arg: Dice | number,\n termText: string | undefined,\n n: number\n): Dice {\n const implicit = labelled.privateData.implicitCrit;\n const argTotal = typeof arg === \"number\" ? 1 : arg.total();\n const result = new Dice();\n let rest = labelled;\n let payload: string | undefined;\n for (const [label, distribution] of Object.entries(labelled.getFullOutcomeDistribution())) {\n if (label === \"hit\" || distribution === undefined) continue;\n const part = new Dice();\n for (const [face, count] of Object.entries(distribution)) part.increment(Number(face), count);\n rest = subtractCounts(rest, part);\n let applied: Dice;\n if (label === \"crit\" && implicit && termText !== undefined) {\n payload = implicit.payload + termText;\n const doubled = critPayload(payload, n);\n // `op` scales every other outcome's counts by the argument's; keep the crit's share.\n applied = doubled.normalize((part.total() * argTotal) / doubled.total());\n } else {\n applied = op.call(part, arg);\n }\n result.combineInPlace(applied);\n result.setOutcomeDistribution(label as OutcomeType, applied.getFaceMap());\n }\n result.combineInPlace(op.call(rest, arg));\n if (labelled.privateData.isDCCheck) result.privateData.isDCCheck = true;\n if (payload !== undefined) result.privateData.implicitCrit = { payload };\n return result;\n}\n\n/**\n * The count of `op(operand, arg)`'s outcomes at 0 that are landed hits: each of `operand`'s hits (a\n * recorded 0-damage hit included) times the count of `arg`'s values that `op` takes it to 0 with.\n */\nfunction landedHitsAtZero(operand: Dice, op: DiceOperation, arg: Dice | number): number {\n let landed = 0;\n for (const [face, count] of Object.entries(operand.calculateHitDistribution())) {\n if (!(count > 0)) continue;\n const hit = new Dice();\n hit.setFace(Number(face), count);\n landed += op.call(hit, arg).get(0);\n }\n return landed;\n}\n\n/**\n * One argument: a repeat chain (`2d6`, `2(1d4 + 1)`, `(1d4)d6`, `4kh3d6`), or a unary minus and the\n * argument it negates, whole chain included: `-2d6` is `-(2d6)`, `1d6 + -3` is `1d6 - 3`.\n */\nfunction parseArgument(s: string[], n: number, inCheck = false): Dice | number {\n if (s[0] === \"-\") {\n s.shift();\n const operand = parseArgument(s, n, inCheck);\n if (typeof operand === \"number\") return 0 - operand;\n const zero = asValue(0);\n const negated = zero.subtract(operand);\n followNaturalRoll(zero, Dice.prototype.subtract, operand, negated, false);\n return negated;\n }\n\n let result = parseArgumentInternal(s, n, inCheck);\n if (result === undefined) {\n const at = s.length === 0 ? \"the end of the expression\" : `'${s.slice(0, 20).join(\"\")}'`;\n throw new Error(`Expected a number, a die, a keep or '(' at ${at}`);\n }\n\n for (let next = parseArgumentInternal(s, n, inCheck); next !== undefined; next = parseArgumentInternal(s, n, inCheck)) {\n result = multiplyDiceByDice(result, next);\n }\n\n return result;\n}\n\nfunction multiplyDiceByDice(d1: Dice | number, d2: Dice | number): Dice {\n // `2(15)`: copies of a constant are still a constant.\n const noDie =\n (typeof d1 === \"number\" || d1.privateData.noDie) && (typeof d2 === \"number\" || d2.privateData.noDie);\n if (typeof d1 === \"number\") d1 = Dice.scalar(d1);\n if (typeof d2 === \"number\") d2 = Dice.scalar(d2);\n\n const result = new Dice();\n // Keyed by face value. A Map avoids the number→string→parseFloat round-trip of\n // an object and preserves insertion order, which matches d1.keys() ascending\n // order — so the combine order below is identical to the previous version.\n const faces = new Map<number, Dice>();\n let common = 1;\n\n const { keep } = d2.privateData;\n for (const key of d1.keys()) {\n const face = keep ? keepDice(d2, key, keep) : multiplyDice(key, d2);\n\n common *= face.total();\n faces.set(key, face);\n }\n\n // Scaled to one common total the counts stay whole numbers; past MAX_EXACT_COUNT they could not,\n // and the product would overflow, so each count becomes its probability instead.\n const exact = common <= MAX_EXACT_COUNT;\n for (const [k, face] of faces) {\n const count = d1.get(k);\n result.combineInPlace(face.normalize(((exact ? common : 1) * count) / face.total()));\n }\n\n result.privateData.except = {};\n // `1d20` is the die itself, and a keep of one of N rolls of it (`2kh1d20` advantage, `2kl1(1d20)`\n // disadvantage, `3kh1(1d20)` elven accuracy) is one kept natural roll, like `d20 > d20`: a crit\n // is read from either. Any other count or keep has no single natural roll.\n const [only, ...more] = d1.keys();\n const { critTrack } = d2.privateData;\n const rolls = keep === undefined ? only : Math.min(only, keep.kept);\n const sides = outranks(naturalSides(d2), naturalSides(d1)) ? naturalSides(d2) : naturalSides(d1);\n if (rolls === 1 && more.length === 0 && critTrack?.bare) {\n result.privateData.critTrack = bareTrack(result);\n } else if (sides > 0) {\n result.privateData.untrackedSides = sides;\n }\n if (noDie) result.privateData.noDie = true;\n return result;\n}\n\n/** A repeat count is a whole number of copies, 0 included (no dice: the point mass at 0). */\nfunction assertRepeatCount(n: number): void {\n if (!Number.isInteger(n) || n < 0) {\n throw new DiceParseError(`A repeat count must be a whole number of 0 or more; this one can be ${n}`);\n }\n if (n > MAX_DICE_COUNT) {\n throw new DiceParseError(\n `Dice count ${n} exceeds the maximum of ${MAX_DICE_COUNT}`\n );\n }\n}\n\nfunction multiplyDice(n: number, d: Dice): Dice {\n assertRepeatCount(n);\n if (n === 0) return Dice.scalar(0);\n if (n === 1) return d;\n\n const half = Math.floor(n / 2);\n let result = multiplyDice(half, d);\n result = result.add(result);\n\n if (n % 2 === 1) {\n result = result.add(d);\n }\n\n // Counts past MAX_EXACT_COUNT are no longer whole numbers and a few more doublings overflow:\n // keep them as probabilities, which lose nothing more.\n const total = result.total();\n return total > MAX_EXACT_COUNT ? result.normalize(1 / total) : result;\n}\n\n/**\n * The sum of the `kept` highest (or lowest) of `count` independent copies of `die`, exactly, for\n * any per-copy distribution. Faces are visited from the kept end. With `placed` copies already on\n * earlier faces, how many of the other m = count - placed land on this face is Binomial(m, q), q\n * being this face's share of the mass from here on. Once `kept` copies are placed the kept sum is\n * final, so only states with fewer placed are carried: kept × (sums so far) states per face.\n */\nfunction keepDice(die: Dice, count: number, { kept, lowest }: { kept: number; lowest: boolean }): Dice {\n assertRepeatCount(count);\n if (kept >= count) return multiplyDice(count, die);\n if (kept <= 0) return Dice.scalar(0);\n\n const faces = die\n .getFaceEntries()\n .filter(([, weight]) => weight > 0)\n .sort(([a], [b]) => (lowest ? a - b : b - a));\n if (faces.length === 0) return new Dice(); // copies of a d0: no outcomes, reported by parse()\n const span = Math.abs(faces[faces.length - 1][0] - faces[0][0]);\n const work = faces.length * kept * kept * (kept * span + 1);\n if (work > MAX_KEEP_WORK) {\n throw new DiceParseError(\n `Keep of ${kept} of ${count} copies of a ${faces.length}-face roll exceeds the maximum work of ${MAX_KEEP_WORK}`\n );\n }\n\n // The mass from each face on, summed from the far end so the last face's share is exactly 1.\n const tails: number[] = new Array(faces.length);\n for (let i = faces.length - 1, tail = 0; i >= 0; i--) tails[i] = tail += faces[i][1];\n\n const addTo = (map: Map<number, number>, key: number, p: number): void => {\n map.set(key, (map.get(key) ?? 0) + p);\n };\n // states[placed]: kept sum so far → probability, with `placed` < `kept` copies placed.\n let states = Array.from({ length: kept }, () => new Map<number, number>());\n states[0].set(0, 1);\n const done = new Map<number, number>();\n\n faces.forEach(([value, weight], i) => {\n const q = weight / tails[i];\n const next = Array.from({ length: kept }, () => new Map<number, number>());\n states.forEach((sums, placed) => {\n if (sums.size === 0) return;\n const left = count - placed;\n const need = kept - placed;\n // P(exactly c of the `left` copies land here) for c < need; the rest completes the keep.\n const few: number[] = [];\n let logChoose = 0;\n for (let c = 0; c < need; c++) {\n if (c > 0) logChoose += Math.log((left - c + 1) / c);\n few.push(q >= 1 ? 0 : Math.exp(logChoose + c * Math.log(q) + (left - c) * Math.log1p(-q)));\n }\n const enough = Math.max(0, 1 - few.reduce((total, p) => total + p, 0));\n for (const [sum, p] of sums) {\n few.forEach((pc, c) => {\n if (pc > 0) addTo(next[placed + c], sum + c * value, p * pc);\n });\n if (enough > 0) addTo(done, sum + need * value, p * enough);\n }\n });\n states = next;\n });\n\n const result = new Dice();\n for (const [sum, p] of done) result.increment(sum, p);\n return result;\n}\n\nfunction parseArgumentInternal(\n s: string[],\n n: number,\n inCheck = false\n): Dice | number | undefined {\n if (s.length === 0) return;\n\n const c = s[0];\n\n switch (c) {\n case \"(\":\n s.shift();\n return assertToken(s, \")\", parseExpression(s, n, inCheck));\n\n case \"h\":\n case \"d\":\n return parseDice(s, n);\n\n case \"k\":\n assertToken(s, \"k\");\n return parseKeep(s, n, inCheck);\n\n case \"n\":\n return parseNumber(s, n);\n\n default:\n if (isDigit(c)) return parseNumber(s, n);\n return;\n }\n}\n\nfunction parseBinaryArgument(\n arg: Dice | number,\n arr: string[],\n n: number\n): Dice {\n if (arr.length >= 4 && arr[0] === \"h\" && peek(arr, \"half\")) {\n assertToken(arr, \"half\");\n\n const diceArg = typeof arg === \"number\" ? Dice.scalar(arg) : arg;\n return diceArg.divideRoundDown(2);\n }\n\n const parsed = parseArgument(arr, n);\n return typeof parsed === \"number\" ? Dice.scalar(parsed) : parsed;\n}\n\nfunction assertToken<T>(s: string[], expected: string, ret?: T): T | undefined {\n for (const ch of expected) {\n const found = s.shift();\n if (found !== ch) {\n throw new Error(`Expected character '${ch}', found '${found}'`);\n }\n }\n return ret;\n}\n\nfunction parseDice(s: string[], n: number): Dice | undefined {\n let rerollOne = false;\n\n if (peek(s, \"hd\") && peekIsNumber(s, 2)) {\n assertToken(s, \"h\");\n assertToken(s, \"d\");\n rerollOne = true;\n } else if (peek(s, \"d\") && peekIsNumber(s, 1)) {\n assertToken(s, \"d\");\n } else {\n return;\n }\n\n const sides = parseNumber(s, n);\n if (sides > MAX_DIE_SIDES) {\n throw new DiceParseError(\n `Die size ${sides} exceeds the maximum of ${MAX_DIE_SIDES}`\n );\n }\n let result = new Dice(sides);\n // A d0 has no faces: it is only a face set (`reroll d0` rerolls nothing), never a roll.\n if (sides === 0) return result;\n\n if (rerollOne) {\n // Reroll a rolled 1 exactly once, keeping the second roll (e.g. halfling\n // luck). This is the same semantics as the `reroll 1` operator; the previous\n // deleteFace(1).combine(result) computed a weighted union (P(1)=1/(2s−1)),\n // not a reroll (correct P(1)=1/s²).\n result = result.reroll(1);\n }\n\n result.privateData.critTrack = bareTrack(result);\n return result;\n}\n\nfunction peek(arr: string[], expected: string): boolean {\n if (expected.length > arr.length) return false;\n\n for (let i = 0; i < expected.length; i++) {\n if (arr[i] !== expected.charAt(i)) return false;\n }\n\n return true;\n}\n\nfunction peekIsNumber(arr: string[], index: number): boolean {\n if (index >= arr.length) return false;\n return isDigit(arr[index]) || arr[index] === \"n\";\n}\n\nfunction parseNumber(s: string[], n: number): number {\n let ret = \"\";\n\n while (s.length > 0 && (isDigit(s[0]) || s[0] === \"n\")) {\n const ch = s.shift()!;\n ret += ch === \"n\" ? n.toString() : ch;\n }\n\n if (ret.length === 0) {\n throw new Error(`Expected number, found: '${s[0]}'`);\n }\n\n return parseInt(ret, 10);\n}\n\nfunction isDigit(c: string): boolean {\n return c >= \"0\" && c <= \"9\";\n}\n\nfunction parseKeep(s: string[], n: number, inCheck: boolean): Dice | undefined {\n let lowest = false;\n\n if (peek(s, \"l\")) {\n assertToken(s, \"l\");\n lowest = true;\n } else if (peek(s, \"h\")) {\n assertToken(s, \"h\");\n } else {\n return;\n }\n\n const kept = parseNumber(s, n);\n const result = parseArgumentInternal(s, n, inCheck);\n\n if (result instanceof Dice) {\n result.privateData.keep = { kept, lowest };\n return result;\n }\n\n throw new Error(\"Expected Dice after keep modifier\");\n}\n\nfunction parseOperation(s: string[]): DiceOperation | undefined {\n switch (s[0]) {\n case \")\":\n return;\n\n case \"a\":\n assertToken(s, \"ac\");\n return Dice.prototype.ac;\n\n case \"d\":\n assertToken(s, \"dc\");\n return Dice.prototype.dc;\n\n case \"!\":\n assertToken(s, \"!\");\n const adv = Dice.prototype.advantage as DiceOperation;\n adv.unary = true;\n return adv;\n\n case \">\":\n assertToken(s, \">\");\n return Dice.prototype.max;\n\n case \"<\":\n assertToken(s, \"<\");\n return Dice.prototype.min;\n\n case \"+\":\n assertToken(s, \"+\");\n return Dice.prototype.addNonZero;\n\n case \"~\":\n assertToken(s, \"~\");\n assertToken(s, \"+\");\n return Dice.prototype.add;\n\n case \"-\":\n assertToken(s, \"-\");\n return Dice.prototype.subtract;\n\n case \"&\":\n assertToken(s, \"&\");\n return Dice.prototype.combine;\n\n case \"r\":\n assertToken(s, \"reroll\");\n return Dice.prototype.reroll;\n\n case \"*\":\n assertToken(s, \"*\");\n\n if (peek(s, \"*\")) {\n assertToken(s, \"*\");\n return Dice.prototype.multiply;\n }\n\n return Dice.prototype.conditionalApply;\n\n case \"/\":\n assertToken(s, \"/\");\n if (s[0] === \"/\") {\n assertToken(s, \"/\");\n return Dice.prototype.divideRoundDown;\n }\n return Dice.prototype.divideRoundUp;\n\n case \"=\":\n assertToken(s, \"=\");\n return Dice.prototype.eq;\n }\n\n return;\n}\n","import type { RollType } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\nimport { parse } from \"./parser\";\n\n/** A bare decimal integer, optionally signed, with surrounding whitespace. */\nconst DECIMAL_INTEGER = /^\\s*[+-]?\\d+\\s*$/;\n\n/**\n * Parse without throwing — for UI code that reparses on every keystroke, where\n * a transiently invalid expression is normal rather than exceptional.\n *\n * Also accepts `+` before an integer, which the grammar has no use for: `\"+7\"`\n * becomes a delta at 7. Integers are read here rather than by the grammar\n * (which reads `\"-3\"` as a unary minus) so a huge one is refused instead of\n * rounded; a half-typed damage field is a bare signed number often enough.\n *\n * The failure value is {@link PMF.empty}, which has **mass 0**, not a\n * distribution. Convolving it collapses the whole result to mass 0, so a caller\n * combining several expressions should check `mass()` (or skip empties) rather\n * than assume a usable PMF. Anywhere a bad expression should be surfaced instead\n * of absorbed, call {@link parse} and handle `DiceParseError`.\n *\n * Takes no second argument on purpose. {@link parse}'s is `n`, the substitution\n * value for an `n`-dice expression — not an epsilon — so forwarding one here\n * would silently reinterpret it: `tryParse(\"nd6\", 1e-9)` rolled `1d6` and\n * reported 3.5 where the default `n` of 0 means no dice at all.\n *\n * @returns the parsed PMF, or an empty (mass 0) PMF for input that is neither a\n * valid expression nor an integer.\n */\nexport function tryParse(expression: string): PMF {\n // Checked before `parse`, not only in the fallback: `parse` accepts unsigned\n // integers itself and converts them with the same precision loss, so\n // `parse(\"9007199254740993\")` would hand back a delta at …992.\n if (DECIMAL_INTEGER.test(expression)) {\n const value = Number(expression);\n return Number.isSafeInteger(value) ? PMF.delta(value) : PMF.empty();\n }\n\n try {\n return parse(expression);\n } catch {\n return PMF.empty();\n }\n}\n\n/** The token naming a check: `AC` for an attack roll, `DC` for a saving throw. */\nconst CHECK_TOKEN = /\\b(AC|DC)\\b/i;\n\n/** The d20 run at the head of a check: `d20`, `hd20 > d20`, `d20 < d20`, … */\nconst D20_RUN = /\\bh?d20(?:\\s*[><]\\s*h?d20)*/i;\n\nconst RUN_FOR_ROLL_TYPE: Record<RollType, string> = {\n flat: \"d20\",\n advantage: \"d20 > d20\",\n disadvantage: \"d20 < d20\",\n \"elven accuracy\": \"d20 > d20 > d20\",\n};\n\n/**\n * Rewrite an expression's attack roll to a different d20 {@link RollType},\n * leaving everything else — damage, crit clause, miss clause, bonuses —\n * untouched.\n *\n * ```ts\n * withRollType(\"(d20 + 8 AC 16) * (1d4 + 4)\", \"advantage\");\n * // \"(d20 > d20 + 8 AC 16) * (1d4 + 4)\"\n * ```\n *\n * **Every** `AC` group is rewritten, because one expression can hold several\n * attacks (`(d20 + 8 AC 16) * (1d8) + (d20 + 5 AC 16) * (1d6)`) and leaving the\n * later ones flat would quietly chart the wrong curve.\n *\n * A `DC` group is the *target's* saving throw, which the attacker's advantage\n * does not touch, so save expressions come back unchanged — as does anything\n * with no attack roll at all. This makes the function safe to map over a mixed\n * list of expressions.\n *\n * Assumes **one check per group**, which is what every well-formed attack or\n * save expression looks like and what `modelToExpression` emits. The grammar\n * will swallow a group naming two — `(d20 + 5 DC 16 + d20 + 8 AC 16)` parses,\n * as a single `AC` check whose roll happens to contain the save's 0/1 result —\n * but that is not an expression anyone means, and the roll type it should get is\n * undefined. Such input is rewritten on a best-effort basis rather than\n * diagnosed.\n *\n * A halfling-luck `h` prefix is preserved on the first die of each run, since it\n * describes the same roll.\n */\nexport function withRollType(expression: string, rollType: RollType): string {\n const scopes = enclosingScopes(expression);\n let rewritten = \"\";\n let copiedUpTo = 0;\n\n for (const run of expression.matchAll(new RegExp(D20_RUN, \"gi\"))) {\n const at = run.index as number;\n if (!isAttackRoll(expression, scopes, at)) continue;\n\n const replacement = run[0].toLowerCase().startsWith(\"h\")\n ? `h${RUN_FOR_ROLL_TYPE[rollType]}`\n : RUN_FOR_ROLL_TYPE[rollType];\n\n rewritten += expression.slice(copiedUpTo, at) + replacement;\n copiedUpTo = at + run[0].length;\n }\n\n return rewritten + expression.slice(copiedUpTo);\n}\n\n/**\n * Balanced parenthesised ranges, innermost first, so a run's enclosing scopes\n * can be walked outwards. Unbalanced input simply yields fewer scopes; the\n * parser is what rejects it.\n */\nfunction enclosingScopes(\n expression: string\n): readonly { start: number; end: number }[] {\n const open: number[] = [];\n const scopes: { start: number; end: number }[] = [];\n\n for (let i = 0; i < expression.length; i++) {\n if (expression[i] === \"(\") open.push(i);\n else if (expression[i] === \")\") {\n const start = open.pop();\n if (start !== undefined) scopes.push({ start, end: i + 1 });\n }\n }\n\n // Closing order is innermost-first already; sorting by width keeps that true\n // for sibling groups too.\n return scopes.sort((a, b) => a.end - a.start - (b.end - b.start));\n}\n\n/**\n * Whether the d20 run at `at` is the attack roll of a check.\n *\n * Classified by the nearest enclosing group that names a check, widening\n * outwards, which is what makes nesting work: in `((d20 + 8) AC 16)` the run's\n * own group names nothing and the group outside it says `AC`.\n *\n * A run whose groups name no check is not an attack roll — the second run in\n * `(d20 + 8 AC 16) * (d20)` is damage — and an unparenthesised run is judged by\n * the whole expression, since there is nothing narrower to go on.\n */\nfunction isAttackRoll(\n expression: string,\n scopes: readonly { start: number; end: number }[],\n at: number\n): boolean {\n let scoped = false;\n\n for (const scope of scopes) {\n if (at < scope.start || at >= scope.end) continue;\n scoped = true;\n const check = CHECK_TOKEN.exec(expression.slice(scope.start, scope.end));\n if (check) return check[1].toUpperCase() === \"AC\";\n }\n\n if (scoped) return false;\n\n const check = CHECK_TOKEN.exec(expression);\n return check !== null && check[1].toUpperCase() === \"AC\";\n}\n","import type { Bin } from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { PMF } from \"./pmf\";\n\n/**\n * A labeled mixture builder that preserves provenance in Bin.count.\n *\n * `eps` prunes relative to the normalized mass: an outcome whose share of the total is below\n * `eps` is dropped when the PMF is built, and the survivors are renormalized. `eps = 0` keeps\n * every outcome with positive mass.\n */\nexport class Mixture<L extends string = string> {\n private readonly totals = new Map<number, number>(); // raw mass per outcome (pre-normalization)\n private readonly labelMass = new Map<number, Record<L, number>>(); // raw mass per outcome per label\n private readonly eps: number;\n\n constructor(eps: number = EPS) {\n this.eps = Number.isFinite(eps) ? eps : EPS;\n }\n\n /** Remove all accumulated state. */\n clear(): this {\n this.totals.clear();\n this.labelMass.clear();\n return this;\n }\n\n /** Number of distinct outcome values currently accumulated. */\n size(): number {\n return this.totals.size;\n }\n\n /** Whether a label was ever added. */\n hasLabel(label: L): boolean {\n for (const bag of this.labelMass.values()) if (bag[label]) return true;\n return false;\n }\n\n /**\n * Add a labeled component with a mixture weight.\n * Weight can be any positive finite number; only the ratios between weights matter.\n */\n add(label: L, pmf: PMF, weight = 1): this {\n if (!Number.isFinite(weight) || weight <= 0) return this;\n\n // Stream probabilities from each [value, Bin] pair.\n for (const [v, bin] of pmf) {\n const p = bin.p;\n if (p <= 0) continue;\n\n const add = weight * p;\n if (!Number.isFinite(add) || add <= 0) continue;\n\n this.totals.set(v, (this.totals.get(v) ?? 0) + add);\n const bag = this.labelMass.get(v) ?? ({} as Record<L, number>);\n bag[label] = (bag[label] ?? 0) + add;\n this.labelMass.set(v, bag);\n }\n\n return this;\n }\n\n /**\n * The normalized mixture. Each bin's `p` and per-label `count` are its raw mass divided by\n * the grand total, so labels sum to `p` whatever the weights summed to. Outcomes below\n * `eps` of the total (the pruning `eps` given to the constructor) are dropped first.\n *\n * @param eps Epsilon carried by the built PMF.\n */\n buildPMF(eps: number = EPS): PMF {\n const grand = kahanSum(this.totals.values());\n if (!(grand > 0)) throw new Error(\"Mixture: zero total mass\");\n\n const threshold = this.eps * grand;\n const kept = [...this.totals].filter(([, m]) => m > 0 && m >= threshold);\n if (kept.length === 0) {\n throw new Error(`Mixture: pruning at eps ${this.eps} removed every outcome`);\n }\n const keptTotal =\n kept.length === this.totals.size ? grand : kahanSum(kept.map(([, m]) => m));\n\n const internal = new Map<number, Bin>();\n for (const [v, m] of kept) {\n const count: Record<string, number> = {};\n const bag = this.labelMass.get(v) ?? ({} as Record<L, number>);\n for (const label in bag) count[label] = bag[label] / keptTotal;\n internal.set(v, { p: m / keptTotal, count });\n }\n return new PMF(internal, eps);\n }\n\n /**\n * Produce normalized *per-label* PMFs (labels independent).\n * These are unlabeled PMFs built from the raw mass of that label alone; values below `eps`\n * of the label's own mass are pruned.\n */\n byOutcome(): Record<L, PMF> {\n // Collect the set of labels present.\n const labels = new Set<L>();\n for (const bag of this.labelMass.values()) {\n for (const k of Object.keys(bag) as L[]) labels.add(k);\n }\n\n const out = {} as Record<L, PMF>;\n for (const label of labels) {\n const labelTotal = kahanSum(\n [...this.labelMass.values()].map((bag) => bag[label] ?? 0)\n );\n if (!(labelTotal > 0)) continue;\n const m = new Map<number, number>();\n for (const [v, bag] of this.labelMass) {\n const w = bag[label];\n if (w) m.set(v, w / labelTotal);\n }\n out[label] = PMF.fromMap(m, this.eps);\n }\n return out;\n }\n\n /**\n * Mixture weights per label, normalized to sum to 1 over labels that appeared.\n * Uses raw mass before per-outcome normalization.\n */\n weights(): Record<L, number> {\n const res = {} as Record<L, number>;\n for (const [, bag] of this.labelMass) {\n for (const [lab, w] of Object.entries(bag) as [L, number][]) {\n if (!Number.isFinite(w) || w <= 0) continue;\n res[lab] = (res[lab] ?? 0) + w;\n }\n }\n const total = kahanSum(Object.values(res) as number[]);\n if (total > 0) {\n for (const k in res) res[k as L] = res[k as L] / total;\n }\n return res;\n }\n\n toJSON(): {\n totals: Array<[number, number]>;\n labels: Array<[number, Record<L, number>]>;\n eps: number;\n } {\n return {\n totals: Array.from(this.totals.entries()).sort((a, b) => a[0] - b[0]),\n labels: Array.from(this.labelMass.entries()).sort((a, b) => a[0] - b[0]),\n eps: this.eps,\n };\n }\n\n static mix<L extends string = string>(\n items: Array<[label: L, pmf: PMF, weight: number]>,\n eps: number = EPS\n ): PMF {\n const mix = new Mixture<L>(eps);\n for (const [lab, pmf, w] of items) mix.add(lab, pmf, w);\n return mix.buildPMF(eps);\n }\n}\n\n/** Compensated (Kahan) sum. */\nfunction kahanSum(values: Iterable<number>): number {\n let sum = 0;\n let c = 0;\n for (const v of values) {\n const y = v - c;\n const t = sum + y;\n c = t - sum - y;\n sum = t;\n }\n return sum;\n}\n"]}
1
+ {"version":3,"sources":["../src/common/bounce.ts","../src/common/errors.ts","../src/common/lru-cache.ts","../src/common/types.ts","../src/pmf/query.ts","../src/pmf/pmf.ts","../src/parser/dice.ts","../src/parser/scaleDice.ts","../src/parser/parser.ts","../src/parser/rollType.ts","../src/pmf/mixture.ts"],"names":["binom","result","cumulativeSum","rest","check"],"mappings":"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","file":"index.cjs","sourcesContent":["/**\n * Bounce odds — the \"birthday problem\" for bouncing damage dice (e.g. Chromatic\n * Orb): the probability that at least two of K dice with S faces show the same\n * value, which is what lets the spell jump to another target.\n *\n * Accounts for two modifiers:\n * - **Elemental Adept** (`minimumDieRoll >= 2`): rolls below the minimum are\n * bumped up to it, collapsing the low faces onto a single heavier value.\n * - **Empowered Spell** (`rerollDamageDice > 0`): up to that many dice may be\n * rerolled once, giving a second chance at a match.\n *\n * Every case is exact. With Empowered Spell, a roll that already matched stands;\n * otherwise the caster rerolls the dice — which ones and how many, up to the\n * limit — that maximise the chance of a match. The rerolled dice match when they\n * collide among themselves or with a kept die.\n */\n\n/** Options that modify bounce odds via metamagic / feats. */\nexport interface BounceOddsOptions {\n /** Minimum die roll — e.g. 2 for Elemental Adept, 3 for Great Weapon Fighting 2024. */\n minimumDieRoll?: number;\n /**\n * How many dice may be rerolled once — e.g. CHA modifier for Empowered Spell. \"Up to\":\n * the odds assume the best choice of which dice, and how many, to reroll.\n */\n rerollDamageDice?: number;\n}\n\n/**\n * Exact per-face probability marginal for a single die, honoring threshold `reroll(k)` and\n * `minimum(v)` — the SAME two transforms `resolveSingleDie` (`builder/ast.ts`) applies, in the\n * same order (reroll, then minimum-floor), so a caller building `weights` for\n * `jointSumAndMatch`/`explodingPoolMatchProbability` gets face weights consistent with the pool's\n * actual resolved PMF. Returns a 1-indexed array (`weights[v - 1] = P(shows v)`, `1 <= v <= faces`);\n * a face collapsed onto by `minimum` carries its collapsed neighbors' mass, and a face below\n * `minimum` carries zero.\n */\nexport function faceWeights(faces: number, minimum = 0, reroll = 0): number[] {\n const f = Math.max(0, Math.floor(faces));\n if (f <= 0) return [];\n\n let weights = new Array<number>(f).fill(1 / f);\n\n const r = Math.max(0, Math.min(Math.floor(reroll), f));\n if (r > 0) {\n const rerollMass = r / f;\n const uniformReroll = rerollMass / f;\n weights = weights.map((_, i) => (i < r ? 0 : 1 / f) + uniformReroll);\n }\n\n const minV = Math.max(0, Math.floor(minimum));\n if (minV > 1) {\n const collapsed = new Array<number>(f).fill(0);\n for (let v = 1; v <= f; v++) {\n const target = Math.min(f, Math.max(v, minV));\n collapsed[target - 1] += weights[v - 1];\n }\n weights = collapsed;\n }\n\n return weights;\n}\n\n/** Binomial coefficient C(n, k), 0 for out-of-range k. */\nfunction binom(n: number, k: number): number {\n if (k < 0 || k > n) return 0;\n let result = 1;\n for (let i = 0; i < k; i++) result = (result * (n - i)) / (i + 1);\n return result;\n}\n\n/**\n * Exact P(all K dice show distinct values) for a die with `uniformCount`\n * ordinary faces (each probability `1/faces`) plus one optional heavy face whose\n * probability is `heavyWeight` (used for the Elemental-Adept collapse; pass 0\n * for a plain die). Uses the elementary symmetric polynomial e_K over the face\n * probabilities: P(all distinct) = K! · e_K.\n */\nfunction pAllDistinct(\n dice: number,\n faces: number,\n uniformCount: number,\n heavyWeight: number\n): number {\n const light = 1 / faces;\n // e_K = (choose K distinct light faces) + (heavy face + K-1 light faces).\n const eK =\n binom(uniformCount, dice) * Math.pow(light, dice) +\n heavyWeight * binom(uniformCount, dice - 1) * Math.pow(light, dice - 1);\n let kFactorial = 1;\n for (let i = 2; i <= dice; i++) kFactorial *= i;\n return kFactorial * eK;\n}\n\n/** Exact P(at least one duplicate) among `dice` dice, honoring Elemental Adept. */\nfunction pMatch(dice: number, faces: number, minimumDieRoll: number): number {\n if (dice <= 1) return 0;\n if (dice > faces) return 1;\n\n if (minimumDieRoll >= 2) {\n // Rolls 1..minimumDieRoll collapse onto the value `minimumDieRoll`, giving it\n // weight minimumDieRoll/faces; the faces above it stay uniform at 1/faces.\n const uniformCount = faces - minimumDieRoll; // values minimumDieRoll+1 .. faces\n const effectiveValues = uniformCount + 1; // + the collapsed value\n if (dice > effectiveValues) return 1;\n const heavyWeight = minimumDieRoll / faces;\n const distinct = pAllDistinct(dice, faces, uniformCount, heavyWeight);\n return Math.min(1, Math.max(0, 1 - distinct));\n }\n\n // Plain die: P(all distinct) = falling_factorial(faces, dice) / faces^dice.\n let pDistinct = 1;\n for (let i = 0; i < dice; i++) pDistinct *= (faces - i) / faces;\n return 1 - pDistinct;\n}\n\n/**\n * P(at least two of `diceCount` dice with `dieFaces` faces match), honoring\n * Elemental Adept and Empowered Spell. Returns a probability in [0, 1].\n *\n * With `rerollDamageDice`, a roll that matched stands; otherwise up to that many\n * dice are rerolled once, choosing which and how many to maximise the chance of a\n * match (rerolling fewer can be better: a kept Elemental Adept face is a likely\n * target). The fresh dice match when they collide among themselves or with a kept die.\n *\n * @param diceCount Number of dice rolled.\n * @param dieFaces Faces per die (e.g. 8 for d8).\n * @param options Optional metamagic / feat modifiers.\n */\nexport function calculateBounceOdds(\n diceCount: number,\n dieFaces: number,\n options?: BounceOddsOptions\n): number {\n if (diceCount <= 1) return 0;\n if (diceCount > dieFaces) return 1; // pigeonhole\n\n const minimumDieRoll = options?.minimumDieRoll ?? 0;\n const rerollDamageDice = options?.rerollDamageDice ?? 0;\n\n const pMatchFirst = pMatch(diceCount, dieFaces, minimumDieRoll);\n\n // Without Empowered Spell we're done.\n const rerollLimit = Math.min(Math.floor(rerollDamageDice), diceCount);\n if (rerollLimit <= 0 || pMatchFirst >= 1) return pMatchFirst;\n\n // A roll with no match shows distinct faces. Elemental Adept gives the die two kinds of\n // face: the collapsed minimum (the heavy face, weight minimumDieRoll/dieFaces) and the\n // `lightCount` faces above it (1/dieFaces each); a plain die has only light faces. After\n // rerolling k dice, no match means the k fresh dice are distinct and avoid every kept\n // face: k!·e_k over the faces not kept, which `pAllDistinct` computes.\n const collapsed = minimumDieRoll >= 2;\n const lightCount = collapsed ? dieFaces - minimumDieRoll : dieFaces;\n const heavyWeight = collapsed ? minimumDieRoll / dieFaces : 0;\n const pMissAfter = (rerolled: number, keptLight: number, heavyKept: boolean): number =>\n pAllDistinct(rerolled, dieFaces, lightCount - keptLight, heavyKept ? 0 : heavyWeight);\n\n // The best reroll for each kind of first roll. Without the heavy face every kept face is\n // light; with it, the caster either keeps it or rerolls it along with k − 1 light dice.\n let missLightOnly = 1;\n let missWithHeavy = 1;\n for (let rerolled = 1; rerolled <= rerollLimit; rerolled++) {\n const allLightKept = pMissAfter(rerolled, diceCount - rerolled, false);\n missLightOnly = Math.min(missLightOnly, allLightKept);\n missWithHeavy = Math.min(missWithHeavy, allLightKept);\n if (rerolled < diceCount) {\n missWithHeavy = Math.min(missWithHeavy, pMissAfter(rerolled, diceCount - 1 - rerolled, true));\n }\n }\n\n // P(distinct, light faces only) = n!·C(L, n)·l^n; P(distinct, one heavy) = n·H·(n−1)!·C(L, n−1)·l^(n−1).\n const pLightOnly = pAllDistinct(diceCount, dieFaces, lightCount, 0);\n const pWithHeavy = diceCount * heavyWeight * pAllDistinct(diceCount - 1, dieFaces, lightCount, 0);\n\n return Math.min(\n 1,\n pMatchFirst + pLightOnly * (1 - missLightOnly) + pWithHeavy * (1 - missWithHeavy)\n );\n}\n\n/**\n * Exact joint P(sum ∧ match), K = 2 hardcoded (per design: every shipped 5e bounce mechanic is\n * \"two or more\" — see `CHROMATIC_ORB.md`). `K > 2` (a face with multiplicity ≥ K) is a harder\n * combinatorial problem with no consumer; a `match` parameter whose only legal value is 2 would\n * advertise a generality this DP does not have, so it is not offered.\n *\n * `weights` is the resolved single-die marginal's per-face probabilities, 1-indexed\n * (`weights[v - 1] = P(one die shows v)`) — NOT assumed uniform, so `minimum`/threshold `reroll`\n * (which collapse or reweight faces) compose correctly. Dice are i.i.d. and homogeneous (same\n * `weights` for all of them): a mixed-face-size pool (e.g. 2d6 + 1d4) is a genuinely different,\n * harder problem (dice are no longer exchangeable) with no consumer here.\n */\n\n/** Exact P(sum = s) for `dice` i.i.d. dice sharing `weights`, as a sum -> mass map. */\nexport function diceSumDistribution(dice: number, weights: readonly number[]): Map<number, number> {\n let dist = new Map<number, number>([[0, 1]]);\n for (let die = 0; die < dice; die++) {\n const next = new Map<number, number>();\n for (const [sum, mass] of dist) {\n for (let face = 1; face <= weights.length; face++) {\n const w = weights[face - 1] ?? 0;\n if (w <= 0) continue;\n const s = sum + face;\n next.set(s, (next.get(s) ?? 0) + mass * w);\n }\n }\n dist = next;\n }\n return dist;\n}\n\n/**\n * Exact P(sum = s ∧ all `dice` values distinct), via the elementary-symmetric DP over faces:\n * `dp[c+1][s+f] += dp[c][s] · w_f`, each face used at most once (0/1 knapsack over faces, tracking\n * both count and sum). `P(sum = s ∧ all distinct) = dice! · dp[dice][s]` — `dp[dice][s]` sums over\n * unordered subsets of `dice` distinct faces; multiplying by `dice!` accounts for every way to\n * assign that subset to the `dice` labeled dice.\n */\nfunction sumAllDistinctDistribution(dice: number, weights: readonly number[]): Map<number, number> {\n const faceCount = weights.length;\n let dp = new Map<number, Map<number, number>>([[0, new Map([[0, 1]])]]);\n\n for (let face = 1; face <= faceCount; face++) {\n const w = weights[face - 1] ?? 0;\n const next = new Map<number, Map<number, number>>();\n for (const [count, sumMap] of dp) next.set(count, new Map(sumMap));\n\n if (w > 0) {\n for (const [count, sumMap] of dp) {\n const nextCount = count + 1;\n if (nextCount > dice) continue;\n const target = next.get(nextCount) ?? new Map<number, number>();\n for (const [sum, mass] of sumMap) {\n const s = sum + face;\n target.set(s, (target.get(s) ?? 0) + mass * w);\n }\n next.set(nextCount, target);\n }\n }\n dp = next;\n }\n\n let factorial = 1;\n for (let i = 2; i <= dice; i++) factorial *= i;\n\n const chosen = dp.get(dice) ?? new Map<number, number>();\n const result = new Map<number, number>();\n for (const [sum, mass] of chosen) result.set(sum, mass * factorial);\n return result;\n}\n\n/**\n * Exact joint P(sum = s ∧ match) for `dice` i.i.d. dice sharing `weights`\n * (`P(sum ∧ match) = P(sum) − P(sum ∧ all distinct)`). Returns a sum -> mass map; sums with zero\n * match mass are omitted. `dice <= 1` returns an empty map (no match possible).\n */\nexport function jointSumAndMatch(dice: number, weights: readonly number[]): Map<number, number> {\n if (dice <= 1) return new Map();\n\n const total = diceSumDistribution(dice, weights);\n const distinct = sumAllDistinctDistribution(dice, weights);\n\n // A sum carries match mass only if a roll with a repeated face reaches it: twice one face\n // plus any `dice − 2` faces. At every other sum the difference below is exactly 0, and\n // float residue must not turn it into a bin.\n const rest = diceSumDistribution(dice - 2, weights);\n const matchable = new Set<number>();\n weights.forEach((weight, index) => {\n if (weight <= 0) return;\n for (const sum of rest.keys()) matchable.add(2 * (index + 1) + sum);\n });\n\n const result = new Map<number, number>();\n for (const [sum, mass] of total) {\n if (!matchable.has(sum)) continue;\n const matchMass = Math.max(0, mass - (distinct.get(sum) ?? 0));\n if (matchMass > 0) result.set(sum, matchMass);\n }\n return result;\n}\n\n/**\n * The joint distribution over `(m, k)` — `m` dice landing on the pool's max face, `k` on anything\n * else — realized by the SAME `(pending, budget)` walk as the pool-wide exploding-dice DP\n * (`resolveExplodingPool` in `builder/ast.ts`): one traversal serves both the sum (there) and this\n * match composition (here), rather than each needing its own. `pMax` is the max face's probability\n * under the single die's resolved marginal.\n */\nfunction explodingPoolMkDistribution(\n pMax: number,\n count: number,\n budget: number\n): Map<string, number> {\n const binomial = (n: number, p: number): number[] => {\n const result = new Array<number>(n + 1).fill(0);\n result[0] = 1;\n for (let trial = 0; trial < n; trial++) {\n const next = new Array<number>(n + 1).fill(0);\n for (let successes = 0; successes <= trial; successes++) {\n const mass = result[successes];\n if (mass <= 0) continue;\n next[successes] += mass * (1 - p);\n next[successes + 1] += mass * p;\n }\n for (let i = 0; i <= n; i++) result[i] = next[i];\n }\n return result;\n };\n\n const memo = new Map<string, Map<string, number>>();\n const f = (pending: number, remainingBudget: number): Map<string, number> => {\n if (pending === 0) return new Map([[\"0,0\", 1]]);\n if (remainingBudget === 0) {\n const binom = binomial(pending, pMax);\n const result = new Map<string, number>();\n for (let m = 0; m <= pending; m++) {\n const mass = binom[m];\n if (mass > 0) result.set(`${m},${pending - m}`, mass);\n }\n return result;\n }\n\n const key = `${pending},${remainingBudget}`;\n const cached = memo.get(key);\n if (cached) return cached;\n\n const result = new Map<string, number>();\n const accumulate = (mk: string, mass: number): void => {\n result.set(mk, (result.get(mk) ?? 0) + mass);\n };\n\n for (const [mk, mass] of f(pending, remainingBudget - 1)) {\n const [m, k] = mk.split(\",\").map(Number);\n accumulate(`${m + 1},${k}`, mass * pMax);\n }\n for (const [mk, mass] of f(pending - 1, remainingBudget)) {\n const [m, k] = mk.split(\",\").map(Number);\n accumulate(`${m},${k + 1}`, mass * (1 - pMax));\n }\n\n memo.set(key, result);\n return result;\n };\n\n return f(count, budget);\n}\n\n/** Exact P(`count` i.i.d. dice with face probabilities `weights` all differ): `count! · e_count(weights)`. */\nfunction allDistinctProbability(count: number, weights: readonly number[]): number {\n const symmetric = new Array<number>(count + 1).fill(0);\n symmetric[0] = 1;\n for (const weight of weights) {\n if (weight <= 0) continue;\n for (let chosen = count; chosen >= 1; chosen--) symmetric[chosen] += symmetric[chosen - 1] * weight;\n }\n let factorial = 1;\n for (let i = 2; i <= count; i++) factorial *= i;\n return factorial * symmetric[count];\n}\n\n/**\n * P(match) for a pool sharing ONE pool-wide exploding-dice budget (see\n * `RollBuilder.explodePool()`). The plain `jointSumAndMatch`/`calculateBounceOdds` formulas assume\n * `dice` i.i.d. dice — false for an exploded pool, since conditioning on a realized size already\n * reveals some die rolled max. Exploiting that max is the only exploding face: condition on `m`\n * (dice showing max, the exploded ones included) and `k` (dice showing anything else) —\n *\n * `m ≥ 2` → match is certain (two dice already share the max face).\n * `m ≤ 1` → match iff the `k` non-max dice collide among themselves. Each shows face `v` with\n * the conditional weight `w_v / (1 − pMax)`, and they cannot collide with the max face,\n * so the two parts separate.\n *\n * So a single die can match its own explosion: a lone d8 with budget ≥ 1 matches when it rolls\n * 8 and then 8 again (1/64).\n *\n * `weights` is the single (non-exploding-budget) die's resolved marginal, 1-indexed with the\n * max face last, as {@link faceWeights} returns it.\n */\nexport function explodingPoolMatchProbability(\n weights: readonly number[],\n count: number,\n budget: number\n): number {\n if (count <= 0 || weights.length === 0) return 0;\n\n const pMax = weights[weights.length - 1];\n const nonMax = pMax < 1 ? weights.slice(0, -1).map((weight) => weight / (1 - pMax)) : [];\n\n let pMatchTotal = 0;\n for (const [mk, weight] of explodingPoolMkDistribution(pMax, count, budget)) {\n const [m, k] = mk.split(\",\").map(Number);\n if (m >= 2) pMatchTotal += weight;\n // Fewer than two non-max dice cannot collide: skip the sum that is 1 only up to rounding.\n else if (k >= 2) pMatchTotal += weight * (1 - allDistinctProbability(k, nonMax));\n }\n return Math.min(1, Math.max(0, pMatchTotal));\n}\n","/**\n * Error thrown when a dice expression cannot be parsed.\n *\n * Extends the built-in {@link Error}, so existing `catch (e)` / message checks\n * continue to work, while callers can now narrow with `instanceof DiceParseError`.\n *\n * @example\n * try {\n * parse(\"d6@3\");\n * } catch (e) {\n * if (e instanceof DiceParseError) {\n * // e.expression === \"d6@3\"\n * }\n * }\n */\nexport class DiceParseError extends Error {\n /** The original expression that failed to parse, when available. */\n readonly expression?: string;\n\n /** The underlying error that triggered this one, when available. */\n readonly cause?: unknown;\n\n constructor(\n message: string,\n options?: { expression?: string; cause?: unknown }\n ) {\n super(message);\n this.name = \"DiceParseError\";\n this.expression = options?.expression;\n this.cause = options?.cause;\n // Restore the prototype chain for reliable `instanceof` across targets.\n Object.setPrototypeOf(this, DiceParseError.prototype);\n }\n}\n","/**\n * Simple LRU cache implementation\n */\n\nlet cachingEnabled = true;\n\n/**\n * Bumped each time caching is turned off. A cache created with `followsCachingToggle` empties\n * itself the next time it is touched after a bump, so no registry holds the caches alive.\n */\nlet cacheGeneration = 0;\n\n/**\n * Enable or disable the library's internal caches: the parse cache, the PMF convolution/power\n * cache, and the builder, die, roll, attack, save and check caches. While disabled those caches\n * store nothing and every lookup misses, and disabling empties them. Caches you construct\n * yourself are unaffected unless created with `followsCachingToggle`.\n */\nexport function setCachingEnabled(enabled: boolean): void {\n cachingEnabled = enabled;\n if (!enabled) cacheGeneration++;\n}\n\n/** Returns whether the library's internal caches are currently enabled. */\nexport function getCachingEnabled(): boolean {\n return cachingEnabled;\n}\n\nexport interface LRUCacheOptions<V> {\n /** Called with every value as it is stored, e.g. to freeze a shared result. */\n onInsert?: (value: V) => void;\n /**\n * Store and return nothing while {@link setCachingEnabled} has turned caching off, and empty\n * this cache when it does.\n */\n followsCachingToggle?: boolean;\n}\n\nexport class LRUCache<K, V> {\n private cache = new Map<K, V>();\n private readonly onInsert?: (value: V) => void;\n private readonly followsCachingToggle: boolean;\n private generation = cacheGeneration;\n\n /**\n * @param maxSize Entries kept before the least recently used is evicted. A capacity of 0 or\n * less (or NaN) makes the cache store nothing.\n */\n constructor(\n private readonly maxSize = 1000,\n options: LRUCacheOptions<V> = {}\n ) {\n this.onInsert = options.onInsert;\n this.followsCachingToggle = options.followsCachingToggle ?? false;\n }\n\n /** Drops the entries of a toggle-following cache when caching was turned off since last use. */\n private sync(): void {\n if (this.followsCachingToggle && this.generation !== cacheGeneration) {\n this.cache.clear();\n this.generation = cacheGeneration;\n }\n }\n\n private get storing(): boolean {\n this.sync();\n return this.maxSize > 0 && (cachingEnabled || !this.followsCachingToggle);\n }\n\n get(key: K): V | undefined {\n if (!this.storing) return undefined;\n const value = this.cache.get(key);\n if (value === undefined) return undefined;\n\n this.cache.delete(key);\n this.cache.set(key, value);\n return value;\n }\n\n delete(key: K): void {\n this.cache.delete(key);\n }\n\n set(key: K, value: V): this {\n if (!this.storing) return this;\n this.onInsert?.(value);\n this.cache.delete(key);\n if (this.cache.size >= this.maxSize) {\n const oldestKey = this.cache.keys().next().value;\n this.cache.delete(oldestKey as K);\n }\n this.cache.set(key, value);\n return this;\n }\n\n clear(): void {\n this.cache.clear();\n }\n\n get size(): number {\n this.sync();\n return this.cache.size;\n }\n\n has(key: K): boolean {\n return this.storing && this.cache.has(key);\n }\n\n keys(): IterableIterator<K> {\n this.sync();\n return this.cache.keys();\n }\n\n values(): IterableIterator<V> {\n this.sync();\n return this.cache.values();\n }\n}\n","/** Mapping from outcome label to probability mass or damage attribution. */\nexport type OutcomeLabelMap = Partial<Record<string, number>>;\n\n/** Computational epsilon for pruning negligible probabilities. */\nexport const EPS = 1e-12;\n\n/** A probability bin for a specific damage value. */\nexport interface Bin {\n /** Total probability mass at this damage value. */\n p: number;\n /** Per-outcome probability mass contributions at this damage. */\n count: OutcomeLabelMap;\n /** Optional per-outcome damage attribution at this damage. */\n attr?: OutcomeLabelMap;\n}\n\n/**\n * One homogeneous die-type's resolved shape within a damage pool — count of dice, faces per die,\n * and the per-die `minimum`/threshold-`reroll` that shape its resolved marginal (see\n * `RollBuilder.getSubRollConfigs()`). The raw material for `dice-match` trigger slicing.\n */\nexport interface DicePoolDescriptor {\n readonly count: number;\n readonly faces: number;\n readonly minimum: number;\n readonly reroll: number;\n}\n\n/**\n * Exact P(match | this branch's own final damage value = d) for a resolved hit/crit branch,\n * keyed by the SAME damage values the branch's PMF uses (post flat `modifier`, post crit\n * doubling) — so a consumer splits a PMF bin-by-bin with no sum/modifier bookkeeping of its own.\n */\nexport interface DiceMatchInfo {\n readonly matchProbabilityByDamage: ReadonlyMap<number, number>;\n}\n\n/**\n * Optional capability of a `dice-match`-eligible damage source (implemented by `AttackBuilder`):\n * exposes the exact per-branch match-probability breakdown needed to slice its hit/crit PMF into\n * matched / did-not-match halves. Absence (a bare `PMF`, a plain non-attack `RollBuilder`, or a\n * `null` branch — `noCrit()`, a parsed/pooled/`keep` source) is a defined \"no match slice\n * available\" state, not a crash: naming such a source in a `dice-match` trigger is a\n * `TurnSpecError`, not a silent zero.\n */\nexport interface HasDiceMatchInfo {\n diceMatchInfo(eps?: number): { hit: DiceMatchInfo | null; crit: DiceMatchInfo | null };\n}\n\nexport interface CritConfig {\n critThreshold: number;\n}\n\n/** Simple mapping from damage value to probability. */\nexport type DamageDistribution = Record<number, number>;\n/** Canonical outcome labels supported by the query helpers. */\nexport type OutcomeType =\n | \"crit\"\n | \"hit\"\n | \"missNone\"\n | \"missDamage\"\n | \"saveHalf\"\n | \"saveFail\"\n | \"pc\";\n\nexport type Rounding = \"none\" | \"floor\" | \"round\" | \"ceil\";\n\n/** How a d20 attack roll resolves: single die, keep-highest of 2/3, or keep-lowest of 2. */\nexport type RollType = \"flat\" | \"advantage\" | \"disadvantage\" | \"elven accuracy\";\n\n/**\n * P(critical hit) for the given crit window and d20 {@link RollType}.\n *\n * `critRange` is the number of top faces that crit (1 for a natural 20, 2 for\n * 19–20, …), so a single die crits with probability `critRange / 20`. Advantage\n * rolls two d20s / elven accuracy three, keeping the best; disadvantage keeps\n * the worst of two.\n */\nexport function critProbability(critRange: number, rollType: RollType = \"flat\"): number {\n const base = critRange / 20;\n switch (rollType) {\n case \"advantage\":\n return 1 - (1 - base) ** 2;\n case \"elven accuracy\":\n return 1 - (1 - base) ** 3;\n case \"disadvantage\":\n return base ** 2;\n case \"flat\":\n default:\n return base;\n }\n}\n\n/**\n * The canonical \"clean miss\" outcome — a point of zero damage with no rider.\n * This is the {@link OutcomeType} that attribution charts and outcome stats key\n * on, and is distinct from the builder's attack-resolution `miss` weight label.\n */\nexport const MISS_NONE_OUTCOME: OutcomeType = \"missNone\";\n\n/**\n * All outcome types in canonical severity order — clean miss → crit. This is\n * also the natural stacking order for attribution charts (least- to\n * most-impactful, bottom → top). Enumerates every {@link OutcomeType} exactly\n * once; use it instead of hand-maintained per-consumer outcome tables.\n */\nexport const ALL_OUTCOME_TYPES: OutcomeType[] = [\n \"missNone\",\n \"missDamage\",\n \"saveFail\",\n \"saveHalf\",\n \"pc\",\n \"hit\",\n \"crit\",\n];\n\n/**\n * Outcome types in display order for stats / breakdown rows — most prominent\n * first (crit, hit, …) down to the clean miss.\n */\nexport const OUTCOME_DISPLAY_ORDER: OutcomeType[] = [\n \"crit\",\n \"hit\",\n \"missDamage\",\n \"saveHalf\",\n \"saveFail\",\n \"pc\",\n \"missNone\",\n];\n\n/**\n * Sort outcome labels by a canonical order (defaults to {@link ALL_OUTCOME_TYPES}).\n * Labels not present in `order` sort after known ones, alphabetically — so\n * ad-hoc/test labels outside the {@link OutcomeType} union stay stable.\n */\nexport function sortOutcomes<T extends string>(\n outcomes: Iterable<T>,\n order: readonly string[] = ALL_OUTCOME_TYPES\n): T[] {\n const rank = new Map(order.map((o, i) => [o, i]));\n return [...outcomes].sort((a, b) => {\n const ra = rank.get(a);\n const rb = rank.get(b);\n if (ra !== undefined && rb !== undefined) return ra - rb;\n if (ra !== undefined) return -1;\n if (rb !== undefined) return 1;\n return a.localeCompare(b);\n });\n}\n\nexport const onAnyHit: OutcomeType[] = [\"hit\", \"crit\"];\nexport const onCritOnly: OutcomeType[] = [\"crit\"];\nexport const onHitOnly: OutcomeType[] = [\"hit\"];\nexport const onMissOnly: OutcomeType[] = [\"missNone\", \"missDamage\"];\nexport const onMissDamageOnly: OutcomeType[] = [\"missDamage\"];\nexport const onSaveHalfOnly: OutcomeType[] = [\"saveHalf\"];\nexport const onSaveFailOnly: OutcomeType[] = [\"saveFail\"];\nexport const onPotentCantripOnly: OutcomeType[] = [\"pc\"];\n","import type { OutcomeType } from \"../common/types\";\nimport { ALL_OUTCOME_TYPES, EPS } from \"../common/types\";\nimport { PMF } from \"./pmf\";\nimport type { DamageAttributionChartModel } from \"./pmf\";\n\n/**\n * Query interface for analyzing dice roll probability distributions.\n *\n * Combines multiple attack PMFs and provides statistical analysis methods for:\n * - Basic statistics (mean, variance, min/max, percentiles)\n * - Probability queries (hit chances, success rates, exact counts)\n * - Damage analysis (ranges by outcome type, expected values)\n * - Data export (charts, tables, visualizations)\n *\n */\n\nexport class DiceQuery {\n public readonly singles: PMF[];\n private readonly _eps: number;\n private readonly _combinedProvided: boolean;\n private _combined?: PMF;\n private _combinedWithAttr?: PMF;\n\n constructor(singles: PMF | PMF[], combined?: PMF, eps = EPS) {\n this.singles = Array.isArray(singles) ? singles : [singles];\n if (this.singles.some((s) => s === undefined)) {\n throw new Error(\"DiceQuery contains undefined singles\");\n }\n this._eps = eps;\n // When the caller supplies an explicit combined distribution that may not\n // equal convolve(singles), the additive closed-form moments would describe\n // a different distribution than cdf/percentiles. Track this so mean()/\n // variance() can fall back to the provided combined and stay consistent.\n this._combinedProvided = combined !== undefined;\n if (combined !== undefined) {\n this._combined =\n Math.abs(combined.mass() - 1) <= eps ? combined : combined.normalize();\n }\n }\n\n /**\n * The combined damage distribution of all single PMFs (their convolution),\n * normalized to total probability 1.\n *\n * Computed lazily on first access and cached. Queries that only need\n * additive statistics — {@link DiceQuery.mean}, {@link DiceQuery.variance},\n * {@link DiceQuery.stddev} — never trigger this convolution.\n */\n get combined(): PMF {\n if (this._combined === undefined) {\n const c = PMF.convolveMany(this.singles);\n this._combined =\n Math.abs(c.mass() - 1) <= this._eps ? c : c.normalize();\n }\n return this._combined;\n }\n\n private static readonly DEFAULT_OUTCOMES: readonly OutcomeType[] = [\n \"hit\",\n \"crit\",\n \"missNone\",\n ] as const;\n\n /**\n * Returns a new PMF with damage attribution metadata populated.\n *\n * This method computes attribution on-demand for builder-generated PMFs,\n * enabling them to work with damage attribution charts. The `attr` field\n * tracks how much damage each outcome type contributes at each damage value.\n *\n * For each bin at damage D: sum(attr.values()) ≈ D × P(damage = D)\n *\n * Performance: Cached after first call. Adds minimal overhead vs `combined`.\n *\n * @returns PMF with attr field populated for damage attribution charts\n *\n * @example\n * const attack = d20.plus(5).ac(15).onHit(d(2,6).plus(3)).onCrit(d(2,6))\n * const query = attack.toQuery()\n * const pmf = query.combinedWithAttribution()\n * // Now pmf can be used with attributionByValue() / damageAttributionChartModel()\n */\n combinedWithAttribution(): PMF {\n if (this._combinedWithAttr) {\n return this._combinedWithAttr;\n }\n\n // An explicitly provided `combined` is NOT the convolution of `singles` —\n // a Turn's exact joint distribution, for instance, is narrower than the\n // independent product because riders correlate with their sources.\n // Re-convolving would silently discard it (and drop the riders' damage\n // entirely), so attribute the provided distribution itself.\n if (this._combinedProvided) {\n this._combinedWithAttr = this.combined.withAttribution();\n return this._combinedWithAttr;\n }\n\n // Fast path: if every single already carries attribution (as parser-\n // generated PMFs do), the attributed convolution is bit-for-bit identical\n // to `combined` — reuse it instead of convolving a second time.\n if (this.singles.every((pmf) => pmf.hasAttribution())) {\n this._combinedWithAttr = this.combined;\n return this._combinedWithAttr;\n }\n\n // Otherwise (e.g. builder-generated PMFs that only carry `count`), add\n // attribution to each single PMF, then convolve.\n const singlesWithAttr = this.singles.map((pmf) => pmf.withAttribution());\n const combined = PMF.convolveMany(singlesWithAttr, this.combined.epsilon);\n\n // Normalize if needed\n const normalized =\n Math.abs(combined.mass() - 1) <= this.combined.epsilon\n ? combined\n : combined.normalize();\n\n this._combinedWithAttr = normalized;\n return normalized;\n }\n\n /**\n * Per-label `damage value → probability mass` series for the combined,\n * attribution-carrying distribution — the provenance core of the stacked\n * damage-attribution chart. Convenience for\n * `combinedWithAttribution().attributionByValue()`; see\n * {@link PMF.attributionByValue}.\n */\n attributionByValue(): Map<string, Map<number, number>> {\n return this.combinedWithAttribution().attributionByValue();\n }\n\n /**\n * Full numeric model for the stacked damage-attribution chart. Convenience for\n * `combinedWithAttribution().damageAttributionChartModel(options)`; see\n * {@link PMF.damageAttributionChartModel}.\n */\n damageAttributionChartModel(options?: {\n maxBuckets?: number;\n stackOrder?: readonly string[];\n epsilon?: number;\n }): DamageAttributionChartModel {\n return this.combinedWithAttribution().damageAttributionChartModel(options);\n }\n\n /**\n * How many of the independent single PMFs can produce the given outcome\n * label. Useful for \"all of them succeeded\" style probabilities where the\n * exponent is the number of contributing attacks (see\n * {@link DiceQuery.probExactlyK}).\n */\n countSinglesWith(label: string): number {\n let count = 0;\n for (const single of this.singles) {\n if (single.hasOutcome(label)) count++;\n }\n return count;\n }\n\n /**\n * Returns the expected damage across all possible outcomes.\n *\n * Example: `query.mean()` → 12.5\n * Use case: \"What's my average damage per round?\"\n */\n mean(): number {\n // If the caller supplied a combined distribution that may diverge from\n // convolve(singles), report its mean so mean() stays consistent with\n // cdf/percentiles/min/max (which all read `combined`).\n if (this._combinedProvided) {\n let m = 0;\n for (const [damageValue, bin] of this.combined) m += damageValue * bin.p;\n return m;\n }\n // Expectation is additive over independent attacks: E[Σ Xᵢ] = Σ E[Xᵢ].\n // Computing it directly from the singles avoids building `combined`.\n let totalMean = 0;\n for (const single of this.singles) {\n const mass = single.mass();\n if (mass <= 0) continue;\n // Match `combined`'s semantics: only divide by mass when it is not\n // already 1 (within eps), so an already-normalized single is bit-exact.\n totalMean +=\n Math.abs(mass - 1) <= this._eps ? single.mean() : single.mean() / mass;\n }\n return totalMean;\n }\n\n /**\n * Returns the variance of the damage distribution.\n *\n * Example: `query.variance()` → 45.2\n * Use case: \"How much does my damage vary from the average?\"\n * High variance means higher risk/reward. Lower variance means more consistent damage.\n */\n variance(): number {\n // Consistent with mean(): if a (possibly divergent) combined was provided,\n // compute the variance of that distribution directly.\n if (this._combinedProvided) {\n const mu = this.mean();\n let v = 0;\n for (const [damageValue, bin] of this.combined) {\n const dev = damageValue - mu;\n v += dev * dev * bin.p;\n }\n return v;\n }\n // Variance is additive over independent attacks: Var[Σ Xᵢ] = Σ Var[Xᵢ].\n // Use the centered form per single (E[(X−μ)²]) rather than E[X²]−μ², which\n // suffers catastrophic cancellation when damage has a large constant offset.\n let totalVariance = 0;\n for (const single of this.singles) {\n const mass = single.mass();\n if (mass <= 0) continue;\n if (Math.abs(mass - 1) <= this._eps) {\n // PMF.variance() is the centered, cached, mass-1 variance.\n totalVariance += single.variance();\n } else {\n // Normalized centered variance of a non-unit-mass single.\n let mu = 0;\n for (const [d, b] of single) mu += d * (b.p / mass);\n let v = 0;\n for (const [d, b] of single) {\n const dev = d - mu;\n v += dev * dev * (b.p / mass);\n }\n totalVariance += v;\n }\n }\n return totalVariance;\n }\n\n /**\n * Returns the standard deviation of the damage distribution.\n *\n * Example: `query.stdev()` → 6.7\n * Use case: \"What's the typical spread around my average damage?\"\n * Used to determine how consistent the damage is.\n */\n stddev(): number {\n return Math.sqrt(this.variance());\n }\n\n /** Alias of {@link DiceQuery.stddev}, matching {@link PMF.stdev}. */\n stdev(): number {\n return this.stddev();\n }\n\n /**\n * Returns the Cumulative Distribution Function.\n */\n cdf(x: number): number {\n return this.probTotalAtMost(x);\n }\n\n /**\n * Returns the probability of dealing X damage or less.\n * In statistics, this is called the cumulative distribution function (CDF).\n * Example: `query.cdf(20)` → 0.75\n * Use case: \"What's the chance I deal 20 damage or less?\"\n */\n probTotalAtMost(x: number): number {\n let cumulativeProbability = 0;\n for (const [damageValue, probabilityBin] of this.combined) {\n if (damageValue <= x) {\n cumulativeProbability += probabilityBin.p;\n }\n }\n return cumulativeProbability;\n }\n\n /**\n * Returns the Complementary Cumulative Distribution Function.\n */\n ccdf(x: number): number {\n return this.probTotalAtLeast(x);\n }\n\n /**\n * Returns the probability of dealing at least X damage.\n *\n * Example: `query.probTotalAtLeast(25)` → 0.35\n * Use case: \"What's the chance I deal at least 25 damage to finish the enemy?\"\n */\n probTotalAtLeast(threshold: number): number {\n let probabilitySum = 0;\n for (const [damageValue, probabilityBin] of this.combined) {\n if (damageValue >= threshold) {\n probabilitySum += probabilityBin.p;\n }\n }\n return probabilitySum;\n }\n\n /**\n * Returns damage values at specific percentiles: for each p, the smallest damage x with\n * P(total ≤ x) ≥ p, exact at CDF boundaries (see {@link PMF.quantile}).\n *\n * Example: `query.percentiles([0.25, 0.5, 0.75])` → [8, 12, 18]\n * Use case: \"What are my 25th, 50th, and 75th percentile damage values?\"\n */\n percentiles(percentileValues: number[]): number[] {\n return percentileValues.map((p) => this.combined.quantile(p));\n }\n\n /**\n * Returns the minimum possible damage.\n *\n * Example: `query.min()` → 0\n * Use case: \"What's the worst-case damage if everything misses?\"\n */\n min(): number {\n return this.combined.min();\n }\n\n /**\n * Returns the maximum possible damage.\n *\n * Example: `query.max()` → 56\n * Use case: \"What's the best-case damage if everything crits and rolls max?\"\n */\n max(): number {\n return this.combined.max();\n }\n\n private singleProb(diceIndex: number, label: OutcomeType): number {\n const single = this.singles[diceIndex];\n let probabilitySum = 0;\n for (const [, probabilityBin] of single) {\n probabilitySum += probabilityBin.count[label] || 0;\n }\n // Return the conditional per-event probability. Dividing by the single's\n // mass keeps the result in [0,1] for a non-normalized single (e.g. one that\n // has been scaled), so probAtLeastOne / the binomial DP stay mass-invariant.\n const mass = single.mass();\n return mass > 0 ? probabilitySum / mass : 0;\n }\n\n /**\n * Full count distribution [P(0), P(1), …, P(n)] for \"an attack succeeds if it\n * carries ANY of `labels`\", over the n independent singles.\n *\n * Each single's per-event success probability is the Poisson-binomial\n * marginal P(≥1 of labels) from {@link probabilityOf} (i.e. probAtLeastOne),\n * computed exactly once. The binomial DP then runs once to produce the whole\n * distribution, so the array-label paths of probExactlyK / probAtLeastK /\n * probAtMostK can slice or sum from it instead of rebuilding a DiceQuery and\n * re-running the DP per requested k.\n */\n private countDistribution(labels: OutcomeType[]): number[] {\n const n = this.singles.length;\n const successProbabilities = this.singles.map((single) =>\n new DiceQuery([single]).probabilityOf(labels)\n );\n\n const dist = new Array(n + 1).fill(0);\n dist[0] = 1;\n for (const successProb of successProbabilities) {\n for (let outcomeCount = n; outcomeCount >= 1; outcomeCount--) {\n dist[outcomeCount] =\n dist[outcomeCount] * (1 - successProb) +\n dist[outcomeCount - 1] * successProb;\n }\n dist[0] *= 1 - successProb;\n }\n return dist;\n }\n\n probAtLeastK(labels: OutcomeType | OutcomeType[], k: number): number {\n const L = Array.isArray(labels) ? [...new Set(labels)] : [labels];\n const n = this.singles.length;\n\n if (k <= 0) return 1;\n if (k > n) return 0;\n\n // Sum the upper tail of the single, shared count distribution rather than\n // calling probExactlyK (which rebuilt the distribution) once per i.\n const dist = this.countDistribution(L);\n let tail = 0;\n for (let i = k; i <= n; i++) {\n tail += dist[i];\n }\n\n if (tail < 0) return 0;\n if (tail > 1) return 1;\n return tail;\n }\n\n /**\n * Returns the probability that at least one attack has the specified outcome(s).\n * - This is the complement of probAtMostK(labels, 0)\n *\n * Examples:\n * - `query.probAtLeastOne('hit')` → 0.88 (88% chance at least one attack hits)\n * - `query.probAtLeastOne(['hit', 'crit'])` → 0.96 (96% chance at least one succeeds)\n *\n * Use cases:\n * - \"What's the chance at least one of my attacks connects?\"\n *\n * Note:\n *\n * - You have to pass in an array of labels to avoid double-counting if you are\n * using multiple labels. You cannot just add them. A label listed twice counts once.\n */\n probAtLeastOne(labels: OutcomeType | OutcomeType[]): number {\n const distinctLabels = typeof labels === \"string\" ? [labels] : [...new Set(labels)];\n\n let productOfNonOccurrence = 1;\n for (let diceIndex = 0; diceIndex < this.singles.length; diceIndex++) {\n // Calculate total probability of any of the specified labels occurring.\n // Clamp to [0,1] so floating-point drift in the per-attack sum cannot push\n // the complement out of range.\n let combinedProbability = 0;\n for (const label of distinctLabels) {\n combinedProbability += this.singleProb(diceIndex, label);\n }\n if (combinedProbability < 0) combinedProbability = 0;\n else if (combinedProbability > 1) combinedProbability = 1;\n productOfNonOccurrence *= 1 - combinedProbability;\n }\n const result = 1 - productOfNonOccurrence;\n return result < 0 ? 0 : result > 1 ? 1 : result;\n }\n\n /**\n * Computes binomial probabilities for exactly 0, 1, 2, ..., maxK occurrences of a label.\n *\n * Uses dynamic programming to efficiently calculate the probability distribution\n * of how many attacks will have the specified outcome, accounting for different\n * success probabilities across individual attacks.\n *\n * Example: For 3 attacks with 50% hit chance each, returns:\n * [0.125, 0.375, 0.375, 0.125] = [P(0 hits), P(1 hit), P(2 hits), P(3 hits)]\n *\n * @param label - The outcome type to count\n * @param maxK - Maximum number of occurrences to calculate (usually number of attacks)\n * @returns Array where index K contains P(exactly K attacks have the label)\n */\n private computeBinomialProbabilities(\n label: OutcomeType,\n maxK: number\n ): number[] {\n const individualProbabilities = this.singles.map((_, diceIndex) =>\n this.singleProb(diceIndex, label)\n );\n const binomialProbs = new Array(maxK + 1).fill(0);\n binomialProbs[0] = 1;\n\n for (const singleProbability of individualProbabilities) {\n for (let outcomeCount = maxK; outcomeCount >= 1; outcomeCount--) {\n binomialProbs[outcomeCount] =\n binomialProbs[outcomeCount] * (1 - singleProbability) +\n binomialProbs[outcomeCount - 1] * singleProbability;\n }\n binomialProbs[0] *= 1 - singleProbability;\n }\n\n return binomialProbs;\n }\n\n /**\n * Returns the probability that exactly K attacks result in the specified outcome(s).\n *\n * Single label examples:\n * - probExactlyK('hit', 2) = probability exactly 2 attacks hit\n * - probExactlyK('crit', 1) = probability exactly 1 attack crits\n * - probExactlyK('crit', 0) = probability no attacks crit\n *\n * Array examples:\n * - probExactlyK(['hit', 'crit'], 2) = probability exactly 2 attacks succeed\n * - probExactlyK(['hit', 'crit'], 1) = probability exactly 1 attack succeeds\n * - probExactlyK(['missDamage', 'missNone'], 0) = probability no attacks miss\n *\n * Use cases:\n * - \"What's the chance exactly one of my attacks hits?\"\n * - \"How likely am I to get exactly 2 successes out of 3 attacks?\"\n * - \"What's the probability that exactly half my attacks succeed?\"\n *\n * Note: For arrays, an attack counts as a \"success\" if it has any of the specified labels,\n * as in probAtLeastK and probAtMostK. A negative k has probability 0.\n */\n probExactlyK(labels: OutcomeType | OutcomeType[], k: number): number {\n if (k < 0) return 0;\n // Handle single label case (backward compatibility)\n if (typeof labels === \"string\") {\n const probabilityArray = this.computeBinomialProbabilities(labels, k);\n return probabilityArray[k];\n }\n\n // For multiple labels, derive P(exactly k) from the single shared count\n // distribution. (k > n is impossible, so index out of range reads as 0.)\n const dist = this.countDistribution(labels);\n return k >= 0 && k < dist.length ? dist[k] : 0;\n }\n\n /**\n * Returns the probability that AT MOST K attacks result in the specified outcome(s).\n *\n * Single label examples:\n * - probAtMostK('hit', 1) = probability 0 or 1 attacks hit (at most 1)\n * - probAtMostK('crit', 0) = probability no attacks crit\n * - probAtMostK('missDamage', 2) = probability at most 2 attacks miss\n *\n * Array examples:\n * - probAtMostK(['hit', 'crit'], 1) = probability at most 1 attack succeeds\n * - probAtMostK(['hit', 'crit'], 0) = probability no attacks succeed (all miss)\n *\n * Use cases:\n * - \"What's the chance that at most one attack hits?\" (rest miss)\n * - \"How likely am I to have mostly failures?\" (at most 1 success)\n * - \"What's the probability of a really bad turn?\" (at most 0 successes)\n *\n */\n probAtMostK(labels: OutcomeType | OutcomeType[], k: number): number {\n // Handle single label case (backward compatibility)\n if (typeof labels === \"string\") {\n const probabilityArray = this.computeBinomialProbabilities(labels, k);\n let cumulativeSum = 0;\n for (let outcomeCount = 0; outcomeCount <= k; outcomeCount++) {\n cumulativeSum += probabilityArray[outcomeCount];\n }\n return cumulativeSum;\n }\n\n // For multiple labels, sum the lower tail of the single shared count\n // distribution rather than recomputing it per outcomeCount.\n const dist = this.countDistribution(labels);\n const upper = Math.min(k, dist.length - 1);\n let cumulativeSum = 0;\n for (let outcomeCount = 0; outcomeCount <= upper; outcomeCount++) {\n cumulativeSum += dist[outcomeCount];\n }\n return cumulativeSum;\n }\n\n /**\n * Returns the expected damage attributed to specific outcome types.\n *\n * Single label examples:\n * - expectedDamageFrom('hit') = expected damage from hit components\n * - expectedDamageFrom('crit') = expected damage from crit components\n *\n * Array examples:\n * - expectedDamageFrom(['hit', 'crit']) = expected damage from any success\n * - expectedDamageFrom(['missDamage', 'missNone']) = expected damage from misses\n *\n * Use cases:\n * - \"How much damage do I expect from successful attacks?\"\n * - \"What's the damage contribution from critical hits specifically?\"\n * - \"How much damage comes from miss effects (like save-for-half spells)?\"\n *\n * A single whose mass is not 1 is normalized exactly as {@link mean} normalizes it, so the\n * contributions of labels that cover every outcome add up to `mean()`. A label listed twice\n * counts once.\n */\n expectedDamageFrom(labels: OutcomeType | OutcomeType[]): number {\n const wanted = Array.isArray(labels) ? [...new Set(labels)] : [labels];\n\n let total = 0;\n // By linearity of expectation, sum the wanted-label damage over each single PMF directly,\n // avoiding the `count` aggregation issues a merged PMF would introduce.\n for (const single of this.singles) {\n const mass = single.mass();\n if (mass <= 0) continue;\n let contribution = 0;\n for (const [dmg, bin] of single) {\n let p = 0;\n for (const label of wanted) p += bin.count[label] ?? 0;\n contribution += dmg * p;\n }\n total += Math.abs(mass - 1) <= this._eps ? contribution : contribution / mass;\n }\n return total;\n }\n\n /**\n * Returns damage statistics for scenarios where AT LEAST ONE attack results in\n * the specified outcome(s).\n *\n * This method answers \"What happens when things go reasonably well?\" rather than\n * \"What's the theoretical maximum?\" It includes mixed scenarios which are more\n * common and tactically relevant than pure scenarios.\n *\n * Single label examples:\n * - damageStatsFrom('hit') = damage range when at least one attack hits\n * - damageStatsFrom('crit') = damage range when at least one attack crits\n *\n * Array examples:\n * - damageStatsFrom(['hit', 'crit']) = damage range when at least one attack succeeds\n * - damageStatsFrom(['missDamage', 'missNone']) = damage range when at least one attack misses\n *\n * Tactical Use Cases:\n * - \"Given that I don't completely whiff (99% of turns), what damage should I expect?\"\n * - \"When planning to kill a 60 HP enemy, what's my damage range on successful turns?\"\n * - \"Should I use this risky spell if it has good damage when it works?\"\n * - \"What's my damage potential when something goes right?\" (vs pure failure)\n *\n * Combat Planning Examples:\n * - 4 attacks with 90% hit chance: \"96% of the time you'll do 25-150 damage, avg 52\"\n * (Much more useful than \"You average 50 damage including complete misses\")\n * - Risk assessment: \"80% of successful turns do 40-80 damage, but 20% do 80-150\"\n * - Resource management: \"If I hit anything, I'll likely finish this enemy\"\n *\n * Statistical Note:\n * This includes mixed scenarios (2 hits + 1 crit, 3 hits + 1 miss, etc.) which\n * occur far more frequently than pure scenarios. For pure scenarios, use combinedDamageStats.\n *\n * KNOWN LIMITATION (multi-attack, single label): the returned `count` is an\n * EXPECTED COUNT (E[#label], so > 1 for N≥2 attacks, not a probability), and\n * `avg` is the size-biased conditional mean E[dmg·#label]/E[#label] rather than\n * E[dmg | the label occurs]. For a single attack both are the plain\n * conditional figures. Use {@link probAtLeastOne} for the scenario probability.\n *\n * @example\n * // High-level tactical planning\n * const successStats = query.damageStatsFrom('hit')\n * const successChance = query.probAtLeastOne('hit')\n * console.log(`${(successChance*100).toFixed(1)}% chance to do ${successStats.min}-${successStats.max} damage`)\n */\n damageStatsFrom(labels: OutcomeType | OutcomeType[]): {\n min: number;\n max: number;\n avg: number;\n count: number;\n } {\n // Normalize input to array for uniform handling\n const labelArray = typeof labels === \"string\" ? [labels] : labels;\n\n let minDamage = Infinity;\n let maxDamage = -Infinity;\n let totalDamage = 0;\n let totalCount = 0;\n\n for (const [damage, probabilityBin] of this.combined) {\n // Check if this bin has any of the specified labels\n let binHasAnyLabel = false;\n let binContribution = 0;\n\n for (const label of labelArray) {\n const count = probabilityBin.count[label] as number;\n if (count && count > 0) {\n binHasAnyLabel = true;\n binContribution += count;\n }\n }\n\n if (damage > 0 && binHasAnyLabel) {\n minDamage = Math.min(minDamage, damage);\n maxDamage = Math.max(maxDamage, damage);\n\n // For single labels, use the specific count; for multiple labels, use total probability\n const weightToUse =\n labelArray.length === 1 ? binContribution : probabilityBin.p;\n totalDamage += damage * weightToUse;\n totalCount += weightToUse;\n }\n }\n\n return {\n min: minDamage === Infinity ? 0 : minDamage,\n max: maxDamage === -Infinity ? 0 : maxDamage,\n avg: totalCount > 0 ? totalDamage / totalCount : 0,\n count: totalCount,\n };\n }\n\n /**\n * Returns damage statistics for scenarios where ALL attacks result in the specified\n * outcome, calculated by leveraging the pure partition of singles.\n *\n * This method answers \"What's the theoretical best/worst case?\" and \"What are the\n * clean mathematical boundaries?\" It provides pure scenarios without mixing outcomes.\n *\n * Examples:\n * - combinedDamageStats('hit') = damage range when all attacks hit (none crit, none miss)\n * - combinedDamageStats('crit') = damage range when all attacks crit (none just hit)\n *\n * UI and Display Use Cases:\n * - Statistics panels showing \"MAX Hit Damage\" (users expect pure hits, not mixed)\n * - \"Best case scenario\" vs \"worst case scenario\" analysis\n * - Mathematical verification: \"Does our hit damage calculation match manual math?\"\n * - Clean damage type attribution: \"How much comes from base hits vs crits?\"\n *\n * Design and Balance Use Cases:\n * - Game designers: \"What's the damage ceiling if someone gets lucky?\"\n * - Character optimization: \"What's my absolute maximum potential?\"\n * - Ability comparison: \"Which build has higher crit ceiling?\"\n * - Minimum guaranteed damage: \"What's the worst I can do if everything hits?\"\n *\n * Mathematical Use Cases:\n * - Validating complex calculations against simple manual math\n * - Understanding damage component contributions in isolation\n * - Separating luck (crit variance) from consistency (hit variance)\n * - Building intuition about damage sources\n *\n * When to Use This vs damageStatsFrom():\n * - Use THIS for: UI max/min displays, theoretical limits, clean comparisons\n * - Use damageStatsFrom() for: tactical planning, realistic expectations, mixed scenarios\n *\n * Statistical Note:\n * Pure scenarios (all hits, all crits) are rare but represent clear mathematical\n * boundaries. These stats help understand the \"shape\" of your damage potential.\n *\n * @example\n * // UI display logic\n * const pureHitMax = query.combinedDamageStats('hit').max // Clean \"MAX Hit Damage: 90\"\n * const pureCritMax = query.combinedDamageStats('crit').max // Clean \"MAX Crit Damage: 168\"\n *\n * // vs tactical planning (use damageStatsFrom instead)\n * const realisticRange = query.damageStatsFrom('hit') // Includes mixed scenarios\n */\n combinedDamageStats(targetLabel: OutcomeType): {\n min: number;\n max: number;\n avg: number;\n count: number;\n } {\n // Get pure statistics from each single attack (singles are already pure partitions)\n const singleStats = this.singles.map((single) =>\n new DiceQuery([single]).damageStatsFrom(targetLabel)\n );\n\n // If any single attack has no outcomes of this type, return zeros\n if (singleStats.some((stats) => stats.count === 0)) {\n return { min: 0, max: 0, avg: 0, count: 0 };\n }\n\n // Calculate combined statistics for N attacks all of target type\n const combinedMin = singleStats.reduce((sum, stats) => sum + stats.min, 0);\n const combinedMax = singleStats.reduce((sum, stats) => sum + stats.max, 0);\n const combinedAvg = singleStats.reduce((sum, stats) => sum + stats.avg, 0);\n const combinedProb = singleStats.reduce(\n (product, stats) => product * stats.count,\n 1\n );\n\n return {\n min: combinedMin,\n max: combinedMax,\n avg: combinedAvg,\n count: combinedProb,\n };\n }\n\n /**\n * Returns the probability that at least one attack carries ANY of the\n * specified labels (the marginal P(≥1) across the independent attacks).\n *\n * Examples:\n * - `query.probabilityOf('hit')` → 0.88 (probability at least one hit occurs)\n * - `query.probabilityOf(['hit', 'crit'])` → 0.96 (probability of any success)\n *\n * Use cases:\n * - \"What's the chance my resolution includes a success label?\"\n * - \"How likely am I to get any hits or crits across all attacks?\"\n *\n * Note: this must NOT be computed by summing `combined` bin probabilities. A\n * single combined damage total is reachable by many outcome combinations and\n * a bin can hold several labels at once, so summing `bin.p` over bins that\n * contain a label over-counts. The correct marginal is the Poisson-binomial\n * complement over the per-attack probabilities, i.e. {@link probAtLeastOne}.\n */\n probabilityOf(labels: OutcomeType | OutcomeType[]): number {\n return this.probAtLeastOne(labels);\n }\n\n /**\n * Returns the probability that at least one attack misses (either kind of miss:\n * `missNone` or `missDamage`). For a single attack this is its miss chance.\n *\n * Example: `query.missChance()` → 0.45\n * Use case: \"What's the chance I miss at least once this turn?\"\n *\n * For the chance that every attack misses, use\n * `probExactlyK([\"missNone\", \"missDamage\"], n)` with n attacks, or\n * `probAtMostK([\"hit\", \"crit\"], 0)`.\n */\n missChance(): number {\n // Miss can be either explicit misses with damage or zero-damage misses\n return this.probabilityOf([\"missDamage\", \"missNone\"]);\n }\n\n /**\n * Returns data formatted for plotting damage probability distribution.\n *\n * Example: `query.toChartSeries()` → [{x: 0, y: 0.04}, {x: 6, y: 0.1}, ...]\n * Use case: \"I want to visualize my damage distribution in a chart.\"\n */\n toChartSeries(): Array<{ x: number; y: number }> {\n return this.combined.support().map((damageValue) => ({\n x: damageValue,\n y: this.combined.map.get(damageValue)!.p,\n }));\n }\n\n /**\n * Returns tabular data showing damage values and their probability breakdowns.\n *\n * Example: `query.toLabeledTable(['hit', 'crit'])` →\n * [{damage: 6, total: 0.01, hit: 0.008, crit: 0}, ...]\n *\n * Use case: \"I want to see exactly how hit/crit probabilities contribute to each damage value.\"\n */\n toLabeledTable(\n labels: OutcomeType[] = []\n ): Array<{ damage: number; total: number } & Record<string, number>> {\n return this.combined.support().map((damageValue) => {\n const probabilityBin = this.combined.map.get(damageValue)!;\n const tableRow: { damage: number; total: number } & Record<\n string,\n number\n > = {\n damage: damageValue,\n total: probabilityBin.p,\n };\n for (const outcomeLabel of labels) {\n tableRow[outcomeLabel] = probabilityBin.count[outcomeLabel] || 0;\n }\n return tableRow;\n });\n }\n\n /**\n * Returns data for stacked charts with unconditional per-label probability mass per damage.\n *\n * - Each dataset value equals the unconditional probability mass for that label at that damage\n * (i.e., `bin.count[label]`).\n * - Column sums may be less than the total probability `bin.p` when you omit labels or when\n * there is unlabeled mass. Include all relevant outcome labels if you need the sum to match.\n * - This behavior matches tests that expect raw per-label mass (not proportional scaling).\n * - NOTE: This implementation may break dprcalc.com chart binning at large n, need to test it more.\n *\n * @example\n * query.toStackedChartData(['hit', 'crit'])\n * // → {labels: [0, 6, 12, ...], datasets: [{label: 'hit', data: [0, 0.03, ...]}, ...]}\n */\n toStackedChartData(\n labels: OutcomeType[] = [],\n epsilon = EPS\n ): { labels: number[]; datasets: Array<{ label: string; data: number[] }> } {\n const damageValues = this.combined.support();\n\n const datasets = labels.map((outcomeLabel) => ({\n label: outcomeLabel,\n data: damageValues.map((dmg) => {\n const bin = this.combined.map.get(dmg);\n const v = bin ? (bin.count[outcomeLabel] as number) || 0 : 0;\n return v <= epsilon ? 0 : v;\n }),\n }));\n\n return { labels: damageValues, datasets };\n }\n\n /**\n * Returns pure mathematical data for cumulative distribution function (CDF).\n * Shows P(X ≤ x) - the probability of getting at most x damage.\n *\n * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)\n * @returns Pure data structure with support and cumulative probabilities\n *\n * @example\n * query.toCDFSeries()\n * // → {support: [0, 6, 12], data: [5.2, 18.3, 45.1]}\n */\n toCDFSeries(asPercentages: boolean = true): {\n support: number[];\n data: number[];\n } {\n const originalSupport = this.combined.support();\n if (originalSupport.length === 0) {\n return { support: [], data: [] };\n }\n\n // Create complete integer range from min to max\n const minDamage = Math.min(...originalSupport);\n const maxDamage = Math.max(...originalSupport);\n const support = Array.from(\n { length: maxDamage - minDamage + 1 },\n (_, i) => minDamage + i\n );\n\n let cumulativeProbability = 0;\n const cdfData: number[] = [];\n\n for (const damage of support) {\n const bin = this.combined.map.get(damage);\n if (bin) {\n cumulativeProbability += bin.p;\n }\n cdfData.push(\n asPercentages ? cumulativeProbability * 100 : cumulativeProbability\n );\n }\n\n return {\n support,\n data: cdfData,\n };\n }\n\n /**\n * Returns pure mathematical data for complementary cumulative distribution function (CCDF).\n * Shows P(X ≥ x) - the probability of getting at least x damage.\n *\n * @param asPercentages Whether to return percentages (0-100) or probabilities (0-1)\n * @returns Pure data structure with support and complementary cumulative probabilities\n *\n * @example\n * query.toCCDFSeries()\n * // → {support: [0, 6, 12], data: [100, 94.8, 81.7]}\n */\n toCCDFSeries(asPercentages: boolean = true): {\n support: number[];\n data: number[];\n } {\n const originalSupport = this.combined.support();\n if (originalSupport.length === 0) {\n return { support: [], data: [] };\n }\n\n // Create complete integer range from min to max\n const minDamage = Math.min(...originalSupport);\n const maxDamage = Math.max(...originalSupport);\n const support = Array.from(\n { length: maxDamage - minDamage + 1 },\n (_, i) => minDamage + i\n );\n\n // Calculate CCDF: P(X ≥ x) = 1 - P(X < x)\n let cumulativeProbability = 0;\n const ccdfData: number[] = [];\n\n for (const damage of support) {\n // P(X ≥ x) is the total mass minus the cumulative up to (not including) x.\n const ccdf = 1 - cumulativeProbability;\n ccdfData.push(asPercentages ? ccdf * 100 : ccdf);\n\n // Now add current probability for next iteration\n const bin = this.combined.map.get(damage);\n if (bin) {\n cumulativeProbability += bin.p;\n }\n }\n\n return {\n support,\n data: ccdfData,\n };\n }\n\n /** Probability of doing strictly more than threshold damage (default >0). */\n probDamageGreaterThan(threshold = 0): number {\n let acc = 0;\n for (const [x, bin] of this.combined.map) if (x > threshold) acc += bin.p;\n return acc;\n }\n\n /** All outcome keys present in the PMF, ordered by `order` when given. */\n outcomeKeys(order?: OutcomeType[]): OutcomeType[] {\n const found = new Set<string>();\n for (const [, bin] of this.combined.map) {\n for (const k in bin.count)\n if (bin.count[k] && (bin.count[k] as number) > 0) found.add(k);\n }\n if (found.size === 0)\n [\"hit\", \"crit\", \"missNone\"].forEach((k) => found.add(k));\n const keys = Array.from(found).filter(\n (k) => order?.includes(k as OutcomeType) ?? true\n ) as OutcomeType[];\n if (order && order.length)\n keys.sort((a, b) => order.indexOf(a) + 999 - (order.indexOf(b) + 999));\n return keys;\n }\n\n /** Total probability per outcome across the PMF. */\n outcomeTotals(\n outcomes: OutcomeType[] = this.outcomeKeys()\n ): Map<OutcomeType, number> {\n const totals = new Map<OutcomeType, number>();\n outcomes.forEach((o) => totals.set(o, 0));\n for (const [, row] of this.combined.map) {\n for (const o of outcomes) {\n const p = (row.count[o] as number) || 0; // if your bins store per-outcome p; else derive via toLabeledTable\n totals.set(o, (totals.get(o) || 0) + p);\n }\n }\n return totals;\n }\n\n /** Conditional damage range per outcome (min/avg/max of X | outcome). */\n outcomeDamageRanges(\n outcomes: OutcomeType[] = this.outcomeKeys()\n ): Map<OutcomeType, { min: number; avg: number; max: number }> {\n // Use toLabeledTable to stay consistent with your existing attribution\n const table = this.toLabeledTable(outcomes);\n const ranges = new Map<\n OutcomeType,\n { min?: number; max?: number; sum: number; mass: number }\n >();\n outcomes.forEach((o) => ranges.set(o, { sum: 0, mass: 0 }));\n\n for (const row of table) {\n const dmg = row.damage as number;\n for (const o of outcomes) {\n const p = (row[o] as number) || 0; // joint mass at (damage, outcome)\n if (p > 0) {\n const r = ranges.get(o)!;\n r.sum += dmg * p;\n r.mass += p;\n if (r.min === undefined || dmg < r.min) r.min = dmg;\n if (r.max === undefined || dmg > r.max) r.max = dmg;\n }\n }\n }\n\n const out = new Map<\n OutcomeType,\n { min: number; avg: number; max: number }\n >();\n for (const o of outcomes) {\n const r = ranges.get(o)!;\n const avg = r.mass > 0 ? r.sum / r.mass : 0;\n out.set(o, { min: r.min ?? 0, avg, max: r.max ?? 0 });\n }\n return out;\n }\n\n /**\n * Per-outcome probabilities and damage ranges, aggregated over the individual\n * singles rather than read off the combined distribution.\n *\n * `damageRange` is the sum, over every single that can produce the outcome, of\n * that single's own conditional damage range: \"what this outcome contributes\n * across the whole turn when every attack that can produce it does\". Linear in\n * the number of attacks by construction.\n *\n * Prefer this over {@link DiceQuery.snapshot} for a multi-attack query.\n * `snapshot` reads `damageRange` off the combined PMF's `count`, which the\n * convolution accumulates as an expected count, so its `avg` is size-biased\n * for N≥2 (its own doc comment says so). The two agree for a single attack.\n *\n * Only outcomes that actually occur appear in the result.\n *\n * Like every `singles`-based helper on this class, it describes the singles\n * and not an explicitly provided `combined`. `Turn.toQuery()` supplies one whose\n * distribution also contains rider attacks that are absent from `singles`\n * (an `otherwise([unarmed, unarmed])` flurry, say), so those attacks do not\n * appear here. For rider-inclusive figures read the combined distribution\n * directly: {@link DiceQuery.outcomeTotals}, {@link DiceQuery.outcomeDamageRanges}.\n *\n * @param outcomes Which outcomes to consider; defaults to every canonical one.\n */\n outcomeStats(\n outcomes: readonly OutcomeType[] = ALL_OUTCOME_TYPES\n ): Map<OutcomeType, OutcomeSnapshot> {\n const stats = new Map<OutcomeType, OutcomeSnapshot>();\n const perSingle = this.singles.map((pmf) => new DiceQuery([pmf], undefined, this._eps));\n\n for (const outcome of outcomes) {\n const atLeastOneProbability = this.probAtLeastOne(outcome);\n if (atLeastOneProbability <= 0) continue;\n\n const damageRange = { min: 0, avg: 0, max: 0 };\n let contributors = 0;\n for (const single of perSingle) {\n if (single.probAtLeastOne(outcome) <= 0) continue;\n contributors++;\n const stat = single.damageStatsFrom(outcome);\n damageRange.min += stat.min;\n damageRange.avg += stat.avg;\n damageRange.max += stat.max;\n }\n\n stats.set(outcome, {\n atLeastOneProbability,\n allProbability:\n contributors > 0 ? this.probExactlyK(outcome, contributors) : 0,\n damageRange,\n });\n }\n\n return stats;\n }\n\n /**\n * Snapshot of the distribution in the exact shape the UI consumes.\n * - outcome probabilities are \"at least one\" (and equal to \"all\" for a single PMF)\n * - damageRange is conditional on the outcome occurring\n *\n * The outcome probabilities use the correct Poisson-binomial marginals\n * (`atLeastOneProbability` = P(≥1 attack has it), `allProbability` = P(all do)),\n * so they are always valid probabilities in [0,1].\n *\n * KNOWN LIMITATION (multi-attack): `damageRange.avg` is still aggregated from\n * the combined PMF's `count`, which the convolution accumulates as an EXPECTED\n * COUNT, so for N≥2 attacks it is the size-biased mean E[dmg·#label]/E[#label]\n * rather than a clean conditional expectation. It is correct for a single\n * attack.\n */\n snapshot(order?: readonly OutcomeType[]): Snapshot {\n // 1) Discover which outcomes actually appear in this PMF\n const discovered = new Set<string>();\n for (const [, bin] of this.combined.map) {\n for (const k in bin.count) {\n if (bin.count[k] && (bin.count[k] as number) > 0) discovered.add(k);\n }\n }\n if (discovered.size === 0) {\n for (const k of DiceQuery.DEFAULT_OUTCOMES) discovered.add(k);\n }\n\n let outcomes = Array.from(discovered);\n\n // Optional filtering + ordering if a preferred order was provided\n if (order && order.length) {\n const inOrder = new Set(order);\n outcomes = outcomes.filter((k) => inOrder.has(k as OutcomeType));\n const rank = new Map(order.map((k, i) => [k, i]));\n outcomes.sort(\n (a, b) =>\n (rank.get(a as OutcomeType) ?? 999) -\n (rank.get(b as OutcomeType) ?? 999)\n );\n }\n\n // 2) Aggregate per-outcome mass and conditional damage ranges via labeled table\n const rows = this.toLabeledTable(outcomes as OutcomeType[]);\n\n const rangeAcc = new Map<\n OutcomeType,\n { min?: number; max?: number; sum: number; mass: number }\n >();\n for (const ot of outcomes) {\n rangeAcc.set(ot as OutcomeType, { sum: 0, mass: 0 });\n }\n\n for (const row of rows) {\n const dmg = row.damage as number;\n for (const ot of outcomes) {\n const p = (row[ot] as number) || 0;\n if (p <= 0) continue;\n\n const r = rangeAcc.get(ot as OutcomeType)!;\n r.sum += dmg * p;\n r.mass += p;\n if (r.min === undefined || dmg < r.min) r.min = dmg;\n if (r.max === undefined || dmg > r.max) r.max = dmg;\n }\n }\n\n const n = this.singles.length;\n const outcomeMap = new Map<OutcomeType, OutcomeSnapshot>();\n for (const ot of outcomes) {\n const r = rangeAcc.get(ot as OutcomeType)!;\n const avg = r.mass > 0 ? r.sum / r.mass : 0;\n // Use the correct per-attack marginals (Poisson-binomial) so these are\n // always valid probabilities in [0,1]. For a single attack both reduce to\n // P(outcome); the previous `total` was an expected count and could exceed 1.\n outcomeMap.set(ot as OutcomeType, {\n atLeastOneProbability: this.probAtLeastOne(ot as OutcomeType),\n allProbability: this.probAtLeastK(ot as OutcomeType, n),\n damageRange: { min: r.min ?? 0, avg, max: r.max ?? 0 },\n });\n }\n\n // 3) Scalars: mean, damageChance, and percentiles\n const averageDPR = this.mean();\n\n let damageChance = 0; // P(total damage > 0)\n for (const [x, bin] of this.combined.map) if (x > 0) damageChance += bin.p;\n\n const percentiles = {\n p25: this.combined.quantile(0.25),\n p50: this.combined.quantile(0.5),\n p75: this.combined.quantile(0.75),\n };\n\n return { averageDPR, damageChance, percentiles, outcomes: outcomeMap };\n }\n\n /**\n * PMF Transformation Methods\n *\n * These methods provide a fluent API for transforming dice queries by wrapping\n * the underlying PMF transformation methods. All operations work on the combined\n * PMF and return new DiceQuery instances.\n */\n\n /**\n * Returns a new DiceQuery with normalized probabilities (ensuring they sum to 1.0).\n *\n * @returns New DiceQuery with normalized combined PMF\n */\n normalize(): DiceQuery {\n return new DiceQuery([this.combined.normalize()]);\n }\n\n /**\n * Returns a new DiceQuery with low-probability outcomes removed.\n *\n * @param eps Minimum probability threshold (defaults to PMF epsilon)\n * @param keepFinalBin Whether to keep the highest damage bin regardless of probability\n * @returns New DiceQuery with compacted combined PMF\n */\n compact(eps?: number, keepFinalBin?: boolean): DiceQuery {\n return new DiceQuery([this.combined.compact(eps, keepFinalBin)]);\n }\n\n /**\n * Returns a new DiceQuery with an additional scaled branch added.\n * Useful for conditional outcomes like \"30% chance of opportunity attack\".\n *\n * @param branch DiceQuery to add as a scaled branch\n * @param probability Probability of the branch occurring (0-1)\n * @returns New DiceQuery combining this query with the scaled branch\n *\n * @example\n * const baseAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n * const opportunityAttack = parse(\"(d20 + 5 AC 15) * (1d8 + 3)\");\n * const withOpportunity = baseAttack.addScaled(opportunityAttack, 0.3);\n */\n addScaled(branch: DiceQuery, probability: number): DiceQuery {\n return new DiceQuery([\n this.combined.addScaled(branch.combined, probability),\n ]);\n }\n\n /**\n * Returns a new DiceQuery with all probabilities scaled by a factor.\n * Used for conditional scenarios where the entire outcome has reduced probability.\n *\n * @param factor Scaling factor for probabilities\n * @returns New DiceQuery with scaled probabilities\n *\n * @example\n * const fullAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n * const conditionalAttack = fullAttack.scaleMass(0.3); // 30% chance scenario\n */\n scaleMass(factor: number): DiceQuery {\n return new DiceQuery([this.combined.scaleMass(factor)]);\n }\n\n totalMass(): number {\n return this.combined.mass();\n }\n\n /**\n * Returns a new DiceQuery with damage values transformed by a function.\n * Useful for applying modifiers, resistances, or other damage transformations.\n *\n * @param damageTransformFunction Function to transform each damage value\n * @returns New DiceQuery with transformed damage values\n *\n * @example\n * const baseAttack = parse(\"2d6 + 3\");\n * const withResistance = baseAttack.mapDamage(dmg => Math.floor(dmg / 2)); // Half damage\n * const withBonus = baseAttack.mapDamage(dmg => dmg + 5); // +5 damage\n */\n mapDamage(\n damageTransformFunction: (damageValue: number) => number\n ): DiceQuery {\n return new DiceQuery([this.combined.mapDamage(damageTransformFunction)]);\n }\n\n /**\n * Returns a new DiceQuery with damage values scaled by `factor / denominator`.\n * Convenient wrapper around mapDamage for multiplicative scaling; see\n * {@link PMF.scaleDamage} for the rounding rules.\n *\n * @param factor Scaling factor for damage values (the numerator of a ratio)\n * @param rounding Rounding method: \"floor\" (default), \"round\", or \"ceil\"\n * @param denominator Divisor; integer `factor` and `denominator` round exactly\n * @returns New DiceQuery with scaled damage values\n *\n * @example\n * const baseAttack = parse(\"2d6 + 3\");\n * const doubled = baseAttack.scaleDamage(2); // Double damage\n * const halfDamage = baseAttack.scaleDamage(0.5, \"round\"); // Half damage, rounded\n * const sevenTenths = baseAttack.scaleDamage(7, \"floor\", 10); // floor(7v/10), exactly\n */\n scaleDamage(\n factor: number,\n rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\",\n denominator = 1\n ): DiceQuery {\n return new DiceQuery([this.combined.scaleDamage(factor, rounding, denominator)]);\n }\n\n /**\n * Returns a new DiceQuery combining this query with another via convolution.\n * Equivalent to rolling both queries independently and adding results.\n * It is important to use this rather than combing()ing the PMFs directly!\n * This method maintains the provenance of the PMFs which is needed for damage attribution.\n * Combining the .combined PMFs directly is still valid for DPR calculations but\n * is not statistically sound for queries.\n *\n * @param other DiceQuery to combine with\n * @param eps Optional epsilon for precision control\n * @returns New DiceQuery representing the combined outcome\n *\n * @example\n * const mainAttack = parse(\"(d20 + 5 AC 15) * (2d6 + 3)\");\n * const bonusAttack = parse(\"(d20 + 3 AC 15) * (1d6 + 1)\");\n * const bothAttacks = mainAttack.convolve(bonusAttack);\n */\n convolve(other: DiceQuery): DiceQuery {\n const singles = [...this.singles, ...other.singles];\n return new DiceQuery(singles);\n }\n\n /**\n * First-success split over an ordered list of DISTINCT single-swing PMFs.\n * Each PMF may have different success/subset probabilities (from labels).\n *\n * successOutcome: e.g., [\"success\"] or [\"hit\", \"crit\"]\n * subsetOutcome: e.g., [\"subset\"] or [\"crit\"] where subset ⊆ success\n *\n * Returns tuple: [pFirstNonSubset, pFirstSubset, pAnySuccess, pNone]\n */\n public firstSuccessSplit(\n successOutcome: OutcomeType | OutcomeType[],\n subsetOutcome: OutcomeType | OutcomeType[],\n eps = EPS\n ): readonly [pSuccess: number, pSubset: number, pAny: number, pNone: number] {\n const pmfs = this.singles;\n if (!pmfs.length) {\n throw new Error(\"firstSuccessSplitFromPMFs: pmfs must be non-empty\");\n }\n\n const toArr = (x: OutcomeType | OutcomeType[]): OutcomeType[] =>\n Array.isArray(x) ? x : [x];\n const clamp01 = (x: number) => Math.max(0, Math.min(1, x));\n const tol = Math.max(eps, 8 * Number.EPSILON);\n\n // Per-event probabilities from each PMF via DiceQuery([pmf])\n const per = pmfs.map((pmf) => {\n const dq = new DiceQuery([pmf]);\n const pS = dq.probAtLeastOne(toArr(successOutcome));\n const pB = dq.probAtLeastOne(toArr(subsetOutcome));\n if (pB - pS > eps) {\n throw new Error(\n \"firstSuccessSplitFromPMFs: P(subset) > P(success) for an event. Ensure subset ⊆ success.\"\n );\n }\n return { pS, pB };\n });\n\n // Aggregate with running miss prefix\n let missSoFar = 1;\n let pFirstSubset = 0;\n let pFirstNonSubset = 0;\n let pNone = 1;\n\n for (const { pS, pB } of per) {\n pFirstSubset += missSoFar * pB;\n pFirstNonSubset += missSoFar * (pS - pB);\n const miss = 1 - pS;\n missSoFar *= miss;\n pNone *= miss;\n }\n\n const pAny = 1 - pNone;\n\n // Clamp and sanity check\n const a = clamp01(pFirstNonSubset);\n const b = clamp01(pFirstSubset);\n const any = clamp01(pAny);\n const none = clamp01(pNone);\n\n if (Math.abs(a + b - any) > tol * Math.max(1, any)) {\n throw new Error(\n `firstSuccessSplitFromPMFs: parts do not sum to pAny. got a+b=${\n a + b\n }, pAny=${any}`\n );\n }\n\n return [a, b, any, none] as const;\n }\n}\n// Make sure these types are exported in your public index, or inline them here.\nexport type OutcomeSnapshot = {\n atLeastOneProbability: number; // P(outcome occurs at least once)\n allProbability: number; // equal to atLeastOneProbability for a single aggregated PMF\n damageRange: { min: number; avg: number; max: number }; // conditional on the outcome occurring\n};\n\nexport type Snapshot = {\n averageDPR: number;\n damageChance: number; // P(total damage > 0)\n percentiles: { p25: number; p50: number; p75: number };\n outcomes: Map<OutcomeType, OutcomeSnapshot>;\n};\n","import { LRUCache } from \"../common/lru-cache\";\nimport type { LRUCacheOptions } from \"../common/lru-cache\";\nimport type { Bin, OutcomeLabelMap, Rounding } from \"../common/types\";\nimport {\n ALL_OUTCOME_TYPES,\n EPS,\n MISS_NONE_OUTCOME,\n sortOutcomes,\n} from \"../common/types\";\nimport { DiceQuery } from \"./query\";\n\n/** Library caches hand the same PMF to every caller, so entries are frozen as they are stored. */\nconst sharedPMFCacheOptions: LRUCacheOptions<PMF> = {\n onInsert: (pmf) => pmf.freeze(),\n followsCachingToggle: true,\n};\n\nexport const pmfCache = new LRUCache<string, PMF>(1000, sharedPMFCacheOptions);\n\n/**\n * Relative slack when comparing a float-summed CDF with a target probability. Float running\n * sums drift by a few ulps; a target within this fraction of the CDF counts as reached.\n */\nconst QUANTILE_RELATIVE_SLACK = 1e-12;\n\n/**\n * The map of a frozen PMF: a copy of the map it was built with that reads like any `Map` but whose\n * `set`, `delete` and `clear` throw a `TypeError`, so a PMF shared through a cache cannot be\n * changed through it. Only frozen PMFs pay for the copy; the unfrozen hot paths keep their own map.\n */\nclass FrozenBinMap extends Map<number, Bin> {\n constructor(source: ReadonlyMap<number, Bin>) {\n super();\n for (const [value, bin] of source) super.set(value, bin);\n }\n\n override set(value: number): never {\n throw new TypeError(`Cannot set damage value ${value}: this PMF is frozen (shared through a cache)`);\n }\n\n override delete(value: number): never {\n throw new TypeError(`Cannot delete damage value ${value}: this PMF is frozen (shared through a cache)`);\n }\n\n override clear(): never {\n throw new TypeError(\"Cannot clear the map: this PMF is frozen (shared through a cache)\");\n }\n}\n\n/**\n * Complete numeric model for the stacked damage-attribution chart, produced by\n * {@link PMF.damageAttributionChartModel}. Carries every dice-and-probability\n * value the chart needs; a renderer only maps these numbers into its own format\n * (colors, human labels, axis units, dataset objects).\n */\nexport interface DamageAttributionChartModel {\n /** Bucket-start value for each column. Numeric; the caller stringifies for labels. */\n labels: number[];\n /** Present only when the distribution was coarsened; [start,end] inclusive, per bucket. */\n binRanges?: { start: number; end: number }[];\n /** Discovered outcome labels in stack order. Empty for pure (unattributed) distributions. */\n outcomes: string[];\n /** outcome → per-bucket probability mass (fraction 0..1). Bar heights. Σ over outcomes ≈ totals[i]. */\n series: Map<string, number[]>;\n /**\n * outcome → per-bucket conditional share (fraction 0..1) of that bucket's total.\n * Tooltip signal. 0 where the bucket total is below `epsilon`; otherwise Σ over\n * outcomes ≈ 1.\n */\n shares: Map<string, number[]>;\n /** Per-bucket total probability mass (fraction 0..1). The only signal for pure distributions. */\n totals: number[];\n /** Reversed-convention CCDF markers: damage at which P(X ≥ x) crosses 80/50/20%. */\n percentiles: { p80: number; p50: number; p20: number };\n /** Distribution mean, `this.mean()`. */\n mean: number;\n}\n\n/**\n * Probability Mass Function for discrete damage distributions.\n */\nexport class PMF {\n // Unique ID generator for anonymous PMFs to avoid cache key collisions\n private static __anonIdCounter = 1;\n\n // Cached computed values\n private _support?: number[];\n private _min?: number;\n private _max?: number;\n private _totalMass?: number;\n private _mean?: number;\n private _variance?: number;\n private _stdev?: number;\n private _fingerprint?: string;\n private _cumulative?: { values: number[]; below: number[]; above: number[] };\n private _frozen = false;\n\n /**\n * @param map Damage value → bin. Typed read-only: a PMF is immutable once built. A PMF returned\n * from the library's caches is frozen: its bins, its map and the `map` property itself reject\n * writes (see {@link freeze}).\n */\n constructor(\n public readonly map: ReadonlyMap<number, Bin> = new Map(),\n public readonly epsilon = EPS,\n public readonly normalized = false,\n public readonly identifier: string = `anon#${PMF.__anonIdCounter++}`,\n private readonly _preservedProvenance = true\n ) {}\n\n /**\n * A PMF cache that freezes every stored PMF and follows `setCachingEnabled`. The library's\n * own caches are built with this.\n */\n static createCache(maxSize: number): LRUCache<string, PMF> {\n return new LRUCache<string, PMF>(maxSize, sharedPMFCacheOptions);\n }\n\n /**\n * Freezes this PMF so it can be shared through a cache. Every bin is deep-frozen, including its\n * `count` and `attr` maps, so writing to one throws a `TypeError`. The map is replaced by a copy\n * whose `set`/`delete`/`clear` throw a `TypeError` (the map this PMF was built with stays the\n * caller's), and the `map` property becomes read-only, so assigning it throws too.\n * Returns this PMF.\n */\n freeze(): this {\n if (this._frozen) return this;\n const map = new FrozenBinMap(this.map);\n for (const bin of map.values()) {\n Object.freeze(bin.count);\n if (bin.attr) Object.freeze(bin.attr);\n Object.freeze(bin);\n }\n // Frozen too, so no own `set`/`delete`/`clear` can be installed over the throwing ones.\n Object.freeze(map);\n // `as object`: `defineProperty` returns its target, which is not a derived PMF to keep.\n Object.defineProperty(this as object, \"map\", { value: map, writable: false, enumerable: true, configurable: false });\n this._frozen = true;\n return this;\n }\n\n static empty(epsilon = EPS, identifier = \"empty\") {\n return new PMF(new Map(), epsilon, false, identifier);\n }\n\n // This has a single bin at value 0, mass of 1\n static zero(epsilon = EPS): PMF {\n const m = new Map();\n m.set(0, { p: 1, count: { miss: 1 }, attr: {} });\n return new PMF(m, epsilon, false, \"zero\");\n }\n\n static delta(value: number, epsilon = EPS): PMF {\n return PMF.fromMap(new Map([[value, 1]]), epsilon);\n }\n\n /**\n * Point mass at damage 0 tagged with the canonical `missNone` outcome.\n *\n * Differs from {@link PMF.zero}, which labels its zero bin `miss` — the\n * builder's attack-resolution vocabulary. This uses the `missNone`\n * {@link OutcomeType} that the attribution charts and outcome stats key on,\n * so it is the correct \"clean miss / no damage\" delta for provenance-aware\n * mixtures feeding those consumers.\n */\n static missNone(epsilon = EPS): PMF {\n const m = new Map<number, Bin>();\n m.set(0, { p: 1, count: { [MISS_NONE_OUTCOME]: 1 }, attr: {} });\n return new PMF(m, epsilon, false, \"missNone\");\n }\n\n // This creates a single bin at value 0, but with weight 0.\n static emptyMass(): PMF {\n return PMF.zero().scaleMass(0);\n }\n\n // Makes PMF iterable over [damage, bin] pairs.\n [Symbol.iterator](): IterableIterator<[number, Bin]> {\n return this.map[Symbol.iterator]();\n }\n\n static clearCache() {\n pmfCache.clear();\n }\n\n /**\n * Creates a conditional PMF from two branches (success and failure) and a probability.\n * This is the core logic for modeling any probabilistic event where there are two\n * distinct outcomes.\n */\n static branch(\n successPMF: PMF,\n failurePMF: PMF,\n successProbability: number\n ): PMF {\n let p = successProbability;\n if (!Number.isFinite(p)) p = 0;\n if (p < 0) p = 0;\n if (p > 1) p = 1;\n\n const q = 1 - p;\n\n // Fast paths. scaleMass(1) returns the same instance, so these hand back the\n // branch PMF unchanged. That is safe because PMFs are treated as immutable\n // (compact() and the other transforms now clone bins rather than mutate).\n if (p === 0) return failurePMF.scaleMass(1);\n if (p === 1) return successPMF.scaleMass(1);\n\n // Choose epsilon. You can also pick Math.min for a tighter threshold.\n const eps = successPMF.epsilon ?? failurePMF.epsilon;\n const id = `branch(${failurePMF.identifier}*${q.toFixed(6)} + ${\n successPMF.identifier\n }*${p.toFixed(6)})`;\n\n // Proper Bernoulli mixture: q·failure ⊕ p·success, assembled in a single\n // pass. The previous `empty().addScaled(failure,q).addScaled(success,p)`\n // chain copied failurePMF's bins twice (into the intermediate, then again\n // when the intermediate was copied by the second addScaled). Merging both\n // scaled branches directly into one fresh map keeps the same accumulation\n // order — q·failure first, then p·success — so the result is bit-identical.\n const resultMap = new Map<number, Bin>();\n for (const [damageValue, bin] of failurePMF.map) {\n PMF.mergeInto(resultMap, damageValue, PMF.scaleBin(bin, q));\n }\n for (const [damageValue, bin] of successPMF.map) {\n PMF.mergeInto(resultMap, damageValue, PMF.scaleBin(bin, p));\n }\n\n return new PMF(resultMap, eps, false, id);\n }\n\n /**\n * withProbability()\n *\n * A convenience wrapper around branch() for the common case where the \"failure\" branch is always zero().\n *\n * Think of this as a shortcut for:\n * pmf.gate(p, PMF.zero())\n *\n * Use this to model a *single* Bernoulli event — an outcome that either happens or doesn't,\n * like an opportunity attack that occurs with probability p, or a single attack that either hits or misses.\n *\n * This is **not** for combining multiple independent attacks or mutually exclusive multi-outcome scenarios.\n * - For multiple independent swings, use DiceQuery with separate PMFs for each attack.\n * - For modeling \"first success\" logic across multiple attacks (like Sneak Attack or Smite)\n * use query.firstSuccessSplit() to get the exact probabilities.\n * - For scenarios with several mutually exclusive outcomes (like crit vs hit vs none), use PMF.exclusive().\n *\n */\n static withProbability(successPMF: PMF, probability: number): PMF {\n return PMF.branch(successPMF, PMF.zero(), probability);\n }\n\n /**\n * gate()\n *\n * A conditional wrapper around branch() that applies this PMF with probability `p`,\n * and applies a provided fallback PMF otherwise.\n *\n * This is useful for modeling a binary choice between two outcomes:\n * - The \"success\" outcome (this PMF) happens with probability `p`.\n * - The \"failure\" outcome (fallback PMF) happens with probability `1 - p`.\n *\n * Examples:\n * - 25% chance to include an opportunity attack, otherwise nothing:\n * attackPMF.gate(0.25, PMF.zero())\n *\n * - 50% chance to deal fireball damage, otherwise cone of cold damage:\n * fireballPMF.gate(0.5, coneOfColdPMF)\n *\n * Relationship to other helpers:\n * - **withProbability()** is a shortcut for the common case where the fallback is `PMF.zero()`.\n * - **exclusive()** is for three or more mutually exclusive outcomes (e.g., crit vs hit vs none).\n *\n * @param p Probability of applying this PMF (between 0 and 1).\n * @param fallback PMF to apply when this PMF is *not* selected.\n * @returns A new PMF representing the weighted mixture of this PMF and the fallback.\n */\n gate(p: number, fallback: PMF) {\n return PMF.branch(this, fallback, p);\n }\n\n /**\n * PMF.exclusive()\n *\n * Builds a single PMF from a set of mutually exclusive weighted outcomes.\n * Exactly one of the provided options will occur.\n *\n * Each option has:\n * - A PMF representing its outcome (e.g., damage dice).\n * - A weight representing its probability of being selected.\n *\n * Notes:\n * - If total weight < 1 (within eps), leftover mass is assumed to be PMF.zero()\n *\n * @param options Array of `{ pmf, weight }` or `[PMF, number]`.\n * @param eps Optional tolerance for floating point rounding.\n */\n static exclusive(\n options: Array<{ pmf: PMF; weight: number } | [PMF, number]>,\n eps = EPS\n ): PMF {\n const items = options.map((o) =>\n Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o\n );\n\n // Validate weights\n for (const { weight } of items) {\n if (!Number.isFinite(weight) || weight < -eps) {\n throw new Error(`PMF.exclusive: invalid weight ${weight}.`);\n }\n }\n\n // Sum and check\n let totalWeight = items.reduce((s, { weight }) => s + weight, 0);\n\n // Normalize tiny negatives to 0 and tiny overshoot to 1 when within eps\n if (Math.abs(totalWeight) <= eps) totalWeight = 0;\n if (Math.abs(1 - totalWeight) <= eps) totalWeight = 1;\n\n if (totalWeight > 1 + EPS) {\n throw new Error(\n `PMF.exclusive: total weight ${totalWeight} exceeds 1. (epsilon: ${eps})`\n );\n }\n\n // Accumulate scaled components, skipping near-zero weights\n let out = PMF.empty(eps);\n for (const { pmf, weight } of items) {\n if (weight > eps) out = out.addScaled(pmf, weight);\n }\n\n // Add leftover mass at zero outcome\n const leftover = Math.max(0, 1 - totalWeight);\n if (leftover > eps) {\n out = out.addScaled(PMF.zero(), leftover);\n }\n\n return out;\n }\n\n /**\n * PMF.mix()\n *\n * Builds a PMF as a linear combination of input PMFs with the given weights.\n * Unlike `exclusive`, this does NOT:\n * - enforce that weights sum to 1\n * - add leftover probability to δ0 (PMF.zero())\n *\n * Use when outcomes are not mutually exclusive, or for interpolation/blending.\n *\n * @param options Array of `{ pmf, weight }` or `[PMF, number]`.\n * @param eps Optional tolerance for skipping tiny weights.\n */\n static mix(\n options: Array<{ pmf: PMF; weight: number } | [PMF, number]>,\n eps = EPS\n ): PMF {\n const items = options.map((o) =>\n Array.isArray(o) ? { pmf: o[0], weight: o[1] } : o\n );\n\n // Validate weights, but do not constrain their sum.\n for (const { weight } of items) {\n if (!Number.isFinite(weight)) {\n throw new Error(`PMF.mix: invalid weight ${weight}.`);\n }\n }\n\n let out = PMF.empty(eps);\n for (const { pmf, weight } of items) {\n if (Math.abs(weight) <= eps) continue; // ignore crumbs\n out = out.addScaled(pmf, weight);\n }\n return out;\n }\n /**\n * Adds damage attribution metadata to this PMF based on existing count metadata.\n * For each bin, sets attr[outcome] = damage × count[outcome].\n *\n * This enables damage attribution charts to work with builder-generated PMFs.\n * The parser generates attr automatically, but builder PMFs only have count.\n *\n * @returns New PMF with attr field populated in each bin\n */\n /**\n * Returns true if this PMF already carries damage attribution metadata.\n *\n * Only the first positive-damage bin is inspected (parser-generated PMFs\n * populate `attr` uniformly), so this is O(1) in practice.\n */\n hasAttribution(): boolean {\n for (const [damage, bin] of this.map) {\n if (damage !== 0 && bin.attr && Object.keys(bin.attr).length > 0) {\n return true;\n }\n // Only check the first non-zero bin for performance\n if (damage > 0) break;\n }\n return false;\n }\n\n withAttribution(): PMF {\n // Fast path: if attr already exists, return this PMF unchanged\n if (this.hasAttribution()) return this;\n\n const newMap = new Map<number, Bin>();\n\n for (const [damage, bin] of this.map) {\n const attr: OutcomeLabelMap = {};\n\n // For each outcome type in count, compute its damage contribution\n for (const outcome in bin.count) {\n const probability = bin.count[outcome] as number;\n if (probability > 0) {\n attr[outcome] = damage * probability;\n }\n }\n\n // Create new bin with attribution\n newMap.set(damage, {\n p: bin.p,\n count: { ...bin.count },\n attr: Object.keys(attr).length > 0 ? attr : undefined,\n });\n }\n\n // Use a different identifier to avoid cache collisions with non-attributed version\n return new PMF(\n newMap,\n this.epsilon,\n this.normalized,\n `${this.identifier}~attr`\n );\n }\n\n /**\n * General-purpose N-way mixture.\n * weights: Array of [weight, PMF].\n *\n * Example: PMF.mixN([\n * [pMiss, zero],\n * [pHit, hitPMF],\n * [pCrit, critPMF],\n * ]);\n */\n static mixN(weights: [number, PMF][], eps = EPS): PMF {\n // Treat tiny/negative as zero; keep performance clean\n const filtered = weights.filter(([w]) => w > eps);\n\n if (filtered.length === 0) {\n return PMF.emptyMass(); // not PMF.zero(): we want \"no mass\" mixture\n }\n\n // No need to normalize up front; accumulation blends by relative weight\n let acc: PMF | null = null;\n let sum = 0;\n\n for (const [w, pmf] of filtered) {\n if (acc === null) {\n acc = pmf;\n sum = w;\n } else {\n const q = w / (sum + w); // relative weight of the new component\n acc = PMF.branch(pmf, acc, q); // success=new pmf, failure=acc\n sum += w;\n }\n }\n\n // If everything got filtered out (all ~0), return empty mass\n return acc ?? PMF.emptyMass();\n }\n\n /**\n * False for a PMF produced by {@link power}, which folds independent attacks into one\n * distribution and cannot say which attack produced which label.\n */\n public preservedProvenance(): boolean {\n return this._preservedProvenance;\n }\n\n private getPowerCacheKey(n: number, eps: number): string {\n // Includes fingerprint() (per-bin probability/count/attr content), matching convolve()'s\n // cache key: the identifier alone is not content-unique. `mapDamage`/`scaleDamage`,\n // `normalize()`, and `compact()` all keep the PARENT's identifier while producing a\n // numerically different PMF\n // (e.g. `X.mapDamage(f).power(2)` and `X.mapDamage(g).power(2)` would otherwise collide on\n // the same key `map(X)+map(X)@eps` and silently return each other's cached result).\n const id = this.identifier;\n let key = `${id}`;\n for (let i = 1; i < n; i++) key += `+${id}`;\n return `${key}@${eps}|${this.fingerprint()}`;\n }\n\n /**\n * Convolves this PMF with itself `n` times, by exponentiation by squaring. `n` must be a\n * positive integer.\n *\n * NOTE: this folds `n` independent, identical attacks into one PMF, so it loses data\n * provenance. It is only safe when computing masses; for `atLeast`-style queries use a\n * `DiceQuery` instead of `power()`.\n */\n power(n: number, eps = this.epsilon): PMF {\n if (!Number.isInteger(n) || n <= 0) {\n throw new Error(\"power(n): n must be a positive integer\");\n }\n if (n === 1) return this;\n\n const epsilon = eps ?? this.epsilon;\n\n const key = this.getPowerCacheKey(n, epsilon);\n const cached = pmfCache.get(key);\n if (cached) return cached;\n\n // Start from the base PMF and accumulate n-1 additional powers\n let base: PMF = this.normalized ? this : this.normalize();\n let result: PMF = base;\n let exp = n - 1;\n\n while (exp > 0) {\n if (exp & 1) {\n result = result.convolve(base, epsilon);\n }\n exp >>= 1;\n if (exp > 0) {\n base = base.convolve(base, epsilon);\n }\n }\n\n // A copy carries the flag: `result` may be a convolution shared through the cache.\n const folded = new PMF(\n result.map,\n result.epsilon,\n result.normalized,\n result.identifier,\n false\n );\n pmfCache.set(key, folded);\n return folded;\n }\n\n /*\n * Helper for chaining multiple identical attacks\n */\n replicate(n: number): PMF[] {\n if (!Number.isInteger(n) || n <= 0) {\n throw new Error(\"replicate(n): n must be a positive integer\");\n }\n if (n === 1) return [this];\n return Array.from({ length: n }, () => this);\n }\n\n mass(): number {\n if (this._totalMass === undefined) {\n let totalProbabilityMass = 0;\n for (const { p } of this.map.values()) {\n totalProbabilityMass += p;\n }\n this._totalMass = totalProbabilityMass;\n }\n return this._totalMass;\n }\n\n outcomeMass(outcome: string): number {\n let totalProbabilityMass = 0;\n for (const { p, count } of this.map.values()) {\n totalProbabilityMass += p * ((count[outcome] as number) ?? 0);\n }\n return totalProbabilityMass;\n }\n\n // Helper for testing\n faceTotal(): number {\n return [...this.map.keys()].reduce((sum, key) => sum + key, 0);\n }\n\n normalize(): PMF {\n if (this.normalized) return this;\n const normalizationFactor = this.mass();\n if (normalizationFactor === 0) return this;\n\n // Note: this divides by normalizationFactor rather than multiplying by its\n // reciprocal, to keep results bit-identical to direct division.\n const normalizedMap = new Map<number, Bin>();\n for (const [damageValue, probabilityBin] of this.map) {\n const normalizedCount: OutcomeLabelMap = {};\n for (const labelKey in probabilityBin.count) {\n normalizedCount[labelKey] =\n (probabilityBin.count[labelKey] as number) / normalizationFactor;\n }\n\n let normalizedAttributes: OutcomeLabelMap | undefined;\n if (probabilityBin.attr) {\n normalizedAttributes = {};\n for (const labelKey in probabilityBin.attr) {\n normalizedAttributes[labelKey] =\n (probabilityBin.attr[labelKey] as number) / normalizationFactor;\n }\n }\n\n normalizedMap.set(damageValue, {\n p: probabilityBin.p / normalizationFactor,\n count: normalizedCount,\n attr: normalizedAttributes,\n });\n }\n return new PMF(normalizedMap, this.epsilon, true, this.identifier);\n }\n\n /**\n * Returns a copy with negligible probabilities removed (p < eps).\n * If keepFinalBin is true, the bin with the largest key is always kept,\n * even if its probability is below eps. count/attr submaps are still cleaned.\n */\n compact(eps = this.epsilon, keepFinalBin = false): PMF {\n let maxKey = -Infinity;\n if (keepFinalBin) {\n for (const key of this.map.keys()) {\n if (key > maxKey) maxKey = key;\n }\n }\n\n const compactedMap = new Map<number, Bin>();\n\n for (const [damageValue, probabilityBin] of this.map) {\n const shouldKeep =\n probabilityBin.p >= eps || (keepFinalBin && damageValue === maxKey);\n\n if (!shouldKeep) continue;\n\n // Build a fresh Bin rather than mutating the source. Bins are shared by\n // reference across PMFs (e.g. branch()/addScaled()/scaleMass() fast paths\n // can carry another PMF's bin objects), so deleting sub-eps entries in\n // place would silently corrupt the source PMF's count/attr.\n const cleanedBin = PMF.cloneBin(probabilityBin);\n\n for (const labelKey in cleanedBin.count) {\n if (Math.abs(cleanedBin.count[labelKey] || 0) < eps) {\n delete cleanedBin.count[labelKey];\n }\n }\n\n if (cleanedBin.attr) {\n for (const labelKey in cleanedBin.attr) {\n if (Math.abs(cleanedBin.attr[labelKey] || 0) < eps) {\n delete cleanedBin.attr[labelKey];\n }\n }\n if (Object.keys(cleanedBin.attr).length === 0) {\n cleanedBin.attr = undefined;\n }\n }\n\n compactedMap.set(damageValue, cleanedBin);\n }\n\n return new PMF(compactedMap, eps, this.normalized, this.identifier);\n }\n\n // Note: The \"support\" of a PMF is the set of all non-zero probability outcomes.\n // This returns all damage values with non-zero probability, sorted ascending.\n support(): number[] {\n if (this._support === undefined) {\n this._support = [...this.map.keys()].sort((a, b) => a - b);\n }\n return this._support!;\n }\n\n // Minimum possible damage value.\n min(): number {\n if (this._min === undefined) {\n const support = this.support();\n this._min = support.length > 0 ? support[0] : 0;\n }\n return this._min;\n }\n\n // Maximum possible damage value.\n max(): number {\n if (this._max === undefined) {\n const support = this.support();\n this._max = support.length > 0 ? support[support.length - 1] : 0;\n }\n return this._max;\n }\n\n /**\n * Returns the expected (mean) damage value, Σ v·p. Cached.\n *\n * On a PMF whose mass is not 1 this is the partial expectation (the slice's contribution to\n * the whole distribution's mean), not the conditional mean; `DiceQuery.mean()` divides by the\n * mass instead.\n */\n mean(): number {\n if (this._mean === undefined) {\n let totalSum = 0;\n for (const [damageValue, probabilityBin] of this.map) {\n totalSum += damageValue * probabilityBin.p;\n }\n this._mean = totalSum;\n }\n return this._mean;\n }\n\n /**\n * Returns the variance of the damage distribution. Cached.\n *\n * On a PMF whose mass is not 1 (a slice such as {@link filterOutcome}'s output) this is the\n * variance of the distribution conditioned on the slice, Σ (v − μ)²·p / m with μ = Σ v·p / m\n * and m = {@link mass}, the same quantity `DiceQuery.variance()` reports for that PMF. Note\n * that {@link mean} is not conditioned: it stays the partial expectation Σ v·p, so slices add\n * up. Within 1e-12 of unit mass (or at zero or negative mass) no conditioning is applied.\n */\n variance(): number {\n if (this._variance === undefined) {\n const mass = this.mass();\n const conditional = mass > 0 && Math.abs(mass - 1) > EPS;\n const meanValue = conditional ? this.mean() / mass : this.mean();\n let varianceSum = 0;\n for (const [damageValue, probabilityBin] of this.map) {\n const deviationFromMean = damageValue - meanValue;\n varianceSum += deviationFromMean * deviationFromMean * probabilityBin.p;\n }\n this._variance = conditional ? varianceSum / mass : varianceSum;\n }\n return this._variance;\n }\n\n /**\n * Returns the standard deviation of the damage distribution.\n */\n stdev(): number {\n if (this._stdev === undefined) {\n this._stdev = Math.sqrt(this.variance());\n }\n return this._stdev;\n }\n\n /** Deep-copies a Bin, cloning its count and (optional) attr maps. */\n private static cloneBin(bin: Bin): Bin {\n return {\n p: bin.p,\n count: { ...bin.count },\n attr: bin.attr ? { ...bin.attr } : undefined,\n };\n }\n\n /** Returns a new Bin with p, count, and attr all multiplied by `factor`. */\n private static scaleBin(bin: Bin, factor: number): Bin {\n const count: OutcomeLabelMap = {};\n for (const k in bin.count) {\n count[k] = (bin.count[k] as number) * factor;\n }\n\n let attr: OutcomeLabelMap | undefined;\n if (bin.attr) {\n attr = {};\n for (const k in bin.attr) {\n attr[k] = (bin.attr[k] as number) * factor;\n }\n }\n\n return { p: bin.p * factor, count, attr };\n }\n\n private static mergeInto(\n destinationMap: Map<number, Bin>,\n damageValue: number,\n binToAdd: Bin\n ) {\n const existingBin = destinationMap.get(damageValue);\n if (!existingBin) {\n destinationMap.set(damageValue, PMF.cloneBin(binToAdd));\n return;\n }\n\n existingBin.p += binToAdd.p;\n\n for (const labelKey in binToAdd.count) {\n existingBin.count[labelKey] =\n (existingBin.count[labelKey] || 0) +\n (binToAdd.count[labelKey] as number);\n }\n\n if (binToAdd.attr) {\n if (!existingBin.attr) {\n existingBin.attr = {};\n }\n for (const labelKey in binToAdd.attr) {\n existingBin.attr[labelKey] =\n (existingBin.attr[labelKey] || 0) +\n (binToAdd.attr[labelKey] as number);\n }\n }\n }\n\n // Convenience method\n add(other: PMF): PMF {\n return this.addScaled(other, 1);\n }\n\n /**\n * Returns a new PMF with `branch` added to this one, scaled by `probability` before merging —\n * the primitive for conditional effects. Example: `pmf.addScaled(critBranch, 0.05)` → a PMF\n * including a 5% crit slice.\n */\n addScaled(branch: PMF, probability: number): PMF {\n if (probability === 0) return this;\n\n const resultMap = new Map<number, Bin>();\n for (const [dmg, bin] of this.map) {\n resultMap.set(dmg, PMF.cloneBin(bin));\n }\n\n for (const [damageValue, probabilityBin] of branch.map) {\n PMF.mergeInto(\n resultMap,\n damageValue,\n PMF.scaleBin(probabilityBin, probability)\n );\n }\n\n return new PMF(\n resultMap,\n this.epsilon,\n false,\n `${this.identifier}+scaled(${branch.identifier},${probability})`\n );\n }\n\n /**\n * Bernoulli thinning: the effect this PMF describes happens with probability\n * `frequency` and otherwise deals nothing — a conditional attack, an on-hit\n * rider, or a sub-one AoE target fraction. The result is\n * `frequency · X + (1 − frequency) · δ0`.\n *\n * Every bin (negative damage included) keeps `frequency` of its probability\n * mass, per-label `count` and per-label `attr`; the zero bin keeps its labels\n * at that share too. The freed mass, `(1 − frequency) · mass()`, is added to\n * the damage-0 bin under the canonical `missNone` outcome, so the total mass\n * is unchanged, also for a slice whose mass is not 1.\n *\n * Unlike a bare {@link scaleMass} or {@link mapDamage}, this keeps damage\n * attribution (`attr`) intact, so a frequency-scaled PMF still renders\n * correctly in the damage-attribution charts.\n *\n * `frequency >= 1` (or non-finite) returns this PMF unchanged; `frequency <= 0`\n * leaves only the damage-0 bin, holding all of the mass as `missNone`.\n *\n * @param frequency Probability in [0, 1] that the effect occurs.\n */\n applyHitFrequency(frequency: number): PMF {\n if (!Number.isFinite(frequency) || frequency >= 1) return this;\n const freq = Math.max(0, frequency);\n const freedMass = (1 - freq) * this.mass();\n\n const newMap = new Map<number, Bin>();\n if (freq > 0) {\n for (const [damage, bin] of this.map) {\n newMap.set(damage, PMF.scaleBin(bin, freq));\n }\n }\n if (freedMass > 0) {\n PMF.mergeInto(newMap, 0, {\n p: freedMass,\n count: { [MISS_NONE_OUTCOME]: freedMass },\n attr: {},\n });\n }\n\n return new PMF(\n newMap,\n this.epsilon,\n false,\n `freq(${this.identifier},${freq})`\n );\n }\n\n /**\n * Splits this PMF into two complementary PMFs by an arbitrary per-damage-value factor in\n * `[0, 1]` — bin `d`'s mass, `count`, and `attr` split `factor(d)` / `1 - factor(d)` between the\n * two results (via the same proportional scaling {@link applyHitFrequency} uses, `scaleBin`), so\n * `a.add(b)` recovers this PMF exactly and both halves stay chart-attributable. Unlike\n * {@link applyHitFrequency}, mass is NOT redistributed to a miss bin at 0 — each bin stays at its\n * own damage value in whichever half it lands in. `factor` outside `[0, 1]` is clamped.\n *\n * Built for `dice-match` trigger slicing: splitting a hit/crit sub-PMF into \"matched\" and\n * \"did not match\" halves by the exact per-damage-value match probability.\n */\n splitByFactor(factor: (damage: number) => number): [PMF, PMF] {\n const a = new Map<number, Bin>();\n const b = new Map<number, Bin>();\n for (const [damage, bin] of this.map) {\n const f = Math.min(1, Math.max(0, factor(damage)));\n if (f > 0) a.set(damage, PMF.scaleBin(bin, f));\n if (f < 1) b.set(damage, PMF.scaleBin(bin, 1 - f));\n }\n return [\n new PMF(a, this.epsilon, false, `split+(${this.identifier})`),\n new PMF(b, this.epsilon, false, `split-(${this.identifier})`),\n ];\n }\n\n /**\n * Max of two i.i.d. copies of this PMF's distribution: normalize, square\n * the CDF, then restore the original mass. The engine's damage-reroll\n * substitution (`onFirstHit(keepBestDamage())`) applies this to a landing\n * attack's base payload slice — \"roll it again, keep the better total\".\n *\n * PRESERVES outcome labels and attribution. A max, unlike a sum, is\n * literally one of the two draws: the value that wins was drawn from this\n * same distribution, so its `count`/`attr` composition is unchanged in\n * *proportion* — only that bin's total mass is recomputed (via the\n * squared-CDF step) and every label is rescaled by the same factor. This\n * is why {@link power}'s documented provenance loss does not apply here:\n * for a sum, one output value arises from many `(x1, x2)` pairs with\n * different attribution mixes, so provenance is genuinely ambiguous; for a\n * max, there is exactly one realized draw per bin. A naive rebuild through\n * {@link fromMap} would silently discard both `count` and `attr`.\n *\n * Works on a non-unit-mass slice (e.g. {@link filterOutcome}'s output):\n * the CDF is squared on the NORMALIZED distribution, then the result is\n * rescaled back to this PMF's original total mass, not to 1.\n */\n maxOfTwo(): PMF {\n const totalMass = this.mass();\n if (totalMass <= 0) return this;\n\n const resultMap = new Map<number, Bin>();\n let cdf = 0; // running NORMALIZED cdf through the previous support value\n\n for (const damage of this.support()) {\n const bin = this.map.get(damage)!;\n const normalizedP = bin.p / totalMass;\n if (normalizedP <= 0) continue;\n\n const prevCdf = cdf;\n cdf += normalizedP;\n\n // P(max = damage), normalized: F(damage)² − F(damage⁻)², factored as\n // p·(F(damage) + F(damage⁻)). The difference of squares near 1 would\n // cancel the tail bins away; the factored form keeps full precision.\n // It also is the scale factor from the original bin to the new one:\n // reusing the bin's count/attr via scaleBin (rather than rebuilding from\n // a bare number) is what keeps every label's proportion intact.\n resultMap.set(damage, PMF.scaleBin(bin, cdf + prevCdf));\n }\n\n return new PMF(\n resultMap,\n this.epsilon,\n this.normalized,\n `maxOfTwo(${this.identifier})`\n );\n }\n\n scaleMass(factor: number): PMF {\n if (factor === 1) return this;\n\n const scaledMap = new Map<number, Bin>();\n for (const [damageValue, probabilityBin] of this.map) {\n scaledMap.set(damageValue, PMF.scaleBin(probabilityBin, factor));\n }\n return new PMF(\n scaledMap,\n this.epsilon,\n false,\n `scale(${this.identifier},${factor})`\n );\n }\n\n mapDamage(damageTransformFunction: (damageValue: number) => number): PMF {\n const transformedMap = new Map<number, Bin>();\n for (const [originalDamage, probabilityBin] of this.map) {\n const transformedDamage = damageTransformFunction(originalDamage);\n PMF.mergeInto(\n transformedMap,\n transformedDamage,\n PMF.cloneBin(probabilityBin)\n );\n }\n return new PMF(\n transformedMap,\n this.epsilon,\n this.normalized,\n `map(${this.identifier})`\n );\n }\n\n /**\n * Multiplies every damage value by `factor / denominator` and rounds: `floor`\n * (toward −∞, the default), `ceil` (toward +∞) or `round` (to nearest, halves\n * toward +∞). Values that land on the same result merge, labels included.\n *\n * With an integer `factor` and `denominator` the rounding is exact: `v·factor`\n * is an exact integer, and one division of two integers below 2^53 lands on\n * the correct side of every integer. Pass a ratio that way, e.g.\n * `scaleDamage(9, \"ceil\", 7)`; `scaleDamage(9 / 7, \"ceil\")` rounds the factor\n * to a double first, so 21·(9/7) = 27.000000000000004 would round up to 28.\n */\n scaleDamage(\n factor: number,\n rounding: \"floor\" | \"round\" | \"ceil\" = \"floor\",\n denominator = 1\n ): PMF {\n if (!Number.isFinite(factor)) {\n throw new RangeError(`scaleDamage() factor must be finite, got ${factor}`);\n }\n if (!Number.isFinite(denominator) || denominator === 0) {\n throw new RangeError(`scaleDamage() denominator must be finite and non-zero, got ${denominator}`);\n }\n const exact = Number.isInteger(factor) && Number.isInteger(denominator);\n return this.mapDamage((damageValue) => {\n if (exact && Number.isInteger(damageValue)) {\n const numerator = damageValue * factor;\n if (rounding === \"round\") {\n return Math.floor((2 * numerator + denominator) / (2 * denominator));\n }\n const quotient = numerator / denominator;\n return rounding === \"ceil\" ? Math.ceil(quotient) : Math.floor(quotient);\n }\n const scaled = (damageValue * factor) / denominator;\n return rounding === \"round\"\n ? Math.round(scaled)\n : rounding === \"ceil\"\n ? Math.ceil(scaled)\n : Math.floor(scaled);\n });\n }\n\n private getPMFCombineCacheKey(\n p1: PMF,\n p2: PMF,\n eps: number,\n raw: boolean\n ): string {\n const [id1, id2] = [p1.identifier, p2.identifier].sort();\n\n return `v4:${raw ? \"RAW\" : \"N\"}:${id1}+${id2}@${eps}|${p1.fingerprint()}|${p2.fingerprint()}`;\n }\n\n /**\n * A content fingerprint of every bin (probability, per-label `count`, per-label `attr`) plus\n * the `normalized` flag, so convolution/power cache keys change whenever the underlying\n * numbers do. Mass/bin-count/face-sum alone are not content-unique: `mapDamage` variants can\n * keep the same identifier, support, mass, and face sum while differing in per-bin\n * probabilities or in the `count`/`attr` channels `convolve()`/`power()` actually propagate --\n * that previously let `power()` return one PMF's cached result for a different PMF. Memoized\n * because a PMF is immutable once constructed -- this avoids re-deriving the key on every\n * convolve()/power() call (including cache hits). Bin order is sorted by damage value (and\n * label keys sorted within each bin) so two equal-content PMFs built via different code paths\n * fingerprint identically regardless of Map insertion order. Label keys are JSON-encoded, so a\n * label containing the separators cannot make two different bins read the same.\n */\n fingerprint(): string {\n if (this._fingerprint === undefined) {\n const labels = (m: OutcomeLabelMap | undefined): string =>\n m === undefined\n ? \"\"\n : Object.keys(m)\n .sort()\n .map((k) => `${JSON.stringify(k)}:${m[k]}`)\n .join(\",\");\n const bins = [...this.map.entries()].sort((a, b) => a[0] - b[0]);\n const parts: string[] = [];\n for (const [damageValue, bin] of bins) {\n parts.push(`${damageValue}:${bin.p}[${labels(bin.count)}]{${labels(bin.attr)}}`);\n }\n this._fingerprint = `${this.normalized ? 1 : 0}|${parts.join(\";\")}`;\n }\n return this._fingerprint;\n }\n\n convolve(other: PMF, eps?: number, raw = false): PMF {\n const epsilon = eps ?? this.epsilon;\n\n // Normalize-by-value on non-raw path\n const norm = (x: PMF) =>\n raw ? x : Math.abs(x.mass() - 1) <= epsilon ? x : x.normalize();\n const A0 = norm(this);\n const B0 = norm(other);\n\n const [A, B] = A0.identifier <= B0.identifier ? [A0, B0] : [B0, A0];\n const cacheKey = this.getPMFCombineCacheKey(A, B, epsilon, raw);\n const cached = pmfCache.get(cacheKey);\n if (cached) return cached;\n\n // Accumulate directly into each destination bin instead of building a\n // temporary Bin per (a,b) pair and merging it. The probability channel\n // (`dest.p += ap*bp`) accumulates in the same order as before, so it is\n // bit-identical; only the per-label `count`/`attr` sums re-associate, which\n // shifts them by at most a few ULP (far below the eps pruning threshold).\n // Label entries are listed once per bin, outside the pair loop: enumerating\n // the keys of a (frozen, cached) bin per pair costs more than the arithmetic.\n const labelEntries = (m: OutcomeLabelMap | undefined): [string, number][] | undefined =>\n m === undefined ? undefined : (Object.entries(m) as [string, number][]);\n const bEntries = [...B.map].map(([bVal, bBin]) => ({\n bVal,\n bp: bBin.p,\n count: labelEntries(bBin.count) as [string, number][],\n attr: labelEntries(bBin.attr),\n }));\n const combinedMap = new Map<number, Bin>();\n for (const [aVal, aBin] of A.map) {\n const ap = aBin.p;\n const aCount = labelEntries(aBin.count) as [string, number][];\n const aAttr = labelEntries(aBin.attr);\n for (const { bVal, bp, count: bCount, attr: bAttr } of bEntries) {\n const dmg = aVal + bVal;\n\n let dest = combinedMap.get(dmg);\n if (dest === undefined) {\n dest = { p: 0, count: {} };\n combinedMap.set(dmg, dest);\n }\n\n dest.p += ap * bp;\n\n const dc = dest.count;\n for (const [k, v] of aCount) dc[k] = (dc[k] || 0) + v * bp;\n for (const [k, v] of bCount) dc[k] = (dc[k] || 0) + v * ap;\n\n if (aAttr || bAttr) {\n let da = dest.attr;\n if (da === undefined) {\n da = {};\n dest.attr = da;\n }\n if (aAttr) for (const [k, v] of aAttr) da[k] = (da[k] || 0) + v * bp;\n if (bAttr) for (const [k, v] of bAttr) da[k] = (da[k] || 0) + v * ap;\n }\n }\n }\n\n let result = new PMF(\n combinedMap,\n epsilon,\n !raw,\n `${A.identifier}${raw ? \"*\" : \"+\"}${B.identifier}`\n );\n\n // Enforce mass invariant: mass(out) = (raw? A.mass():1) * (raw? B.mass():1)\n const mExp = (raw ? A.mass() : 1) * (raw ? B.mass() : 1);\n const mGot = result.mass();\n // Guard mGot !== 0: a zero-mass operand convolves to the zero measure\n // (mass 0). Without this guard the non-raw path would scaleMass(mExp/0) =\n // scaleMass(Infinity), poisoning every bin to 0*Infinity = NaN.\n if (mExp !== 0 && mGot !== 0 && Math.abs(mGot - mExp) > epsilon) {\n result = result.scaleMass(mExp / mGot);\n }\n if (!raw && mGot !== 0 && Math.abs(result.mass() - 1) > epsilon)\n result = result.normalize();\n\n pmfCache.set(cacheKey, result);\n return result;\n }\n\n // Convolve without renormalizing (raw = true), for callers that combine raw counts.\n combineRaw(other: PMF, eps?: number): PMF {\n return this.convolve(other, eps, true);\n }\n\n // Reduce a list of PMFs by left-folding convolve() with the given eps\n private static reduceConvolveLeft(pmfList: PMF[], eps: number): PMF {\n let result = pmfList[0];\n for (let i = 1; i < pmfList.length; i++) {\n result = result.convolve(pmfList[i], eps);\n }\n return result;\n }\n\n /**\n * Convolves multiple PMFs using linear convolution with automatic caching.\n * Uses a left-to-right accumulation approach for maximum cache reuse.\n * Each convolve() call automatically uses the convolution cache for performance.\n *\n * This linear approach provides better cache hits than pairwise because:\n * - Intermediate results are more predictable and stable\n * - Similar PMF lists share common prefixes (A+B, (A+B)+C, etc.)\n * - Order-independent cache keys work better with consistent build patterns\n */\n static convolveMany(pmfList: PMF[], eps = EPS): PMF {\n if (pmfList.length === 0) return PMF.empty(eps);\n if (pmfList.length === 1) return pmfList[0];\n\n // Linear combination with automatic intermediate caching: each prefix\n // (A+B, (A+B)+C, ...) is a stable cache key, maximizing reuse.\n return PMF.reduceConvolveLeft(pmfList, eps);\n }\n\n /**\n * Returns a plain, JSON-serializable representation of this PMF.\n *\n * Follows the standard `toJSON` contract, so `JSON.stringify(pmf)` produces\n * the expected output (no double-encoding). Use {@link PMF.fromJSON} to\n * reconstruct, or {@link PMF.toJSONString} if you need the string directly.\n */\n toJSON(): {\n bins: Array<[number, Bin]>;\n normalized: boolean;\n identifier: string;\n } {\n return {\n bins: [...this.map.entries()],\n normalized: this.normalized,\n identifier: this.identifier,\n };\n }\n\n /** Serializes this PMF to a JSON string (equivalent to `JSON.stringify(pmf)`). */\n toJSONString(): string {\n return JSON.stringify(this);\n }\n\n static fromJSON(jsonData: {\n bins: Array<[number, Bin]>;\n normalized?: boolean;\n identifier?: string;\n }) {\n return new PMF(\n new Map(jsonData.bins),\n EPS,\n !!jsonData.normalized,\n jsonData.identifier || \"fromJSON\"\n );\n }\n\n /**\n * Relative pruning with optional top-K floor.\n * Keeps bins with p >= epsRel * peak, always keeps min and max damage,\n * optionally guarantees at least `minBins` survivors by adding top-K.\n * Returns a new, non-normalized PMF.\n */\n prune(epsRel: number, minBins = 0): PMF {\n const size = this.map.size;\n if (size === 0) return this;\n\n // One pass: peak, min, max\n let peak = 0;\n let minDamage = Number.POSITIVE_INFINITY;\n let maxDamage = Number.NEGATIVE_INFINITY;\n for (const [dmg, bin] of this.map) {\n if (bin.p > peak) peak = bin.p;\n if (dmg < minDamage) minDamage = dmg;\n if (dmg > maxDamage) maxDamage = dmg;\n }\n if (peak === 0)\n return new PMF(new Map(this.map), epsRel, false, this.identifier);\n\n const thresh = epsRel * peak;\n const entries = [...this.map.entries()];\n\n // Protect endpoints\n const survivorsByDmg = new Map<number, Bin>();\n const protect = (d: number) => {\n const b = this.map.get(d);\n if (b) survivorsByDmg.set(d, b);\n };\n protect(minDamage);\n if (maxDamage !== minDamage) protect(maxDamage);\n\n // Relative survivors\n for (const [dmg, bin] of entries) {\n if (bin.p >= thresh) survivorsByDmg.set(dmg, bin);\n }\n\n // Enforce minBins via top-K if requested\n if (minBins > 0 && survivorsByDmg.size < minBins) {\n // Sort all entries by probability desc (or replace with Quickselect for O(n))\n entries.sort((a, b) => b[1].p - a[1].p);\n for (const [dmg, bin] of entries) {\n if (!survivorsByDmg.has(dmg)) {\n survivorsByDmg.set(dmg, bin);\n if (survivorsByDmg.size >= minBins) break;\n }\n }\n }\n\n // Rebuild map, pruning tiny count/attr entries with the same threshold\n const prunedMap = new Map<number, Bin>();\n for (const [dmg, bin] of survivorsByDmg) {\n const newCount: OutcomeLabelMap = {};\n for (const k in bin.count) {\n const v = bin.count[k] as number;\n if (Math.abs(v) >= thresh) newCount[k] = v;\n }\n let newAttr: OutcomeLabelMap | undefined;\n if (bin.attr) {\n for (const k in bin.attr) {\n const v = bin.attr[k] as number;\n if (Math.abs(v) >= thresh) {\n if (!newAttr) newAttr = {};\n newAttr[k] = v;\n }\n }\n }\n prunedMap.set(dmg, { p: bin.p, count: newCount, attr: newAttr });\n }\n\n // Return non-normalized PMF\n return new PMF(prunedMap, epsRel, false, `prune(${this.identifier})`);\n }\n\n /** Probability mass at exactly x. */\n pAt(x: number): number {\n return this.map.get(x)?.p ?? 0;\n }\n\n /**\n * P(any damage) — the mass on all non-zero outcomes, i.e. `1 - P(0)`.\n * Assumes a miss is encoded as the damage-0 bin (the convention used across\n * attack/save PMFs). The dual of {@link missProbability}.\n */\n hitProbability(): number {\n return 1 - this.pAt(0);\n }\n\n /** P(no damage) — the mass at damage 0. The dual of {@link hitProbability}. */\n missProbability(): number {\n return this.pAt(0);\n }\n\n /**\n * Coarsen the distribution into at most `maxBuckets` contiguous, equal-width\n * damage buckets, aggregating probability mass (and `count`/`attr`\n * provenance) into each bucket's start value. Returns this PMF unchanged when\n * its integer support already fits within `maxBuckets`.\n *\n * This is a lossy display/downsampling transform (bucket start replaces the\n * exact damage value) — use it for charting wide distributions, not for DPR\n * math.\n */\n rebin(maxBuckets: number): PMF {\n if (!(maxBuckets > 0)) return this;\n const support = this.support();\n if (support.length === 0) return this;\n const min = support[0];\n const max = support[support.length - 1];\n const range = max - min;\n if (range + 1 <= maxBuckets) return this;\n const binSize = Math.ceil((range + 1) / maxBuckets);\n return this.mapDamage((d) => min + Math.floor((d - min) / binSize) * binSize);\n }\n\n /** Dense integer support from min..max (inclusive).\n * Useful for showing empty bars in charts.\n */\n denseSupport(): number[] {\n const s = this.support();\n if (s.length === 0) return [];\n const lo = Math.min(...s),\n hi = Math.max(...s);\n return Array.from({ length: hi - lo + 1 }, (_, i) => lo + i).sort(\n (a, b) => a - b\n );\n }\n\n /** CDF at x: P(X ≤ x). */\n cdfAt(x: number): number {\n let acc = 0;\n for (const [val, bin] of this.map) if (val <= x) acc += bin.p;\n return acc;\n }\n\n /**\n * Quantile / inverse CDF: the smallest support value x with P(X ≤ x) ≥ p·mass().\n * `p <= 0` gives the smallest support value; `p >= 1` or NaN gives the largest.\n *\n * A float running sum can land an ulp short of a CDF that is exactly p (a d20's CDF(10) sums\n * to 0.49999999999999994), so the comparison allows a relative slack of a few ulps per bin.\n * Below the median it compares the CDF summed from the low end; above it, the mass strictly\n * above x summed from the high end. A sum of non-negative terms is accurate relative to its\n * own size, so the tail that decides the answer is never swamped by the rest of the mass.\n */\n quantile(p: number): number {\n const { values, below, above } = this.cumulative();\n const n = values.length;\n if (n === 0) return 0;\n const total = below[n - 1];\n if (!(total > 0)) return 0;\n if (p <= 0) return values[0];\n if (p >= 1) return values[n - 1];\n\n const slack = Math.max(QUANTILE_RELATIVE_SLACK, 4 * n * Number.EPSILON);\n const lowTarget = p * total * (1 - slack);\n const highTarget = (1 - p) * total * (1 + slack);\n const lowSide = p <= 0.5;\n\n // Smallest index whose CDF reaches p; the test is monotone in the index.\n let lo = 0;\n let hi = n;\n while (lo < hi) {\n const mid = (lo + hi) >>> 1;\n const reached = lowSide ? below[mid] >= lowTarget : above[mid] <= highTarget;\n if (reached) hi = mid;\n else lo = mid + 1;\n }\n return values[Math.min(lo, n - 1)];\n }\n\n /**\n * Sorted support with `below[i]` = Σ p over values ≤ values[i], summed from the low end,\n * and `above[i]` = Σ p over values > values[i], summed from the high end. Cached.\n */\n private cumulative(): { values: number[]; below: number[]; above: number[] } {\n if (this._cumulative === undefined) {\n const values = this.support();\n const n = values.length;\n const below = new Array<number>(n);\n const above = new Array<number>(n);\n let sum = 0;\n for (let i = 0; i < n; i++) {\n sum += (this.map.get(values[i]) as Bin).p;\n below[i] = sum;\n }\n sum = 0;\n for (let i = n - 1; i >= 0; i--) {\n above[i] = sum;\n sum += (this.map.get(values[i]) as Bin).p;\n }\n this._cumulative = { values, below, above };\n }\n return this._cumulative;\n }\n\n /** Get outcome probability at specific damage value. */\n outcomeAt(damage: number, outcome: string): number {\n return (this.map.get(damage)?.count[outcome] as number) ?? 0;\n }\n\n /** Get all outcome types present in this PMF. */\n outcomes(): string[] {\n const outcomeSet = new Set<string>();\n for (const [, bin] of this.map) {\n for (const outcome in bin.count) {\n if ((bin.count[outcome] as number) > 0) {\n outcomeSet.add(outcome);\n }\n }\n }\n return Array.from(outcomeSet).sort();\n }\n\n /** Get total probability of an outcome across all damage values. */\n outcomeProbability(outcome: string): number {\n let total = 0;\n for (const [, bin] of this.map) {\n total += (bin.count[outcome] as number) ?? 0;\n }\n return total;\n }\n\n /** Get damage attribution for an outcome at specific damage value. */\n outcomeAttributionAt(damage: number, outcome: string): number {\n return (this.map.get(damage)?.attr?.[outcome] as number) ?? 0;\n }\n\n /** Get all outcome data at specific damage value. */\n binAt(damage: number): {\n p: number;\n count: Record<string, number>;\n attr?: Record<string, number>;\n } | null {\n const bin = this.map.get(damage);\n if (!bin) return null;\n\n return {\n p: bin.p,\n count: { ...bin.count } as Record<string, number>,\n attr: bin.attr ? ({ ...bin.attr } as Record<string, number>) : undefined,\n };\n }\n\n /** Check if outcome exists in this PMF. */\n hasOutcome(outcome: string): boolean {\n for (const [, bin] of this.map) {\n if (((bin.count[outcome] as number) ?? 0) > 0) {\n return true;\n }\n }\n return false;\n }\n\n /**\n * Split each damage value's probability mass across outcome labels, returning\n * per-label maps of `damage value → probability mass attributable to that\n * label`. Summing over labels at a given value recovers that value's `p`.\n *\n * Damage-bearing bins are split by `attr` weight (the share of damage each\n * outcome contributed); the clean-miss bin at 0 is split by `count` weight\n * (there is no damage to attribute). Attribution is computed on demand via\n * {@link withAttribution} when absent, so builder-generated PMFs work too.\n *\n * This is the provenance core of the stacked damage-attribution chart — the\n * caller only maps these series into its rendering format (colors, binning,\n * axis labels).\n */\n attributionByValue(): Map<string, Map<number, number>> {\n const src = this.hasAttribution() ? this : this.withAttribution();\n const result = new Map<string, Map<number, number>>();\n\n const add = (label: string, damage: number, mass: number): void => {\n if (!(mass > 0)) return;\n let series = result.get(label);\n if (!series) {\n series = new Map<number, number>();\n result.set(label, series);\n }\n series.set(damage, (series.get(damage) ?? 0) + mass);\n };\n\n for (const [damage, bin] of src.map) {\n const p = bin.p || 0;\n if (p <= 0) continue;\n const isMissBin = damage === 0;\n\n // Damage-0 (clean miss): split by count, crediting the missNone label.\n if (isMissBin) {\n let totalCount = 0;\n for (const k in bin.count) totalCount += (bin.count[k] as number) || 0;\n if (totalCount > 0) {\n const c = (bin.count[MISS_NONE_OUTCOME] as number) || 0;\n add(MISS_NONE_OUTCOME, damage, (c / totalCount) * p);\n }\n continue;\n }\n\n // Damage-bearing bin: split by attribution weight.\n let totalAttr = 0;\n if (bin.attr) for (const k in bin.attr) totalAttr += (bin.attr[k] as number) || 0;\n if (bin.attr && totalAttr > 0) {\n for (const k in bin.attr) {\n if (k === MISS_NONE_OUTCOME) continue;\n add(k, damage, (((bin.attr[k] as number) || 0) / totalAttr) * p);\n }\n }\n }\n\n return result;\n }\n\n /**\n * Reversed-convention CCDF percentile markers used by the attribution chart:\n * for each target probability t, the largest damage x still reached with\n * P(X ≥ x) > t%, falling back to the smallest/largest support value at the\n * edges. Ported verbatim from the app so `p80/p50/p20` keep their intentional\n * reversed meaning (p80 is the low-damage end). Computed on the full, un-binned\n * support. Assumes a non-empty map.\n */\n private attributionPercentiles(): { p80: number; p50: number; p20: number } {\n const sortedKeys = [...this.map.keys()].sort((a, b) => a - b);\n const sparseCCDF: { x: number; y: number }[] = [];\n let cumulativeP = 0;\n for (let i = sortedKeys.length - 1; i >= 0; i--) {\n const key = sortedKeys[i];\n const bin = this.map.get(key);\n if (!bin) continue;\n cumulativeP += bin.p;\n sparseCCDF.unshift({ x: key, y: cumulativeP * 100 });\n }\n const findDamageAtProbability = (targetProb: number): number => {\n for (let i = 0; i < sparseCCDF.length; i++) {\n if (sparseCCDF[i].y <= targetProb) {\n return i > 0 ? sparseCCDF[i - 1].x : sparseCCDF[i].x;\n }\n }\n return sparseCCDF[sparseCCDF.length - 1].x;\n };\n return {\n p80: findDamageAtProbability(80),\n p50: findDamageAtProbability(50),\n p20: findDamageAtProbability(20),\n };\n }\n\n /**\n * Full numeric model for the stacked damage-attribution chart — bar-height\n * masses, tooltip shares, bucket labels/ranges, percentile markers, and the\n * mean. The caller only maps these into a rendering format (colors, labels,\n * axis units); all of the dice-and-probability logic lives here.\n *\n * Built split-first-then-bin: the attribution split ({@link attributionByValue})\n * runs on the un-binned distribution, then the resulting series are coarsened.\n * {@link rebin} is deliberately *not* used — rebinning first would fold any\n * sub-`binSize` damage into the damage-0 bucket, which the split then mistakes\n * for a clean miss and drops.\n *\n * @param options.maxBuckets Coarsen to at most this many equal-width buckets\n * when the integer support is wider (`range > maxBuckets`); omit for a dense,\n * per-integer model.\n * @param options.stackOrder Preferred outcome order (defaults to\n * {@link ALL_OUTCOME_TYPES}); labels outside it sort alphabetically after.\n * @param options.epsilon Bucket-total floor below which a `shares` entry is 0\n * (divide-by-~0 guard). Defaults to 1e-9.\n */\n damageAttributionChartModel(\n options: {\n maxBuckets?: number;\n stackOrder?: readonly string[];\n epsilon?: number;\n } = {}\n ): DamageAttributionChartModel {\n const { maxBuckets, stackOrder = ALL_OUTCOME_TYPES, epsilon = 1e-9 } = options;\n\n const empty: DamageAttributionChartModel = {\n labels: [],\n outcomes: [],\n series: new Map(),\n shares: new Map(),\n totals: [],\n percentiles: { p80: 0, p50: 0, p20: 0 },\n mean: 0,\n };\n if (this.map.size === 0) return empty;\n\n // Split on the un-binned distribution: outcome → (damage → probability mass).\n const split = this.attributionByValue();\n\n // Discover outcomes across BOTH count and attr keys so any all-zero legend\n // entries survive (matches the app's discovery), then order for stacking.\n const discovered = new Set<string>();\n for (const [, bin] of this.map) {\n for (const k in bin.count) discovered.add(k);\n if (bin.attr) for (const k in bin.attr) discovered.add(k);\n }\n const outcomes = sortOutcomes([...discovered], stackOrder);\n const hasAttribution = outcomes.length > 0;\n\n // Support window over values carrying positive mass (the app's allDamageValues):\n // from the split for attributed PMFs, from positive-p bins for pure ones.\n let min = Infinity;\n let max = -Infinity;\n const widen = (d: number): void => {\n if (d < min) min = d;\n if (d > max) max = d;\n };\n if (hasAttribution) {\n for (const s of split.values())\n for (const [d, m] of s) if (m > 0) widen(d);\n } else {\n for (const [d, bin] of this.map) if ((bin.p || 0) > 0) widen(d);\n }\n if (max < min) return empty; // nothing carried positive mass\n const range = max - min;\n\n // Binning geometry — dense (per-integer) unless range > maxBuckets.\n const binned =\n maxBuckets !== undefined && maxBuckets > 0 && range > maxBuckets;\n const binSize = binned ? Math.ceil((range + 1) / maxBuckets!) : 1;\n const numBins = binned ? Math.ceil((range + 1) / binSize) : range + 1;\n const bucketOf = (d: number): number => Math.floor((d - min) / binSize);\n\n const labels: number[] = [];\n const binRanges: { start: number; end: number }[] | undefined = binned\n ? []\n : undefined;\n for (let i = 0; i < numBins; i++) {\n const start = min + i * binSize;\n labels.push(start);\n if (binRanges)\n binRanges.push({ start, end: Math.min(start + binSize - 1, max) });\n }\n\n // Aggregate per-outcome masses into buckets.\n const series = new Map<string, number[]>();\n for (const outcome of outcomes) {\n const arr = new Array<number>(numBins).fill(0);\n const s = split.get(outcome);\n if (s) {\n for (const [d, m] of s) {\n const b = bucketOf(d);\n if (b >= 0 && b < numBins) arr[b] += m;\n }\n }\n series.set(outcome, arr);\n }\n\n // Per-bucket totals: sum of the attributed series, or (pure) of raw p.\n const totals = new Array<number>(numBins).fill(0);\n if (hasAttribution) {\n for (const arr of series.values())\n for (let i = 0; i < numBins; i++) totals[i] += arr[i];\n } else {\n for (const [d, bin] of this.map) {\n const p = bin.p || 0;\n if (p <= 0) continue;\n const b = bucketOf(d);\n if (b >= 0 && b < numBins) totals[b] += p;\n }\n }\n\n // Conditional shares for tooltips (guarded against a ~zero bucket total).\n const shares = new Map<string, number[]>();\n for (const outcome of outcomes) {\n const arr = series.get(outcome)!;\n const sh = new Array<number>(numBins).fill(0);\n for (let i = 0; i < numBins; i++) {\n sh[i] = totals[i] > epsilon ? arr[i] / totals[i] : 0;\n }\n shares.set(outcome, sh);\n }\n\n return {\n labels,\n binRanges,\n outcomes,\n series,\n shares,\n totals,\n percentiles: this.attributionPercentiles(),\n mean: this.mean(),\n };\n }\n\n tailProbGE(t: number): number {\n let s = 0;\n for (const [x, bin] of this) {\n if (bin.p > 0 && x >= t) s += bin.p;\n }\n return s;\n }\n\n tailProbGT(t: number): number {\n let s = 0;\n for (const [x, rec] of this) {\n if (x > t) s += rec.p;\n }\n return s;\n }\n\n /**\n * Returns a new PMF containing only bins where the specified outcome has non-zero probability.\n * This creates a marginal distribution for the given outcome type, with probabilities\n * scaled to represent the unconditional mass attributable to that outcome.\n */\n filterOutcome(outcome: string): PMF {\n const filteredMap = new Map<number, Bin>();\n\n for (const [damageValue, bin] of this.map) {\n const outcomeCount = (bin.count[outcome] as number) ?? 0;\n\n // total paths that reached this bin (sum across labels)\n const totalCount = Object.values(bin.count ?? {}).reduce(\n (a, b) => (a ?? 0) + ((b as number) ?? 0),\n 0\n );\n\n if (outcomeCount > 0 && totalCount !== undefined && totalCount > 0) {\n // proportion of this bin's mass attributable to the outcome\n const proportion = outcomeCount / totalCount;\n\n // downweight p to the unconditional mass from the outcome only\n const newP = bin.p * proportion;\n\n const newCount: OutcomeLabelMap = { [outcome]: outcomeCount };\n\n let newAttr: OutcomeLabelMap | undefined;\n if (bin.attr && bin.attr[outcome] !== undefined) {\n // A count-like attr accumulator is scaled by the same proportion; a per-outcome-only\n // attr carries over as-is.\n newAttr = { [outcome]: (bin.attr[outcome] as number) * proportion };\n }\n\n filteredMap.set(damageValue, {\n p: newP,\n count: newCount,\n attr: newAttr,\n });\n }\n }\n\n return new PMF(\n filteredMap,\n this.epsilon,\n false, // don't normalize by default\n `filter(${this.identifier},${outcome})`\n );\n }\n /**\n * Calculates probabilities for first-success outcomes across n independent attempts.\n *\n * @param pSuccess - Total probability of any success on a single attempt.\n * @param pSpecial - Probability of a specific subset of successes (e.g., critical success).\n * @param n - Number of independent attempts.\n *\n * Returns:\n * - pSpecificSuccess: Probability that the first success was of the \"special\" type\n * - pGeneralSuccess: Probability that the first success was of the non-special type\n * - pNone: Probability that no successes occurred\n * - pAny: Probability that at least one success occurred\n */\n public static firstSuccessWeights(\n pSuccess: number,\n pSpecial: number,\n n: number\n ) {\n // Preconditions: the \"special\" successes are a subset of all successes, so\n // 0 <= pSpecial <= pSuccess <= 1. Without this guard, violating inputs\n // silently produce probabilities outside [0,1].\n if (\n !Number.isFinite(pSuccess) ||\n !Number.isFinite(pSpecial) ||\n pSuccess < 0 ||\n pSuccess > 1 ||\n pSpecial < 0 ||\n pSpecial - pSuccess > EPS\n ) {\n throw new Error(\n `firstSuccessWeights: require 0 <= pSpecial <= pSuccess <= 1 (got pSuccess=${pSuccess}, pSpecial=${pSpecial})`\n );\n }\n\n const pFail = 1 - pSuccess;\n const pFailAll = Math.pow(pFail, n);\n\n // Probability of at least one success\n const pAny = 1 - pFailAll;\n\n // Avoid divide-by-zero if pSuccess is 0\n const denom = pSuccess === 0 ? 1 : pSuccess;\n\n // Breakdown of first success type\n const pSpecificSuccess = (pSpecial * pAny) / denom;\n const pGeneralSuccess = ((pSuccess - pSpecial) * pAny) / denom;\n\n const pNone = 1 - pSpecificSuccess - pGeneralSuccess; // Should equal pFailAll\n\n return { pSpecificSuccess, pGeneralSuccess, pNone, pAny };\n }\n\n /**\n * Maps every damage value through `f`, then optionally rounds it (`rounding`, default\n * `\"none\"`). Values that land on the same result merge their probability and, unless\n * `preserveCounts` is false, their per-label `count`. Damage attribution (`attr`) is dropped,\n * because it is tied to the old values. Nothing is pruned and the mass is unchanged.\n *\n * @param eps Epsilon carried by the result.\n * @throws Error when a mapped value is not a finite integer.\n */\n mapValues(\n f: (v: number) => number,\n eps: number = EPS,\n opts?: { rounding?: Rounding; preserveCounts?: boolean }\n ): PMF {\n const rounding = opts?.rounding ?? \"none\";\n const preserveCounts = opts?.preserveCounts ?? true;\n\n const round = (x: number) =>\n rounding === \"floor\"\n ? Math.floor(x)\n : rounding === \"ceil\"\n ? Math.ceil(x)\n : rounding === \"round\"\n ? Math.round(x)\n : x;\n\n const merged = new Map<number, Bin>();\n for (const [v, bin] of this) {\n if (bin.p === 0) continue;\n const u = round(f(v));\n if (!Number.isInteger(u)) {\n throw new Error(`mapValues: ${v} maps to ${u}, not a finite integer`);\n }\n PMF.mergeInto(merged, u, {\n p: bin.p,\n count: preserveCounts ? bin.count : {},\n });\n }\n\n const sorted = new Map([...merged.entries()].sort((a, b) => a[0] - b[0]));\n return new PMF(sorted, eps, this.normalized, `mapValues(${this.identifier})`);\n }\n\n static fromMap(\n m: Map<number, number>,\n eps: number = EPS,\n { requireIntegerValues = true }: { requireIntegerValues?: boolean } = {}\n ): PMF {\n const filtered: Array<[number, number]> = [];\n for (const [v, p] of m) {\n if (!Number.isFinite(v) || !Number.isFinite(p)) continue;\n if (p <= 0 || Math.abs(p) < eps) continue;\n if (requireIntegerValues && !Number.isInteger(v)) {\n throw new Error(`fromMap: non-integer outcome ${v}`);\n }\n filtered.push([v, p]);\n }\n\n if (filtered.length === 0) {\n throw new Error(\"fromMap: empty or invalid input map\");\n }\n\n // Kahan sum for stability\n let sum = 0;\n let c = 0;\n for (const [, p] of filtered) {\n const y = p - c;\n const t = sum + y;\n c = t - sum - y;\n sum = t;\n }\n if (sum <= 0) throw new Error(\"pmfFromMap: probabilities sum to 0\");\n\n filtered.sort((a, b) => a[0] - b[0]);\n\n const internal = new Map<number, Bin>();\n for (const [v, p] of filtered) {\n internal.set(v, { p: p / sum, count: {} }); // keep count object present for consistency\n }\n return new PMF(internal, eps);\n }\n\n query(): DiceQuery {\n return new DiceQuery(this);\n }\n}\n","// dice.ts (internal)\n\nimport { DiceParseError } from \"../common/errors\";\nimport type {\n Bin,\n DamageDistribution,\n OutcomeLabelMap,\n OutcomeType,\n} from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\n\n/**\n * Work budget for a single dice×dice operation. binaryOp is O(faces₁ × faces₂),\n * so two individually-legal large dice (e.g. `d100000 + d100000`) would otherwise\n * enumerate ~10^10 face pairs and hang. The parser's per-die / per-count caps\n * bound each operand but not their product, so this bounds the operation itself.\n * Generous enough for any realistic expression; only pathological blow-ups trip\n * it. (Chosen so expressions well beyond normal use still parse; tune if needed.)\n */\nconst MAX_BINARY_OUTCOMES = 100_000_000;\n\n/** Internal bookkeeping attached to a {@link Dice} during parsing. */\nexport interface DicePrivateData {\n /** Marks a DC (saving-throw) check so outcomes are attributed correctly. */\n isDCCheck?: boolean;\n /** The \"other\" distribution recorded by {@link Dice.combine}. */\n except?: Dice | Record<string, never>;\n /** Set by a keep (`4kh3`, `2kl1`) on the dice it keeps from: how many of the repeated copies are\n * kept, and whether the lowest or the highest. A keep of one (`2kh1d20`) keeps a single natural roll. */\n keep?: { kept: number; lowest: boolean };\n /** The natural roll of an attack check, followed through every op applied to it, so a crit is the\n * natural-max event (or an `xcrit` range of natural faces) at any bonus roll. It is the check's one\n * d20 wherever it sits in the sum, or with no d20 its largest die; other dice are bonus dice. Read\n * and written by {@link parseExpression} in parser.ts; set on every freshly parsed `dN`/`hdN` atom. */\n critTrack?: CritTrack;\n /** Set instead of {@link critTrack} on a value whose natural die has no single natural roll to\n * follow (`2d20`, `d20 + d20`, `(d20 + 1d4)!`, a bonus pool like `2d4`): that die's size, so a\n * die it outranks never passes for the natural roll. Read and written by parser.ts. */\n untrackedSides?: number;\n /** Set on a value built from numbers alone, with no die anywhere in it but an AC or DC target. As an\n * attack check it has no natural roll, so its crit mass is exactly 0. Read and written by parser.ts. */\n noDie?: true;\n /** The operands of an `&` mix, each carried through every op since with its own natural roll, so the\n * mix crits where a branch does, at that branch's share. Read and written by parser.ts. */\n branches?: readonly Dice[];\n /** Set on the result of an `AC` gate: a following `*` is an attack's hit payload, which crits\n * even with no crit clause. Read by {@link parseExpression} in parser.ts. */\n isACCheck?: boolean;\n /** Set on an attack whose crit is its hit payload doubled (no crit clause): the payload's\n * text, so a trailing hit-only term joins the payload and doubles with it. See parser.ts. */\n implicitCrit?: { payload: string };\n /** Set on an attack's payload: the result of an AC check's `*`, and of each hit-only term after it.\n * A landed hit that deals 0 there is recorded under `hit` at 0, where the misses also sit, as an AC\n * check's landed total of exactly 0 is (see {@link Dice.ac}). A later hit-only term treats it as\n * the hit it is (see {@link Dice.calculateHitDistribution}). Read and written by parser.ts. */\n attackPayload?: true;\n}\n\n/**\n * An attack check's natural roll. `slice(f)` is the check's share where the kept natural roll is f,\n * in the check's own counts: every op after the natural die acts face by face, so replaying the\n * ops on face f's weight gives exactly that share, and a mix of checks adds its branches' shares.\n */\nexport interface CritTrack {\n /** The natural die's size. */\n readonly sides: number;\n /** The check is its natural roll itself, with no op since (`d20`, `2kh1d20`, `d20 > d20`, `d20 & d20`). */\n readonly bare: boolean;\n readonly slice: (face: number) => Dice;\n}\n\n/**\n * @internal\n */\nexport class Dice {\n private readonly faces: DamageDistribution = {};\n public privateData: DicePrivateData = {};\n // Partial: the object starts empty and gains keys as outcomes are recorded,\n // so the type must not claim every OutcomeType is present. (Previously typed\n // as a full Record via an `as` cast, which lied about missing keys.)\n private outcomeData: Partial<Record<OutcomeType, DamageDistribution>> = {};\n private hasHitDistributionCalculated = false;\n public identifier?: string;\n\n constructor(x: number = 0) {\n if (x <= 0) return;\n for (let i = 1; i <= x; i++) {\n this.faces[i] = 1;\n }\n }\n\n getOutcomeDistribution(key: OutcomeType): DamageDistribution | undefined {\n if (key === \"hit\") {\n this.ensureHitDistribution();\n }\n\n const distribution = this.outcomeData[key];\n if (distribution === undefined) return undefined;\n\n return { ...distribution };\n }\n\n getFullOutcomeDistribution(): Partial<\n Record<OutcomeType, DamageDistribution>\n > {\n return { ...this.outcomeData };\n }\n\n setOutcomeDistribution(\n key: OutcomeType,\n data: DamageDistribution | undefined\n ): void {\n if (data) {\n this.outcomeData[key] = data;\n } else {\n delete this.outcomeData[key];\n }\n }\n\n hasOutcomeData(key: OutcomeType): boolean {\n if (key === \"hit\") {\n this.ensureHitDistribution();\n }\n const data = this.outcomeData[key];\n return data !== undefined && Object.keys(data).length > 0;\n }\n\n getOutcomeCount(key: OutcomeType, face: number): number {\n return this.outcomeData[key]?.[face] ?? 0;\n }\n\n getAverage(key: OutcomeType): number {\n const distribution = this.getOutcomeDistribution(key);\n if (!distribution) return 0;\n\n const totalCount = Object.values(distribution).reduce(\n (sum, count) => sum + count,\n 0\n );\n const expectedDamage = Object.entries(distribution).reduce(\n (sum, [damage, count]) => sum + Number(damage) * count,\n 0\n );\n if (totalCount === 0) return 0;\n return expectedDamage / totalCount;\n }\n\n // Public (no modifier) for direct test access.\n calculateHitDistribution(): DamageDistribution {\n const hitValues: DamageDistribution = {};\n\n // Hoist the per-outcome distributions out of the face loop: they are\n // constant across faces, so fetching (and previously cloning) them once is\n // O(faces + outcomes) instead of O(faces × outcomes). The stored maps are\n // only read here, never mutated, so reading them directly is safe and\n // produces identical counts.\n const subtractedOutcomes: (DamageDistribution | undefined)[] = [\n this.outcomeData.crit,\n this.outcomeData.missNone,\n this.outcomeData.missDamage,\n this.outcomeData.saveHalf,\n this.outcomeData.saveFail,\n this.outcomeData.pc,\n ];\n\n for (const [face, totalCount] of Object.entries(this.faces)) {\n const numFace = Number(face);\n let hitCount = totalCount;\n\n for (const distribution of subtractedOutcomes) {\n const outcomeCount = distribution?.[numFace];\n if (outcomeCount) {\n hitCount -= outcomeCount;\n }\n }\n\n // At 0 a miss and a hit that deals nothing coincide: only the landed hits recorded there are\n // hits (an AC check's total of exactly 0 that met its target, or an attack payload's 0-damage\n // hit, see `attackPayload`); everything else at 0 is a miss.\n if (numFace === 0) {\n hitCount = this.outcomeData.hit?.[0] ?? 0;\n }\n\n // Defensive clamp: guards against negative hit counts from older\n // inclusion-exclusion logic. Should never trigger in practice.\n if (hitCount < 0) {\n hitCount = 0;\n }\n hitValues[numFace] = hitCount;\n }\n\n return hitValues;\n }\n\n private ensureHitDistribution(): void {\n if (!this.hasHitDistributionCalculated) {\n const hitValues = this.calculateHitDistribution();\n this.setOutcomeDistribution(\"hit\", hitValues);\n this.hasHitDistributionCalculated = true;\n }\n }\n\n // PRIVATE FUNCTIONS\n\n private binaryOp(\n other: Dice | number,\n op: (a: number, b: number) => number,\n diceConstructor?: () => Dice\n ): Dice {\n const result = diceConstructor ? diceConstructor() : new Dice();\n\n const isScalar = typeof other === \"number\";\n const keys1 = this.keys();\n // Hoist the inner die's faces out of the outer loop: they are constant\n // across key1, so computing them once avoids re-allocating the array on\n // every outer iteration.\n const keys2 = isScalar ? [] : (other as Dice).keys();\n\n // Guard the O(faces₁ × faces₂) work before running it: a binary op between\n // two large (but individually legal) dice would otherwise blow up.\n if (!isScalar && keys1.length * keys2.length > MAX_BINARY_OUTCOMES) {\n throw new DiceParseError(\n `Dice operation over ${keys1.length}×${keys2.length} face pairs exceeds the maximum of ${MAX_BINARY_OUTCOMES}`\n );\n }\n\n for (const key1 of keys1) {\n const value1 = this.faces[key1]!;\n\n if (isScalar) {\n const resultKey = op(key1, other as number);\n result.increment(resultKey, value1);\n } else {\n for (const key2 of keys2) {\n const value2 = other.faces[key2]!;\n const resultKey = op(key1, key2);\n result.increment(resultKey, value1 * value2);\n }\n }\n }\n\n return result;\n }\n\n // PUBLIC FUNCTIONS\n\n getFaceEntries(): [number, number][] {\n return Object.entries(this.faces).map(([k, v]) => [Number(k), v]);\n }\n\n getFaceMap(): DamageDistribution {\n return { ...this.faces };\n }\n\n get(face: number): number {\n return this.faces[face] ?? 0;\n }\n\n keys(): number[] {\n return Object.keys(this.faces).map(Number);\n }\n\n values(): number[] {\n return Object.values(this.faces);\n }\n\n total(): number {\n return Object.values(this.faces).reduce((sum, value) => sum + value, 0);\n }\n\n public setFace(key: number, value: number): void {\n this.faces[key] = value;\n }\n\n public static scalar(value: number): Dice {\n const result = new Dice();\n result.increment(value, 1);\n return result;\n }\n\n public maxFace(): number {\n const numericKeys = this.keys();\n\n if (numericKeys.length === 0) {\n throw new Error(\"No numeric faces found\");\n }\n\n return Math.max(...numericKeys);\n }\n\n public minFace(): number {\n const numericKeys = this.keys();\n\n if (numericKeys.length === 0) {\n throw new Error(\"No numeric faces found\");\n }\n\n return Math.min(...numericKeys);\n }\n\n public increment(face: number, count: number): void {\n const current = this.faces[face] || 0;\n this.faces[face] = current + count;\n }\n\n /** Scales every face count, and every outcome's counts with it, so each outcome keeps its share. */\n public normalize(scalar: number): Dice {\n const result = new Dice();\n\n for (const [face, count] of Object.entries(this.faces)) {\n result.faces[Number(face)] = count * scalar;\n }\n\n result.privateData = { ...this.privateData };\n for (const [key, distribution] of Object.entries(this.outcomeData)) {\n const scaled: DamageDistribution = {};\n for (const [face, count] of Object.entries(distribution)) {\n scaled[Number(face)] = count * scalar;\n }\n result.outcomeData[key as OutcomeType] = scaled;\n }\n return result;\n }\n\n // OPERATIONS\n\n public add(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a + b);\n }\n\n public subtract(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a - b);\n }\n\n public conditionalApply(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a === 0 ? 0 : 1) * b);\n }\n\n public multiply(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a * b);\n }\n\n public addNonZero(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a !== 0 ? a + b : a));\n }\n\n public eq(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a === b ? 1 : 0));\n }\n\n public max(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => Math.max(a, b));\n }\n\n public min(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => Math.min(a, b));\n }\n\n public advantage(): Dice {\n return this.max(this);\n }\n\n public ge(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a >= b ? 0 : 1));\n }\n\n public divide(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => a / b);\n }\n\n public divideRoundUp(other: Dice | number): Dice {\n this.assertNonZeroDivisor(other);\n return this.binaryOp(other, (a, b) => (b === 0 ? 0 : Math.ceil(a / b)));\n }\n\n public divideRoundDown(other: Dice | number): Dice {\n this.assertNonZeroDivisor(other);\n return this.binaryOp(other, (a, b) => (b === 0 ? 0 : Math.floor(a / b)));\n }\n\n /** A divisor that can be 0 has no quotient there. A 0 face with no weight is never rolled, so it passes. */\n private assertNonZeroDivisor(other: Dice | number): void {\n if (typeof other === \"number\" ? other === 0 : other.get(0) > 0) {\n throw new DiceParseError(\"Division by zero: the divisor can be 0\");\n }\n }\n\n public and(other: Dice | number): Dice {\n return this.binaryOp(other, (a, b) => (a && b ? 1 : 0));\n }\n\n private checkTarget(\n other: Dice | number,\n comparisonLogic: (roll: number, target: number) => number\n ): Dice {\n const createResult = () => {\n const result = new Dice();\n result.increment(0, 0); // Success\n result.increment(1, 0); // Failure\n return result;\n };\n\n return this.binaryOp(other, comparisonLogic, createResult);\n }\n\n public dc(other: Dice | number): Dice {\n const dcCheck = (a: number, b: number) => (a >= b ? 0 : 1);\n const result = this.checkTarget(other, dcCheck);\n // Mark this as a DC check (save mechanic) for proper attribute assignment\n result.privateData.isDCCheck = true;\n return result;\n }\n\n /**\n * An attack check: a total that meets the target lands at its own value, and a miss is 0. A total\n * of exactly 0 that meets the target (a target of 0 or less) lands at 0 too, where the misses sit:\n * its count is recorded under `hit` at 0, like a payload's 0-damage hit, so the ops after the\n * check tell it from a miss.\n */\n public ac(other: Dice | number): Dice {\n const acCheck = (a: number, b: number) => (a >= b ? a : 0);\n const result = this.checkTarget(other, acCheck);\n const zero = this.get(0);\n if (zero > 0) {\n let met = 0;\n if (typeof other === \"number\") met = other <= 0 ? 1 : 0;\n else for (const [target, count] of other.getFaceEntries()) if (target <= 0) met += count;\n if (met > 0) result.setOutcomeDistribution(\"hit\", { 0: zero * met });\n }\n return result;\n }\n\n public deleteFace(face: number): Dice {\n const result = new Dice();\n\n for (const [key, value] of Object.entries(this.faces)) {\n const numKey = Number(key);\n if (numKey !== face) {\n result.increment(numKey, value);\n }\n }\n\n result.privateData = { ...this.privateData };\n result.outcomeData = { ...this.outcomeData };\n return result;\n }\n\n /**\n * Roll once and, on a result in `toReroll`'s faces, roll again and keep the second roll. Each\n * result keeps its own weight: with T the total count and c_R the count on the rerolled faces,\n * face v's new count is c_v·(T·[v∉R] + c_R), i.e. p′(v) = p(v)·[v∉R] + P(R)·p(v).\n */\n public reroll(toReroll: Dice | number): Dice {\n const rerolled = new Set(typeof toReroll === \"number\" ? [toReroll] : toReroll.keys());\n const total = this.total();\n let rerolledCount = 0;\n for (const [face, count] of this.getFaceEntries()) if (rerolled.has(face)) rerolledCount += count;\n\n const result = new Dice();\n for (const [face, count] of this.getFaceEntries()) {\n result.increment(face, count * ((rerolled.has(face) ? 0 : total) + rerolledCount));\n }\n return result;\n }\n\n // This is not addition and not rolling two dice at once.\n // Instead, it’s mixing two distributions into a single weighted die.\n public combine(other: Dice | number): Dice {\n if (typeof other === \"number\") {\n other = Dice.scalar(other);\n }\n\n // Start by copying \"other\" into a new Dice object\n const result = new Dice();\n for (const [key, value] of Object.entries(other.faces)) {\n result.faces[Number(key)] = value;\n }\n\n // Build the \"except\" dice and add faces from `this` to result\n const except = new Dice();\n for (const [key, value] of Object.entries(this.faces)) {\n const numKey = Number(key);\n result.increment(numKey, value);\n\n // A key absent from `other` is still tracked in `except`.\n if (!(numKey in other.faces)) {\n except.increment(numKey, value); // still tracked in except\n }\n }\n\n result.privateData = { ...this.privateData, except: other };\n result.outcomeData = { ...this.outcomeData };\n return result;\n }\n\n public combineInPlace(other: Dice): void {\n for (const [key, value] of Object.entries(other.faces)) {\n const numKey = Number(key);\n const current = this.faces[numKey] || 0;\n this.faces[numKey] = current + value;\n }\n }\n\n public percent(): DamageDistribution {\n const total = this.total();\n const result: DamageDistribution = {};\n\n for (const [face, count] of Object.entries(this.faces)) {\n result[Number(face)] = count / total;\n }\n\n return result;\n }\n\n public average(): number {\n const total = this.total();\n if (total === 0) return 0;\n\n let sum = 0;\n for (const [key, value] of Object.entries(this.faces)) {\n sum += Number(key) * value;\n }\n\n return sum / total;\n }\n\n /*\n * Convert dice to PMF using OutcomeType labels directly from damage distribution.\n * This is much cleaner than the original complex distribution conversion.\n */\n public toPMF(numEpsilon: number = EPS): PMF {\n const total = this.total();\n if (total === 0) return PMF.empty(numEpsilon);\n\n // Ensure hit distribution is calculated before using it\n this.ensureHitDistribution();\n\n const map = new Map<number, Bin>();\n\n // Outcome distributions (counts, not probabilities)\n const hitDistro = this.getOutcomeDistribution(\"hit\") || {};\n const critDistro = this.getOutcomeDistribution(\"crit\") || {};\n const missDistro = this.getOutcomeDistribution(\"missDamage\") || {};\n const saveDistro = this.getOutcomeDistribution(\"saveHalf\") || {};\n const saveFailDistro = this.getOutcomeDistribution(\"saveFail\") || {};\n const pcDistro = this.getOutcomeDistribution(\"pc\") || {};\n\n // A save string records its failed saves as `saveFail` and its halved successes as\n // `saveHalf`, a failed save that rolls 0 damage included. What is left of a save-half string\n // is full damage on a failed save too; a bare DC check (no payload) is 1 on a failed save.\n const isSaveHalf = Object.keys(saveDistro).length > 0;\n\n const isDCCheck = this.privateData.isDCCheck === true;\n\n const clampNonNeg = (x: number) => (x < 0 && x > -1e-15 ? 0 : x);\n\n // Process each face value (iterate the internal map directly; this loop\n // only reads it, so the defensive clone from getFaceMap() is unnecessary)\n for (const [faceStr, faceCountRaw] of Object.entries(this.faces)) {\n const face = Number(faceStr);\n const faceCount = Number(faceCountRaw);\n\n // Skip structurally present but empty bins early\n if (faceCount <= 0) continue;\n\n let p = faceCount / total;\n p = clampNonNeg(p);\n\n // Always drop exact zeros to keep PMF semantics clean\n if (!(p > 0)) continue;\n\n // Optional pruning only when epsilon is enabled\n if (numEpsilon >= 0 && p < numEpsilon) continue;\n\n const count: OutcomeLabelMap = {};\n const attr: OutcomeLabelMap = {};\n\n // Add distribution counts and attributions\n if (hitDistro[face]) {\n const c = clampNonNeg(hitDistro[face] / total);\n if (c > 0) {\n if (isSaveHalf || isDCCheck) {\n count.saveFail = c; // full damage on failed save\n attr.saveFail = clampNonNeg((face * hitDistro[face]) / total);\n } else {\n count.hit = c;\n attr.hit = clampNonNeg((face * hitDistro[face]) / total);\n }\n }\n }\n\n if (critDistro[face]) {\n const c = clampNonNeg(critDistro[face] / total);\n if (c > 0) {\n count.crit = c;\n attr.crit = clampNonNeg((face * critDistro[face]) / total);\n }\n }\n\n if (missDistro[face]) {\n const c = clampNonNeg(missDistro[face] / total);\n if (c > 0) {\n count.missDamage = c;\n attr.missDamage = clampNonNeg((face * missDistro[face]) / total);\n }\n }\n\n if (saveDistro[face]) {\n const c = clampNonNeg(saveDistro[face] / total);\n if (c > 0) {\n count.saveHalf = c; // half damage on successful save\n attr.saveHalf = clampNonNeg((face * saveDistro[face]) / total);\n }\n }\n\n if (saveFailDistro[face]) {\n const c = clampNonNeg(saveFailDistro[face] / total);\n if (c > 0) {\n count.saveFail = (count.saveFail ?? 0) + c;\n attr.saveFail = clampNonNeg((attr.saveFail ?? 0) + (face * saveFailDistro[face]) / total);\n }\n }\n\n if (pcDistro[face]) {\n const c = clampNonNeg(pcDistro[face] / total);\n if (c > 0) {\n count.pc = c;\n attr.pc = clampNonNeg((face * pcDistro[face]) / total);\n }\n }\n\n // What no outcome claims deals no damage (missNone); a bare DC check's successes stay unlabelled.\n if (!isDCCheck) {\n const distroCountRaw =\n (hitDistro[face] || 0) +\n (critDistro[face] || 0) +\n (missDistro[face] || 0) +\n (saveDistro[face] || 0) +\n (saveFailDistro[face] || 0) +\n (pcDistro[face] || 0);\n\n const unaccountedCount = clampNonNeg(faceCount - distroCountRaw);\n if (unaccountedCount > 0) {\n const frac = clampNonNeg(unaccountedCount / total);\n if (frac > 0) {\n count.missNone = (count.missNone ?? 0) + frac;\n // missNone does 0 damage, so no attr contribution\n }\n }\n }\n\n const bin: Bin = { p, count };\n if (Object.keys(attr).length > 0) {\n bin.attr = attr;\n }\n\n map.set(face, bin);\n }\n\n // Fall back to a sentinel identifier if none was assigned. This indicates\n // a Dice constructed outside the normal parse/build flow.\n const identifier = this.identifier || \"ERROR\";\n\n // Normalize, drop zeros again if any snuck in, then compaction and pruning\n return new PMF(map, numEpsilon, true, identifier).compact(numEpsilon, true);\n }\n}\n\nexport type _DiceInternal = never;\n","/**\n * Crit doubling for parsed damage strings: scale every dice term's count, keep every\n * operator and flat. A dice term is a die together with its per-die modifiers, so the rewrite\n * reads the string with the same grammar `parse()` uses:\n *\n * - `2d6 + 5` → `4d6 + 5`; `2d6 // 2` → `4d6 // 2` (the division applies to the doubled total).\n * - `d6 reroll 1 + 3` → `2(d6 reroll 1) + 3` and `3>d6` → `2(3>d6)`: a lone die with `reroll`,\n * `>`, `<` or `!` applied to it is one die term; a `reroll`'s argument is a face set, never dice.\n * - `2(d6 reroll 1)` → `4(d6 reroll 1)`; `3(1d6 + 2)` → `3(2d6 + 2)` (copies of a group whose\n * flats must not double are doubled inside).\n * - `2kh1(2d6 + 3)` → `2kh1(4d6 + 3)`: a pool doubles inside, then pools; its trial count stays.\n * Only keep-highest-of-1 (\"roll it N times, keep the best\") does: any other keep (`4kh3d6`,\n * `3kl1(1d6)`), a min of two dice terms (`d6 < d6`) and an `&` mix with dice on either side\n * (`1d6 & 3`: doubling its dice also changes each side's share of the mix) have no single doubled\n * meaning, so they throw {@link AmbiguousCritDoublingError} and the caller must give the crit\n * explicitly.\n *\n * An attack or save check (`AC`/`DC`, or a crit/save/pc/miss clause) is not a damage expression —\n * doubling it would double the d20 — so it throws, as does a dice-valued repeat count (`d4d6`).\n */\ntype DiceAtom =\n | { kind: \"number\"; start: number; end: number; value: number }\n | { kind: \"die\"; start: number; end: number }\n | { kind: \"group\"; start: number; end: number; expr: DiceExpr }\n | { kind: \"keep\"; start: number; end: number; inner: DiceAtom; mode: \"h\" | \"l\"; kept: number };\ntype DiceChain = { start: number; atoms: DiceAtom[] };\ntype DiceOp = { op: string; arg: DiceChain | undefined; end: number };\ntype DiceExpr = { first: DiceChain; rest: DiceOp[] };\n\nconst isDigitOrN = (c: string | undefined): boolean =>\n c !== undefined && ((c >= \"0\" && c <= \"9\") || c === \"n\");\n\n/** Operators that, applied to a lone die, modify that die rather than a total. */\nconst isPerDieOp = (op: string): boolean =>\n op === \"reroll\" || op === \">\" || op === \"<\" || op === \"!\";\n\n/** Why a parsed string's dice cannot double: it is not a damage expression `scaleParsedDice` can rewrite. */\nexport class UndoubleableExpressionError extends Error {}\n\n/**\n * Why a damage payload's dice cannot double on a crit: it is damage, but \"double the dice\"\n * has more than one reading for it (a keep other than keep-highest-of-1, a `bestOf()`, a die rolled\n * with advantage, an `&` mix with dice). Never caught as {@link UndoubleableExpressionError}: no\n * crit is approximated.\n */\nexport class AmbiguousCritDoublingError extends Error {}\n\n/** A recursive-descent reader over `parse()`'s cleaned grammar (see `parser.ts`). */\nclass DiceTermReader {\n private pos = 0;\n\n constructor(\n private readonly s: string,\n private readonly expression: string\n ) {}\n\n read(): DiceExpr {\n const expr = this.expr();\n if (this.pos !== this.s.length) this.fail(`unexpected '${this.s[this.pos]}'`);\n return expr;\n }\n\n private fail(reason: string): never {\n throw new UndoubleableExpressionError(`Cannot double the dice of \"${this.expression}\": ${reason}.`);\n }\n\n private expr(): DiceExpr {\n const first = this.chain();\n const rest: DiceOp[] = [];\n for (let op = this.operation(); op !== undefined; op = this.operation()) {\n if (op === \"ac\") {\n this.fail(\"it contains an attack check (a d20 roll against an AC), so it is not a damage expression\");\n }\n if (op === \"dc\") {\n this.fail(\"it contains a saving throw check (a d20 roll against a DC), so it is not a damage expression\");\n }\n const arg = op === \"!\" ? undefined : this.chain();\n const c = this.s[this.pos];\n if (c === \"x\" || c === \"c\" || c === \"s\" || c === \"m\" || this.s.startsWith(\"pc\", this.pos)) {\n this.fail(\"it contains a check-outcome clause (crit/save/pc/miss), so it is not a damage expression\");\n }\n rest.push({ op, arg, end: this.pos });\n }\n return { first, rest };\n }\n\n private chain(): DiceChain {\n const start = this.pos;\n const atoms: DiceAtom[] = [];\n for (let atom = this.atom(); atom !== undefined; atom = this.atom()) atoms.push(atom);\n return { start, atoms };\n }\n\n private atom(): DiceAtom | undefined {\n const start = this.pos;\n const c = this.s[start];\n if (c === \"(\") {\n this.pos++;\n const expr = this.expr();\n if (this.s[this.pos] !== \")\") this.fail(\"unbalanced parentheses\");\n this.pos++;\n return { kind: \"group\", start, end: this.pos, expr };\n }\n if (c === \"h\" && this.s[start + 1] === \"d\" && isDigitOrN(this.s[start + 2])) {\n this.pos += 2;\n this.number();\n return { kind: \"die\", start, end: this.pos };\n }\n if (c === \"d\" && isDigitOrN(this.s[start + 1])) {\n this.pos += 1;\n this.number();\n return { kind: \"die\", start, end: this.pos };\n }\n if (c === \"k\") {\n const mode = this.s[start + 1];\n if (mode !== \"h\" && mode !== \"l\") this.fail(\"'k' must be followed by 'h' or 'l'\");\n this.pos += 2;\n const kept = this.number();\n const inner = this.atom();\n if (inner === undefined) this.fail(\"a keep needs dice after it\");\n return { kind: \"keep\", start, end: this.pos, inner, mode, kept };\n }\n if (isDigitOrN(c)) {\n const value = this.number();\n return { kind: \"number\", start, end: this.pos, value };\n }\n return undefined;\n }\n\n private number(): number {\n let digits = \"\";\n while (isDigitOrN(this.s[this.pos])) {\n const ch = this.s[this.pos++];\n digits += ch === \"n\" ? \"0\" : ch; // ParsedRollBuilder always parses with n = 0\n }\n if (digits.length === 0) this.fail(`expected a number at '${this.s[this.pos]}'`);\n return parseInt(digits, 10);\n }\n\n private operation(): string | undefined {\n const rest = this.s.slice(this.pos);\n const op = [\"reroll\", \"**\", \"//\", \"~+\", \"ac\", \"dc\", \"!\", \">\", \"<\", \"+\", \"-\", \"&\", \"*\", \"/\", \"=\"].find(\n (token) => rest.startsWith(token)\n );\n if (op !== undefined) this.pos += op.length;\n return op;\n }\n}\n\nfunction atomHasDice(atom: DiceAtom): boolean {\n switch (atom.kind) {\n case \"die\":\n return true;\n case \"number\":\n return false;\n case \"keep\":\n return atomHasDice(atom.inner);\n case \"group\":\n // A `reroll`'s argument is a face set (`reroll d2` = faces 1–2), never damage dice.\n return (\n chainHasDice(atom.expr.first) ||\n atom.expr.rest.some(({ op, arg }) => op !== \"reroll\" && arg !== undefined && chainHasDice(arg))\n );\n }\n}\n\nconst chainHasDice = (chain: DiceChain): boolean => chain.atoms.some(atomHasDice);\n\nconst isSingleDieAtom = (atom: DiceAtom): boolean =>\n atom.kind === \"die\" || (atom.kind === \"group\" && isSingleDieExpr(atom.expr, atom.expr.rest.length));\n\n/** Is `expr`'s first `opCount` operations one die term: one lone die, per-die operators, and flats? */\nfunction isSingleDieExpr(expr: DiceExpr, opCount: number): boolean {\n const operands = [expr.first];\n for (const { op, arg } of expr.rest.slice(0, opCount)) {\n if (!isPerDieOp(op)) return false;\n if (op !== \"reroll\" && arg !== undefined) operands.push(arg);\n }\n let dice = 0;\n for (const chain of operands) {\n if (chain.atoms.length === 1 && isSingleDieAtom(chain.atoms[0])) dice++;\n else if (chainHasDice(chain)) return false;\n }\n return dice === 1;\n}\n\n/** Rewrites every dice term's count in a parsed damage expression by `scale`. */\nexport function scaleParsedDice(expression: string, scale: number): string {\n // `parse()` drops every space and lowercases; keep a map back to the original characters so\n // the rewrite leaves the caller's spacing and casing alone.\n let cleaned = \"\";\n const original: number[] = [];\n for (let i = 0; i < expression.length; i++) {\n if (expression[i] === \" \") continue;\n cleaned += expression[i].toLowerCase();\n original.push(i);\n }\n const root = new DiceTermReader(cleaned, expression).read();\n\n const edits: { from: number; to: number; text: string }[] = [];\n /** The original characters behind cleaned `[start, end)`, spaces inside included. */\n const span = (start: number, end: number) => ({ from: original[start], to: original[end - 1] + 1 });\n const wrap = (start: number, end: number, open: string) => {\n const { from, to } = span(start, end);\n edits.push({ from, to: from, text: open }, { from: to, to, text: \")\" });\n };\n const source = (start: number, end: number) => {\n const { from, to } = span(start, end);\n return expression.slice(from, to);\n };\n\n // Shapes whose doubling has no single meaning, each with why. They are refused after the whole\n // walk, so a string that is not damage at all still reports that (UndoubleableExpressionError).\n const ambiguous: string[] = [];\n const keepReading =\n 'has no single doubled meaning (only keep-highest-of-1, \"roll it N times, keep the best\", doubles its dice inside each trial)';\n const noteKeep = (keep: Extract<DiceAtom, { kind: \"keep\" }>, trials?: DiceAtom): void => {\n // A keep of numbers alone is a constant: it has no dice to double, so one meaning.\n if ((keep.mode === \"h\" && keep.kept === 1) || !atomHasDice(keep.inner)) return;\n ambiguous.push(`the keep \\`${source(trials?.kind === \"number\" ? trials.start : keep.start, keep.inner.start)}\\` ${keepReading}`);\n };\n\n // After a keep's count a bare prefix would merge into that number (`4kh3d6` → `4kh32d6`), so a\n // kept lone die takes its count inside new parentheses: `4kh3(2d6)`.\n const scaleKept = (inner: DiceAtom): void => {\n if (isSingleDieAtom(inner)) wrap(inner.start, inner.end, `(${scale}`);\n else if (inner.kind === \"group\") scaleExpr(inner.expr);\n else if (inner.kind === \"keep\") {\n noteKeep(inner);\n scaleKept(inner.inner);\n }\n };\n\n const scaleChain = (chain: DiceChain): void => {\n const { atoms } = chain;\n if (atoms.length === 0) return;\n const last = atoms[atoms.length - 1];\n const counts = atoms.slice(0, -1);\n if (counts.some(atomHasDice)) {\n throw new UndoubleableExpressionError(\n `Cannot double the dice of \"${expression}\": a dice-valued repeat count (like d4d6) has no single dice term to double.`\n );\n }\n if (last.kind === \"keep\") {\n noteKeep(last, counts[counts.length - 1]);\n scaleKept(last.inner); // the pool's trial count stays; its dice double inside\n } else if (isSingleDieAtom(last)) {\n const count = counts[counts.length - 1];\n if (count?.kind === \"number\") {\n edits.push({ ...span(count.start, count.end), text: String(count.value * scale) });\n } else {\n const at = original[last.start];\n edits.push({ from: at, to: at, text: String(scale) });\n }\n } else if (last.kind === \"group\") {\n scaleExpr(last.expr); // copies of a group: double inside so its flats stay single\n }\n };\n\n function scaleExpr(expr: DiceExpr): void {\n // Operators bind left to right, so a leading lone die with per-die operators is one term.\n let unitOps = 0;\n for (let i = 1; i <= expr.rest.length && isPerDieOp(expr.rest[i - 1].op); i++) {\n if (isSingleDieExpr(expr, i)) unitOps = i;\n }\n if (unitOps > 0) wrap(expr.first.start, expr.rest[unitOps - 1].end, `${scale}(`);\n else scaleChain(expr.first);\n let leftHasDice = unitOps > 0 || chainHasDice(expr.first);\n for (const { op, arg, end } of expr.rest.slice(unitOps)) {\n if (op === \"reroll\" || arg === undefined) continue;\n const argHasDice = chainHasDice(arg);\n // `a < b` is min(a, b): with dice on both sides it keeps the lower of two dice terms.\n if (op === \"<\" && leftHasDice && argHasDice) {\n ambiguous.push(`the lower of two dice terms \\`${source(expr.first.start, end)}\\` ${keepReading}`);\n }\n // `a & b` mixes by count: doubling a side's dice multiplies its count, so its share moves.\n if (op === \"&\" && (leftHasDice || argHasDice)) {\n ambiguous.push(\n `the mix \\`${source(expr.first.start, end)}\\` has no single doubled meaning (an \\`&\\` weights each side ` +\n `by its count of outcomes, so doubling a side's dice also changes its share of the mix)`\n );\n }\n leftHasDice ||= argHasDice;\n scaleChain(arg);\n }\n }\n\n scaleExpr(root);\n if (ambiguous.length > 0) {\n throw new AmbiguousCritDoublingError(\n `Cannot double the dice of \"${expression}\" on a crit: ${ambiguous[0]}. ` +\n `Give the crit explicitly: onCrit(...) on an attack, critDamage on a rider, or a crit (...) clause.`\n );\n }\n\n let result = expression;\n for (const { from, to, text } of edits.sort((a, b) => b.from - a.from)) {\n result = result.slice(0, from) + text + result.slice(to);\n }\n return result;\n}\n","import { DiceParseError } from \"../common/errors\";\nimport { getCachingEnabled } from \"../common/lru-cache\";\nimport type { OutcomeType } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\nimport { Dice } from \"./dice\";\nimport type { CritTrack } from \"./dice\";\nimport { scaleParsedDice, UndoubleableExpressionError } from \"./scaleDice\";\n\ntype DiceOperation = ((this: Dice, other: Dice | number) => Dice) & {\n unary?: boolean;\n};\n\n/**\n * Resource-exhaustion guards. Adversarial expressions (a huge die, a huge dice\n * count, or a keep over a huge pool) can otherwise blow up memory and CPU.\n * These caps are deliberately generous so every legitimate expression the suite\n * exercises (e.g. d100000) still parses.\n */\n// Must stay >= 100000: the suite asserts d100000 (100k faces) parses.\nconst MAX_DIE_SIDES = 1_000_000;\nconst MAX_DICE_COUNT = 10_000;\n// Bound on keepDice's work, faces · kept² · (kept · face span + 1): its states times its steps.\nconst MAX_KEEP_WORK = 100_000_000;\n// Face counts are whole numbers up to here; a repeat whose counts would pass it keeps probabilities.\nconst MAX_EXACT_COUNT = Number.MAX_SAFE_INTEGER;\n\n/**\n * Internal parse cache for PMFs produced from string expressions.\n * Keyed by cleaned expression (spaces stripped, lowercased) and optional `n` value.\n */\nconst parseCache = PMF.createCache(1000);\n\n/** Clears the internal parse cache. */\nexport function clearParserCache(): void {\n parseCache.clear();\n}\n\n/**\n * Parse a dice expression into a PMF.\n *\n * - Expression is case-insensitive and ignores spaces.\n */\nexport function parse(expression: string, n: number = 0): PMF {\n // Check cache first if enabled\n const cleaned = expression.replace(/ /g, \"\").toLowerCase();\n\n if (getCachingEnabled()) {\n const cacheKey = `${cleaned}:${n}`;\n const cached = parseCache.get(cacheKey);\n if (cached) return cached;\n }\n\n const chars = [...cleaned];\n\n let result: Dice;\n try {\n result = parseExpression(chars, n);\n } catch (error) {\n throw new DiceParseError(\n `Cannot parse dice expression [${expression}]: ${error}`,\n { expression, cause: error }\n );\n }\n\n result.privateData = result.privateData || {};\n result.identifier = cleaned;\n\n if (chars.length > 0) {\n throw new DiceParseError(\n `Unexpected token: '${chars[0]}' from expression: '${expression}'`,\n { expression }\n );\n }\n\n const total = result.total();\n if (total === 0) {\n throw new DiceParseError(\n `Cannot parse dice expression [${expression}]: it has no outcomes (a d0 has no faces; it is only a reroll set, as in \\`reroll d0\\`)`,\n { expression }\n );\n }\n if (!Number.isFinite(total)) {\n throw new DiceParseError(\n `Cannot parse dice expression [${expression}]: its outcome counts overflow (too many dice combined to count exactly)`,\n { expression }\n );\n }\n\n // When creating the PMF, do not epsilon prune\n const resultPMF = result.toPMF(-1);\n if (getCachingEnabled()) {\n // Store under the same cleaned key used for the lookup above.\n const cacheKey = `${cleaned}:${n}`;\n parseCache.set(cacheKey, resultPMF);\n }\n\n return resultPMF;\n}\n\nfunction combineDiceWithNormalization(\n dice: Dice,\n normValue: number,\n outcomeType: OutcomeType,\n currentNorm: number,\n finalResult: Dice\n): { newNorm: number; updatedResult: Dice } {\n dice = dice.normalize(currentNorm);\n finalResult = finalResult.normalize(normValue);\n finalResult.setOutcomeDistribution(outcomeType, dice.getFaceMap());\n finalResult = finalResult.combine(dice);\n return { newNorm: currentNorm * normValue, updatedResult: finalResult };\n}\n\n/**\n * Face-wise histogram difference. NOT the same as {@link Dice.subtract}, which convolves VALUES\n * (`a - b` as numbers); this subtracts raw face COUNTS, used to take a sub-distribution (a crit\n * slice, one outcome's share) back out of the distribution it is part of.\n */\nfunction subtractCounts(a: Dice, b: Dice): Dice {\n const result = new Dice();\n for (const [key, value] of a.getFaceEntries()) result.increment(key, value);\n for (const [key, value] of b.getFaceEntries()) result.increment(key, -value);\n return result;\n}\n\n/**\n * Ops that leave a 0 (a miss) at 0 whatever their argument. A term joined to an attack by one of\n * these applies only where the attack lands, so it is part of the payload, since the grammar reads\n * left to right: `(check) * (1d4 - 1) + 1d6` is `(check) * ((1d4 - 1) ~+ 1d6)`, a `+` adding to\n * every landed outcome, one at 0 included (see {@link applyToLanded}).\n */\nconst HIT_ONLY_OPS: ReadonlySet<DiceOperation> = new Set<DiceOperation>([\n Dice.prototype.addNonZero,\n Dice.prototype.conditionalApply,\n Dice.prototype.multiply,\n Dice.prototype.divideRoundUp,\n Dice.prototype.divideRoundDown,\n]);\n\n/** An AC or DC gate: its target, on the right, is never the check's natural roll. */\nconst GATE_OPS: ReadonlySet<DiceOperation> = new Set<DiceOperation>([Dice.prototype.ac, Dice.prototype.dc]);\n\n/**\n * The count of tokens left in `arr` where the last `AC`/`DC` gate at this nesting level starts, or\n * undefined with none. Every term read while more tokens are left builds that check's total.\n */\nfunction lastGateAt(arr: readonly string[]): number | undefined {\n let depth = 0;\n let at: number | undefined;\n for (let i = 0; i < arr.length - 1; i++) {\n const c = arr[i];\n if (c === \"(\") depth++;\n else if (c === \")\") {\n if (depth === 0) break;\n depth--;\n } else if (depth === 0 && (c === \"a\" || c === \"d\") && arr[i + 1] === \"c\") {\n at = arr.length - i;\n }\n }\n return at;\n}\n\n/**\n * `inCheck`: `arr` is part of a check total (a group left of an `AC`/`DC`), so its `+` always adds.\n */\nfunction parseExpression(arr: string[], n: number, inCheck = false): Dice {\n const gate = lastGateAt(arr);\n const buildsCheck = (): boolean => inCheck || (gate !== undefined && arr.length > gate);\n // `+` adds only to a non-zero total, so a miss (0) stays 0 -- except in a check total, where a\n // running total of exactly 0 (`d20 - 5` on a natural 5) is a roll like any other.\n const readOperation = (): DiceOperation | undefined => {\n const checkTerm = buildsCheck();\n const parsed = parseOperation(arr);\n return parsed === Dice.prototype.addNonZero && checkTerm ? Dice.prototype.add : parsed;\n };\n\n const first = parseArgument(arr, n, buildsCheck());\n let finalResult = typeof first === \"number\" ? Dice.scalar(first) : first;\n if (typeof first === \"number\") finalResult.privateData.noDie = true;\n\n // While `finalResult` crits with its doubled hit payload, the text of each op and its argument,\n // so a trailing hit-only term joins the payload it is part of. Joined only for that case.\n let opText = finalResult.privateData.implicitCrit ? arr.join(\"\") : undefined;\n let op = readOperation();\n\n while (op != null) {\n // An AC check times a payload is an attack's hit: keep the payload's text, so its crit can\n // double the dice when the string has no crit clause. Joined only for that case.\n const pending =\n op === Dice.prototype.conditionalApply && finalResult.privateData.isACCheck ? arr.join(\"\") : undefined;\n const arg = !op.unary ? parseArgument(arr, n, buildsCheck()) : finalResult;\n const hitText = pending?.slice(0, pending.length - arr.length);\n const termText = opText?.slice(0, opText.length - arr.length);\n const before = finalResult;\n // An attack's check or payload: at 0 it holds its misses and its landed hits at 0 (`hit` at 0).\n const attack = isAttack(finalResult);\n const acCheck = finalResult.privateData.isACCheck === true;\n if (op === Dice.prototype.combine) assertMixable(before, arg, arr);\n\n // Handle crit (e.g. xcrit, crit). With no clause, an attack's crit is its hit payload with\n // every dice term doubled, at the check's natural-max rate, like the builder's. A check\n // with no die in it has no natural roll: its crit mass is exactly 0, so it takes no crit, and a\n // crit clause on it can never fire -- it is read and ignored, and the hit payload applies.\n let crit: Dice | undefined;\n let critNorm = 1;\n const critClause = arr[0] === \"x\" || arr[0] === \"c\";\n const implicitCrit = !critClause && hitText !== undefined && !finalResult.privateData.noDie;\n if (critClause || implicitCrit) {\n let count = 1;\n if (critClause) {\n const isXcrit = arr[0] === \"x\";\n if (isXcrit) assertToken(arr, \"x\");\n assertToken(arr, \"c\");\n assertToken(arr, \"r\");\n assertToken(arr, \"i\");\n assertToken(arr, \"t\");\n if (isXcrit) count = parseNumber(arr, n);\n }\n\n if (finalResult.privateData.noDie) {\n parseBinaryArgument(arg, arr, n);\n } else {\n ({ crit, rest: finalResult } = splitCrit(finalResult, count));\n\n critNorm = crit.total();\n const critArg = critClause ? parseBinaryArgument(arg, arr, n) : critPayload(hitText!, n);\n // Every crit landed, one whose total is 0 included: it takes the payload like any hit.\n crit = HIT_ONLY_OPS.has(op) ? applyToLanded(crit, op, critArg, crit.get(0), acCheck) : op.call(crit, critArg);\n\n critNorm = crit && critNorm ? crit.total() / critNorm : 1;\n }\n }\n\n // Handle save\n let save: Dice | undefined;\n let saveNorm = 1;\n if (arr[0] === \"s\") {\n assertToken(arr, \"s\");\n assertToken(arr, \"a\");\n assertToken(arr, \"v\");\n assertToken(arr, \"e\");\n\n const { miss: missed, rest } = splitMiss(finalResult, attack);\n finalResult = rest;\n saveNorm = missed.total();\n save = op.call(missed, parseBinaryArgument(arg, arr, n));\n saveNorm = save && saveNorm ? save.total() / saveNorm : 1;\n }\n\n // Handle half damage on hit (potent cantrip)\n let pc: Dice | undefined;\n let pcNorm = 1;\n\n if (arr.length >= 2 && arr[0] === \"p\" && arr[1] === \"c\") {\n assertToken(arr, \"p\");\n assertToken(arr, \"c\");\n\n const { miss: missed, rest } = splitMiss(finalResult, attack);\n finalResult = rest;\n const missBefore = missed.total();\n\n pc = op.call(missed, parseBinaryArgument(arg, arr, n)).divideRoundDown(2); // parse the damage\n\n const missAfter = pc ? pc.total() : 0;\n pcNorm = missBefore ? missAfter / missBefore : 1;\n }\n\n // Handle miss\n let miss: Dice | undefined;\n let missNorm = 1;\n\n if (arr[0] === \"m\") {\n assertToken(arr, \"m\");\n assertToken(arr, \"i\");\n assertToken(arr, \"s\");\n assertToken(arr, \"s\");\n\n const { miss: missed, rest } = splitMiss(finalResult, attack);\n finalResult = rest;\n missNorm = missed.total();\n\n miss = op.call(missed, parseBinaryArgument(arg, arr, n));\n missNorm = miss && missNorm ? miss.total() / missNorm : 1;\n }\n\n let norm = finalResult.total();\n\n const clause = crit !== undefined || save !== undefined || pc !== undefined || miss !== undefined;\n const labelled = hasOutcomeLabels(finalResult);\n const operand = finalResult;\n if (!clause && labelled && HIT_ONLY_OPS.has(op)) {\n finalResult = applyByOutcome(finalResult, op, arg, termText, n);\n } else if (HIT_ONLY_OPS.has(op)) {\n finalResult = applyToLanded(finalResult, op, arg, landedAtZero(finalResult), acCheck);\n } else {\n finalResult = op.call(finalResult, arg);\n }\n // A save's payload: every failed save (a 1) is `saveFail`, whatever the payload rolls there.\n if (operand.privateData.isDCCheck && HIT_ONLY_OPS.has(op)) {\n finalResult.setOutcomeDistribution(\"saveFail\", op.call(operand.deleteFace(0), arg).getFaceMap());\n }\n // A landed hit that deals 0 is still a hit: record it at 0, where the misses also sit, from the\n // AC check on through every hit-only term after it.\n if (attack && HIT_ONLY_OPS.has(op)) {\n finalResult.privateData.attackPayload = true;\n const landed = landedHitsAtZero(operand, op, arg, acCheck);\n if (landed > 0) finalResult.setOutcomeDistribution(\"hit\", { 0: landed });\n } else if (op === Dice.prototype.combine && typeof arg !== \"number\") {\n // `combine` keeps the left side's data; an `&` mix lands the hits at 0 of both sides.\n if (arg.privateData.attackPayload) finalResult.privateData.attackPayload = true;\n const landed = landedAtZero(operand) + landedAtZero(arg);\n if (landed > 0) finalResult.setOutcomeDistribution(\"hit\", { 0: landed });\n }\n // An `&` mix is an attack check whichever side the gate is on: `combine` copies the left's data.\n const gated = op === Dice.prototype.combine && typeof arg !== \"number\" && arg.privateData.isACCheck;\n if (op === Dice.prototype.ac || gated) finalResult.privateData.isACCheck = true;\n followNaturalRoll(before, op, arg, finalResult, clause);\n norm = norm ? finalResult.total() / norm : 1;\n\n // Combine dice with normalization\n if (crit) {\n const result = combineDiceWithNormalization(\n crit,\n critNorm,\n \"crit\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (save) {\n const result = combineDiceWithNormalization(\n save,\n saveNorm,\n \"saveHalf\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (miss) {\n const result = combineDiceWithNormalization(\n miss,\n missNorm,\n \"missDamage\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (pc) {\n const result = combineDiceWithNormalization(\n pc,\n pcNorm,\n \"pc\",\n norm,\n finalResult\n );\n norm = result.newNorm;\n finalResult = result.updatedResult;\n }\n\n if (implicitCrit) finalResult.privateData.implicitCrit = { payload: hitText! };\n opText = finalResult.privateData.implicitCrit ? arr.join(\"\") : undefined;\n op = readOperation();\n }\n\n return finalResult;\n}\n\n/** The size of `value`'s natural die, whether or not its natural roll is tracked; 0 with no die. */\nfunction naturalSides(value: Dice | number): number {\n if (typeof value === \"number\") return 0;\n const { critTrack, untrackedSides } = value.privateData;\n return critTrack ? critTrack.sides : (untrackedSides ?? 0);\n}\n\n/**\n * Whether a die of `sides` takes the natural roll from one of `other` sides (0: no die): a d20\n * outranks every other die, and with no d20 the larger die does. A d30 or d100 beside the d20 is a\n * bonus die.\n */\nfunction outranks(sides: number, other: number): boolean {\n if (sides === other) return false;\n if (sides === 20 || other === 20) return sides === 20;\n return sides > other;\n}\n\n/** A check that is its natural roll itself: face f's share is its own count at f. */\nfunction bareTrack(die: Dice): CritTrack {\n return {\n sides: die.maxFace(),\n bare: true,\n slice: (face) => {\n const slice = new Dice();\n const weight = die.get(face);\n if (weight) slice.setFace(face, weight);\n return slice;\n },\n };\n}\n\n/** A number operand as a value: a die-less branch of an `&` mix. */\nfunction asValue(value: Dice | number): Dice {\n if (typeof value !== \"number\") return value;\n const scalar = Dice.scalar(value);\n scalar.privateData.noDie = true;\n return scalar;\n}\n\nfunction branchesOf(value: Dice | number): readonly Dice[] {\n return typeof value === \"number\" ? [asValue(value)] : (value.privateData.branches ?? [value]);\n}\n\nconst hasOutcomeLabels = (value: Dice | number): boolean =>\n typeof value !== \"number\" && Object.keys(value.getFullOutcomeDistribution()).some((label) => label !== \"hit\");\n\nconst isSave = (value: Dice | number): boolean => typeof value !== \"number\" && value.privateData.isDCCheck === true;\n\n/** An AC check, or an attack's payload: its outcomes at 0 are its misses and its landed hits at 0. */\nconst isAttack = (value: Dice): boolean =>\n value.privateData.isDCCheck !== true && (value.privateData.isACCheck === true || value.privateData.attackPayload === true);\n\n/**\n * The count of `value`'s outcomes at 0 that are landed hits, not misses: an AC check's total of\n * exactly 0 that met its target, or a payload's hit that deals 0 (its `hit` at 0).\n */\nconst landedAtZero = (value: Dice | number): number => (typeof value === \"number\" ? 0 : value.getOutcomeCount(\"hit\", 0));\n\n/**\n * `op(value, arg)` for a hit-only op, where `landed` of `value`'s outcomes at 0 are landed hits and\n * the rest there are misses. A miss stays 0; a landed hit at 0 takes `+` like any other hit, so the\n * term is added to it, and on an AC check (`gate`) takes the payload of the check's `*`. Everywhere\n * else it is 0 damage, which `*`, `**`, `/` and `//` keep at 0.\n */\nfunction applyToLanded(value: Dice, op: DiceOperation, arg: Dice | number, landed: number, gate: boolean): Dice {\n const lands = op === Dice.prototype.addNonZero || (gate && op === Dice.prototype.conditionalApply);\n if (!(landed > 0) || !lands) return op.call(value, arg);\n const misses = value.deleteFace(0);\n const missed = value.get(0) - landed;\n if (missed > 0) misses.setFace(0, missed);\n const result = op.call(misses, arg);\n result.combineInPlace(asValue(arg).normalize(landed));\n return result;\n}\n\n/**\n * `op(value, arg)` for a hit-only op on an attack's check (`gate`) or payload with no outcome labels\n * (a crit slice): its landed hits at 0 take the op as hits, and the result records its own.\n */\nfunction applyToAttack(value: Dice, op: DiceOperation, arg: Dice | number, gate: boolean): Dice {\n const result = applyToLanded(value, op, arg, landedAtZero(value), gate);\n result.privateData.attackPayload = true;\n const landed = landedHitsAtZero(value, op, arg, gate);\n if (landed > 0) result.setOutcomeDistribution(\"hit\", { 0: landed });\n return result;\n}\n\n/**\n * Split the misses a `miss`, `pc` or `save` clause applies to off `check`: an attack's (`attack`) at\n * 0, less its landed hits there, which stay with the hits; any other check's on its lowest face (a\n * save's success). The misses are moved to face 1, so the clause's `*` deals them its payload.\n */\nfunction splitMiss(check: Dice, attack: boolean): { miss: Dice; rest: Dice } {\n const face = attack ? 0 : check.minFace();\n const landed = face === 0 ? landedAtZero(check) : 0;\n const miss = new Dice();\n miss.increment(face > 0 ? face : 1, check.get(face) - landed);\n const rest = check.deleteFace(face);\n if (landed > 0) rest.setFace(0, landed);\n return { miss, rest };\n}\n\n/**\n * An `&` mix weights each side by its count of outcomes and keeps the left side's labels. An attack\n * already split into crit, miss or save outcomes has no count to weight by (the split renormalises\n * it), a save beside a non-save has no one set of labels, and a crit, save, pc or miss clause after\n * the mix would split the left side alone. Each reading would depend on operand order, so all three\n * are refused. `rest` is the text after the mix's right side.\n */\nfunction assertMixable(left: Dice, right: Dice | number, rest: readonly string[]): void {\n if (hasOutcomeLabels(left) || hasOutcomeLabels(right)) {\n throw new Error(\n \"an `&` mix of an attack already split into crit, miss or save outcomes has no single reading: \" +\n \"mix the checks before the payload, like `((d20 AC 10) & (d20 AC 15)) * (1d6)`\"\n );\n }\n if (isSave(left) !== isSave(right)) {\n throw new Error(\"an `&` mix of a saving throw (DC) with anything but another saving throw has no single set of outcomes\");\n }\n const [next, after] = rest;\n if (next === \"x\" || next === \"c\" || next === \"s\" || next === \"m\" || (next === \"p\" && after === \"c\")) {\n throw new Error(\"a crit, save, pc or miss clause on an `&` mix has no single reading: put it after the payload's `*`\");\n }\n}\n\n/**\n * Record on `after = op(before, arg)` the natural roll a crit is read from, or the size of the die\n * whose natural roll it lost, replacing whatever `op` copied from `before`. The natural roll is the\n * check's one d20 wherever it sits in the sum, or with no d20 its largest die: other dice are bonus\n * dice, and an AC or DC target is never the roll. Two dice of that size have no single natural roll\n * (`d20 + d20`, like `2d20`), except as advantage or disadvantage between two natural rolls\n * (`d20 > d20`), whose result is the new kept roll. Advantage and rerolls choose which natural roll\n * is kept, so they apply only to a bare die (no op since it). A max or min against anything else\n * follows the natural roll only where its value is the one kept: `d20 > d4` crits on every natural\n * 20, `d20 < 15` never. Every other op acts face by face, so replaying it on one natural face's\n * slice follows that face exactly. A clause splits the check's outcomes off by face, so its natural\n * roll no longer maps onto them.\n *\n * An `&` mix adds its operands' counts, so it keeps them as branches, and every later op but a\n * reroll (which draws again from the whole mix) is replayed on each branch, or each pair of branches:\n * `(d20 & d4) > d20` is `(d20 > d20) & (d4 > d20)`. The mix crits where a branch rolls the natural\n * roll's top faces, at that branch's share: `d4 & d20` crits on the d20 branch's 20, 1 in 24.\n */\nfunction followNaturalRoll(before: Dice, op: DiceOperation, arg: Dice | number, after: Dice, clause: boolean): void {\n const data = after.privateData;\n delete data.critTrack;\n delete data.untrackedSides;\n delete data.noDie;\n delete data.branches;\n const gate = GATE_OPS.has(op);\n if (!clause && before.privateData.noDie && (gate || typeof arg === \"number\" || arg.privateData.noDie)) {\n data.noDie = true;\n }\n\n const mixed =\n before.privateData.branches !== undefined ||\n (!gate && typeof arg !== \"number\" && arg.privateData.branches !== undefined);\n if (!clause && op === Dice.prototype.combine) {\n data.branches = [...branchesOf(before), ...branchesOf(arg)];\n } else if (!clause && mixed && op !== Dice.prototype.reroll) {\n // Advantage is a max of two independent rolls of the mix: every pair of its branches.\n const advantage = op === Dice.prototype.advantage;\n const pairOp = advantage ? Dice.prototype.max : op;\n const lefts = branchesOf(before);\n const rights = advantage ? lefts : gate ? [asValue(arg)] : branchesOf(arg);\n data.branches = lefts.flatMap((left) =>\n rights.map((right) => {\n const part =\n HIT_ONLY_OPS.has(pairOp) && isAttack(left)\n ? applyToAttack(left, pairOp, right, left.privateData.isACCheck === true)\n : pairOp.call(left, right);\n followNaturalRoll(left, pairOp, right, part, false);\n return part;\n })\n );\n }\n if (data.branches) {\n mixNaturalRolls(after, data.branches);\n return;\n }\n\n const track = before.privateData.critTrack;\n const argTrack = typeof arg === \"number\" || gate ? undefined : arg.privateData.critTrack;\n const sides = naturalSides(before);\n const argSides = gate ? 0 : naturalSides(arg);\n const extremum = op === Dice.prototype.max || op === Dice.prototype.min;\n const own = track !== undefined && outranks(sides, argSides);\n const followed = own ? track : argTrack && outranks(argSides, sides) ? argTrack : undefined;\n\n if (clause) {\n // A clause leaves no natural roll: untracked below.\n } else if (op === Dice.prototype.advantage || op === Dice.prototype.reroll) {\n if (track?.bare) data.critTrack = bareTrack(after);\n } else if (extremum && track?.bare && argTrack?.bare && sides === argSides) {\n data.critTrack = bareTrack(after);\n } else if (followed) {\n // A hit-only op on an attack's slice carries its landed hits at 0 (see `applyToAttack`).\n const attack = HIT_ONLY_OPS.has(op) && isAttack(before);\n const gated = before.privateData.isACCheck === true;\n const call = (value: Dice, other: Dice | number): Dice =>\n attack ? applyToAttack(value, op, other, gated) : op.call(value, other);\n const apply = own ? (value: Dice) => call(value, arg) : (value: Dice) => call(before, value);\n const step = extremum ? (slice: Dice) => keptPart(slice, apply) : apply;\n data.critTrack = { sides: followed.sides, bare: false, slice: (face) => step(followed.slice(face)) };\n }\n if (!data.critTrack) {\n const top = outranks(argSides, sides) ? argSides : sides;\n if (top > 0) data.untrackedSides = top;\n }\n}\n\n/**\n * The natural roll of an `&` mix `after` of `branches`: the top-ranked natural die among them. A\n * branch without that die never crits; one that has it but not as one natural roll (`d20 + d20`)\n * leaves the mix without one.\n */\nfunction mixNaturalRolls(after: Dice, branches: readonly Dice[]): void {\n const sides = branches.reduce((top, branch) => (outranks(naturalSides(branch), top) ? naturalSides(branch) : top), 0);\n if (sides === 0) return;\n const tracks: CritTrack[] = [];\n for (const branch of branches) {\n if (naturalSides(branch) !== sides) continue;\n const track = branch.privateData.critTrack;\n if (!track) {\n after.privateData.untrackedSides = sides;\n return;\n }\n tracks.push(track);\n }\n after.privateData.critTrack = {\n sides,\n bare: tracks.length === branches.length && tracks.every((track) => track.bare),\n slice: (face) => {\n const slice = new Dice();\n let landed = 0;\n for (const track of tracks) {\n const part = track.slice(face);\n slice.combineInPlace(part);\n landed += landedAtZero(part);\n }\n if (landed > 0) slice.setOutcomeDistribution(\"hit\", { 0: landed });\n return slice;\n },\n };\n}\n\n/**\n * The share of a max or min, `apply(face)` per face of `slice`, whose result is that face's own\n * value: where the natural roll is the value kept (ties included), not the other side's.\n */\nfunction keptPart(slice: Dice, apply: (face: Dice) => Dice): Dice {\n const result = new Dice();\n for (const [value, count] of slice.getFaceEntries()) {\n const face = new Dice();\n face.setFace(value, count);\n const kept = apply(face).get(value);\n if (kept) result.increment(value, kept);\n }\n return result;\n}\n\n/**\n * Split an attack check's crit mass off `check`: the slices of its `count` highest natural faces\n * (`count` is 1 for a natural max, N for `xcrit N`), each replayed through every op since the die --\n * bonus dice, modifiers, the AC gate -- so a crit is a natural roll in range at any bonus roll, the\n * builder's rule. A check whose natural roll is not one die throws rather than guessing from its\n * highest totals, which smear a natural roll across several totals once bonus dice are added.\n *\n * A crit face whose total missed the target reads 0 (parse() has no natural-20 auto-hit): it stays\n * miss mass and is never labelled a crit. One whose total is exactly 0 and met a target of 0 or less\n * landed: it stays a crit at 0. `xcrit0` crits on no face, so it needs no natural roll.\n */\nfunction splitCrit(check: Dice, count: number): { crit: Dice; rest: Dice } {\n if (count === 0) {\n const none = new Dice();\n const rest = subtractCounts(check, none);\n if (landedAtZero(check) > 0) rest.setOutcomeDistribution(\"hit\", { 0: landedAtZero(check) });\n return { crit: none, rest };\n }\n const track = check.privateData.critTrack;\n if (!track) {\n throw new Error(\n \"crit rate cannot be computed exactly for this attack check: its natural roll is not one die \" +\n \"(a dice-valued check like 2d20 or 2kh2d20, two d20s like d20 + d20, or advantage \" +\n \"over a total). Build the attack with the builder API instead.\"\n );\n }\n const { sides } = track;\n if (count > sides) {\n // Usually a count run into the next number: `xcrit2 1d6` reads as `xcrit21 d6`.\n throw new Error(`xcrit${count} is wider than the d${sides} it reads its natural roll from`);\n }\n let crit = new Dice();\n let landed = 0;\n for (let face = sides; face > sides - count; face--) {\n const slice = track.slice(face);\n crit.combineInPlace(slice);\n landed += landedAtZero(slice);\n }\n const rest = subtractCounts(check, crit);\n const missed = crit.get(0) - landed;\n if (missed) {\n crit = crit.deleteFace(0);\n if (landed > 0) crit.setFace(0, landed);\n rest.increment(0, missed);\n }\n const restLanded = landedAtZero(check) - landed;\n if (restLanded > 0) rest.setOutcomeDistribution(\"hit\", { 0: restLanded });\n return { crit, rest };\n}\n\n/**\n * The crit payload of an attack string with no crit clause is its hit payload `text` with\n * every dice term doubled and its flats kept -- the rewrite the parsed builder's `doubleDice()`\n * uses, so `(d20 + 5 AC 12) * (1d8 + 3)` crits as `(2d8 + 3)`, exactly like the builder. A payload\n * that rewrite cannot double (a dice-valued count like `d4d6`, a nested check) is added as-is,\n * like a bare PMF.\n */\nfunction critPayload(text: string, n: number): Dice {\n let doubled = text;\n try {\n // The rewrite reads `n` as a digit; substitute it first so a count of `n` doubles by value.\n doubled = scaleParsedDice(text.replace(/n/g, String(n)), 2);\n } catch (error) {\n if (!(error instanceof UndoubleableExpressionError)) throw error;\n }\n const chars = [...doubled];\n const payload = parseExpression(chars, n);\n if (chars.length > 0) {\n throw new Error(`Unexpected token '${chars[0]}' in the crit payload '${doubled}'`);\n }\n return payload;\n}\n\n/**\n * Outcomes that carry a payload, so a trailing `+` adds to them even where they rolled 0: a crit, a\n * miss clause's damage, a potent-cantrip half, and a save's failure or half. A miss with no payload\n * (`missNone`) never takes it.\n */\nconst PAYLOAD_OUTCOMES: Readonly<Record<string, true>> = {\n crit: true,\n missDamage: true,\n pc: true,\n saveFail: true,\n saveHalf: true,\n};\n\n/**\n * `op(labelled, arg)` for a hit-only op, outcome by outcome, so an attack's labels survive a\n * trailing term. A doubled crit (no crit clause) takes the term into its payload and doubles the\n * whole payload again, exactly as if the term were written inside it; every other outcome,\n * an explicit crit clause's included, takes the term as written. A trailing `+` adds to every\n * outcome with a payload, one that rolled 0 included -- each hit and crit, each miss a `miss (…)`\n * clause deals damage to, a potent-cantrip half, and a save's failure or half -- the way the\n * builder's `plus` does, while a miss with no payload stays 0.\n */\nfunction applyByOutcome(\n labelled: Dice,\n op: DiceOperation,\n arg: Dice | number,\n termText: string | undefined,\n n: number\n): Dice {\n const implicit = labelled.privateData.implicitCrit;\n const argTotal = typeof arg === \"number\" ? 1 : arg.total();\n const result = new Dice();\n let rest = labelled;\n let payload: string | undefined;\n for (const [label, distribution] of Object.entries(labelled.getFullOutcomeDistribution())) {\n if (label === \"hit\" || distribution === undefined) continue;\n const part = new Dice();\n for (const [face, count] of Object.entries(distribution)) part.increment(Number(face), count);\n rest = subtractCounts(rest, part);\n let applied: Dice;\n if (label === \"crit\" && implicit && termText !== undefined) {\n // Written into the payload, a `+` term always adds: `~+`.\n payload = implicit.payload + (op === Dice.prototype.addNonZero ? \"~\" : \"\") + termText;\n const doubled = critPayload(payload, n);\n // `op` scales every other outcome's counts by the argument's; keep the crit's share.\n applied = doubled.normalize((part.total() * argTotal) / doubled.total());\n } else if (PAYLOAD_OUTCOMES[label] === true) {\n applied = applyToLanded(part, op, arg, part.get(0), false);\n } else {\n applied = op.call(part, arg);\n }\n result.combineInPlace(applied);\n result.setOutcomeDistribution(label as OutcomeType, applied.getFaceMap());\n }\n result.combineInPlace(applyToLanded(rest, op, arg, landedAtZero(labelled), false));\n if (labelled.privateData.isDCCheck) result.privateData.isDCCheck = true;\n if (payload !== undefined) result.privateData.implicitCrit = { payload };\n return result;\n}\n\n/**\n * The count of `op(operand, arg)`'s outcomes at 0 that are landed hits: each of `operand`'s hits (a\n * landed hit at 0 included, which takes the op as `applyToLanded` says) times the count of `arg`'s\n * values that `op` takes it to 0 with. `gate`: `operand` is an AC check.\n */\nfunction landedHitsAtZero(operand: Dice, op: DiceOperation, arg: Dice | number, gate: boolean): number {\n let landed = 0;\n for (const [face, count] of Object.entries(operand.calculateHitDistribution())) {\n if (!(count > 0)) continue;\n const hit = new Dice();\n hit.setFace(Number(face), count);\n landed += applyToLanded(hit, op, arg, Number(face) === 0 ? count : 0, gate).get(0);\n }\n return landed;\n}\n\n/**\n * One argument: a repeat chain (`2d6`, `2(1d4 + 1)`, `(1d4)d6`, `4kh3d6`), or a unary minus and the\n * argument it negates, whole chain included: `-2d6` is `-(2d6)`, `1d6 + -3` is `1d6 - 3`.\n */\nfunction parseArgument(s: string[], n: number, inCheck = false): Dice | number {\n if (s[0] === \"-\") {\n s.shift();\n const operand = parseArgument(s, n, inCheck);\n if (typeof operand === \"number\") return 0 - operand;\n const zero = asValue(0);\n const negated = zero.subtract(operand);\n followNaturalRoll(zero, Dice.prototype.subtract, operand, negated, false);\n return negated;\n }\n\n let result = parseArgumentInternal(s, n, inCheck);\n if (result === undefined) {\n const at = s.length === 0 ? \"the end of the expression\" : `'${s.slice(0, 20).join(\"\")}'`;\n throw new Error(`Expected a number, a die, a keep or '(' at ${at}`);\n }\n\n for (let next = parseArgumentInternal(s, n, inCheck); next !== undefined; next = parseArgumentInternal(s, n, inCheck)) {\n result = multiplyDiceByDice(result, next);\n }\n\n return result;\n}\n\nfunction multiplyDiceByDice(d1: Dice | number, d2: Dice | number): Dice {\n // `2(15)`: copies of a constant are still a constant.\n const noDie =\n (typeof d1 === \"number\" || d1.privateData.noDie) && (typeof d2 === \"number\" || d2.privateData.noDie);\n if (typeof d1 === \"number\") d1 = Dice.scalar(d1);\n if (typeof d2 === \"number\") d2 = Dice.scalar(d2);\n\n const result = new Dice();\n // Keyed by face value. A Map avoids the number→string→parseFloat round-trip of\n // an object and preserves insertion order, which matches d1.keys() ascending\n // order — so the combine order below is identical to the previous version.\n const faces = new Map<number, Dice>();\n let common = 1;\n\n const { keep } = d2.privateData;\n for (const key of d1.keys()) {\n const face = keep ? keepDice(d2, key, keep) : multiplyDice(key, d2);\n\n common *= face.total();\n faces.set(key, face);\n }\n\n // Scaled to one common total the counts stay whole numbers; past MAX_EXACT_COUNT they could not,\n // and the product would overflow, so each count becomes its probability instead.\n const exact = common <= MAX_EXACT_COUNT;\n for (const [k, face] of faces) {\n const count = d1.get(k);\n result.combineInPlace(face.normalize(((exact ? common : 1) * count) / face.total()));\n }\n\n result.privateData.except = {};\n // `1d20` is the die itself, and a keep of one of N rolls of it (`2kh1d20` advantage, `2kl1(1d20)`\n // disadvantage, `3kh1(1d20)` elven accuracy) is one kept natural roll, like `d20 > d20`: a crit\n // is read from either. Any other count or keep has no single natural roll.\n const [only, ...more] = d1.keys();\n const { critTrack } = d2.privateData;\n const rolls = keep === undefined ? only : Math.min(only, keep.kept);\n const sides = outranks(naturalSides(d2), naturalSides(d1)) ? naturalSides(d2) : naturalSides(d1);\n if (rolls === 1 && more.length === 0 && critTrack?.bare) {\n result.privateData.critTrack = bareTrack(result);\n } else if (sides > 0) {\n result.privateData.untrackedSides = sides;\n }\n if (noDie) result.privateData.noDie = true;\n return result;\n}\n\n/** A repeat count is a whole number of copies, 0 included (no dice: the point mass at 0). */\nfunction assertRepeatCount(n: number): void {\n if (!Number.isInteger(n) || n < 0) {\n throw new DiceParseError(`A repeat count must be a whole number of 0 or more; this one can be ${n}`);\n }\n if (n > MAX_DICE_COUNT) {\n throw new DiceParseError(\n `Dice count ${n} exceeds the maximum of ${MAX_DICE_COUNT}`\n );\n }\n}\n\nfunction multiplyDice(n: number, d: Dice): Dice {\n assertRepeatCount(n);\n if (n === 0) return Dice.scalar(0);\n if (n === 1) return d;\n\n const half = Math.floor(n / 2);\n let result = multiplyDice(half, d);\n result = result.add(result);\n\n if (n % 2 === 1) {\n result = result.add(d);\n }\n\n // Counts past MAX_EXACT_COUNT are no longer whole numbers and a few more doublings overflow:\n // keep them as probabilities, which lose nothing more.\n const total = result.total();\n return total > MAX_EXACT_COUNT ? result.normalize(1 / total) : result;\n}\n\n/**\n * The sum of the `kept` highest (or lowest) of `count` independent copies of `die`, exactly, for\n * any per-copy distribution. Faces are visited from the kept end. With `placed` copies already on\n * earlier faces, how many of the other m = count - placed land on this face is Binomial(m, q), q\n * being this face's share of the mass from here on. Once `kept` copies are placed the kept sum is\n * final, so only states with fewer placed are carried: kept × (sums so far) states per face.\n */\nfunction keepDice(die: Dice, count: number, { kept, lowest }: { kept: number; lowest: boolean }): Dice {\n assertRepeatCount(count);\n if (kept >= count) return multiplyDice(count, die);\n if (kept <= 0) return Dice.scalar(0);\n\n const faces = die\n .getFaceEntries()\n .filter(([, weight]) => weight > 0)\n .sort(([a], [b]) => (lowest ? a - b : b - a));\n if (faces.length === 0) return new Dice(); // copies of a d0: no outcomes, reported by parse()\n const span = Math.abs(faces[faces.length - 1][0] - faces[0][0]);\n const work = faces.length * kept * kept * (kept * span + 1);\n if (work > MAX_KEEP_WORK) {\n throw new DiceParseError(\n `Keep of ${kept} of ${count} copies of a ${faces.length}-face roll exceeds the maximum work of ${MAX_KEEP_WORK}`\n );\n }\n\n // The mass from each face on, summed from the far end so the last face's share is exactly 1.\n const tails: number[] = new Array(faces.length);\n for (let i = faces.length - 1, tail = 0; i >= 0; i--) tails[i] = tail += faces[i][1];\n\n const addTo = (map: Map<number, number>, key: number, p: number): void => {\n map.set(key, (map.get(key) ?? 0) + p);\n };\n // states[placed]: kept sum so far → probability, with `placed` < `kept` copies placed.\n let states = Array.from({ length: kept }, () => new Map<number, number>());\n states[0].set(0, 1);\n const done = new Map<number, number>();\n\n faces.forEach(([value, weight], i) => {\n const q = weight / tails[i];\n const next = Array.from({ length: kept }, () => new Map<number, number>());\n states.forEach((sums, placed) => {\n if (sums.size === 0) return;\n const left = count - placed;\n const need = kept - placed;\n // P(exactly c of the `left` copies land here) for c < need; the rest completes the keep.\n const few: number[] = [];\n let logChoose = 0;\n for (let c = 0; c < need; c++) {\n if (c > 0) logChoose += Math.log((left - c + 1) / c);\n few.push(q >= 1 ? 0 : Math.exp(logChoose + c * Math.log(q) + (left - c) * Math.log1p(-q)));\n }\n const enough = Math.max(0, 1 - few.reduce((total, p) => total + p, 0));\n for (const [sum, p] of sums) {\n few.forEach((pc, c) => {\n if (pc > 0) addTo(next[placed + c], sum + c * value, p * pc);\n });\n if (enough > 0) addTo(done, sum + need * value, p * enough);\n }\n });\n states = next;\n });\n\n const result = new Dice();\n for (const [sum, p] of done) result.increment(sum, p);\n return result;\n}\n\nfunction parseArgumentInternal(\n s: string[],\n n: number,\n inCheck = false\n): Dice | number | undefined {\n if (s.length === 0) return;\n\n const c = s[0];\n\n switch (c) {\n case \"(\":\n s.shift();\n return assertToken(s, \")\", parseExpression(s, n, inCheck));\n\n case \"h\":\n case \"d\":\n return parseDice(s, n);\n\n case \"k\":\n assertToken(s, \"k\");\n return parseKeep(s, n, inCheck);\n\n case \"n\":\n return parseNumber(s, n);\n\n default:\n if (isDigit(c)) return parseNumber(s, n);\n return;\n }\n}\n\nfunction parseBinaryArgument(\n arg: Dice | number,\n arr: string[],\n n: number\n): Dice {\n if (arr.length >= 4 && arr[0] === \"h\" && peek(arr, \"half\")) {\n assertToken(arr, \"half\");\n\n const diceArg = typeof arg === \"number\" ? Dice.scalar(arg) : arg;\n return diceArg.divideRoundDown(2);\n }\n\n const parsed = parseArgument(arr, n);\n return typeof parsed === \"number\" ? Dice.scalar(parsed) : parsed;\n}\n\nfunction assertToken<T>(s: string[], expected: string, ret?: T): T | undefined {\n for (const ch of expected) {\n const found = s.shift();\n if (found !== ch) {\n throw new Error(`Expected character '${ch}', found '${found}'`);\n }\n }\n return ret;\n}\n\nfunction parseDice(s: string[], n: number): Dice | undefined {\n let rerollOne = false;\n\n if (peek(s, \"hd\") && peekIsNumber(s, 2)) {\n assertToken(s, \"h\");\n assertToken(s, \"d\");\n rerollOne = true;\n } else if (peek(s, \"d\") && peekIsNumber(s, 1)) {\n assertToken(s, \"d\");\n } else {\n return;\n }\n\n const sides = parseNumber(s, n);\n if (sides > MAX_DIE_SIDES) {\n throw new DiceParseError(\n `Die size ${sides} exceeds the maximum of ${MAX_DIE_SIDES}`\n );\n }\n let result = new Dice(sides);\n // A d0 has no faces: it is only a face set (`reroll d0` rerolls nothing), never a roll.\n if (sides === 0) return result;\n\n if (rerollOne) {\n // Reroll a rolled 1 exactly once, keeping the second roll (e.g. halfling\n // luck). This is the same semantics as the `reroll 1` operator; the previous\n // deleteFace(1).combine(result) computed a weighted union (P(1)=1/(2s−1)),\n // not a reroll (correct P(1)=1/s²).\n result = result.reroll(1);\n }\n\n result.privateData.critTrack = bareTrack(result);\n return result;\n}\n\nfunction peek(arr: string[], expected: string): boolean {\n if (expected.length > arr.length) return false;\n\n for (let i = 0; i < expected.length; i++) {\n if (arr[i] !== expected.charAt(i)) return false;\n }\n\n return true;\n}\n\nfunction peekIsNumber(arr: string[], index: number): boolean {\n if (index >= arr.length) return false;\n return isDigit(arr[index]) || arr[index] === \"n\";\n}\n\nfunction parseNumber(s: string[], n: number): number {\n let ret = \"\";\n\n while (s.length > 0 && (isDigit(s[0]) || s[0] === \"n\")) {\n const ch = s.shift()!;\n ret += ch === \"n\" ? n.toString() : ch;\n }\n\n if (ret.length === 0) {\n throw new Error(`Expected number, found: '${s[0]}'`);\n }\n\n return parseInt(ret, 10);\n}\n\nfunction isDigit(c: string): boolean {\n return c >= \"0\" && c <= \"9\";\n}\n\nfunction parseKeep(s: string[], n: number, inCheck: boolean): Dice | undefined {\n let lowest = false;\n\n if (peek(s, \"l\")) {\n assertToken(s, \"l\");\n lowest = true;\n } else if (peek(s, \"h\")) {\n assertToken(s, \"h\");\n } else {\n return;\n }\n\n const kept = parseNumber(s, n);\n const result = parseArgumentInternal(s, n, inCheck);\n\n if (result instanceof Dice) {\n result.privateData.keep = { kept, lowest };\n return result;\n }\n\n throw new Error(\"Expected Dice after keep modifier\");\n}\n\nfunction parseOperation(s: string[]): DiceOperation | undefined {\n switch (s[0]) {\n case \")\":\n return;\n\n case \"a\":\n assertToken(s, \"ac\");\n return Dice.prototype.ac;\n\n case \"d\":\n assertToken(s, \"dc\");\n return Dice.prototype.dc;\n\n case \"!\":\n assertToken(s, \"!\");\n const adv = Dice.prototype.advantage as DiceOperation;\n adv.unary = true;\n return adv;\n\n case \">\":\n assertToken(s, \">\");\n return Dice.prototype.max;\n\n case \"<\":\n assertToken(s, \"<\");\n return Dice.prototype.min;\n\n case \"+\":\n assertToken(s, \"+\");\n return Dice.prototype.addNonZero;\n\n case \"~\":\n assertToken(s, \"~\");\n assertToken(s, \"+\");\n return Dice.prototype.add;\n\n case \"-\":\n assertToken(s, \"-\");\n return Dice.prototype.subtract;\n\n case \"&\":\n assertToken(s, \"&\");\n return Dice.prototype.combine;\n\n case \"r\":\n assertToken(s, \"reroll\");\n return Dice.prototype.reroll;\n\n case \"*\":\n assertToken(s, \"*\");\n\n if (peek(s, \"*\")) {\n assertToken(s, \"*\");\n return Dice.prototype.multiply;\n }\n\n return Dice.prototype.conditionalApply;\n\n case \"/\":\n assertToken(s, \"/\");\n if (s[0] === \"/\") {\n assertToken(s, \"/\");\n return Dice.prototype.divideRoundDown;\n }\n return Dice.prototype.divideRoundUp;\n\n case \"=\":\n assertToken(s, \"=\");\n return Dice.prototype.eq;\n }\n\n return;\n}\n","import type { RollType } from \"../common/types\";\nimport { PMF } from \"../pmf/pmf\";\nimport { parse } from \"./parser\";\n\n/** A bare decimal integer, optionally signed, with surrounding whitespace. */\nconst DECIMAL_INTEGER = /^\\s*[+-]?\\d+\\s*$/;\n\n/**\n * Parse without throwing — for UI code that reparses on every keystroke, where\n * a transiently invalid expression is normal rather than exceptional.\n *\n * Also accepts `+` before an integer, which the grammar has no use for: `\"+7\"`\n * becomes a delta at 7. Integers are read here rather than by the grammar\n * (which reads `\"-3\"` as a unary minus) so a huge one is refused instead of\n * rounded; a half-typed damage field is a bare signed number often enough.\n *\n * The failure value is {@link PMF.empty}, which has **mass 0**, not a\n * distribution. Convolving it collapses the whole result to mass 0, so a caller\n * combining several expressions should check `mass()` (or skip empties) rather\n * than assume a usable PMF. Anywhere a bad expression should be surfaced instead\n * of absorbed, call {@link parse} and handle `DiceParseError`.\n *\n * Takes no second argument on purpose. {@link parse}'s is `n`, the substitution\n * value for an `n`-dice expression — not an epsilon — so forwarding one here\n * would silently reinterpret it: `tryParse(\"nd6\", 1e-9)` rolled `1d6` and\n * reported 3.5 where the default `n` of 0 means no dice at all.\n *\n * @returns the parsed PMF, or an empty (mass 0) PMF for input that is neither a\n * valid expression nor an integer.\n */\nexport function tryParse(expression: string): PMF {\n // Checked before `parse`, not only in the fallback: `parse` accepts unsigned\n // integers itself and converts them with the same precision loss, so\n // `parse(\"9007199254740993\")` would hand back a delta at …992.\n if (DECIMAL_INTEGER.test(expression)) {\n const value = Number(expression);\n return Number.isSafeInteger(value) ? PMF.delta(value) : PMF.empty();\n }\n\n try {\n return parse(expression);\n } catch {\n return PMF.empty();\n }\n}\n\n/** The token naming a check: `AC` for an attack roll, `DC` for a saving throw. */\nconst CHECK_TOKEN = /\\b(AC|DC)\\b/i;\n\n/** The d20 run at the head of a check: `d20`, `hd20 > d20`, `d20 < d20`, … */\nconst D20_RUN = /\\bh?d20(?:\\s*[><]\\s*h?d20)*/i;\n\nconst RUN_FOR_ROLL_TYPE: Record<RollType, string> = {\n flat: \"d20\",\n advantage: \"d20 > d20\",\n disadvantage: \"d20 < d20\",\n \"elven accuracy\": \"d20 > d20 > d20\",\n};\n\n/**\n * Rewrite an expression's attack roll to a different d20 {@link RollType},\n * leaving everything else — damage, crit clause, miss clause, bonuses —\n * untouched.\n *\n * ```ts\n * withRollType(\"(d20 + 8 AC 16) * (1d4 + 4)\", \"advantage\");\n * // \"(d20 > d20 + 8 AC 16) * (1d4 + 4)\"\n * ```\n *\n * **Every** `AC` group is rewritten, because one expression can hold several\n * attacks (`(d20 + 8 AC 16) * (1d8) + (d20 + 5 AC 16) * (1d6)`) and leaving the\n * later ones flat would quietly chart the wrong curve.\n *\n * A `DC` group is the *target's* saving throw, which the attacker's advantage\n * does not touch, so save expressions come back unchanged — as does anything\n * with no attack roll at all. This makes the function safe to map over a mixed\n * list of expressions.\n *\n * Assumes **one check per group**, which is what every well-formed attack or\n * save expression looks like and what `modelToExpression` emits. The grammar\n * will swallow a group naming two — `(d20 + 5 DC 16 + d20 + 8 AC 16)` parses,\n * as a single `AC` check whose roll happens to contain the save's 0/1 result —\n * but that is not an expression anyone means, and the roll type it should get is\n * undefined. Such input is rewritten on a best-effort basis rather than\n * diagnosed.\n *\n * A halfling-luck `h` prefix is preserved on the first die of each run, since it\n * describes the same roll.\n */\nexport function withRollType(expression: string, rollType: RollType): string {\n const scopes = enclosingScopes(expression);\n let rewritten = \"\";\n let copiedUpTo = 0;\n\n for (const run of expression.matchAll(new RegExp(D20_RUN, \"gi\"))) {\n const at = run.index as number;\n if (!isAttackRoll(expression, scopes, at)) continue;\n\n const replacement = run[0].toLowerCase().startsWith(\"h\")\n ? `h${RUN_FOR_ROLL_TYPE[rollType]}`\n : RUN_FOR_ROLL_TYPE[rollType];\n\n rewritten += expression.slice(copiedUpTo, at) + replacement;\n copiedUpTo = at + run[0].length;\n }\n\n return rewritten + expression.slice(copiedUpTo);\n}\n\n/**\n * Balanced parenthesised ranges, innermost first, so a run's enclosing scopes\n * can be walked outwards. Unbalanced input simply yields fewer scopes; the\n * parser is what rejects it.\n */\nfunction enclosingScopes(\n expression: string\n): readonly { start: number; end: number }[] {\n const open: number[] = [];\n const scopes: { start: number; end: number }[] = [];\n\n for (let i = 0; i < expression.length; i++) {\n if (expression[i] === \"(\") open.push(i);\n else if (expression[i] === \")\") {\n const start = open.pop();\n if (start !== undefined) scopes.push({ start, end: i + 1 });\n }\n }\n\n // Closing order is innermost-first already; sorting by width keeps that true\n // for sibling groups too.\n return scopes.sort((a, b) => a.end - a.start - (b.end - b.start));\n}\n\n/**\n * Whether the d20 run at `at` is the attack roll of a check.\n *\n * Classified by the nearest enclosing group that names a check, widening\n * outwards, which is what makes nesting work: in `((d20 + 8) AC 16)` the run's\n * own group names nothing and the group outside it says `AC`.\n *\n * A run whose groups name no check is not an attack roll — the second run in\n * `(d20 + 8 AC 16) * (d20)` is damage — and an unparenthesised run is judged by\n * the whole expression, since there is nothing narrower to go on.\n */\nfunction isAttackRoll(\n expression: string,\n scopes: readonly { start: number; end: number }[],\n at: number\n): boolean {\n let scoped = false;\n\n for (const scope of scopes) {\n if (at < scope.start || at >= scope.end) continue;\n scoped = true;\n const check = CHECK_TOKEN.exec(expression.slice(scope.start, scope.end));\n if (check) return check[1].toUpperCase() === \"AC\";\n }\n\n if (scoped) return false;\n\n const check = CHECK_TOKEN.exec(expression);\n return check !== null && check[1].toUpperCase() === \"AC\";\n}\n","import type { Bin } from \"../common/types\";\nimport { EPS } from \"../common/types\";\nimport { PMF } from \"./pmf\";\n\n/**\n * A labeled mixture builder that preserves provenance in Bin.count.\n *\n * `eps` prunes relative to the normalized mass: an outcome whose share of the total is below\n * `eps` is dropped when the PMF is built, and the survivors are renormalized. `eps = 0` keeps\n * every outcome with positive mass.\n */\nexport class Mixture<L extends string = string> {\n private readonly totals = new Map<number, number>(); // raw mass per outcome (pre-normalization)\n private readonly labelMass = new Map<number, Record<L, number>>(); // raw mass per outcome per label\n private readonly eps: number;\n\n constructor(eps: number = EPS) {\n this.eps = Number.isFinite(eps) ? eps : EPS;\n }\n\n /** Remove all accumulated state. */\n clear(): this {\n this.totals.clear();\n this.labelMass.clear();\n return this;\n }\n\n /** Number of distinct outcome values currently accumulated. */\n size(): number {\n return this.totals.size;\n }\n\n /** Whether a label was ever added. */\n hasLabel(label: L): boolean {\n for (const bag of this.labelMass.values()) if (bag[label]) return true;\n return false;\n }\n\n /**\n * Add a labeled component with a mixture weight.\n * Weight can be any positive finite number; only the ratios between weights matter.\n */\n add(label: L, pmf: PMF, weight = 1): this {\n if (!Number.isFinite(weight) || weight <= 0) return this;\n\n // Stream probabilities from each [value, Bin] pair.\n for (const [v, bin] of pmf) {\n const p = bin.p;\n if (p <= 0) continue;\n\n const add = weight * p;\n if (!Number.isFinite(add) || add <= 0) continue;\n\n this.totals.set(v, (this.totals.get(v) ?? 0) + add);\n const bag = this.labelMass.get(v) ?? ({} as Record<L, number>);\n bag[label] = (bag[label] ?? 0) + add;\n this.labelMass.set(v, bag);\n }\n\n return this;\n }\n\n /**\n * The normalized mixture. Each bin's `p` and per-label `count` are its raw mass divided by\n * the grand total, so labels sum to `p` whatever the weights summed to. Outcomes below\n * `eps` of the total (the pruning `eps` given to the constructor) are dropped first.\n *\n * @param eps Epsilon carried by the built PMF.\n */\n buildPMF(eps: number = EPS): PMF {\n const grand = kahanSum(this.totals.values());\n if (!(grand > 0)) throw new Error(\"Mixture: zero total mass\");\n\n const threshold = this.eps * grand;\n const kept = [...this.totals].filter(([, m]) => m > 0 && m >= threshold);\n if (kept.length === 0) {\n throw new Error(`Mixture: pruning at eps ${this.eps} removed every outcome`);\n }\n const keptTotal =\n kept.length === this.totals.size ? grand : kahanSum(kept.map(([, m]) => m));\n\n const internal = new Map<number, Bin>();\n for (const [v, m] of kept) {\n const count: Record<string, number> = {};\n const bag = this.labelMass.get(v) ?? ({} as Record<L, number>);\n for (const label in bag) count[label] = bag[label] / keptTotal;\n internal.set(v, { p: m / keptTotal, count });\n }\n return new PMF(internal, eps);\n }\n\n /**\n * Produce normalized *per-label* PMFs (labels independent).\n * These are unlabeled PMFs built from the raw mass of that label alone; values below `eps`\n * of the label's own mass are pruned.\n */\n byOutcome(): Record<L, PMF> {\n // Collect the set of labels present.\n const labels = new Set<L>();\n for (const bag of this.labelMass.values()) {\n for (const k of Object.keys(bag) as L[]) labels.add(k);\n }\n\n const out = {} as Record<L, PMF>;\n for (const label of labels) {\n const labelTotal = kahanSum(\n [...this.labelMass.values()].map((bag) => bag[label] ?? 0)\n );\n if (!(labelTotal > 0)) continue;\n const m = new Map<number, number>();\n for (const [v, bag] of this.labelMass) {\n const w = bag[label];\n if (w) m.set(v, w / labelTotal);\n }\n out[label] = PMF.fromMap(m, this.eps);\n }\n return out;\n }\n\n /**\n * Mixture weights per label, normalized to sum to 1 over labels that appeared.\n * Uses raw mass before per-outcome normalization.\n */\n weights(): Record<L, number> {\n const res = {} as Record<L, number>;\n for (const [, bag] of this.labelMass) {\n for (const [lab, w] of Object.entries(bag) as [L, number][]) {\n if (!Number.isFinite(w) || w <= 0) continue;\n res[lab] = (res[lab] ?? 0) + w;\n }\n }\n const total = kahanSum(Object.values(res) as number[]);\n if (total > 0) {\n for (const k in res) res[k as L] = res[k as L] / total;\n }\n return res;\n }\n\n toJSON(): {\n totals: Array<[number, number]>;\n labels: Array<[number, Record<L, number>]>;\n eps: number;\n } {\n return {\n totals: Array.from(this.totals.entries()).sort((a, b) => a[0] - b[0]),\n labels: Array.from(this.labelMass.entries()).sort((a, b) => a[0] - b[0]),\n eps: this.eps,\n };\n }\n\n static mix<L extends string = string>(\n items: Array<[label: L, pmf: PMF, weight: number]>,\n eps: number = EPS\n ): PMF {\n const mix = new Mixture<L>(eps);\n for (const [lab, pmf, w] of items) mix.add(lab, pmf, w);\n return mix.buildPMF(eps);\n }\n}\n\n/** Compensated (Kahan) sum. */\nfunction kahanSum(values: Iterable<number>): number {\n let sum = 0;\n let c = 0;\n for (const v of values) {\n const y = v - c;\n const t = sum + y;\n c = t - sum - y;\n sum = t;\n }\n return sum;\n}\n"]}