@platonic-dice/core 2.0.0

package/README.md

@@ -0,0 +1,57 @@
+# @platonic-dice/core
+
+Core JavaScript/TypeScript library providing dice-roll logic, modifiers, and test evaluation for tabletop RPGs.
+
+This package contains the pure logic used by higher-level packages (for example `@platonic-dice/dice`). It exports rolling helpers, entities (die types, roll types, outcomes), and utility functions.
+
+## Installation
+
+Install from npm:
+
+```bash
+npm install @platonic-dice/core
+```
+
+## Quick usage
+
+CommonJS:
+
+```js
+const { roll, rollDice, DieType, RollType } = require('@platonic-dice/core');
+
+console.log( roll(DieType.D20) );
+console.log( rollDice(DieType.D6, { count: 3 }) );
+```
+
+ESM / TypeScript:
+
+```ts
+import { roll, DieType } from '@platonic-dice/core';
+console.log( roll(DieType.D20) );
+```
+
+## Build & Test
+
+This package's sources live under `src/`. To run tests or build from the monorepo root:
+
+```bash
+# from repo root
+npm run build
+npm test
+```
+
+Or run package-local scripts:
+
+```bash
+cd packages/core
+# run unit tests
+npm test
+```
+
+## Contributing
+
+See the repository root `README.md` for contribution guidelines. Keep changes backwards-compatible where possible and include tests.
+
+## License
+
+MIT — see the repository `LICENSE` file.

package/dist/entities/DieType.d.ts

@@ -0,0 +1,35 @@
+export type DieTypeKey = keyof typeof DieType;
+export type DieTypeValue = (typeof DieType)[keyof typeof DieType];
+/**
+ * *
+ */
+export type DieType = string;
+/**
+ * @module @platonic-dice/core/src/entities/DieType
+ * @description
+ * Enum for die types used in rolling functions.
+ *
+ * @readonly
+ * @enum {string}
+ *
+ * @example
+ * import { DieType } from "@platonic-dice/core/src/entities";
+ * const result = roll(DieType.D20);
+ */
+export const DieType: Readonly<{
+    D4: "d4";
+    D6: "d6";
+    D8: "d8";
+    D10: "d10";
+    D12: "d12";
+    D20: "d20";
+}>;
+/**
+ * Checks whether a given value is a valid `DieType`.
+ *
+ * @function isValidDieType
+ * @param {DieTypeValue | null | undefined} dieType
+ * @returns {boolean}
+ */
+export function isValidDieType(dieType: DieTypeValue | null | undefined): boolean;
+//# sourceMappingURL=DieType.d.ts.map

package/dist/entities/DieType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DieType.d.ts","sourceRoot":"","sources":["../../src/entities/DieType.js"],"names":[],"mappings":"yBAmCa,MAAM,OAAO,OAAO;2BACpB,CAAA,OAAO,OAAO,EAAC,MAAM,OAAO,OAAO,CAAC;;;;sBA7BvC,MAAM;AANhB;;;;;;;;;;;GAWG;AACH;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,wCAHW,YAAY,GAAG,IAAI,GAAG,SAAS,GAC7B,OAAO,CAKnB"}

package/dist/entities/DieType.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * @module @platonic-dice/core/src/entities/DieType
+ * @description
+ * Enum for die types used in rolling functions.
+ *
+ * @readonly
+ * @enum {string}
+ *
+ * @example
+ * import { DieType } from "@platonic-dice/core/src/entities";
+ * const result = roll(DieType.D20);
+ */
+const DieType = Object.freeze({
+  D4: "d4",
+  D6: "d6",
+  D8: "d8",
+  D10: "d10",
+  D12: "d12",
+  D20: "d20",
+});
+
+/**
+ * Checks whether a given value is a valid `DieType`.
+ *
+ * @function isValidDieType
+ * @param {DieTypeValue | null | undefined} dieType
+ * @returns {boolean}
+ */
+function isValidDieType(dieType) {
+  if (!dieType) return false;
+  return Object.values(DieType).includes(dieType);
+}
+
+/**
+ * @typedef {keyof typeof DieType} DieTypeKey
+ * @typedef {typeof DieType[keyof typeof DieType]} DieTypeValue
+ */
+
+module.exports = {
+  DieType,
+  isValidDieType,
+};

