@platonic-dice/core 2.0.2 → 2.1.0

package/dist/entities/ModifiedTestConditions.d.ts

@@ -0,0 +1,89 @@
+export type TestTypeValue = import("./TestType").TestTypeValue;
+export type DieTypeValue = import("./DieType").DieTypeValue;
+export type RollModifierFunction = import("./RollModifier").RollModifierFunction;
+export type RollModifierInstance = import("./RollModifier").RollModifierInstance;
+export type BaseTestCondition = {
+    modifiedRange: {
+        min: number;
+        max: number;
+    };
+};
+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 Conditions = TargetConditions | SkillConditions | WithinConditions | SpecificListConditions;
+export type ModifiedTestConditionsInstance = InstanceType<typeof ModifiedTestConditions>;
+/**
+ * Represents a set of validated test conditions for modified rolls.
+ *
+ * This class is similar to {@link TestConditions} but validates numeric
+ * targets against the achievable range after applying a modifier.
+ */
+export class ModifiedTestConditions {
+    /**
+     * @param {TestTypeValue} testType - The test type.
+     * @param {Conditions} conditions - The test conditions object.
+     * @param {DieTypeValue} dieType - The base die type.
+     * @param {RollModifierFunction | RollModifierInstance} modifier - The modifier to apply.
+     * @throws {TypeError|RangeError} If the test type or conditions are invalid.
+     */
+    constructor(testType: TestTypeValue, conditions: Conditions, dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance);
+    /** @type {TestTypeValue} */
+    testType: TestTypeValue;
+    /** @type {Conditions} */
+    conditions: Conditions;
+    /** @type {DieTypeValue} */
+    dieType: DieTypeValue;
+    /** @type {RollModifierInstance} */
+    modifier: RollModifierInstance;
+    /** @type {{ min: number, max: number }} */
+    modifiedRange: {
+        min: number;
+        max: number;
+    };
+    /**
+     * Validates that the test conditions still conform to spec.
+     * @throws {TypeError} If the test conditions are invalid.
+     */
+    validate(): void;
+}
+/**
+ * Validates test conditions against a modified range.
+ *
+ * @private
+ * @param {Conditions & Record<string, any>} c - Conditions with modifiedRange
+ * @param {TestTypeValue} testType
+ * @returns {boolean}
+ */
+export function areValidModifiedTestConditions(c: Conditions & Record<string, any>, testType: TestTypeValue): boolean;
+/**
+ * @typedef {import("./TestType").TestTypeValue} TestTypeValue
+ * @typedef {import("./DieType").DieTypeValue} DieTypeValue
+ * @typedef {import("./RollModifier").RollModifierFunction} RollModifierFunction
+ * @typedef {import("./RollModifier").RollModifierInstance} RollModifierInstance
+ */
+/**
+ * Computes the achievable range for a die + modifier combination.
+ *
+ * @private
+ * @param {DieTypeValue} dieType
+ * @param {RollModifierInstance} modifier
+ * @returns {{ min: number, max: number }}
+ */
+export function computeModifiedRange(dieType: DieTypeValue, modifier: RollModifierInstance): {
+    min: number;
+    max: number;
+};
+//# sourceMappingURL=ModifiedTestConditions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ModifiedTestConditions.d.ts","sourceRoot":"","sources":["../../src/entities/ModifiedTestConditions.js"],"names":[],"mappings":"4BAyBa,OAAO,YAAY,EAAE,aAAa;2BAClC,OAAO,WAAW,EAAE,YAAY;mCAChC,OAAO,gBAAgB,EAAE,oBAAoB;mCAC7C,OAAO,gBAAgB,EAAE,oBAAoB;;mBAsN5C;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE;;+BAI7B,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE;+BACtC,iBAAiB,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE;qCAChD,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE;8BACxC,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE;yBAI5F,gBAAgB,GAAG,eAAe,GAAG,gBAAgB,GAAG,sBAAsB;6CAI9E,YAAY,CAAC,OAAO,sBAAsB,CAAC;AA1MxD;;;;;GAKG;AACH;IACE;;;;;;OAMG;IACH,sBANW,aAAa,cACb,UAAU,WACV,YAAY,YACZ,oBAAoB,GAAG,oBAAoB,EAmErD;IAVC,4BAA4B;IAC5B,UADW,aAAa,CACA;IACxB,yBAAyB;IACzB,YADW,UAAU,CACO;IAC5B,2BAA2B;IAC3B,SADW,YAAY,CACD;IACtB,mCAAmC;IACnC,UADW,oBAAoB,CACZ;IACnB,2CAA2C;IAC3C,eADW;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CACb;IAG5B;;;OAGG;IACH,iBASC;CACF;AAED;;;;;;;GAOG;AACH,kDAJW,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,YAChC,aAAa,GACX,OAAO,CAiFnB;AAtND;;;;;GAKG;AAEH;;;;;;;GAOG;AACH,8CAJW,YAAY,YACZ,oBAAoB,GAClB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAgBxC"}

