roll-parser 3.0.0-alpha.0 → 3.0.0

package/dist/types.d.ts

@@ -3,29 +3,105 @@
  *
  * @module types
  */
-import type { ASTNode } from './parser/ast';
+import type { ASTNode } from './parser/ast.js';
 /**
- * Comparison operator for compare points.
+ * Comparison operator for compare points. Spelled exactly as it appears in
+ * notation — `4d6!>=5` carries `'>='`, bare `f1` normalizes to `'='`.
+ *
+ * @category AST
  */
 export type CompareOp = '>' | '>=' | '<' | '<=' | '=';
 /**
- * A comparison threshold used by exploding dice, reroll, and success counting.
+ * A comparison threshold used by exploding dice, reroll, success counting, and
+ * crit-threshold overrides.
+ *
+ * The value is an {@link ASTNode} to support computed thresholds
+ * (`1d6!>(1d2+3)`), matching the pattern used by `DiceNode.count` and
+ * `DiceNode.sides`. The evaluated counterpart is {@link ResolvedComparePoint}.
  *
- * The value is an ASTNode to support computed thresholds (e.g., `>=ceil(5)`),
- * matching the pattern used by DiceNode.count and DiceNode.sides.
+ * @category AST
  */
 export type ComparePoint = {
-    operator: CompareOp;
-    value: ASTNode;
+    readonly operator: CompareOp;
+    readonly value: ASTNode;
+};
+/**
+ * A {@link ComparePoint} whose value has been evaluated to a number. Used
+ * throughout {@link RollPart}, where meta-expressions are already resolved —
+ * `1d6!>(1d2+3)` surfaces as `{ operator: '>', value: 5 }`.
+ *
+ * @category Results
+ */
+export type ResolvedComparePoint = {
+    readonly operator: CompareOp;
+    readonly value: number;
 };
 /**
- * Modifier flags applied to individual die results.
+ * A resolved crit threshold — `'default'` means the per-die default rule
+ * (`result === sides` for critical, `result === 1` for fumble), which is what
+ * bare `cs` / `cf` produce.
+ *
+ * @category Results
+ */
+export type ResolvedCritThreshold = ResolvedComparePoint | 'default';
+/**
+ * Tags attached to a {@link DieResult} by the evaluator. A die can carry more
+ * than one (an exploded die that was later dropped is `['dropped',
+ * 'exploded']`), and the set drives the markers in `RollResult.rendered`.
+ *
+ * | Tag | Meaning | Rendered as |
+ * |-----|---------|-------------|
+ * | `'kept'` | Counted toward the total. Every non-dropped die carries it. | plain |
+ * | `'dropped'` | Excluded from the total by `kh`/`kl`/`dh`/`dl` or group selection. | `~~n~~` |
+ * | `'exploded'` | Produced by, or the trigger of, an explosion (`!`, `!!`, `!p`). | plain |
+ * | `'rerolled'` | A discarded intermediate from `r` / `ro`, always paired with `'dropped'` — the replacement die carries no tag. | `~~n~~` (via `'dropped'`) |
+ * | `'min'` | Raised to a `minN` bound; `initialResult` keeps the raw face. | plain |
+ * | `'max'` | Lowered to a `maxN` bound; `initialResult` keeps the raw face. | plain |
+ * | `'success'` | Met a success-count threshold (`>=6`). | `**n**` |
+ * | `'failure'` | Met a failure threshold (`f1`). | `__n__` |
+ * | `'meta'` | Rolled by a meta-expression rather than by the visible pool. | not shown |
+ * | `'dc'` | The DC side of a `vs` comparison. Never part of the roll-side pool. | plain |
+ *
+ * `'meta'` is the one tag with no counterpart in the notation. Dice counts,
+ * sides, modifier counts and computed thresholds may themselves be dice
+ * (`(1d4)d6`, `4d6kh(1d2)`, `1d6!>(1d2+3)`). Those inner dice are not part of
+ * any pool, so they never appear in a {@link RollPart}; they are appended to
+ * `RollResult.rolls` tagged `'meta'` so an audit log can still show what the
+ * meta-expression rolled. Filter them out when summing or displaying a pool.
+ *
+ * `'dc'` marks the DC side of a `vs` comparison. Unlike `'meta'` these dice do
+ * render — `1d20[3] vs 2d10[5, 6]` shows both sides — but they are not part of
+ * the roll-side pool, so no modifier may sum, select, clamp, reroll, explode,
+ * or tally them. Filter them out when summing a pool, exactly as with `'meta'`.
+ *
+ * @category Results
  */