package/dist/entities/Outcome.d.ts

@@ -0,0 +1,26 @@
+export type OutcomeKey = keyof typeof Outcome;
+export type OutcomeValue = (typeof Outcome)[keyof typeof Outcome];
+export type Outcome = string;
+/**
+ * @module @platonic-dice/core/src/entities/Outcome
+ * @description
+ * Enum for possible roll outcomes.
+ *
+ * @readonly
+ * @enum {string}
+ */
+export const Outcome: Readonly<{
+    Success: "success";
+    Failure: "failure";
+    CriticalSuccess: "critical_success";
+    CriticalFailure: "critical_failure";
+}>;
+/**
+ * Checks whether a given value is a valid `Outcome`.
+ *
+ * @function isValidOutcome
+ * @param {OutcomeValue | null | undefined} outcome
+ * @returns {boolean}
+ */
+export function isValidOutcome(outcome: OutcomeValue | null | undefined): boolean;
+//# sourceMappingURL=Outcome.d.ts.map

package/dist/entities/Outcome.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Outcome.d.ts","sourceRoot":"","sources":["../../src/entities/Outcome.js"],"names":[],"mappings":"yBA6Ba,MAAM,OAAO,OAAO;2BACpB,CAAA,OAAO,OAAO,EAAC,MAAM,OAAO,OAAO,CAAC;sBAvBvC,MAAM;AANhB;;;;;;;GAOG;AACH;;;;;GAKG;AAEH;;;;;;GAMG;AACH,wCAHW,YAAY,GAAG,IAAI,GAAG,SAAS,GAC7B,OAAO,CAKnB"}

package/dist/entities/Outcome.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * @module @platonic-dice/core/src/entities/Outcome
+ * @description
+ * Enum for possible roll outcomes.
+ *
+ * @readonly
+ * @enum {string}
+ */
+const Outcome = Object.freeze({
+  Success: "success",
+  Failure: "failure",
+  CriticalSuccess: "critical_success",
+  CriticalFailure: "critical_failure",
+});
+
+/**
+ * Checks whether a given value is a valid `Outcome`.
+ *
+ * @function isValidOutcome
+ * @param {OutcomeValue | null | undefined} outcome
+ * @returns {boolean}
+ */
+function isValidOutcome(outcome) {
+  if (!outcome) return false;
+  return Object.values(Outcome).includes(outcome);
+}
+
+/**
+ * @typedef {keyof typeof Outcome} OutcomeKey
+ * @typedef {typeof Outcome[keyof typeof Outcome]} OutcomeValue
+ */
+
+module.exports = {
+  Outcome,
+  isValidOutcome,
+};

package/dist/entities/RollModifier.d.ts