package/dist/entities/ModifiedTestConditions.js

@@ -0,0 +1,265 @@
+/**
+ * @module @platonic-dice/core/src/entities/ModifiedTestConditions
+ * @description
+ * Represents test conditions for modified rolls, where the achievable range
+ * is determined by both the base die type and the applied modifier.
+ *
+ * Unlike {@link TestConditions}, this class validates targets against the
+ * **modified range** rather than just the base die faces.
+ *
+ * @example
+ * // D6 with +10 modifier can reach 11-16
+ * const conditions = new ModifiedTestConditions(
+ *   TestType.AtLeast,
+ *   { target: 15 },
+ *   DieType.D6,
+ *   (n) => n + 10
+ * );
+ */
+
+const { isValidDieType } = require("./DieType");
+const { isValidTestType } = require("./TestType");
+const { normaliseRollModifier } = require("./RollModifier");
+const { numSides } = require("../utils");
+
+/**
+ * @typedef {import("./TestType").TestTypeValue} TestTypeValue
+ * @typedef {import("./DieType").DieTypeValue} DieTypeValue
+ * @typedef {import("./RollModifier").RollModifierFunction} RollModifierFunction
+ * @typedef {import("./RollModifier").RollModifierInstance} RollModifierInstance
+ */
+
+/**
+ * Computes the achievable range for a die + modifier combination.
+ *
+ * @private
+ * @param {DieTypeValue} dieType
+ * @param {RollModifierInstance} modifier
+ * @returns {{ min: number, max: number }}
+ */
+function computeModifiedRange(dieType, modifier) {
+  const sides = numSides(dieType);
+  const minRoll = 1;
+  const maxRoll = sides;
+
+  // Apply modifier to both extremes
+  const minModified = modifier.apply(minRoll);
+  const maxModified = modifier.apply(maxRoll);
+
+  // Handle cases where modifier might reverse order (e.g., negative multipliers)
+  return {
+    min: Math.min(minModified, maxModified),
+    max: Math.max(minModified, maxModified),
+  };
+}
+
+/**
+ * Represents a set of validated test conditions for modified rolls.
+ *
+ * This class is similar to {@link TestConditions} but validates numeric
+ * targets against the achievable range after applying a modifier.
+ */
+class ModifiedTestConditions {
+  /**
+   * @param {TestTypeValue} testType - The test type.
+   * @param {Conditions} conditions - The test conditions object.
+   * @param {DieTypeValue} dieType - The base die type.
+   * @param {RollModifierFunction | RollModifierInstance} modifier - The modifier to apply.
+   * @throws {TypeError|RangeError} If the test type or conditions are invalid.
+   */
+  constructor(testType, conditions, dieType, modifier) {
+    if (!isValidTestType(testType)) {
+      throw new TypeError(`Invalid test type: ${testType}`);
+    }
+
+    if (!conditions || typeof conditions !== "object") {
+      throw new TypeError("conditions must be an object.");
+    }
+
+    if (!dieType) {
+      throw new TypeError("dieType is required.");
+    }
+
+    if (!modifier) {
+      throw new TypeError("modifier is required.");
+    }
+
+    // Normalize the modifier
+    const mod = normaliseRollModifier(modifier);
+
+    // Compute the achievable range with this modifier
+    const range = computeModifiedRange(dieType, mod);
+
+    // Validate conditions against the modified range
+    if (
+      !areValidModifiedTestConditions(
+        { ...conditions, modifiedRange: range },
+        testType
+      )
+    ) {
+      switch (testType) {
+        case "at_least":
+        case "at_most":
+        case "exact":
+          throw new RangeError(
+            `Invalid ${testType} condition for ${dieType} with modifier: target must be achievable (range: ${range.min}–${range.max}).`
+          );
+        case "within":
+          throw new RangeError(
+            `Invalid 'within' condition for ${dieType} with modifier: range must be achievable (${range.min}–${range.max}).`
+          );
+        case "in_list":
+          throw new RangeError(
+            `Invalid 'in_list' condition for ${dieType} with modifier: values must be achievable (${range.min}–${range.max}).`
+          );
+        case "skill":
+          throw new RangeError(
+            `Invalid 'skill' condition for ${dieType} with modifier: thresholds must be achievable (${range.min}–${range.max}).`
+          );
+        default:
+          throw new TypeError(`Unknown testType '${testType}'.`);
+      }
+    }
+
+    /** @type {TestTypeValue} */
+    this.testType = testType;
+    /** @type {Conditions} */
+    this.conditions = conditions;
+    /** @type {DieTypeValue} */
+    this.dieType = dieType;
+    /** @type {RollModifierInstance} */
+    this.modifier = mod;
+    /** @type {{ min: number, max: number }} */
+    this.modifiedRange = range;
+  }
+
+  /**
+   * Validates that the test conditions still conform to spec.
+   * @throws {TypeError} If the test conditions are invalid.
+   */
+  validate() {
+    if (
+      !areValidModifiedTestConditions(
+        { ...this.conditions, modifiedRange: this.modifiedRange },
+        this.testType
+      )
+    ) {
+      throw new TypeError("Invalid modified test conditions.");
+    }
+  }
+}
+
+/**
+ * Validates test conditions against a modified range.
+ *
+ * @private
+ * @param {Conditions & Record<string, any>} c - Conditions with modifiedRange
+ * @param {TestTypeValue} testType
+ * @returns {boolean}
+ */
+function areValidModifiedTestConditions(c, testType) {
+  if (!c.modifiedRange) return false;
+
+  const { min, max } = c.modifiedRange;
+
+  switch (testType) {
+    case "exact":
+    case "at_least":
+    case "at_most":
+      return (
+        typeof c.target === "number" &&
+        Number.isInteger(c.target) &&
+        c.target >= min &&
+        c.target <= max
+      );
+
+    case "within":
+      return (
+        typeof c.min === "number" &&
+        typeof c.max === "number" &&
+        Number.isInteger(c.min) &&
+        Number.isInteger(c.max) &&
+        c.min <= c.max &&
+        c.min >= min &&
+        c.max <= max
+      );
+
+    case "in_list":
+      return (
+        Array.isArray(c.values) &&
+        c.values.length > 0 &&
+        c.values.every(
+          (v) =>
+            typeof v === "number" && Number.isInteger(v) && v >= min && v <= max
+        )
+      );
+
+    case "skill":
+      // target is required
+      if (
+        typeof c.target !== "number" ||
+        !Number.isInteger(c.target) ||
+        c.target < min ||
+        c.target > max
+      ) {
+        return false;
+      }
+
+      // critical_success is optional but must be valid if present
+      if (c.critical_success !== undefined) {
+        if (
+          typeof c.critical_success !== "number" ||
+          !Number.isInteger(c.critical_success) ||
+          c.critical_success < min ||
+          c.critical_success > max ||
+          c.critical_success < c.target
+        ) {
+          return false;
+        }
+      }
+
+      // critical_failure is optional but must be valid if present
+      if (c.critical_failure !== undefined) {
+        if (
+          typeof c.critical_failure !== "number" ||
+          !Number.isInteger(c.critical_failure) ||
+          c.critical_failure < min ||
+          c.critical_failure > max ||
+          c.critical_failure > c.target
+        ) {
+          return false;
+        }
+      }
+
+      return true;
+
+    default:
+      return false;
+  }
+}
+
+/**
+ * @typedef {Object} BaseTestCondition
+ * @property {{ min: number, max: number }} modifiedRange
+ */
+
+/**
+ * @typedef {BaseTestCondition & { target: number }} TargetConditions
+ * @typedef {BaseTestCondition & { min: number, max: number }} WithinConditions
+ * @typedef {BaseTestCondition & { values: number[] }} SpecificListConditions
+ * @typedef {BaseTestCondition & { target: number, critical_success?: number, critical_failure?: number }} SkillConditions
+ */
+
+/**
+ * @typedef {TargetConditions | SkillConditions | WithinConditions | SpecificListConditions} Conditions
+ */
+
+/**
+ * @typedef {InstanceType<typeof ModifiedTestConditions>} ModifiedTestConditionsInstance
+ */
+
+module.exports = {
+  ModifiedTestConditions,
+  areValidModifiedTestConditions,
+  computeModifiedRange,
+};