-export type DieModifier = 'dropped' | 'kept' | 'exploded' | 'rerolled' | 'success' | 'failure';
+export type DieModifier = 'dropped' | 'kept' | 'exploded' | 'rerolled' | 'min' | 'max' | 'success' | 'failure' | 'meta' | 'dc';
 /**
  * PF2e Degree of Success. Produced by the `vs` operator when comparing a
  * roll against a Difficulty Class. Ordering is significant — natural 20
  * upgrades one step and natural 1 downgrades one step.
+ *
+ * Numeric by design: the enum members are plain numbers, so `--json` CLI
+ * output and `JSON.stringify` emit `0`–`3` and comparisons like
+ * `degree >= DegreeOfSuccess.Success` work.
+ *
+ * @example
+ * ```typescript
+ * import { DegreeOfSuccess, roll } from 'roll-parser';
+ * import { createMockRng } from 'roll-parser/testing';
+ *
+ * const result = roll('1d20+7 vs 15', { rng: createMockRng([12]) });
+ * result.degree; // DegreeOfSuccess.Success (2)
+ * result.natural; // 12 — the raw d20 face, used for the ±1 step
+ * result.rendered; // '1d20[12] + 7 vs 15 = Success'
+ *
+ * if (result.degree != null && result.degree >= DegreeOfSuccess.Success) {
+ *   // hit
+ * }
+ * ```
+ *
+ * @category Results
  */
 export declare enum DegreeOfSuccess {
     CriticalFailure = 0,
@@ -34,7 +110,25 @@ export declare enum DegreeOfSuccess {
     CriticalSuccess = 3
 }
 /**
- * Individual die roll result with metadata.
+ * One physical die and everything the evaluator learned about it.
+ *
+ * The same object is shared between `RollResult.rolls` and the `rolls[]` of
+ * the {@link RollPart} that produced it — there is no deep clone, so mutating
+ * a die is visible through both views.
+ *
+ * @example
+ * ```typescript
+ * import { roll } from 'roll-parser';
+ * import { createMockRng } from 'roll-parser/testing';
+ *
+ * const result = roll('4d6kh3', { rng: createMockRng([3, 6, 2, 5]) });
+ * result.rolls[1];
+ * // { sides: 6, result: 6, modifiers: ['kept'], critical: true, fumble: false }
+ * result.rolls[2];
+ * // { sides: 6, result: 2, modifiers: ['dropped'], critical: false, fumble: false }
+ * ```
+ *
+ * @category Results
  */
 export type DieResult = {
     /**
@@ -45,6 +139,13 @@ export type DieResult = {
     sides: number;
     /** The rolled value */
     result: number;
+    /**
+     * Raw first roll before any mutation (e.g., compound-explode accumulation).
+     * Only populated when `result` has been overwritten with a computed value.
+     * Consumers that need the original face (nat-20 / nat-1 detection) should
+     * read `initialResult ?? result`.
+     */
+    initialResult?: number;
     /** Modifiers applied to this die */
     modifiers: DieModifier[];
     /** True if rolled the maximum value (always false for Fate dice) */
@@ -53,9 +154,242 @@ export type DieResult = {
     fumble: boolean;
 };
 /**
- * Complete roll result with all metadata.
+ * One entry inside a flattened keep/drop chain. Counts are resolved at
+ * evaluation time (meta-expressions like `kh(1d2)` become the rolled number).
+ *
+ * Chained keep/drop modifiers flatten into one list — `4d6kh3dl1` yields two
+ * specs against a single pool, each applied independently, with drop sets
+ * unioned (Roll20 semantics).
+ *
+ * @category Results
+ */
+export type KeepDropSpec = {
+    readonly kind: 'keep' | 'drop';
+    readonly selector: 'highest' | 'lowest';
+    readonly count: number;
+};
+/**
+ * Fields shared by every {@link RollPart} variant. `start`/`end` mirror the
+ * source span of the AST node the part was evaluated from — present whenever
+ * the AST came from `parse()`, absent on hand-built ASTs.
+ *
+ * Useful for code that walks the parts tree generically: any part can be
+ * narrowed to this shape without switching on `type` first.
+ *
+ * @category Results
+ */
+export type RollPartBase = {
+    /** Sub-total this part contributed to its parent. */
+    total: number;
+    start?: number;
+    end?: number;
+};
+/**
+ * Structured breakdown of an evaluated expression, mirroring the AST 1:1 —
+ * every ASTNode produces exactly one RollPart. Discriminants are lowercase
+ * camelCase to distinguish evaluation-tree types from `ASTNode.type`
+ * (PascalCase) at a glance.
+ *
+ * Invariants:
+ * - `RollResult.parts.total === RollResult.total`.
+ * - `successCount.total === successes - failures`.
+ * - `literal.total === value` and `variable.total === value`.
+ * - Each part's `rolls[]` shares `DieResult` references with
+ *   `RollResult.rolls[]`; both reflect post-evaluation state (explode
+ *   accumulation, reroll flags, keep/drop flags). No deep clone.
+ *
+ * Meta-expression sub-trees (`4d6kh(1d2)`, `(1+1)d6` counts/sides, computed
+ * thresholds) are not surfaced as nested parts — their resolved numbers
+ * appear in the owning part, and their dice are inspectable in
+ * `RollResult.rolls` via the `'meta'` modifier tag.
+ *
+ * @example Walking the tree with an exhaustive switch
+ * ```typescript
+ * import type { RollPart } from 'roll-parser';
+ *
+ * function describe(part: RollPart): string {
+ *   switch (part.type) {
+ *     case 'literal':
+ *       return String(part.value);
+ *     case 'variable':
+ *       return `@${part.name}`;
+ *     case 'dice':
+ *       return `${part.count}d${part.sides}[${part.rolls.map((d) => d.result).join(', ')}]`;
+ *     case 'fateDice':
+ *       return `${part.count}dF`;
+ *     case 'grouped':
+ *       return `(${describe(part.inner)})`;
+ *     case 'binaryOp':
+ *       return `${describe(part.left)} ${part.operator} ${describe(part.right)}`;
+ *     case 'unaryOp':
+ *       return `-${describe(part.operand)}`;
+ *     case 'keepDrop':
+ *       return `${describe(part.target)} [${part.specs.length} keep/drop]`;
+ *     case 'explode':
+ *       return `${describe(part.target)} (${part.variant} explode)`;
+ *     case 'reroll':
+ *       return `${describe(part.target)} (reroll${part.once ? ' once' : ''})`;
+ *     case 'dieBound':
+ *       return `${describe(part.target)} (${part.bound} ${part.value})`;
+ *     case 'successCount':
+ *       return `${describe(part.target)} => ${part.successes}-${part.failures}`;
+ *     case 'versus':
+ *       return `${describe(part.roll)} vs ${describe(part.dc)}`;
+ *     case 'functionCall':
+ *       return `${part.name}(${part.args.map(describe).join(', ')})`;
+ *     case 'group':
+ *       return `{${part.parts.map(describe).join(', ')}}`;
+ *     case 'sort':
+ *       return `${describe(part.target)} (${part.order})`;
+ *     case 'critThreshold':
+ *       return `${describe(part.target)} (crit override)`;
+ *   }
+ * }
+ * ```
+ *
+ * @example Reading a concrete tree
+ * ```typescript
+ * import { roll } from 'roll-parser';
+ * import { createMockRng } from 'roll-parser/testing';
+ *
+ * const result = roll('4d6kh3 + 2', { rng: createMockRng([3, 6, 2, 5]) });
+ * result.parts.type; // 'binaryOp'
+ * result.parts.total; // 16 — always equal to result.total
+ * describe(result.parts); // '4d6[3, 6, 2, 5] [1 keep/drop] + 2'
+ * ```
+ *
+ * @category Results
+ */
+export type RollPart = (RollPartBase & {
+    type: 'literal';
+    value: number;
+}) | (RollPartBase & {
+    type: 'variable';
+    name: string;
+    value: number;
+}) | (RollPartBase & {
+    type: 'dice';
+    count: number;
+    sides: number;
+    rolls: DieResult[];
+}) | (RollPartBase & {
+    type: 'fateDice';
+    count: number;
+    rolls: DieResult[];
+}) | (RollPartBase & {
+    type: 'grouped';
+    inner: RollPart;
+}) | (RollPartBase & {
+    type: 'binaryOp';
+    operator: '+' | '-' | '*' | '/' | '%' | '**';
+    left: RollPart;
+    right: RollPart;
+}) | (RollPartBase & {
+    type: 'unaryOp';
+    operator: '-';
+    operand: RollPart;
+}) | (RollPartBase & {
+    type: 'keepDrop';
+    specs: KeepDropSpec[];
+    target: RollPart;
+}) | (RollPartBase & {
+    type: 'explode';
+    variant: 'standard' | 'compound' | 'penetrating';
+    threshold?: ResolvedComparePoint;
+    target: RollPart;
+}) | (RollPartBase & {
+    type: 'reroll';
+    once: boolean;
+    condition: ResolvedComparePoint;
+    target: RollPart;
+}) | (RollPartBase & {
+    type: 'dieBound';
+    bound: 'min' | 'max';
+    value: number;
+    target: RollPart;
+}) | (RollPartBase & {
+    type: 'successCount';
+    threshold: ResolvedComparePoint;
+    failThreshold?: ResolvedComparePoint;
+    target: RollPart;
+    successes: number;
+    failures: number;
+}) | (RollPartBase & {
+    type: 'versus';
+    roll: RollPart;
+    dc: RollPart;
+    degree: DegreeOfSuccess;
+}) | (RollPartBase & {
+    type: 'functionCall';
+    name: string;
+    args: RollPart[];
+}) | (RollPartBase & {
+    type: 'group';
+    parts: RollPart[];
+    keptIndices?: number[];
+}) | (RollPartBase & {
+    type: 'sort';
+    order: 'ascending' | 'descending';
+    /**
+     * Every die the target produced, in sorted order, sharing `DieResult`
+     * references with `target` — so flags set after the sort (`4d6s dl1`)
+     * show through both. Like `RollResult.rolls` it keeps `'meta'` dice,
+     * which `rendered` omits from the bracket.
+     */
+    rolls: DieResult[];
+    target: RollPart;
+}) | (RollPartBase & {
+    type: 'critThreshold';
+    successThresholds: ResolvedCritThreshold[];
+    failThresholds: ResolvedCritThreshold[];
+    target: RollPart;
+});
+/**
+ * The 17 discriminant strings of {@link RollPart}. Convenience alias for
+ * consumers writing exhaustive switches or part-type lookup tables.
+ *
+ * @category Results
+ */
+export type RollPartType = RollPart['type'];
+/**
+ * Complete roll result with all metadata — what {@link roll} and
+ * {@link evaluate} return.
+ *
+ * The top level is `Readonly` — a result describes one completed evaluation
+ * and is never re-targeted. The `rolls` array and the `parts` tree stay
+ * mutable so consumers can annotate or re-sort their own views.
+ *
+ * Fully JSON-serializable; this is exactly what the CLI's `--json` flag emits.
+ *
+ * @example
+ * ```typescript
+ * import { roll } from 'roll-parser';
+ * import { createMockRng } from 'roll-parser/testing';
+ *
+ * const result = roll('3d6', { rng: createMockRng([4, 2, 6]) });
+ *
+ * JSON.stringify(result);
+ * // {
+ * //   "total": 12,
+ * //   "notation": "3d6",
+ * //   "expression": "3d6",
+ * //   "rendered": "3d6[4, 2, 6] = 12",
+ * //   "rolls": [
+ * //     { "sides": 6, "result": 4, "modifiers": ["kept"], "critical": false, "fumble": false },
+ * //     { "sides": 6, "result": 2, "modifiers": ["kept"], "critical": false, "fumble": false },
+ * //     { "sides": 6, "result": 6, "modifiers": ["kept"], "critical": true,  "fumble": false }
+ * //   ],
+ * //   "parts": {
+ * //     "type": "dice", "count": 3, "sides": 6,
+ * //     "rolls": [ ...the same three objects... ],
+ * //     "total": 12, "start": 0, "end": 3
+ * //   }
+ * // }
+ * ```
+ *
+ * @category Results
  */
-export type RollResult = {
+export type RollResult = Readonly<{
     /** Final computed total */
     total: number;
     /** Original input notation */
@@ -64,18 +398,28 @@ export type RollResult = {
     expression: string;
     /** Rendered result with individual rolls shown */
     rendered: string;
-    /** All individual die results */
+    /**
+     * All individual die results, in evaluation order.
+     *
+     * Shares `DieResult` object references with the `rolls[]` arrays inside
+     * `parts` — no deep clone. Mutating a die here is visible through the part
+     * tree and vice versa; clone first if that matters.
+     */
     rolls: DieResult[];
+    /** Structured breakdown of the evaluated expression, mirroring the AST 1:1. */
+    parts: RollPart;
     /**
      * Number of dice tagged as success across the whole expression. Present
      * only when a success-counting modifier was used. Independent of `total` —
-     * arithmetic on top of a success count (e.g. `5d6>=5 * 2`) affects `total`
-     * but not `successes`.
+     * arithmetic on top of a success count (e.g. `{5d6>=5}+2`) affects `total`
+     * but not `successes`. Success counts are terminal, so the group braces are
+     * required: `5d6>=5 * 2` is an `INVALID_SUCCESS_COUNT_TARGET` parse error.
      */
     successes?: number;
     /**
      * Number of dice tagged as failure across the whole expression. Present
-     * only when a success-counting modifier with a fail threshold was used.
+     * whenever a success-counting modifier was used — `0` when no failure
+     * threshold was given, since nothing can be tagged as a failure.
      */
     failures?: number;
     /**
@@ -88,18 +432,77 @@ export type RollResult = {
      * exactly one kept d20 was rolled on the roll side of a `vs` expression.
      */
     natural?: number;
-};
+}>;
 /**
- * Options for the evaluate function.
+ * Evaluation guardrails and variable resolution, shared by `EvaluateOptions`
+ * and `RollOptions`. Every field is optional — the defaults bound adversarial
+ * notation without capping any realistic expression.
+ *
+ * Tighten them when the notation comes from users you do not control; the
+ * caps are the difference between a typed `EvaluatorError` and a request that
+ * rolls ten million dice. Parse depth is capped separately and
+ * unconditionally by {@link MAX_PARSE_DEPTH}.
+ *
+ * The three numeric limits fail closed: omit one — or pass `undefined` or
+ * `null`, the no-options path a partial config produces — and it takes its
+ * default, but supply anything else that is not a safe integer in range — a
+ * string, `NaN`, `±Infinity`, a negative, a fraction — and evaluation throws
+ * `INVALID_EVALUATION_LIMIT` before rolling. `maxDice` accepts `>= 1`, the two
+ * iteration limits `>= 0`. No coercion: `maxDice: Number(input)` on
+ * unparseable input rejects rather than quietly reverting to the permissive
+ * default.
+ *
+ * @example Untrusted input
+ * ```typescript
+ * import { isRollParserError, roll } from 'roll-parser';
+ *
+ * const limits = {
+ *   maxDice: 100,
+ *   maxExplodeIterations: 20,
+ *   maxRerollIterations: 20,
+ * };
+ *
+ * try {
+ *   roll('99999d6', limits).total;
+ * } catch (error) {
+ *   isRollParserError(error) && error.code; // 'DICE_LIMIT_EXCEEDED'
+ * }
+ * ```
+ *
+ * @example Variables
+ * ```typescript
+ * import { roll } from 'roll-parser';
+ *
+ * roll('1d20+@str', { context: { str: 4 }, seed: 'demo' }).total; // 5
+ * roll('1d20+@str', { onMissingVariable: 'zero', seed: 'demo' }).total; // 1
+ * ```
+ *
+ * @category Core
  */
-export type EvaluateOptions = {
-    /** Original notation string (for result metadata) */
-    notation?: string;
-    /** Maximum total dice allowed per evaluation (default: 10,000) */
+export type EvaluationOptions = {
+    /** Maximum total dice allowed per evaluation; integer >= 1 (default: 10,000) */
     maxDice?: number;
-    /** Maximum explosion iterations allowed per die (default: 1,000) */
+    /** Maximum explosion iterations allowed per die; integer >= 0 (default: 1,000) */
     maxExplodeIterations?: number;
-    /** Maximum reroll iterations allowed per die (default: 1,000) */
+    /** Maximum reroll iterations allowed per die; integer >= 0 (default: 1,000) */
     maxRerollIterations?: number;
+    /** Variable context for `@name` / `@{name}` references (default: empty) */
+    context?: Readonly<Record<string, number>>;
+    /** Behavior when a referenced variable is missing from context (default: 'throw') */
+    onMissingVariable?: 'throw' | 'zero';
+};
+/**
+ * Options for {@link evaluate}: the shared {@link EvaluationOptions} plus the
+ * original notation, which `evaluate` cannot recover from an AST.
+ *
+ * @category Core
+ */
+export type EvaluateOptions = EvaluationOptions & {
+    /**
+     * Original notation string, echoed back as `RollResult.notation`. When
+     * omitted, falls back to the normalized `expression` reconstructed from the
+     * AST — {@link roll} always forwards the string the caller typed.
+     */
+    notation?: string;
 };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;AAE/F;;;;GAIG;AACH,oBAAY,eAAe;IACzB,eAAe,IAAI;IACnB,OAAO,IAAI;IACX,OAAO,IAAI;IACX,eAAe,IAAI;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,SAAS,EAAE,WAAW,EAAE,CAAC;IACzB,oEAAoE;IACpE,QAAQ,EAAE,OAAO,CAAC;IAClB,oDAAoD;IACpD,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,4BAA4B;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,kDAAkD;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,iCAAiC;IACjC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oEAAoE;IACpE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,8 @@
+export var DegreeOfSuccess;
+(function (DegreeOfSuccess) {
+    DegreeOfSuccess[DegreeOfSuccess["CriticalFailure"] = 0] = "CriticalFailure";
+    DegreeOfSuccess[DegreeOfSuccess["Failure"] = 1] = "Failure";
+    DegreeOfSuccess[DegreeOfSuccess["Success"] = 2] = "Success";
+    DegreeOfSuccess[DegreeOfSuccess["CriticalSuccess"] = 3] = "CriticalSuccess";
+})(DegreeOfSuccess || (DegreeOfSuccess = {}));
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AA0HA,MAAM,CAAN,IAAY,eAKX;AALD,WAAY,eAAe;IACzB,2EAAmB,CAAA;IACnB,2DAAW,CAAA;IACX,2DAAW,CAAA;IACX,2EAAmB,CAAA;AACrB,CAAC,EALW,eAAe,KAAf,eAAe,QAK1B"}

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "3.0.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/dist/version.js

@@ -0,0 +1,2 @@
+export const version = '3.0.0';
+//# sourceMappingURL=version.js.map

package/dist/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../src/version.ts"],"names":[],"mappings":"AACA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC"}