@@ -0,0 +1,115 @@
+export type RollModifierFunction = (n: number) => number;
+export type DiceModifier = {
+    /**
+     * Function or {@link RollModifier} applied to each individual die.
+     */
+    each?: RollModifierFunction | RollModifier | null | undefined;
+    /**
+     * Function or {@link RollModifier} applied to the total (sum) of all dice.
+     */
+    net?: RollModifierFunction | RollModifier | null | undefined;
+};
+export type RollModifierInstance = InstanceType<typeof RollModifier>;
+/**
+ * @module @platonic-dice/core/src/entities/RollModifier
+ * @description
+ * Represents a numeric modifier applied to dice rolls.
+ *
+ * A `RollModifier` wraps a pure function `(n: number) => number`
+ * that takes a base roll and returns a modified value.
+ *
+ * @example
+ * const bonus = new RollModifier(n => n + 2);
+ * const result = bonus.apply(10); // 12
+ */
+/**
+ * @typedef {(n: number) => number} RollModifierFunction
+ * @description
+ * A function that takes a single numeric input (the base roll or the total sum)
+ * and returns a numeric result. Implementations SHOULD:
+ *  - declare exactly one parameter (helps static checks: `fn.length === 1`)
+ *  - accept a number and return a number (ideally integer for dice use-cases)
+ *
+ * Examples:
+ * - Per-die modifier: `(n) => n + 1`
+ * - Net modifier: `(sum) => Math.floor(sum * 1.5)`
+ *
+ * Notes:
+ * - The runtime `isValidRollModifier` performs a light validation:
+ *   checks the function arity and performs a test call `fn(1)` to ensure
+ *   a numeric, integer-like result is returned. Keep modifiers pure.
+ */
+/**
+ * @typedef {Object} DiceModifier
+ * @property {RollModifierFunction | RollModifier | null | undefined} [each]
+ *   Function or {@link RollModifier} applied to each individual die.
+ * @property {RollModifierFunction | RollModifier | null | undefined} [net]
+ *   Function or {@link RollModifier} applied to the total (sum) of all dice.
+ *
+ * @description
+ * Represents the composite modifier structure used by {@link rollDiceMod}.
+ * Each field is optional and defaults to the identity modifier if omitted.
+ *
+ * @example
+ * const modifier = {
+ *   each: (n) => n + 1,
+ *   net: (sum) => sum + 2,
+ * };
+ *
+ * const mod2 = {
+ *   each: new RollModifier((n) => n * 2),
+ * };
+ */
+/**
+ * Represents a numeric modifier applied to dice rolls.
+ */
+export class RollModifier {
+    /**
+     * @param {RollModifierFunction} fn - Modifier function.
+     * @throws {TypeError} If the function is not a valid roll modifier.
+     */
+    constructor(fn: RollModifierFunction);
+    /** @type {RollModifierFunction} */
+    fn: RollModifierFunction;
+    /**
+     * Applies this modifier to a roll result.
+     * @param {number} baseValue - The base roll result.
+     * @returns {number} - The modified roll result.
+     */
+    apply(baseValue: number): number;
+    /**
+     * Validates that this modifier still conforms to spec.
+     * (Useful if modifiers are loaded dynamically or serialized.)
+     * @throws {TypeError} If the modifier is invalid.
+     */
+    validate(): void;
+}
+/**
+ * Checks whether a given function is a valid roll modifier.
+ *
+ * @function isValidRollModifier
+ * @param {Function | null} m
+ * @returns {boolean}
+ */
+export function isValidRollModifier(m: Function | null): boolean;
+/**
+ * This function ensures all modifiers conform to the correct structure:
+ *  - A {@link RollModifier} instance → returned as-is.
+ *  - A function `(n: number) => number` → wrapped in a new {@link RollModifier}.
+ *  - `null` or `undefined` → treated as an identity modifier.
+ *
+ * @function normaliseRollModifier
+ * @param {RollModifier | ((n: number) => number) | null | undefined} m
+ *   The input modifier to normalise.
+ * @returns {RollModifier}
+ *   A valid {@link RollModifier} instance.
+ * @throws {TypeError}
+ *   If the input is invalid (not a RollModifier, function, or null/undefined).
+ *
+ * @example
+ * const rm1 = normaliseRollModifier(); // → identity modifier
+ * const rm2 = normaliseRollModifier(x => x + 1); // → RollModifier wrapping function
+ * const rm3 = normaliseRollModifier(new RollModifier(x => x * 2)); // → same instance
+ */
+export function normaliseRollModifier(m: RollModifier | ((n: number) => number) | null | undefined): RollModifier;
+//# sourceMappingURL=RollModifier.d.ts.map

package/dist/entities/RollModifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RollModifier.d.ts","sourceRoot":"","sources":["../../src/entities/RollModifier.js"],"names":[],"mappings":"mCAca,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM;;;;;WAmBpB,oBAAoB,GAAG,YAAY,GAAG,IAAI,GAAG,SAAS;;;;UAEtD,oBAAoB,GAAG,YAAY,GAAG,IAAI,GAAG,SAAS;;mCAwGvD,YAAY,CAAC,OAAO,YAAY,CAAC;AA3I9C;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,gBAHW,oBAAoB,EAY9B;IAFC,mCAAmC;IACnC,IADW,oBAAoB,CACnB;IAGd;;;;OAIG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAIC;CACF;AAED;;;;;;GAMG;AACH,uCAHW,WAAW,IAAI,GACb,OAAO,CAWnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCAZW,YAAY,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,IAAI,GAAG,SAAS,GAEvD,YAAY,CAgBxB"}

package/dist/entities/RollModifier.js