package/dist/entities/index.d.ts

@@ -10,7 +10,10 @@ import { isValidRollType } from "./RollType.js";
 import { TestConditions } from "./TestConditions.js";
 import { areValidTestConditions } from "./TestConditions.js";
 import { normaliseTestConditions } from "./TestConditions.js";
+import { ModifiedTestConditions } from "./ModifiedTestConditions.js";
+import { areValidModifiedTestConditions } from "./ModifiedTestConditions.js";
+import { computeModifiedRange } from "./ModifiedTestConditions.js";
 import { TestType } from "./TestType.js";
 import { isValidTestType } from "./TestType.js";
-export { DieType, isValidDieType, Outcome, isValidOutcome, RollModifier, isValidRollModifier, normaliseRollModifier, RollType, isValidRollType, TestConditions, areValidTestConditions, normaliseTestConditions, TestType, isValidTestType };
+export { DieType, isValidDieType, Outcome, isValidOutcome, RollModifier, isValidRollModifier, normaliseRollModifier, RollType, isValidRollType, TestConditions, areValidTestConditions, normaliseTestConditions, ModifiedTestConditions, areValidModifiedTestConditions, computeModifiedRange, TestType, isValidTestType };
 //# sourceMappingURL=index.d.ts.map

package/dist/entities/index.js