@@ -0,0 +1,147 @@
+/**
+ * @module @platonic-dice/core/src/entities/RollModifier
+ * @description
+ * Represents a numeric modifier applied to dice rolls.
+ *
+ * A `RollModifier` wraps a pure function `(n: number) => number`
+ * that takes a base roll and returns a modified value.
+ *
+ * @example
+ * const bonus = new RollModifier(n => n + 2);
+ * const result = bonus.apply(10); // 12
+ */
+
+/**
+ * @typedef {(n: number) => number} RollModifierFunction
+ * @description
+ * A function that takes a single numeric input (the base roll or the total sum)
+ * and returns a numeric result. Implementations SHOULD:
+ *  - declare exactly one parameter (helps static checks: `fn.length === 1`)
+ *  - accept a number and return a number (ideally integer for dice use-cases)
+ *
+ * Examples:
+ * - Per-die modifier: `(n) => n + 1`
+ * - Net modifier: `(sum) => Math.floor(sum * 1.5)`
+ *
+ * Notes:
+ * - The runtime `isValidRollModifier` performs a light validation:
+ *   checks the function arity and performs a test call `fn(1)` to ensure
+ *   a numeric, integer-like result is returned. Keep modifiers pure.
+ */
+
+/**
+ * @typedef {Object} DiceModifier
+ * @property {RollModifierFunction | RollModifier | null | undefined} [each]
+ *   Function or {@link RollModifier} applied to each individual die.
+ * @property {RollModifierFunction | RollModifier | null | undefined} [net]
+ *   Function or {@link RollModifier} applied to the total (sum) of all dice.
+ *
+ * @description
+ * Represents the composite modifier structure used by {@link rollDiceMod}.
+ * Each field is optional and defaults to the identity modifier if omitted.
+ *
+ * @example
+ * const modifier = {
+ *   each: (n) => n + 1,
+ *   net: (sum) => sum + 2,
+ * };
+ *
+ * const mod2 = {
+ *   each: new RollModifier((n) => n * 2),
+ * };
+ */
+
+/**
+ * Represents a numeric modifier applied to dice rolls.
+ */
+class RollModifier {
+  /**
+   * @param {RollModifierFunction} fn - Modifier function.
+   * @throws {TypeError} If the function is not a valid roll modifier.
+   */
+  constructor(fn) {
+    if (!isValidRollModifier(fn)) {
+      throw new TypeError(
+        "Invalid roll modifier: must be a function accepting one numeric argument and returning a number."
+      );
+    }
+
+    /** @type {RollModifierFunction} */
+    this.fn = fn;
+  }
+
+  /**
+   * Applies this modifier to a roll result.
+   * @param {number} baseValue - The base roll result.
+   * @returns {number} - The modified roll result.
+   */
+  apply(baseValue) {
+    return this.fn(baseValue);
+  }
+
+  /**
+   * Validates that this modifier still conforms to spec.
+   * (Useful if modifiers are loaded dynamically or serialized.)
+   * @throws {TypeError} If the modifier is invalid.
+   */
+  validate() {
+    if (!isValidRollModifier(this.fn)) {
+      throw new TypeError("Invalid roll modifier function shape.");
+    }
+  }
+}
+
+/**
+ * Checks whether a given function is a valid roll modifier.
+ *
+ * @function isValidRollModifier
+ * @param {Function | null} m
+ * @returns {boolean}
+ */
+function isValidRollModifier(m) {
+  if (!m || typeof m !== "function") return false;
+
+  /** ---Validate modifier shape --- */
+  if (m.length !== 1) return false; // Must declare exactly 1 parameter
+
+  // Quick runtime check: apply to a number and verify return is an integer.
+  const testValue = m(1);
+  return typeof testValue === "number" && Number.isInteger(testValue);
+}
+
+/**
+ * This function ensures all modifiers conform to the correct structure:
+ *  - A {@link RollModifier} instance → returned as-is.
+ *  - A function `(n: number) => number` → wrapped in a new {@link RollModifier}.
+ *  - `null` or `undefined` → treated as an identity modifier.
+ *
+ * @function normaliseRollModifier
+ * @param {RollModifier | ((n: number) => number) | null | undefined} m
+ *   The input modifier to normalise.
+ * @returns {RollModifier}
+ *   A valid {@link RollModifier} instance.
+ * @throws {TypeError}
+ *   If the input is invalid (not a RollModifier, function, or null/undefined).
+ *
+ * @example
+ * const rm1 = normaliseRollModifier(); // → identity modifier
+ * const rm2 = normaliseRollModifier(x => x + 1); // → RollModifier wrapping function
+ * const rm3 = normaliseRollModifier(new RollModifier(x => x * 2)); // → same instance
+ */
+function normaliseRollModifier(m) {
+  if (!m) return new RollModifier((n) => n); // identity modifier
+  if (m instanceof RollModifier) return m;
+  if (typeof m === "function" && isValidRollModifier(m))
+    return new RollModifier(m);
+  throw new TypeError("Invalid RollModifier");
+}
+
+/**
+ * @typedef {InstanceType<typeof RollModifier>} RollModifierInstance
+ */
+
+module.exports = {
+  RollModifier,
+  isValidRollModifier,
+  normaliseRollModifier,
+};

package/dist/entities/RollType.d.ts

@@ -0,0 +1,24 @@
+export type RollTypeKey = keyof typeof RollType;
+export type RollTypeValue = (typeof RollType)[keyof typeof RollType];
+export type RollType = string;
+/**
+ * @module @platonic-dice/core/src/entities/RollType
+ * @description
+ * Enum for roll modes (normal, advantage, disadvantage).
+ *
+ * @readonly
+ * @enum {string}
+ */
+export const RollType: Readonly<{
+    Advantage: "advantage";
+    Disadvantage: "disadvantage";
+}>;
+/**
+ * Checks whether a given value is a valid `RollType`.
+ *
+ * @function isValidRollType
+ * @param {RollTypeValue | null | undefined} rollType
+ * @returns {boolean}
+ */
+export function isValidRollType(rollType: RollTypeValue | null | undefined): boolean;
+//# sourceMappingURL=RollType.d.ts.map

package/dist/entities/RollType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RollType.d.ts","sourceRoot":"","sources":["../../src/entities/RollType.js"],"names":[],"mappings":"0BA2Ba,MAAM,OAAO,QAAQ;4BACrB,CAAA,OAAO,QAAQ,EAAC,MAAM,OAAO,QAAQ,CAAC;uBArBzC,MAAM;AANhB;;;;;;;GAOG;AACH;;;GAGG;AAEH;;;;;;GAMG;AACH,0CAHW,aAAa,GAAG,IAAI,GAAG,SAAS,GAC9B,OAAO,CAKnB"}

package/dist/entities/RollType.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * @module @platonic-dice/core/src/entities/RollType
+ * @description
+ * Enum for roll modes (normal, advantage, disadvantage).
+ *
+ * @readonly
+ * @enum {string}
+ */
+const RollType = Object.freeze({
+  Advantage: "advantage",
+  Disadvantage: "disadvantage",
+});
+
+/**
+ * Checks whether a given value is a valid `RollType`.
+ *
+ * @function isValidRollType
+ * @param {RollTypeValue | null | undefined} rollType
+ * @returns {boolean}
+ */
+function isValidRollType(rollType) {
+  if (!rollType) return false;
+  return Object.values(RollType).includes(rollType);
+}
+
+/**
+ * @typedef {keyof typeof RollType} RollTypeKey
+ * @typedef {typeof RollType[keyof typeof RollType]} RollTypeValue
+ */
+
+module.exports = {
+  RollType,
+  isValidRollType,
+};

package/dist/entities/TestConditions.d.ts