@@ -26,6 +26,11 @@ const {
   areValidTestConditions,
   normaliseTestConditions,
 } = require("./TestConditions.js");
+const {
+  ModifiedTestConditions,
+  areValidModifiedTestConditions,
+  computeModifiedRange,
+} = require("./ModifiedTestConditions.js");
 const { TestType, isValidTestType } = require("./TestType.js");
 
 module.exports = {
@@ -41,6 +46,9 @@ module.exports = {
   TestConditions,
   areValidTestConditions,
   normaliseTestConditions,
+  ModifiedTestConditions,
+  areValidModifiedTestConditions,
+  computeModifiedRange,
   TestType,
   isValidTestType,
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-declare const _exports: typeof import("./roll") & typeof import("./rollDice") & typeof import("./rollMod") & typeof import("./rollDiceMod") & typeof import("./rollTest") & typeof import("./entities") & {
+declare const _exports: typeof import("./roll") & typeof import("./rollDice") & typeof import("./rollMod") & typeof import("./rollDiceMod") & typeof import("./rollTest") & typeof import("./rollModTest") & typeof import("./analyseTest") & typeof import("./analyseModTest") & typeof import("./entities") & {
     default: any;
 };
 export = _exports;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"wBAsBU,cAAc,QAAQ,CAAC,GAChC,cAAuB,YAAY,CAAC,GACpC,cAAuB,WAAW,CAAC,GACnC,cAAuB,eAAe,CAAC,GACvC,cAAuB,YAAY,CAAC,GACpC,cAAuB,YAAY,CAAC,GACpC;IAAW,OAAO,EAAE,GAAG,CAAA;CAAE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"wBAyBU,cAAc,QAAQ,CAAC,GAChC,cAAuB,YAAY,CAAC,GACpC,cAAuB,WAAW,CAAC,GACnC,cAAuB,eAAe,CAAC,GACvC,cAAuB,YAAY,CAAC,GACpC,cAAuB,eAAe,CAAC,GACvC,cAAuB,eAAe,CAAC,GACvC,cAAuB,kBAAkB,CAAC,GAC1C,cAAuB,YAAY,CAAC,GACpC;IAAW,OAAO,EAAE,GAAG,CAAA;CAAE"}

package/dist/index.js

@@ -5,7 +5,7 @@
  * Re-exports all main rolling functions and modifiers.
  *
  * @example
- * import { roll, rollMod, rollDice, rollDiceMod, rollTest } from "@platonic-dice/core";
+ * import { roll, rollMod, rollDice, rollDiceMod, rollTest, rollModTest } from "@platonic-dice/core";
  */
 
 // --- Core modules ---
@@ -14,6 +14,9 @@ const roll = require("./roll.js");
 const rollMod = require("./rollMod.js");
 const rollDiceMod = require("./rollDiceMod.js");
 const rollTest = require("./rollTest.js");
+const rollModTest = require("./rollModTest.js");
+const analyseTest = require("./analyseTest.js");
+const analyseModTest = require("./analyseModTest.js");
 
 // --- Entities (public API) ---
 const entities = require("./entities");
@@ -25,6 +28,9 @@ const entities = require("./entities");
  *        typeof import("./rollMod") &
  *        typeof import("./rollDiceMod") &
  *        typeof import("./rollTest") &
+ *        typeof import("./rollModTest") &
+ *        typeof import("./analyseTest") &
+ *        typeof import("./analyseModTest") &
  *        typeof import("./entities") &
  *        { default: any }}
  */
@@ -35,6 +41,9 @@ module.exports = {
   ...rollDiceMod,
   ...entities,
   ...rollTest,
+  ...rollModTest,
+  ...analyseTest,
+  ...analyseModTest,
   default: undefined, // placeholder; will be overwritten
 };
 

package/dist/rollModTest.d.ts

@@ -0,0 +1,72 @@
+export type DieTypeValue = import("./entities/DieType").DieTypeValue;
+export type OutcomeValue = import("./entities/Outcome").OutcomeValue;
+export type RollTypeValue = import("./entities/RollType").RollTypeValue;
+export type RollModifierFunction = import("./entities/RollModifier").RollModifierFunction;
+export type RollModifierInstance = import("./entities/RollModifier").RollModifierInstance;
+export type TestTypeValue = import("./entities/TestType").TestTypeValue;
+export type TestConditionsInstance = import("./entities/TestConditions").TestConditionsInstance;
+/**
+ * Rolls a die with a modifier and evaluates the modified result against test conditions.
+ *
+ * @function rollModTest
+ * @param {DieTypeValue} dieType - The type of die to roll (e.g., `DieType.D20`).
+ * @param {RollModifierFunction|RollModifierInstance} modifier - The modifier to apply to the roll.
+ *   Can be either:
+ *   - A function `(n: number) => number`
+ *   - A {@link RollModifier} instance
+ * @param {TestConditionsInstance|{ testType: TestTypeValue, [key: string]: any }} testConditions
+ *   Can be:
+ *   - A `TestConditions` instance
+ *   - A plain object `{ testType, ...conditions }`
+ * @param {RollTypeValue} [rollType=undefined] - Optional roll mode (`RollType.Advantage` or `RollType.Disadvantage`).
+ * @param {Object} [options={}] - Optional configuration.
+ * @param {boolean} [options.useNaturalCrits] - If true, natural max/min rolls on the die trigger
+ *   critical success/failure (for Skill tests) or success/failure (for other test types).
+ *   If undefined, defaults to true for Skill test type and false for all others.
+ * @returns {{ base: number, modified: number, outcome: OutcomeValue }}
+ *   - `base`: The raw die roll
+ *   - `modified`: The roll after applying the modifier
+ *   - `outcome`: The success/failure result based on test conditions
+ * @throws {TypeError} If `dieType`, `modifier`, or `testConditions` are invalid.
+ *
+ * @example
+ * const result = rollModTest(
+ *   DieType.D20,
+ *   (n) => n + 2,
+ *   { testType: TestType.AtLeast, target: 15 }
+ * );
+ * console.log(result); // { base: 14, modified: 16, outcome: "success" }
+ *
+ * @example
+ * // With natural crits enabled (TTRPG style)
+ * const result = rollModTest(
+ *   DieType.D20,
+ *   (n) => n + 5,
+ *   { testType: TestType.Skill, target: 15, critical_success: 25, critical_failure: 2 },
+ *   undefined,
+ *   { useNaturalCrits: true }
+ * );
+ * // If base roll is 20, outcome is always "critical_success"
+ * // If base roll is 1, outcome is always "critical_failure"
+ *
+ * @example
+ * // With advantage - compares outcomes, not just base rolls
+ * const result = rollModTest(
+ *   DieType.D20,
+ *   (n) => n + 3,
+ *   { testType: TestType.Skill, target: 12, critical_success: 20, critical_failure: 1 },
+ *   RollType.Advantage
+ * );
+ * // Rolls twice, returns the result with the better outcome
+ */
+export function rollModTest(dieType: DieTypeValue, modifier: RollModifierFunction | RollModifierInstance, testConditions: TestConditionsInstance | {
+    testType: TestTypeValue;
+    [key: string]: any;
+}, rollType?: RollTypeValue, options?: {
+    useNaturalCrits?: boolean | undefined;
+}): {
+    base: number;
+    modified: number;
+    outcome: OutcomeValue;
+};
+//# sourceMappingURL=rollModTest.d.ts.map

package/dist/rollModTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollModTest.d.ts","sourceRoot":"","sources":["../src/rollModTest.js"],"names":[],"mappings":"2BAoCa,OAAO,oBAAoB,EAAE,YAAY;2BACzC,OAAO,oBAAoB,EAAE,YAAY;4BACzC,OAAO,qBAAqB,EAAE,aAAa;mCAC3C,OAAO,yBAAyB,EAAE,oBAAoB;mCACtD,OAAO,yBAAyB,EAAE,oBAAoB;4BACtD,OAAO,qBAAqB,EAAE,aAAa;qCAC3C,OAAO,2BAA2B,EAAE,sBAAsB;AAyBvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,qCAlDW,YAAY,YACZ,oBAAoB,GAAC,oBAAoB,kBAIzC,sBAAsB,GAAC;IAAE,QAAQ,EAAE,aAAa,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,aAItE,aAAa,YAErB;IAA0B,eAAe;CAGzC,GAAU;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,CAsHrE"}