@@ -0,0 +1,97 @@
+export type BaseTestCondition = {
+    dieType: DieTypeValue;
+};
+export type TargetConditions = BaseTestCondition & {
+    target: number;
+};
+export type WithinConditions = BaseTestCondition & {
+    min: number;
+    max: number;
+};
+export type SpecificListConditions = BaseTestCondition & {
+    values: number[];
+};
+export type SkillConditions = BaseTestCondition & {
+    target: number;
+    critical_success?: number;
+    critical_failure?: number;
+};
+export type TestTypeValue = import("./TestType").TestTypeValue;
+export type DieTypeValue = import("./DieType").DieTypeValue;
+/**
+ * Represents any valid dice roll test condition.
+ *
+ * This is a union type of all the internal test condition shapes:
+ * - `TargetConditions` – single target value
+ * - `SkillConditions` – target with optional critical thresholds
+ * - `WithinConditions` – min/max range
+ * - `SpecificListConditions` – array of specific allowed values
+ */
+export type Conditions = TargetConditions | SkillConditions | WithinConditions | SpecificListConditions;
+export type TestConditionsInstance = InstanceType<typeof TestConditions>;
+/**
+ * @typedef {import("./TestType").TestTypeValue} TestTypeValue
+ * @typedef {import("./DieType").DieTypeValue} DieTypeValue
+ */
+/**
+ * Represents a set of conditions for a dice roll test.
+ */
+export class TestConditions {
+    /**
+     * @param {TestTypeValue} testType - The test type.
+     * @param {Conditions} conditions - The test conditions object.
+     * @param {DieTypeValue} dieType - The die type to validate numeric ranges.
+     * @throws {TypeError|RangeError} If the test type or conditions are invalid.
+     */
+    constructor(testType: TestTypeValue, conditions: Conditions, dieType: DieTypeValue);
+    /** @type {TestTypeValue} */
+    testType: TestTypeValue;
+    /** @type {Conditions} */
+    conditions: Conditions;
+    /** @type {DieTypeValue} */
+    dieType: DieTypeValue;
+    /**
+     * Validates that the test conditions still conforms to spec.
+     * (Useful if they are loaded dynamically or serialized.)
+     * @throws {TypeError} If the test conditions are invalid.
+     */
+    validate(): void;
+}
+/**
+ * Master validation function for all test conditions.
+ *
+ * @function areValidTestConditions
+ * @param {Conditions} c
+ * @param {TestTypeValue} testType
+ * @returns {boolean}
+ */
+export function areValidTestConditions(c: Conditions, testType: TestTypeValue): boolean;
+/**
+ * Normalises any input into a {@link TestConditions} instance.
+ * Supports both pre-existing instances and plain objects.
+ * Automatically validates all conditions for the specified die type.
+ *
+ * @function normaliseTestConditions
+ * @param {TestConditions | { testType: TestTypeValue, [key: string]: any }} tc
+ *   A {@link TestConditions} instance or plain object with `testType` and other fields.
+ * @param {DieTypeValue} dieType
+ *   The die type (e.g., `'d6'`, `'d20'`) used for validation.
+ * @returns {TestConditions}
+ *   A validated {@link TestConditions} instance.
+ * @throws {TypeError}
+ *   If the input is neither a TestConditions instance nor a plain object.
+ *
+ * @example
+ * // Passing a plain object
+ * const conditions = normaliseTestConditions({ testType: 'atLeast', target: 4 }, 'd6');
+ *
+ * @example
+ * // Passing an existing TestConditions instance
+ * const existing = new TestConditions('exact', { target: 3 }, 'd6');
+ * const conditions2 = normaliseTestConditions(existing, 'd6');
+ */
+export function normaliseTestConditions(tc: TestConditions | {
+    testType: TestTypeValue;
+    [key: string]: any;
+}, dieType: DieTypeValue): TestConditions;
+//# sourceMappingURL=TestConditions.d.ts.map

package/dist/entities/TestConditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestConditions.d.ts","sourceRoot":"","sources":["../../src/entities/TestConditions.js"],"names":[],"mappings":";aAiMc,YAAY;;+BAKb,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;+BAEtC,iBAAiB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;qCAEhD,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE;8BAExC,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE;4BA5L5F,OAAO,YAAY,EAAE,aAAa;2BAClC,OAAO,WAAW,EAAE,YAAY;;;;;;;;;;yBA4JhC,gBAAgB,GAAG,eAAe,GAAG,gBAAgB,GAAG,sBAAsB;qCAI9E,YAAY,CAAC,OAAO,cAAc,CAAC;AAlKhD;;;GAGG;AAEH;;GAEG;AACH;IACE;;;;;OAKG;IACH,sBALW,aAAa,cACb,UAAU,WACV,YAAY,EAgDtB;IANC,4BAA4B;IAC5B,UADW,aAAa,CACA;IACxB,yBAAyB;IACzB,YADW,UAAU,CACO;IAC5B,2BAA2B;IAC3B,SADW,YAAY,CACD;IAGxB;;;;OAIG;IACH,iBASC;CACF;AAED;;;;;;;GAOG;AACH,0CAJW,UAAU,YACV,aAAa,GACX,OAAO,CAwBnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,4CAlBW,cAAc,GAAG;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,WAEhE,YAAY,GAEV,cAAc,CA0B1B"}