arbitrary-numbers 1.0.0

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 (9) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +503 -0
  3. package/dist/index.cjs +1510 -0
  4. package/dist/index.cjs.map +1 -0
  5. package/dist/index.d.cts +1211 -0
  6. package/dist/index.d.ts +1211 -0
  7. package/dist/index.js +1484 -0
  8. package/dist/index.js.map +1 -0
  9. package/package.json +70 -0
package/dist/index.cjs.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"sources":["../src/plugin/ScientificNotation.ts","../src/constants/pow10.ts","../src/errors.ts","../src/core/ArbitraryNumber.ts","../src/core/an.ts","../src/core/AnChain.ts","../src/core/AnFormula.ts","../src/plugin/SuffixNotationBase.ts","../src/plugin/AlphabetNotation.ts","../src/constants/units.ts","../src/plugin/UnitNotation.ts","../src/utility/ArbitraryNumberGuard.ts","../src/utility/ArbitraryNumberOps.ts","../src/utility/ArbitraryNumberHelpers.ts"],"names":[],"mappings":"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","file":"index.cjs","sourcesContent":["import { type NotationPlugin } from \"../types/plugin\";\r\n\r\n/**\r\n * Formats numbers using standard scientific notation: `\"1.50e+3\"`, `\"1.50e-5\"`.\r\n *\r\n * Numbers with `exponent === 0` are formatted without an exponent part: `\"1.50\"`.\r\n * This is the default plugin used by {@link ArbitraryNumber.toString}.\r\n *\r\n * @example\r\n * const n = new ArbitraryNumber(1.5, 3);\r\n * n.toString(); // \"1.50e+3\" (default decimals = 2)\r\n * n.toString(scientificNotation, 6); // \"1.500000e+3\"\r\n */\r\nexport class ScientificNotation implements NotationPlugin {\r\n /**\r\n * Formats a normalised value as `\"<coefficient>e±<exponent>\"`.\r\n *\r\n * @param coefficient - The significand in `[1, 10)` or `0`.\r\n * @param exponent - The power of 10.\r\n * @param decimals - Number of decimal places in the output.\r\n * @returns The formatted string.\r\n */\r\n public format(coefficient: number, exponent: number, decimals: number): string {\r\n if (exponent === 0) return coefficient.toFixed(decimals);\r\n\r\n const sign = exponent < 0 ? \"-\" : \"+\";\r\n return `${coefficient.toFixed(decimals)}e${sign}${Math.abs(exponent)}`;\r\n }\r\n}\r\n\r\n/** Pre-built {@link ScientificNotation} instance. The default notation used by {@link ArbitraryNumber.toString}. */\r\nexport const scientificNotation = new ScientificNotation();\r\n","/**\r\n * Pre-computed powers of 10 for shift values 0-15.\r\n *\r\n * 16 values * 8 bytes = 128 bytes. Avoids a `Math.pow(10, n)` call (~1-2 ns)\r\n * on every add, sub, floor, ceil, round, and isInteger operation.\r\n * Used by both `ArbitraryNumber` and `ArbitraryNumberArithmetic`.\r\n */\r\nexport const POW10 = [\r\n 1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7,\r\n 1e8, 1e9, 1e10, 1e11, 1e12, 1e13, 1e14, 1e15,\r\n] as const;\r\n\r\n/**\r\n * Returns `10^n`.\r\n *\r\n * Uses the {@link POW10} lookup table for integer `n ∈ [0, 15]` and falls back to\r\n * `Math.pow(10, n)` for values outside that range (e.g. when `PrecisionCutoff > 15`).\r\n *\r\n * @param n - The exponent. Must be a non-negative integer; fractional values are not supported.\r\n */\r\nexport function pow10(n: number): number {\r\n return (n >= 0 && n < 16) ? POW10[n]! : Math.pow(10, n);\r\n}\r\n","/**\r\n * Base class for all errors thrown by the arbitrary-numbers library.\r\n *\r\n * Catch this to handle any error from the library regardless of type.\r\n */\r\nexport class ArbitraryNumberError extends Error {\r\n public constructor(message: string) {\r\n super(message);\r\n this.name = \"ArbitraryNumberError\";\r\n }\r\n}\r\n\r\n/**\r\n * Thrown when invalid input is provided to a constructor or factory method.\r\n *\r\n * @example\r\n * try {\r\n * ArbitraryNumber.from(Infinity);\r\n * } catch (e) {\r\n * if (e instanceof ArbitraryNumberInputError) {\r\n * console.log(e.value); // Infinity\r\n * }\r\n * }\r\n */\r\nexport class ArbitraryNumberInputError extends ArbitraryNumberError {\r\n /** The invalid value that caused the error. */\r\n public readonly value: number | string;\r\n\r\n public constructor(message: string, value: number | string) {\r\n super(message);\r\n this.name = \"ArbitraryNumberInputError\";\r\n this.value = value;\r\n }\r\n}\r\n\r\n/**\r\n * Thrown when a mathematical operation is undefined for the given operands.\r\n *\r\n * @example\r\n * try {\r\n * an(10).div(an(0));\r\n * } catch (e) {\r\n * if (e instanceof ArbitraryNumberDomainError) {\r\n * console.log(e.context); // { dividend: 10 }\r\n * }\r\n * }\r\n */\r\nexport class ArbitraryNumberDomainError extends ArbitraryNumberError {\r\n /** The operands involved in the failed operation, as plain numbers. */\r\n public readonly context: Record<string, number>;\r\n\r\n public constructor(message: string, context: Record<string, number>) {\r\n super(message);\r\n this.name = \"ArbitraryNumberDomainError\";\r\n this.context = context;\r\n }\r\n}\r\n","import { scientificNotation } from \"../plugin/ScientificNotation\";\r\nimport { type NormalizedNumber, type Signum } from \"../types/core\";\r\nimport { type NotationPlugin } from \"../types/plugin\";\r\nimport { pow10 } from \"../constants/pow10\";\r\nimport { ArbitraryNumberInputError, ArbitraryNumberDomainError } from \"../errors\";\r\n\r\n/**\r\n * An immutable number with effectively unlimited range, stored as `coefficient * 10^exponent`\r\n * in normalised scientific notation.\r\n *\r\n * The coefficient is always in `[1, 10)` (or `0`). Addition short-circuits when the exponent\r\n * difference between operands exceeds {@link PrecisionCutoff} - the smaller value is below\r\n * the precision floor of the larger and is silently discarded.\r\n *\r\n * @example\r\n * const a = new ArbitraryNumber(1.5, 3); // 1,500\r\n * const b = new ArbitraryNumber(2.5, 3); // 2,500\r\n * a.add(b).toString(); // \"4.00e+3\"\r\n * a.mul(b).toString(); // \"3.75e+6\"\r\n */\r\nexport class ArbitraryNumber implements NormalizedNumber {\r\n /** The significand, always in `[1, 10)` or `0`. */\r\n public readonly coefficient: number;\r\n /** The power of 10 by which the coefficient is scaled. */\r\n public readonly exponent: number;\r\n\r\n /**\r\n * Precision cutoff: exponent-difference threshold below which the smaller operand\r\n * is negligible and silently skipped during addition/subtraction.\r\n *\r\n * When |exponent_diff| > PrecisionCutoff, the smaller operand contributes less than\r\n * 10^-PrecisionCutoff of the result - below float64 coefficient precision for the default of 15.\r\n *\r\n * Default: 15 (matches float64 coefficient precision of ~15.95 significant digits).\r\n * Game patterns: diffs 0-8 (exact), prestige 15-25 (loss <0.0001%), idle 20-50 (~0.1% loss).\r\n *\r\n * Override globally via assignment, or use {@link withPrecision} for a scoped block.\r\n */\r\n public static PrecisionCutoff: number = 15;\r\n\r\n /** The additive identity: `0`. */\r\n public static readonly Zero = new ArbitraryNumber(0, 0);\r\n /** The multiplicative identity: `1`. */\r\n public static readonly One = new ArbitraryNumber(1, 0);\r\n /** `10`. */\r\n public static readonly Ten = new ArbitraryNumber(1, 1);\r\n\r\n /**\r\n * Creates an `ArbitraryNumber` from a plain JavaScript `number`.\r\n *\r\n * Prefer this over `new ArbitraryNumber(value, 0)` when working with\r\n * ordinary numeric literals - it reads clearly at the call site and\r\n * validates the input.\r\n *\r\n * @example\r\n * ArbitraryNumber.from(1500); // { coefficient: 1.5, exponent: 3 }\r\n * ArbitraryNumber.from(0.005); // { coefficient: 5, exponent: -3 }\r\n * ArbitraryNumber.from(0); // ArbitraryNumber.Zero\r\n *\r\n * @param value - Any finite number.\r\n * @throws `\"ArbitraryNumber.from: value must be finite\"` for `NaN`, `Infinity`, or `-Infinity`.\r\n */\r\n public static from(value: number): ArbitraryNumber {\r\n if (!isFinite(value)) {\r\n throw new ArbitraryNumberInputError(\"ArbitraryNumber.from: value must be finite\", value);\r\n }\r\n\r\n return new ArbitraryNumber(value, 0);\r\n }\r\n\r\n /**\r\n * Constructs a new `ArbitraryNumber` and immediately normalises it so that\r\n * `1 <= |coefficient| < 10` (or `coefficient === 0`).\r\n *\r\n * @example\r\n * new ArbitraryNumber(15, 3); // stored as { coefficient: 1.5, exponent: 4 }\r\n *\r\n * @param coefficient - The significand. Must be a finite number; will be normalised.\r\n * @param exponent - The power of 10. Must be a finite number.\r\n * @throws `\"ArbitraryNumber: coefficient must be finite\"` for `NaN`, `Infinity`, or `-Infinity`.\r\n * @throws `\"ArbitraryNumber: exponent must be finite\"` for non-finite exponents.\r\n */\r\n public constructor(coefficient: number, exponent: number) {\r\n if (coefficient === 0) {\r\n this.coefficient = 0;\r\n this.exponent = 0;\r\n return;\r\n }\r\n if (!isFinite(coefficient)) {\r\n throw new ArbitraryNumberInputError(\"ArbitraryNumber: coefficient must be finite\", coefficient);\r\n }\r\n if (!isFinite(exponent)) {\r\n throw new ArbitraryNumberInputError(\"ArbitraryNumber: exponent must be finite\", exponent);\r\n }\r\n\r\n const abs = Math.abs(coefficient);\r\n const shift = Math.floor(Math.log10(abs));\r\n // Table lookup for shifts 0-15; fall back to Math.pow for out-of-range.\r\n const scale = pow10(shift);\r\n if (scale === 0) {\r\n // Subnormal float - indistinguishable from zero at any practical precision.\r\n this.coefficient = 0;\r\n this.exponent = 0;\r\n return;\r\n }\r\n\r\n this.coefficient = coefficient / scale;\r\n this.exponent = exponent + shift;\r\n }\r\n\r\n /**\r\n * @internal Fast-path factory for already-normalised values.\r\n *\r\n * Uses Object.create() to bypass the constructor (zero normalisation cost).\r\n * Only valid when |coefficient| is already in [1, 10) and exponent is correct.\r\n * Do NOT use for unnormalised inputs - call new ArbitraryNumber(c, e) instead.\r\n */\r\n private static createNormalized(coefficient: number, exponent: number): ArbitraryNumber {\r\n // Object.create skips the constructor; coefficient/exponent are set here for the\r\n // first (and only) time, so readonly semantics are not violated.\r\n const n = Object.create(ArbitraryNumber.prototype);\r\n n.coefficient = coefficient;\r\n n.exponent = exponent;\r\n return n as ArbitraryNumber;\r\n }\r\n\r\n /**\r\n * Normalises raw (coefficient, exponent) into a new ArbitraryNumber.\r\n *\r\n * INVARIANT: all ArbitraryNumber values must have coefficient in [1, 10).\r\n * Algorithm: shift = floor(log10(|c|)); scale c by 10^-shift; adjust exponent.\r\n * Cost: one Math.log10 call (~3-4 ns). This is the fundamental cost floor - logarithm\r\n * is the only way to compute magnitude in JavaScript.\r\n */\r\n private static normalizeFrom(c: number, e: number): ArbitraryNumber {\r\n if (c === 0) return ArbitraryNumber.Zero;\r\n\r\n const abs = Math.abs(c);\r\n const shift = Math.floor(Math.log10(abs));\r\n const scale = pow10(shift);\r\n if (scale === 0) return ArbitraryNumber.Zero;\r\n\r\n return ArbitraryNumber.createNormalized(c / scale, e + shift);\r\n }\r\n\r\n /**\r\n * Returns `this + other`.\r\n *\r\n * When the exponent difference exceeds {@link PrecisionCutoff}, the smaller\r\n * operand has no effect and the larger is returned as-is.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.5, 3).add(new ArbitraryNumber(2.5, 3)); // 4*10^3\r\n */\r\n public add(other: ArbitraryNumber): ArbitraryNumber {\r\n if (this.coefficient === 0) return other;\r\n if (other.coefficient === 0) return this;\r\n\r\n const diff = this.exponent - other.exponent;\r\n // Fast-path: when |exponent diff| > PrecisionCutoff, the smaller operand contributes\r\n // less than 10^-PrecisionCutoff of the result - below float64 coefficient precision.\r\n // Game math accepts this loss; returning the larger operand directly is both correct and faster.\r\n if (diff > ArbitraryNumber.PrecisionCutoff) return this;\r\n if (diff < -ArbitraryNumber.PrecisionCutoff) return other;\r\n\r\n // Aligned sum - inlined to avoid intermediate NormalizedNumber object allocations.\r\n let c: number;\r\n let e: number;\r\n if (diff >= 0) {\r\n c = this.coefficient + other.coefficient / pow10(diff);\r\n e = this.exponent;\r\n } else {\r\n c = other.coefficient + this.coefficient / pow10(-diff);\r\n e = other.exponent;\r\n }\r\n\r\n return ArbitraryNumber.normalizeFrom(c, e);\r\n }\r\n\r\n /**\r\n * Returns `this - other`.\r\n *\r\n * @example\r\n * new ArbitraryNumber(3.5, 3).sub(new ArbitraryNumber(1.5, 3)); // 2*10^3\r\n */\r\n public sub(other: ArbitraryNumber): ArbitraryNumber {\r\n if (other.coefficient === 0) return this;\r\n\r\n const negC = -other.coefficient;\r\n if (this.coefficient === 0) return ArbitraryNumber.createNormalized(negC, other.exponent);\r\n\r\n const diff = this.exponent - other.exponent;\r\n if (diff > ArbitraryNumber.PrecisionCutoff) return this;\r\n if (diff < -ArbitraryNumber.PrecisionCutoff) return ArbitraryNumber.createNormalized(negC, other.exponent);\r\n\r\n let c: number;\r\n let e: number;\r\n if (diff >= 0) {\r\n c = this.coefficient + negC / pow10(diff);\r\n e = this.exponent;\r\n } else {\r\n c = negC + this.coefficient / pow10(-diff);\r\n e = other.exponent;\r\n }\r\n\r\n return ArbitraryNumber.normalizeFrom(c, e);\r\n }\r\n\r\n /**\r\n * Returns `this * other`.\r\n *\r\n * @example\r\n * new ArbitraryNumber(2, 3).mul(new ArbitraryNumber(3, 4)); // 6*10^7\r\n */\r\n public mul(other: ArbitraryNumber): ArbitraryNumber {\r\n if (this.coefficient === 0 || other.coefficient === 0) return ArbitraryNumber.Zero;\r\n\r\n const c = this.coefficient * other.coefficient;\r\n const e = this.exponent + other.exponent;\r\n // Both inputs are in [1,10) (or (-10,-1]), so |c| in [1,100) - at most one step up.\r\n const absC = c < 0 ? -c : c;\r\n if (absC >= 10) return ArbitraryNumber.createNormalized(c / 10, e + 1);\r\n\r\n return ArbitraryNumber.createNormalized(c, e);\r\n }\r\n\r\n /**\r\n * Returns `this / other`.\r\n *\r\n * @example\r\n * new ArbitraryNumber(6, 7).div(new ArbitraryNumber(3, 4)); // 2*10^3\r\n *\r\n * @throws `\"Division by zero\"` when `other` is zero.\r\n */\r\n public div(other: ArbitraryNumber): ArbitraryNumber {\r\n if (other.coefficient === 0) throw new ArbitraryNumberDomainError(\"Division by zero\", { dividend: this.toNumber(), divisor: 0 });\r\n\r\n const c = this.coefficient / other.coefficient;\r\n const e = this.exponent - other.exponent;\r\n if (c === 0) return ArbitraryNumber.Zero;\r\n\r\n // Both inputs are in [1,10) (or (-10,-1]), so |c| in (0.1,10) - at most one step down.\r\n const absC = c < 0 ? -c : c;\r\n if (absC < 1) return ArbitraryNumber.createNormalized(c * 10, e - 1);\r\n\r\n return ArbitraryNumber.createNormalized(c, e);\r\n }\r\n\r\n /**\r\n * Returns the arithmetic negation of this number (`-this`).\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.5, 3).negate(); // -1.5*10^3\r\n */\r\n public negate(): ArbitraryNumber {\r\n if (this.coefficient === 0) return ArbitraryNumber.Zero;\r\n\r\n return ArbitraryNumber.createNormalized(-this.coefficient, this.exponent);\r\n }\r\n\r\n /**\r\n * Returns the absolute value of this number (`|this|`).\r\n *\r\n * Returns `this` unchanged when the number is already non-negative.\r\n *\r\n * @example\r\n * new ArbitraryNumber(-1.5, 3).abs(); // 1.5*10^3\r\n */\r\n public abs(): ArbitraryNumber {\r\n if (this.coefficient >= 0) return this;\r\n\r\n return ArbitraryNumber.createNormalized(-this.coefficient, this.exponent);\r\n }\r\n\r\n /**\r\n * Returns `this^n`.\r\n *\r\n * Supports integer, fractional, and negative exponents.\r\n * `x^0` always returns {@link One}, including `0^0` (by convention).\r\n *\r\n * @example\r\n * new ArbitraryNumber(2, 3).pow(2); // 4*10^6\r\n * new ArbitraryNumber(2, 0).pow(-1); // 5*10^-1 (= 0.5)\r\n *\r\n * @param n - The exponent to raise this number to.\r\n * @throws `\"Zero cannot be raised to a negative power\"` when this is zero and `n < 0`.\r\n */\r\n public pow(n: number): ArbitraryNumber {\r\n if (n === 0) {\r\n return ArbitraryNumber.One;\r\n }\r\n\r\n if (this.coefficient === 0) {\r\n if (n < 0) {\r\n throw new ArbitraryNumberDomainError(\"Zero cannot be raised to a negative power\", { exponent: n });\r\n }\r\n\r\n return ArbitraryNumber.Zero;\r\n }\r\n\r\n if (this.coefficient < 0 && !Number.isInteger(n)) {\r\n throw new ArbitraryNumberDomainError(\"ArbitraryNumber.pow: fractional exponent of a negative base is not supported\", { base: this.toNumber(), exponent: n });\r\n }\r\n\r\n // Fold any fractional part of (exponent * n) into the coefficient so the\r\n // stored exponent stays integral. Suffix formatters require exponent % 3 in {0,1,2}.\r\n const rawExp = this.exponent * n;\r\n const intExp = Math.floor(rawExp);\r\n const fracExp = rawExp - intExp;\r\n return new ArbitraryNumber(\r\n Math.pow(this.coefficient, n) * pow10(fracExp),\r\n intExp,\r\n );\r\n }\r\n\r\n /**\r\n * Fused multiply-add: `(this * multiplier) + addend`.\r\n *\r\n * Faster than `.mul(multiplier).add(addend)` because it avoids allocating an\r\n * intermediate ArbitraryNumber for the product. One normalisation pass total.\r\n *\r\n * Common pattern - prestige loop: `value = value.mulAdd(prestigeMultiplier, prestigeBoost)`\r\n *\r\n * @example\r\n * // Equivalent to value.mul(mult).add(boost) but ~35-50% faster\r\n * const prestiged = currentValue.mulAdd(multiplier, boost);\r\n */\r\n public mulAdd(multiplier: ArbitraryNumber, addend: ArbitraryNumber): ArbitraryNumber {\r\n // Step 1: Multiply (this * multiplier).\r\n // Both coefficients in [1, 10) so the product in [1, 100) - at most one normalisation step.\r\n if (this.coefficient === 0 || multiplier.coefficient === 0) return addend;\r\n\r\n let cp = this.coefficient * multiplier.coefficient; // product coefficient\r\n let ep = this.exponent + multiplier.exponent; // product exponent\r\n\r\n // Normalise product: one comparison instead of Math.log10 (product always in [1, 100))\r\n const absCp = cp < 0 ? -cp : cp;\r\n if (absCp >= 10) { cp /= 10; ep += 1; }\r\n\r\n // Step 2: Add addend to the product - single normalisation pass for the whole operation.\r\n if (addend.coefficient === 0) return ArbitraryNumber.createNormalized(cp, ep);\r\n\r\n const diff = ep - addend.exponent;\r\n // Fast-path: addend is negligible relative to the product\r\n if (diff > ArbitraryNumber.PrecisionCutoff) return ArbitraryNumber.createNormalized(cp, ep);\r\n if (diff < -ArbitraryNumber.PrecisionCutoff) return addend;\r\n\r\n let c: number, e: number;\r\n if (diff >= 0) {\r\n c = cp + addend.coefficient / pow10(diff);\r\n e = ep;\r\n } else {\r\n c = addend.coefficient + cp / pow10(-diff);\r\n e = addend.exponent;\r\n }\r\n\r\n return ArbitraryNumber.normalizeFrom(c, e);\r\n }\r\n\r\n /**\r\n * Fused add-multiply: `(this + addend) * multiplier`.\r\n *\r\n * Faster than `.add(addend).mul(multiplier)` because it avoids allocating an\r\n * intermediate ArbitraryNumber for the sum. One normalisation pass total.\r\n *\r\n * Common pattern - upgrade calculation: `newValue = baseValue.addMul(bonus, multiplier)`\r\n *\r\n * @example\r\n * // Equivalent to base.add(bonus).mul(multiplier) but ~20-25% faster\r\n * const upgraded = baseValue.addMul(bonus, multiplier);\r\n */\r\n public addMul(addend: ArbitraryNumber, multiplier: ArbitraryNumber): ArbitraryNumber {\r\n if (multiplier.coefficient === 0) return ArbitraryNumber.Zero;\r\n\r\n // Step 1: Sum (this + addend) - same logic as add() but we keep raw (c, e) to avoid allocation.\r\n let cs: number, es: number; // sum coefficient and exponent\r\n\r\n if (this.coefficient === 0 && addend.coefficient === 0) return ArbitraryNumber.Zero;\r\n if (this.coefficient === 0) { cs = addend.coefficient; es = addend.exponent; }\r\n else if (addend.coefficient === 0) { cs = this.coefficient; es = this.exponent; }\r\n else {\r\n const diff = this.exponent - addend.exponent;\r\n if (diff > ArbitraryNumber.PrecisionCutoff) { cs = this.coefficient; es = this.exponent; }\r\n else if (diff < -ArbitraryNumber.PrecisionCutoff) { cs = addend.coefficient; es = addend.exponent; }\r\n else {\r\n if (diff >= 0) { cs = this.coefficient + addend.coefficient / pow10(diff); es = this.exponent; }\r\n else { cs = addend.coefficient + this.coefficient / pow10(-diff); es = addend.exponent; }\r\n\r\n // Normalise the sum so the subsequent multiply has a [1, 10) coefficient.\r\n if (cs === 0) return ArbitraryNumber.Zero;\r\n\r\n const abs = Math.abs(cs);\r\n const shift = Math.floor(Math.log10(abs));\r\n const scale = pow10(shift);\r\n if (scale === 0) return ArbitraryNumber.Zero;\r\n\r\n cs /= scale;\r\n es += shift;\r\n }\r\n }\r\n\r\n // Step 2: Multiply the sum by multiplier.\r\n // cs is now normalised in [1, 10), so product in [1, 100) - one comparison suffices.\r\n let cp = cs * multiplier.coefficient;\r\n const ep = es + multiplier.exponent;\r\n const absCp = cp < 0 ? -cp : cp;\r\n if (absCp >= 10) { cp /= 10; return ArbitraryNumber.createNormalized(cp, ep + 1); }\r\n\r\n return ArbitraryNumber.createNormalized(cp, ep);\r\n }\r\n\r\n /**\r\n * Fused multiply-subtract: `(this * multiplier) - subtrahend`.\r\n *\r\n * Avoids one intermediate allocation vs `.mul(multiplier).sub(subtrahend)`.\r\n *\r\n * Common pattern - resource drain: `income.mulSub(rate, upkeepCost)`\r\n */\r\n public mulSub(multiplier: ArbitraryNumber, subtrahend: ArbitraryNumber): ArbitraryNumber {\r\n if (this.coefficient === 0 || multiplier.coefficient === 0) {\r\n // (0 * mult) - sub = -sub\r\n if (subtrahend.coefficient === 0) return ArbitraryNumber.Zero;\r\n\r\n return ArbitraryNumber.createNormalized(-subtrahend.coefficient, subtrahend.exponent);\r\n }\r\n\r\n let cp = this.coefficient * multiplier.coefficient;\r\n let ep = this.exponent + multiplier.exponent;\r\n const absCp = cp < 0 ? -cp : cp;\r\n if (absCp >= 10) { cp /= 10; ep += 1; }\r\n\r\n if (subtrahend.coefficient === 0) return ArbitraryNumber.createNormalized(cp, ep);\r\n\r\n const diff = ep - subtrahend.exponent;\r\n if (diff > ArbitraryNumber.PrecisionCutoff) return ArbitraryNumber.createNormalized(cp, ep);\r\n if (diff < -ArbitraryNumber.PrecisionCutoff) {\r\n return ArbitraryNumber.createNormalized(-subtrahend.coefficient, subtrahend.exponent);\r\n }\r\n\r\n let c: number, e: number;\r\n if (diff >= 0) {\r\n c = cp - subtrahend.coefficient / pow10(diff);\r\n e = ep;\r\n } else {\r\n c = -subtrahend.coefficient + cp / pow10(-diff);\r\n e = subtrahend.exponent;\r\n }\r\n\r\n return ArbitraryNumber.normalizeFrom(c, e);\r\n }\r\n\r\n /**\r\n * Fused subtract-multiply: `(this - subtrahend) * multiplier`.\r\n *\r\n * Avoids one intermediate allocation vs `.sub(subtrahend).mul(multiplier)`.\r\n *\r\n * Common pattern - upgrade after penalty: `health.subMul(damage, multiplier)`\r\n */\r\n public subMul(subtrahend: ArbitraryNumber, multiplier: ArbitraryNumber): ArbitraryNumber {\r\n if (multiplier.coefficient === 0) return ArbitraryNumber.Zero;\r\n\r\n let cs: number, es: number;\r\n\r\n if (this.coefficient === 0 && subtrahend.coefficient === 0) return ArbitraryNumber.Zero;\r\n if (this.coefficient === 0) {\r\n // (0 - sub) * mult = -sub * mult\r\n cs = -subtrahend.coefficient; es = subtrahend.exponent;\r\n } else if (subtrahend.coefficient === 0) {\r\n cs = this.coefficient; es = this.exponent;\r\n } else {\r\n const diff = this.exponent - subtrahend.exponent;\r\n if (diff > ArbitraryNumber.PrecisionCutoff) { cs = this.coefficient; es = this.exponent; }\r\n else if (diff < -ArbitraryNumber.PrecisionCutoff) {\r\n cs = -subtrahend.coefficient; es = subtrahend.exponent;\r\n } else {\r\n if (diff >= 0) {\r\n cs = this.coefficient - subtrahend.coefficient / pow10(diff); es = this.exponent;\r\n } else {\r\n cs = -subtrahend.coefficient + this.coefficient / pow10(-diff); es = subtrahend.exponent;\r\n }\r\n if (cs === 0) return ArbitraryNumber.Zero;\r\n\r\n const abs = Math.abs(cs);\r\n const shift = Math.floor(Math.log10(abs));\r\n const scale = pow10(shift);\r\n if (scale === 0) return ArbitraryNumber.Zero;\r\n\r\n cs /= scale; es += shift;\r\n }\r\n }\r\n\r\n let cp = cs * multiplier.coefficient;\r\n const ep = es + multiplier.exponent;\r\n const absCp = cp < 0 ? -cp : cp;\r\n if (absCp >= 10) { cp /= 10; return ArbitraryNumber.createNormalized(cp, ep + 1); }\r\n\r\n return ArbitraryNumber.createNormalized(cp, ep);\r\n }\r\n\r\n /**\r\n * Fused divide-add: `(this / divisor) + addend`.\r\n *\r\n * Avoids one intermediate allocation vs `.div(divisor).add(addend)`.\r\n *\r\n * Common pattern - efficiency bonus: `damage.divAdd(armor, flat)`\r\n *\r\n * @throws `\"Division by zero\"` when divisor is zero.\r\n */\r\n public divAdd(divisor: ArbitraryNumber, addend: ArbitraryNumber): ArbitraryNumber {\r\n if (divisor.coefficient === 0) throw new ArbitraryNumberDomainError(\"Division by zero\", { dividend: this.toNumber(), divisor: 0 });\r\n\r\n // Step 1: Divide (mirrors div() without creating an ArbitraryNumber)\r\n if (this.coefficient === 0) return addend;\r\n\r\n let cd = this.coefficient / divisor.coefficient;\r\n let ed = this.exponent - divisor.exponent;\r\n const absC = cd < 0 ? -cd : cd;\r\n if (absC < 1) { cd *= 10; ed -= 1; }\r\n\r\n // Step 2: Add addend (same logic as mulAdd step 2)\r\n if (addend.coefficient === 0) return ArbitraryNumber.createNormalized(cd, ed);\r\n\r\n const diff = ed - addend.exponent;\r\n if (diff > ArbitraryNumber.PrecisionCutoff) return ArbitraryNumber.createNormalized(cd, ed);\r\n if (diff < -ArbitraryNumber.PrecisionCutoff) return addend;\r\n\r\n let c: number, e: number;\r\n if (diff >= 0) { c = cd + addend.coefficient / pow10(diff); e = ed; }\r\n else { c = addend.coefficient + cd / pow10(-diff); e = addend.exponent; }\r\n\r\n return ArbitraryNumber.normalizeFrom(c, e);\r\n }\r\n\r\n /**\r\n * Efficiently sums an array of ArbitraryNumbers in a single normalisation pass.\r\n *\r\n * **Why it's fast:** standard chained `.add()` normalises after every element (N log10 calls).\r\n * `sumArray` aligns all coefficients to the largest exponent (pivot), sums them,\r\n * then normalises once - regardless of array size.\r\n *\r\n * For 50 elements: chained add ~ 50 log10 calls + 50 allocations;\r\n * sumArray ~ 50 divisions + 1 log10 call + 1 allocation -> ~9* faster.\r\n *\r\n * Common pattern - income aggregation: `total = ArbitraryNumber.sumArray(incomeSourcesPerTick)`\r\n *\r\n * @example\r\n * const total = ArbitraryNumber.sumArray(incomeSources); // far faster than .reduce((a, b) => a.add(b))\r\n *\r\n * @param numbers - Array to sum. Empty array returns {@link Zero}. Single element returned as-is.\r\n */\r\n public static sumArray(numbers: ArbitraryNumber[]): ArbitraryNumber {\r\n const len = numbers.length;\r\n if (len === 0) return ArbitraryNumber.Zero;\r\n if (len === 1) return numbers[0]!;\r\n\r\n // Find the pivot exponent (largest) - sets the alignment anchor.\r\n // Values with exponent diff > PrecisionCutoff relative to the pivot are negligible.\r\n let pivotExp = numbers[0]!.exponent;\r\n for (let i = 1; i < len; i++) {\r\n const n = numbers[i]!;\r\n if (n.exponent > pivotExp) pivotExp = n.exponent;\r\n }\r\n\r\n // Align all coefficients to the pivot exponent and accumulate - no log10 yet.\r\n let total = 0;\r\n for (let i = 0; i < len; i++) {\r\n const n = numbers[i]!;\r\n if (n.coefficient === 0) continue;\r\n\r\n const diff = pivotExp - n.exponent; // always >= 0\r\n if (diff > ArbitraryNumber.PrecisionCutoff) continue; // negligible vs pivot\r\n\r\n total += n.coefficient / pow10(diff);\r\n }\r\n\r\n // Single normalisation pass for the entire array.\r\n if (total === 0) return ArbitraryNumber.Zero;\r\n\r\n const abs = Math.abs(total);\r\n const shift = Math.floor(Math.log10(abs));\r\n const scale = pow10(shift);\r\n if (scale === 0) return ArbitraryNumber.Zero;\r\n\r\n return ArbitraryNumber.createNormalized(total / scale, pivotExp + shift);\r\n }\r\n\r\n /**\r\n * Compares this number to `other`.\r\n *\r\n * @returns `1` if `this > other`, `-1` if `this < other`, `0` if equal.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1, 4).compareTo(new ArbitraryNumber(9, 3)); // 1 (10000 > 9000)\r\n * new ArbitraryNumber(-1, 4).compareTo(new ArbitraryNumber(1, 3)); // -1 (-10000 < 1000)\r\n */\r\n public compareTo(other: ArbitraryNumber): number {\r\n const thisNegative = this.coefficient < 0;\r\n const otherNegative = other.coefficient < 0;\r\n\r\n // one is negative and the other is not\r\n if (thisNegative !== otherNegative) {\r\n return thisNegative ? -1 : 1;\r\n }\r\n\r\n if (this.exponent !== other.exponent) {\r\n // Zero is stored as {coefficient: 0, exponent: 0}. Without the guard below,\r\n // Zero.compareTo({c: 5, e: -1}) would hit the exponent branch and return 1\r\n // (0 > -1) instead of the correct -1 (0 < 0.5). The guard is inside the\r\n // exponent-differs branch so the same-exponent hot path pays zero extra cost.\r\n if (this.coefficient === 0) return otherNegative ? 1 : -1;\r\n if (other.coefficient === 0) return thisNegative ? -1 : 1;\r\n\r\n const thisExponentIsHigher = this.exponent > other.exponent;\r\n // For negatives, a larger exponent means a more negative (smaller) value\r\n return thisNegative\r\n ? (thisExponentIsHigher ? -1 : 1)\r\n : (thisExponentIsHigher ? 1 : -1);\r\n }\r\n\r\n // exponents are equal, compare coefficients\r\n if (this.coefficient !== other.coefficient) {\r\n return this.coefficient > other.coefficient ? 1 : -1;\r\n }\r\n\r\n // they are equal\r\n return 0;\r\n }\r\n\r\n /** Returns `true` if `this > other`. */\r\n public greaterThan(other: ArbitraryNumber): boolean {\r\n return this.compareTo(other) > 0;\r\n }\r\n\r\n /** Returns `true` if `this < other`. */\r\n public lessThan(other: ArbitraryNumber): boolean {\r\n return this.compareTo(other) < 0;\r\n }\r\n\r\n /** Returns `true` if `this >= other`. */\r\n public greaterThanOrEqual(other: ArbitraryNumber): boolean {\r\n return this.compareTo(other) >= 0;\r\n }\r\n\r\n /** Returns `true` if `this <= other`. */\r\n public lessThanOrEqual(other: ArbitraryNumber): boolean {\r\n return this.compareTo(other) <= 0;\r\n }\r\n\r\n /** Returns `true` if `this === other` in value. */\r\n public equals(other: ArbitraryNumber): boolean {\r\n return this.compareTo(other) === 0;\r\n }\r\n\r\n /**\r\n * Returns the largest integer less than or equal to this number (floor toward -Infinity).\r\n *\r\n * Numbers with `exponent >= PrecisionCutoff` are already integers at that scale\r\n * and are returned unchanged.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.7, 0).floor(); // 1\r\n * new ArbitraryNumber(-1.7, 0).floor(); // -2\r\n */\r\n public floor(): ArbitraryNumber {\r\n if (this.coefficient === 0) {\r\n return ArbitraryNumber.Zero;\r\n }\r\n\r\n if (this.exponent >= ArbitraryNumber.PrecisionCutoff) {\r\n return this;\r\n }\r\n\r\n if (this.exponent < 0) {\r\n return this.coefficient >= 0 ? ArbitraryNumber.Zero : new ArbitraryNumber(-1, 0);\r\n }\r\n\r\n return new ArbitraryNumber(Math.floor(this.coefficient * pow10(this.exponent)), 0);\r\n }\r\n\r\n /**\r\n * Returns the smallest integer greater than or equal to this number (ceil toward +Infinity).\r\n *\r\n * Numbers with `exponent >= PrecisionCutoff` are already integers at that scale\r\n * and are returned unchanged.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.2, 0).ceil(); // 2\r\n * new ArbitraryNumber(-1.7, 0).ceil(); // -1\r\n */\r\n public ceil(): ArbitraryNumber {\r\n if (this.coefficient === 0) {\r\n return ArbitraryNumber.Zero;\r\n }\r\n\r\n if (this.exponent >= ArbitraryNumber.PrecisionCutoff) {\r\n return this;\r\n }\r\n\r\n if (this.exponent < 0) {\r\n return this.coefficient > 0 ? ArbitraryNumber.One : ArbitraryNumber.Zero;\r\n }\r\n\r\n return new ArbitraryNumber(Math.ceil(this.coefficient * pow10(this.exponent)), 0);\r\n }\r\n\r\n /**\r\n * Clamps `value` to the inclusive range `[min, max]`.\r\n *\r\n * @example\r\n * ArbitraryNumber.clamp(new ArbitraryNumber(5, 2), new ArbitraryNumber(1, 3), new ArbitraryNumber(2, 3)); // 1*10^3 (500 clamped to [1000, 2000])\r\n *\r\n * @param value - The value to clamp.\r\n * @param min - Lower bound (inclusive).\r\n * @param max - Upper bound (inclusive).\r\n */\r\n public static clamp(value: ArbitraryNumber, min: ArbitraryNumber, max: ArbitraryNumber): ArbitraryNumber {\r\n if (value.lessThan(min)) return min;\r\n if (value.greaterThan(max)) return max;\r\n\r\n return value;\r\n }\r\n\r\n /**\r\n * Returns the smaller of `a` and `b`.\r\n * @example ArbitraryNumber.min(a, b)\r\n */\r\n public static min(a: ArbitraryNumber, b: ArbitraryNumber): ArbitraryNumber {\r\n return a.lessThan(b) ? a : b;\r\n }\r\n\r\n /**\r\n * Returns the larger of `a` and `b`.\r\n * @example ArbitraryNumber.max(a, b)\r\n */\r\n public static max(a: ArbitraryNumber, b: ArbitraryNumber): ArbitraryNumber {\r\n return a.greaterThan(b) ? a : b;\r\n }\r\n\r\n /**\r\n * Linear interpolation: `a + (b - a) * t` where `t in [0, 1]` is a plain number.\r\n *\r\n * Used for smooth animations and tweening in game UIs.\r\n * `t = 0` returns `a`; `t = 1` returns `b`.\r\n *\r\n * @param t - Interpolation factor as a plain `number`. Values outside [0, 1] are allowed (extrapolation).\r\n * @example\r\n * ArbitraryNumber.lerp(an(100), an(200), 0.5); // 150\r\n */\r\n public static lerp(a: ArbitraryNumber, b: ArbitraryNumber, t: number): ArbitraryNumber {\r\n if (t === 0) return a;\r\n if (t === 1) return b;\r\n\r\n return a.add(b.sub(a).mul(ArbitraryNumber.from(t)));\r\n }\r\n\r\n /**\r\n * Runs `fn` with `PrecisionCutoff` temporarily set to `cutoff`, then restores the previous value.\r\n *\r\n * Useful when one section of code needs different precision than the rest.\r\n *\r\n * @example\r\n * // Run financial calculation with higher precision\r\n * const result = ArbitraryNumber.withPrecision(50, () => a.add(b));\r\n */\r\n public static withPrecision<T>(cutoff: number, fn: () => T): T {\r\n const prev = ArbitraryNumber.PrecisionCutoff;\r\n ArbitraryNumber.PrecisionCutoff = cutoff;\r\n try {\r\n return fn();\r\n } finally {\r\n ArbitraryNumber.PrecisionCutoff = prev;\r\n }\r\n }\r\n\r\n /**\r\n * Returns `log10(this)` as a plain JavaScript `number`.\r\n *\r\n * Because the number is stored as `c * 10^e`, this is computed exactly as\r\n * `log10(c) + e` - no precision loss from the exponent.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1, 6).log10(); // 6\r\n * new ArbitraryNumber(1.5, 3).log10(); // log10(1.5) + 3 ~ 3.176\r\n *\r\n * @throws `\"Logarithm of zero is undefined\"` when this is zero.\r\n * @throws `\"Logarithm of a negative number is undefined\"` when this is negative.\r\n */\r\n public log10(): number {\r\n if (this.coefficient === 0) {\r\n throw new ArbitraryNumberDomainError(\"Logarithm of zero is undefined\", { value: 0 });\r\n }\r\n\r\n if (this.coefficient < 0) {\r\n throw new ArbitraryNumberDomainError(\"Logarithm of a negative number is undefined\", { value: this.toNumber() });\r\n }\r\n\r\n return Math.log10(this.coefficient) + this.exponent;\r\n }\r\n\r\n /**\r\n * Returns √this.\r\n *\r\n * Computed as pure coefficient math - no `Math.log10` call. Cost: one `Math.sqrt`.\r\n * For even exponents: `sqrt(c) * 10^(e/2)`.\r\n * For odd exponents: `sqrt(c * 10) * 10^((e-1)/2)`.\r\n *\r\n * @throws `\"Square root of negative number\"` when this is negative.\r\n * @example\r\n * new ArbitraryNumber(4, 0).sqrt(); // 2\r\n * new ArbitraryNumber(1, 4).sqrt(); // 1*10^2 (= 100)\r\n */\r\n public sqrt(): ArbitraryNumber {\r\n if (this.coefficient < 0) throw new ArbitraryNumberDomainError(\"Square root of negative number\", { value: this.toNumber() });\r\n if (this.coefficient === 0) return ArbitraryNumber.Zero;\r\n if (this.exponent % 2 !== 0) {\r\n // Odd exponent: shift one factor of 10 into the coefficient\r\n return ArbitraryNumber.createNormalized(Math.sqrt(this.coefficient * 10), (this.exponent - 1) / 2);\r\n }\r\n\r\n return ArbitraryNumber.createNormalized(Math.sqrt(this.coefficient), this.exponent / 2);\r\n }\r\n\r\n /**\r\n * Returns the nearest integer value (rounds half-up).\r\n *\r\n * Numbers with `exponent >= PrecisionCutoff` are already integers at that scale\r\n * and are returned unchanged.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.5, 0).round(); // 2\r\n * new ArbitraryNumber(1.4, 0).round(); // 1\r\n * new ArbitraryNumber(-1.5, 0).round(); // -1 (half-up toward positive infinity)\r\n */\r\n public round(): ArbitraryNumber {\r\n if (this.coefficient === 0) return ArbitraryNumber.Zero;\r\n if (this.exponent >= ArbitraryNumber.PrecisionCutoff) return this;\r\n\r\n if (this.exponent < 0) {\r\n // exponent <= -2: |value| < 0.1 -> always rounds to 0\r\n if (this.exponent <= -2) return ArbitraryNumber.Zero;\r\n\r\n // exponent === -1: value = coefficient * 0.1 (no Math.pow needed)\r\n const rounded = Math.round(this.coefficient * 0.1);\r\n return rounded === 0\r\n ? ArbitraryNumber.Zero\r\n : new ArbitraryNumber(rounded, 0);\r\n }\r\n\r\n return new ArbitraryNumber(Math.round(this.coefficient * pow10(this.exponent)), 0);\r\n }\r\n\r\n /**\r\n * Returns `1` if positive, `-1` if negative, `0` if zero.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.5, 3).sign(); // 1\r\n * new ArbitraryNumber(-1.5, 3).sign(); // -1\r\n * ArbitraryNumber.Zero.sign(); // 0\r\n */\r\n public sign(): Signum {\r\n return Math.sign(this.coefficient) as Signum;\r\n }\r\n\r\n /**\r\n * Converts to a plain JavaScript `number`.\r\n *\r\n * Precision is limited to float64 (~15 significant digits).\r\n * Returns `Infinity` for exponents beyond the float64 range (>=308).\r\n * Returns `0` for exponents below the float64 range (<=-324).\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.5, 3).toNumber(); // 1500\r\n * new ArbitraryNumber(1, 400).toNumber(); // Infinity\r\n */\r\n public toNumber(): number {\r\n return this.coefficient * pow10(this.exponent);\r\n }\r\n\r\n /** Returns `true` when this number is zero. */\r\n public isZero(): boolean { return this.coefficient === 0; }\r\n\r\n /** Returns `true` when this number is strictly positive. */\r\n public isPositive(): boolean { return this.coefficient > 0; }\r\n\r\n /** Returns `true` when this number is strictly negative. */\r\n public isNegative(): boolean { return this.coefficient < 0; }\r\n\r\n /**\r\n * Returns `true` when this number has no fractional part.\r\n * Numbers with `exponent >= PrecisionCutoff` are always considered integers.\r\n */\r\n public isInteger(): boolean {\r\n if (this.coefficient === 0) return true;\r\n if (this.exponent >= ArbitraryNumber.PrecisionCutoff) return true;\r\n if (this.exponent < 0) return false;\r\n\r\n // exponent in [0, PrecisionCutoff-1] - covered by pow10 table (0-15)\r\n return Number.isInteger(this.coefficient * pow10(this.exponent));\r\n }\r\n\r\n /**\r\n * Formats this number as a string using the given notation plugin.\r\n *\r\n * Defaults to {@link scientificNotation} when no plugin is provided.\r\n * `decimals` controls the number of decimal places passed to the plugin and defaults to `2`.\r\n *\r\n * @example\r\n * new ArbitraryNumber(1.5, 3).toString(); // \"1.50e+3\"\r\n * new ArbitraryNumber(1.5, 3).toString(unitNotation); // \"1.50 K\"\r\n * new ArbitraryNumber(1.5, 3).toString(unitNotation, 4); // \"1.5000 K\"\r\n *\r\n * @param notation - The formatting plugin to use.\r\n * @param decimals - Number of decimal places to render. Defaults to `2`.\r\n */\r\n public toString(notation: NotationPlugin = scientificNotation, decimals = 2): string {\r\n return notation.format(this.coefficient, this.exponent, decimals);\r\n }\r\n}\r\n","import type { AnFunction } from \"../types/core\";\r\nimport { ArbitraryNumber } from \"./ArbitraryNumber\";\r\n\r\nconst createAn = ((coefficient: number, exponent = 0) =>\r\n new ArbitraryNumber(coefficient, exponent)) as AnFunction;\r\n\r\ncreateAn.from = (value: number) => ArbitraryNumber.from(value);\r\n\r\nexport const an: AnFunction = createAn;\r\n","import { ArbitraryNumber } from \"./ArbitraryNumber\";\r\n\r\n/**\r\n * Fluent builder for multi-step `ArbitraryNumber` expressions.\r\n *\r\n * Each method mutates the accumulated value in-place and returns `this`,\r\n * enabling a readable left-to-right pipeline with no expression-tree\r\n * overhead. Every step delegates directly to the underlying\r\n * `ArbitraryNumber` method - fused variants (`mulAdd`, `mulSub`, etc.)\r\n * are available here too.\r\n *\r\n * @example\r\n * // Damage formula: ((base - armour) * mult) + flatBonus\r\n * const result = chain(base)\r\n * .subMul(armour, multiplier)\r\n * .add(flatBonus)\r\n * .done();\r\n *\r\n * @remarks\r\n * No deferred execution - each call runs immediately. Overhead vs direct\r\n * method chaining is a single extra method call + `return this` per step\r\n * (~1-2 ns). Use fused ops for hot inner loops; the builder is optimised\r\n * for readability in complex multi-step formulas.\r\n */\r\nexport class AnChain {\r\n private value: ArbitraryNumber;\r\n\r\n private constructor(start: ArbitraryNumber) {\r\n this.value = start;\r\n }\r\n\r\n // ── Construction ────────────────────────────────────────────────────\r\n\r\n /** Creates an `AnChain` from an `ArbitraryNumber` or a plain `number`. */\r\n public static from(value: ArbitraryNumber | number): AnChain {\r\n if (value instanceof ArbitraryNumber) return new AnChain(value);\r\n\r\n return new AnChain(ArbitraryNumber.from(value));\r\n }\r\n\r\n // ── Arithmetic ───────────────────────────────────────────────────────\r\n\r\n /** Adds `other` to the accumulated value. */\r\n public add(other: ArbitraryNumber): this {\r\n this.value = this.value.add(other);\r\n return this;\r\n }\r\n\r\n /** Subtracts `other` from the accumulated value. */\r\n public sub(other: ArbitraryNumber): this {\r\n this.value = this.value.sub(other);\r\n return this;\r\n }\r\n\r\n /** Multiplies the accumulated value by `other`. */\r\n public mul(other: ArbitraryNumber): this {\r\n this.value = this.value.mul(other);\r\n return this;\r\n }\r\n\r\n /** Divides the accumulated value by `other`. */\r\n public div(other: ArbitraryNumber): this {\r\n this.value = this.value.div(other);\r\n return this;\r\n }\r\n\r\n /** Raises the accumulated value to `exp`. */\r\n public pow(exp: number): this {\r\n this.value = this.value.pow(exp);\r\n return this;\r\n }\r\n\r\n // ── Fused (avoids one intermediate allocation per call) ──────────────\r\n\r\n /** `(this * mult) + add` */\r\n public mulAdd(mult: ArbitraryNumber, add: ArbitraryNumber): this {\r\n this.value = this.value.mulAdd(mult, add);\r\n return this;\r\n }\r\n\r\n /** `(this + add) * mult` */\r\n public addMul(add: ArbitraryNumber, mult: ArbitraryNumber): this {\r\n this.value = this.value.addMul(add, mult);\r\n return this;\r\n }\r\n\r\n /** `(this * mult) - sub` */\r\n public mulSub(mult: ArbitraryNumber, sub: ArbitraryNumber): this {\r\n this.value = this.value.mulSub(mult, sub);\r\n return this;\r\n }\r\n\r\n /** `(this - sub) * mult` */\r\n public subMul(sub: ArbitraryNumber, mult: ArbitraryNumber): this {\r\n this.value = this.value.subMul(sub, mult);\r\n return this;\r\n }\r\n\r\n /** `(this / div) + add` */\r\n public divAdd(div: ArbitraryNumber, add: ArbitraryNumber): this {\r\n this.value = this.value.divAdd(div, add);\r\n return this;\r\n }\r\n\r\n // ── Unary ────────────────────────────────────────────────────────────\r\n\r\n /** Absolute value. */\r\n public abs(): this {\r\n this.value = this.value.abs();\r\n return this;\r\n }\r\n\r\n /** Negates the accumulated value. */\r\n public neg(): this {\r\n this.value = this.value.negate();\r\n return this;\r\n }\r\n\r\n /** Square root of the accumulated value. */\r\n public sqrt(): this {\r\n this.value = this.value.sqrt();\r\n return this;\r\n }\r\n\r\n /** Rounds down to the nearest integer. */\r\n public floor(): this {\r\n this.value = this.value.floor();\r\n return this;\r\n }\r\n\r\n /** Rounds up to the nearest integer. */\r\n public ceil(): this {\r\n this.value = this.value.ceil();\r\n return this;\r\n }\r\n\r\n /** Rounds to the nearest integer. */\r\n public round(): this {\r\n this.value = this.value.round();\r\n return this;\r\n }\r\n\r\n // ── Terminal ─────────────────────────────────────────────────────────\r\n\r\n /** Returns the accumulated `ArbitraryNumber` result. */\r\n public done(): ArbitraryNumber {\r\n return this.value;\r\n }\r\n}\r\n\r\n/**\r\n * Creates an {@link AnChain} builder starting from `value`.\r\n *\r\n * Mirrors the `an` factory shorthand.\r\n *\r\n * @example\r\n * import { chain, an } from 'arbitrary-numbers';\r\n *\r\n * const result = chain(an(1.5, 6))\r\n * .mulAdd(multiplier, bonus)\r\n * .floor()\r\n * .done();\r\n */\r\nexport function chain(value: ArbitraryNumber | number): AnChain {\r\n return AnChain.from(value);\r\n}\r\n","import { ArbitraryNumber } from \"./ArbitraryNumber\";\r\n\r\ntype FormulaStep = (value: ArbitraryNumber) => ArbitraryNumber;\r\n\r\n/**\r\n * A reusable, named pipeline of `ArbitraryNumber` operations.\r\n *\r\n * Unlike {@link AnChain}, which executes each step immediately against an\r\n * accumulated value, `AnFormula` stores the operations as a list of closures\r\n * and runs them only when {@link apply} is called. The same formula can be\r\n * applied to any number of values without re-defining the pipeline.\r\n *\r\n * Each builder method returns a **new** `AnFormula` - the original is\r\n * unchanged. This makes branching and composition safe:\r\n *\r\n * @example\r\n * const base = formula().mul(an(2));\r\n * const withFloor = base.floor(); // new formula - base is unchanged\r\n * const withCeil = base.ceil(); // another branch from base\r\n *\r\n * @example\r\n * // Define once, apply to many values\r\n * const armorReduction = formula(\"Armor Reduction\")\r\n * .subMul(armor, an(0.75))\r\n * .floor();\r\n *\r\n * const physDamage = armorReduction.apply(physBase);\r\n * const magDamage = armorReduction.apply(magBase);\r\n *\r\n * @example\r\n * // Compose formulas\r\n * const critBonus = formula(\"Crit Bonus\").mul(critMult).ceil();\r\n * const full = armorReduction.then(critBonus);\r\n * const result = full.apply(baseDamage);\r\n */\r\nexport class AnFormula {\r\n private readonly _name?: string;\r\n private readonly steps: ReadonlyArray<FormulaStep>;\r\n\r\n /**\r\n * Prefer the {@link formula} factory function over calling this directly.\r\n */\r\n public constructor(name?: string, steps: ReadonlyArray<FormulaStep> = []) {\r\n this._name = name;\r\n this.steps = steps;\r\n }\r\n\r\n /** The name passed to {@link formula}, if any. */\r\n public get name(): string | undefined {\r\n return this._name;\r\n }\r\n\r\n /**\r\n * Returns a copy of this formula with a new name, leaving the original unchanged.\r\n *\r\n * @param name - The new name.\r\n * @example\r\n * const base = formula().mul(an(2));\r\n * const named = base.named(\"Double\");\r\n * named.name // \"Double\"\r\n * base.name // undefined\r\n */\r\n public named(name: string): AnFormula {\r\n return new AnFormula(name, this.steps);\r\n }\r\n\r\n // ── Private helper ────────────────────────────────────────────────────────\r\n\r\n private step(fn: FormulaStep): AnFormula {\r\n return new AnFormula(this._name, [...this.steps, fn]);\r\n }\r\n\r\n // ── Arithmetic ────────────────────────────────────────────────────────────\r\n\r\n /** Appends `+ other` to the pipeline. */\r\n public add(other: ArbitraryNumber): AnFormula { return this.step(v => v.add(other)); }\r\n /** Appends `- other` to the pipeline. */\r\n public sub(other: ArbitraryNumber): AnFormula { return this.step(v => v.sub(other)); }\r\n /** Appends `* other` to the pipeline. */\r\n public mul(other: ArbitraryNumber): AnFormula { return this.step(v => v.mul(other)); }\r\n /** Appends `/ other` to the pipeline. */\r\n public div(other: ArbitraryNumber): AnFormula { return this.step(v => v.div(other)); }\r\n /** Appends `^ exp` to the pipeline. */\r\n public pow(exp: number): AnFormula { return this.step(v => v.pow(exp)); }\r\n\r\n // ── Fused (avoids one intermediate allocation per call) ───────────────────\r\n\r\n /** Appends `(value * mult) + add` to the pipeline. */\r\n public mulAdd(mult: ArbitraryNumber, add: ArbitraryNumber): AnFormula { return this.step(v => v.mulAdd(mult, add)); }\r\n /** Appends `(value + add) * mult` to the pipeline. */\r\n public addMul(add: ArbitraryNumber, mult: ArbitraryNumber): AnFormula { return this.step(v => v.addMul(add, mult)); }\r\n /** Appends `(value * mult) - sub` to the pipeline. */\r\n public mulSub(mult: ArbitraryNumber, sub: ArbitraryNumber): AnFormula { return this.step(v => v.mulSub(mult, sub)); }\r\n /** Appends `(value - sub) * mult` to the pipeline. */\r\n public subMul(sub: ArbitraryNumber, mult: ArbitraryNumber): AnFormula { return this.step(v => v.subMul(sub, mult)); }\r\n /** Appends `(value / div) + add` to the pipeline. */\r\n public divAdd(div: ArbitraryNumber, add: ArbitraryNumber): AnFormula { return this.step(v => v.divAdd(div, add)); }\r\n\r\n // ── Unary ─────────────────────────────────────────────────────────────────\r\n\r\n /** Appends `abs()` to the pipeline. */\r\n public abs(): AnFormula { return this.step(v => v.abs()); }\r\n /** Appends `neg()` to the pipeline. */\r\n public neg(): AnFormula { return this.step(v => v.negate()); }\r\n /** Appends `sqrt()` to the pipeline. */\r\n public sqrt(): AnFormula { return this.step(v => v.sqrt()); }\r\n /** Appends `floor()` to the pipeline. */\r\n public floor(): AnFormula { return this.step(v => v.floor()); }\r\n /** Appends `ceil()` to the pipeline. */\r\n public ceil(): AnFormula { return this.step(v => v.ceil()); }\r\n /** Appends `round()` to the pipeline. */\r\n public round(): AnFormula { return this.step(v => v.round()); }\r\n\r\n // ── Composition ───────────────────────────────────────────────────────────\r\n\r\n /**\r\n * Returns a new formula that first applies `this`, then applies `next`.\r\n *\r\n * Neither operand is mutated.\r\n *\r\n * @param next - The formula to apply after `this`.\r\n * @example\r\n * const full = armorReduction.then(critBonus);\r\n * const result = full.apply(baseDamage);\r\n */\r\n public then(next: AnFormula): AnFormula {\r\n return new AnFormula(this._name, [...this.steps, ...next.steps]);\r\n }\r\n\r\n // ── Terminal ──────────────────────────────────────────────────────────────\r\n\r\n /**\r\n * Runs this formula's pipeline against `value` and returns the result.\r\n *\r\n * The formula itself is unchanged - call `apply` as many times as needed.\r\n *\r\n * @param value - The starting value. Plain `number` is coerced via `ArbitraryNumber.from`.\r\n * @throws `\"ArbitraryNumber.from: value must be finite\"` when a plain `number` is non-finite.\r\n * @example\r\n * const damage = damageFormula.apply(baseDamage);\r\n * const scaled = damageFormula.apply(boostedBase);\r\n */\r\n public apply(value: ArbitraryNumber | number): ArbitraryNumber {\r\n let result: ArbitraryNumber = value instanceof ArbitraryNumber\r\n ? value\r\n : ArbitraryNumber.from(value);\r\n\r\n for (const step of this.steps) {\r\n result = step(result);\r\n }\r\n\r\n return result;\r\n }\r\n}\r\n\r\n/**\r\n * Creates an {@link AnFormula} pipeline, optionally named.\r\n *\r\n * Build the pipeline by chaining methods - each returns a new `AnFormula`\r\n * so the original is always safe to branch or reuse. Call {@link AnFormula.apply}\r\n * to run the pipeline against a value.\r\n *\r\n * @param name - Optional label, available via {@link AnFormula.name} for debugging.\r\n * @example\r\n * import { formula, an } from 'arbitrary-numbers';\r\n *\r\n * const armorReduction = formula(\"Armor Reduction\")\r\n * .subMul(armor, an(0.75)) // (base - armor) * 0.75\r\n * .floor();\r\n *\r\n * const critBonus = formula(\"Crit Bonus\").mul(critMult).ceil();\r\n *\r\n * // Reuse across many values\r\n * const physDmg = armorReduction.apply(physBase);\r\n * const magDmg = armorReduction.apply(magBase);\r\n *\r\n * // Compose\r\n * const full = armorReduction.then(critBonus);\r\n * const result = full.apply(baseDamage);\r\n */\r\nexport function formula(name?: string): AnFormula {\r\n return new AnFormula(name, []);\r\n}\r\n","import { type Mod3 } from \"../types/core\";\r\nimport { type SuffixNotationPlugin, type SuffixNotationPluginOptions } from \"../types/plugin\";\r\n\r\n/**\r\n * Abstract base class for suffix-based notation plugins (e.g. `\"1.50 K\"`, `\"3.20a\"`).\r\n *\r\n * Subclasses implement {@link getSuffix} to map a tier to a display label.\r\n * All coefficient/remainder math is handled here.\r\n *\r\n * @example\r\n * class EmojiNotation extends SuffixNotationBase {\r\n * private static readonly TIERS = [\"\", \"🔥\", \"💥\", \"🌟\", \"🚀\"];\r\n * getSuffix(tier: number): string {\r\n * return EmojiNotation.TIERS[tier] ?? `e+${tier * 3}`;\r\n * }\r\n * }\r\n */\r\nexport abstract class SuffixNotationBase implements SuffixNotationPlugin {\r\n /** Lookup for remainder values 0, 1, 2 (exponent mod 3). */\r\n protected readonly displayScale = [1, 10, 100] as const;\r\n protected readonly separator: string;\r\n\r\n /**\r\n * @param options - Plugin options. `separator` defaults to `\"\"`.\r\n */\r\n public constructor(options: SuffixNotationPluginOptions = { separator: \"\" }) {\r\n this.separator = options.separator ?? \"\";\r\n }\r\n\r\n /**\r\n * Returns the suffix label for the given tier, where `tier = floor(exponent / 3)`.\r\n *\r\n * Tier 0 corresponds to values below 10^3 - return `\"\"` to render with no suffix.\r\n * Tier 1 = 10^3, tier 2 = 10^6, and so on.\r\n *\r\n * @param tier - The exponent tier (`floor(exponent / 3)`), >= 0.\r\n * @returns The suffix string (e.g. `\"K\"`, `\"a\"`), or `\"\"` for no suffix.\r\n */\r\n public abstract getSuffix(tier: number): string;\r\n\r\n /**\r\n * Formats the number by combining the scaled coefficient with the suffix returned\r\n * by {@link getSuffix}. When `getSuffix` returns an empty string, the separator is\r\n * omitted and only the plain value is returned.\r\n *\r\n * @param coefficient - The significand in `[1, 10)` or `0`.\r\n * @param exponent - The power of 10.\r\n * @param decimals - Number of decimal places in the output.\r\n * @returns The formatted string.\r\n */\r\n public format(coefficient: number, exponent: number, decimals: number): string {\r\n if (exponent < 0) {\r\n return (coefficient * Math.pow(10, exponent)).toFixed(decimals);\r\n }\r\n\r\n const tier = Math.floor(exponent / 3);\r\n const remainder = (exponent - tier * 3) as Mod3;\r\n const displayC = coefficient * this.displayScale[remainder];\r\n const suffix = this.getSuffix(tier);\r\n\r\n if (!suffix) return displayC.toFixed(decimals);\r\n\r\n return `${displayC.toFixed(decimals)}${this.separator}${suffix}`;\r\n }\r\n}\r\n","import { ArbitraryNumberInputError } from \"../errors\";\r\nimport { type AlphabetNotationOptions } from \"../types/plugin\";\r\nimport { SuffixNotationBase } from \"./SuffixNotationBase\";\r\n\r\n/**\r\n * Converts a tier number to a multi-character suffix using an ordered symbol set.\r\n *\r\n * This is the raw algorithm behind {@link AlphabetNotation}, exposed as a standalone\r\n * function for cases where you need suffix generation without the full notation plugin\r\n * (e.g. column headers, label generators, custom renderers).\r\n *\r\n * The algorithm is base-N positional with no leading-symbol ambiguity:\r\n * - Tier 0 -> `\"\"` (no suffix)\r\n * - Tier 1 -> `alphabet[0]`\r\n * - Tier N -> `alphabet[N-1]` (last single-character suffix)\r\n * - Tier N+1 -> `alphabet[0]+alphabet[0]` (first two-character suffix)\r\n *\r\n * This matches Excel column naming when `alphabet = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"`.\r\n *\r\n * @param tier - The tier number (`Math.floor(exponent / 3)` in notation context). Must be >= 0.\r\n * @param alphabet - The ordered symbol set. Defaults to `\"abcdefghijklmnopqrstuvwxyz\"`.\r\n * @returns The suffix string, or `\"\"` for tier 0.\r\n *\r\n * @example\r\n * alphabetSuffix(0, \"abc\") // \"\"\r\n * alphabetSuffix(1, \"abc\") // \"a\"\r\n * alphabetSuffix(3, \"abc\") // \"c\"\r\n * alphabetSuffix(4, \"abc\") // \"aa\"\r\n * alphabetSuffix(6, \"abc\") // \"ac\"\r\n * alphabetSuffix(7, \"abc\") // \"ba\"\r\n *\r\n * // Excel columns\r\n * alphabetSuffix(1, \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\") // \"A\"\r\n * alphabetSuffix(26, \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\") // \"Z\"\r\n * alphabetSuffix(27, \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\") // \"AA\"\r\n */\r\nexport function alphabetSuffix(tier: number, alphabet = \"abcdefghijklmnopqrstuvwxyz\"): string {\r\n if (alphabet.length === 0) throw new ArbitraryNumberInputError(\"alphabet must not be empty\", alphabet);\r\n if (tier <= 0) return \"\";\r\n\r\n const index = tier - 1; // tier 1 = first symbol = index 0\r\n\r\n // Find which length group this index falls in.\r\n let length = 1;\r\n let capacity = alphabet.length;\r\n let offset = 0;\r\n\r\n while (index >= offset + capacity) {\r\n offset += capacity;\r\n length++;\r\n capacity = alphabet.length ** length;\r\n }\r\n\r\n let remaining = index - offset;\r\n const chars = new Array<string>(length);\r\n\r\n for (let i = length - 1; i >= 0; i--) {\r\n chars[i] = alphabet[remaining % alphabet.length]!;\r\n remaining = Math.floor(remaining / alphabet.length);\r\n }\r\n\r\n return chars.join(\"\");\r\n}\r\n\r\n/**\r\n * Formats numbers using multi-character suffixes derived from a configurable symbol set\r\n * (e.g. `\"1.50a\"`, `\"3.20b\"`, `\"1.00aa\"`).\r\n *\r\n * The suffix sequence is generated by {@link alphabetSuffix}: tier 1 -> first symbol,\r\n * tier N -> last symbol, tier N+1 -> first two-symbol combination, and so on.\r\n *\r\n * Pass a custom `alphabet` to produce any suffix sequence - lowercase letters (default),\r\n * uppercase (Excel-style columns), Greek letters, emoji, or any ordered set of strings.\r\n *\r\n * @example\r\n * // Default: lowercase a-z\r\n * letterNotation.format(1.5, 3, 2); // \"1.50a\"\r\n * letterNotation.format(1.5, 78, 2); // \"1.50z\"\r\n * letterNotation.format(1.5, 81, 2); // \"1.50aa\"\r\n *\r\n * @example\r\n * // Excel-style columns\r\n * const excelNotation = new AlphabetNotation({ alphabet: \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\" });\r\n * excelNotation.format(1.5, 3, 2); // \"1.50A\"\r\n * excelNotation.format(1.5, 78, 2); // \"1.50Z\"\r\n * excelNotation.format(1.5, 81, 2); // \"1.50AA\"\r\n */\r\nexport class AlphabetNotation extends SuffixNotationBase {\r\n private readonly defaultSuffix = \"\";\r\n private readonly alphabet: string;\r\n private readonly suffixCache = new Map<number, string>();\r\n\r\n /**\r\n * @param options - Plugin options. `alphabet` defaults to `\"abcdefghijklmnopqrstuvwxyz\"`.\r\n * `separator` defaults to `\"\"` (no space between the number and suffix).\r\n */\r\n public constructor(options: AlphabetNotationOptions = {}) {\r\n super(options);\r\n this.alphabet = options.alphabet ?? \"abcdefghijklmnopqrstuvwxyz\";\r\n }\r\n\r\n /**\r\n * Returns the suffix label for the given tier.\r\n *\r\n * Tier 0 returns `\"\"` - no suffix for values below 10^3.\r\n * Tier 1 -> first alphabet symbol, tier N -> last, tier N+1 -> first two-symbol combination.\r\n *\r\n * Results are cached after the first call per tier.\r\n *\r\n * @param tier - The exponent tier (`floor(exponent / 3)`), >= 0.\r\n * @returns The suffix string, or `\"\"` for tier 0.\r\n */\r\n public override getSuffix(tier: number): string {\r\n if (tier === 0) {\r\n return this.defaultSuffix;\r\n }\r\n\r\n const cached = this.suffixCache.get(tier);\r\n if (cached !== undefined) return cached;\r\n\r\n const result = alphabetSuffix(tier, this.alphabet);\r\n this.suffixCache.set(tier, result);\r\n return result;\r\n }\r\n}\r\n\r\n/** Pre-built {@link AlphabetNotation} instance using lowercase `a-z` with no separator. */\r\nexport const letterNotation = new AlphabetNotation();\r\n","import { type Unit, type UnitArray } from \"../types/plugin\";\r\n\r\n/**\r\n * Full tier-indexed unit list from Thousand (tier 1, 10^3) to Centillion (tier 101, 10^303).\r\n *\r\n * Array index = tier = `Math.floor(exponent / 3)`. Tiers 34-100 are `undefined` -\r\n * numbers in that range fall through to whatever fallback is configured on the\r\n * {@link UnitNotation} instance (letterNotation for the pre-built `unitNotation`).\r\n *\r\n * @example\r\n * const notation = new UnitNotation({ units: CLASSIC_UNITS, separator: \" \" });\r\n * notation.format(1.5, 3, 2); // \"1.50 K\"\r\n * notation.format(1.5, 6, 2); // \"1.50 M\"\r\n */\r\nexport const CLASSIC_UNITS: UnitArray = (() => {\r\n const u: Array<Unit | undefined> = [\r\n undefined, // tier 0: exponent 0-2 (no unit)\r\n { symbol: \"K\", name: \"Thousand\" }, // tier 1: exponent 3\r\n { symbol: \"M\", name: \"Million\" }, // tier 2: exponent 6\r\n { symbol: \"B\", name: \"Billion\" }, // tier 3: exponent 9\r\n { symbol: \"T\", name: \"Trillion\" }, // tier 4: exponent 12\r\n { symbol: \"Qa\", name: \"Quadrillion\" }, // tier 5: exponent 15\r\n { symbol: \"Qi\", name: \"Quintillion\" }, // tier 6: exponent 18\r\n { symbol: \"Sx\", name: \"Sextillion\" }, // tier 7: exponent 21\r\n { symbol: \"Sp\", name: \"Septillion\" }, // tier 8: exponent 24\r\n { symbol: \"Oc\", name: \"Octillion\" }, // tier 9: exponent 27\r\n { symbol: \"No\", name: \"Nonillion\" }, // tier 10: exponent 30\r\n { symbol: \"Dc\", name: \"Decillion\" }, // tier 11: exponent 33\r\n { symbol: \"UDc\", name: \"Undecillion\" }, // tier 12: exponent 36\r\n { symbol: \"DDc\", name: \"Duodecillion\" }, // tier 13: exponent 39\r\n { symbol: \"TDc\", name: \"Tredecillion\" }, // tier 14: exponent 42\r\n { symbol: \"QaDc\", name: \"Quattuordecillion\" }, // tier 15: exponent 45\r\n { symbol: \"QiDc\", name: \"Quindecillion\" }, // tier 16: exponent 48\r\n { symbol: \"SxDc\", name: \"Sexdecillion\" }, // tier 17: exponent 51\r\n { symbol: \"SpDc\", name: \"Septendecillion\" }, // tier 18: exponent 54\r\n { symbol: \"OcDc\", name: \"Octodecillion\" }, // tier 19: exponent 57\r\n { symbol: \"NoDc\", name: \"Novemdecillion\" }, // tier 20: exponent 60\r\n { symbol: \"Vg\", name: \"Vigintillion\" }, // tier 21: exponent 63\r\n { symbol: \"UVg\", name: \"Unvigintillion\" }, // tier 22: exponent 66\r\n { symbol: \"DVg\", name: \"Duovigintillion\" }, // tier 23: exponent 69\r\n { symbol: \"TVg\", name: \"Trevigintillion\" }, // tier 24: exponent 72\r\n { symbol: \"QaVg\", name: \"Quattuorvigintillion\" }, // tier 25: exponent 75\r\n { symbol: \"QiVg\", name: \"Quinvigintillion\" }, // tier 26: exponent 78\r\n { symbol: \"SxVg\", name: \"Sexvigintillion\" }, // tier 27: exponent 81\r\n { symbol: \"SpVg\", name: \"Septenvigintillion\" }, // tier 28: exponent 84\r\n { symbol: \"OcVg\", name: \"Octovigintillion\" }, // tier 29: exponent 87\r\n { symbol: \"NoVg\", name: \"Novemvigintillion\" }, // tier 30: exponent 90\r\n { symbol: \"Tg\", name: \"Trigintillion\" }, // tier 31: exponent 93\r\n { symbol: \"UTg\", name: \"Untrigintillion\" }, // tier 32: exponent 96\r\n { symbol: \"DTg\", name: \"Duotrigintillion\" }, // tier 33: exponent 99\r\n // tiers 34-100: undefined - fallback fires for these exponents\r\n ];\r\n u[101] = { symbol: \"Ct\", name: \"Centillion\" }; // tier 101: exponent 303\r\n return Object.freeze(u);\r\n})();\r\n\r\n/**\r\n * Compact tier-indexed unit list from Thousand (tier 1, 10^3) to Nonillion (tier 10, 10^30).\r\n *\r\n * Intended for tight UI spaces. Tiers beyond 10 (exponent > 32) fall back to whatever\r\n * fallback plugin is configured on the {@link UnitNotation} instance.\r\n *\r\n * @example\r\n * const notation = new UnitNotation({ units: COMPACT_UNITS, fallback: letterNotation, separator: \" \" });\r\n * notation.format(1.5, 3, 2); // \"1.50 k\"\r\n * notation.format(1.5, 6, 2); // \"1.50 M\"\r\n */\r\nexport const COMPACT_UNITS: UnitArray = Object.freeze([\r\n undefined, // tier 0: exponent 0-2 (no unit)\r\n { symbol: \"k\" }, // tier 1: exponent 3\r\n { symbol: \"M\" }, // tier 2: exponent 6\r\n { symbol: \"B\" }, // tier 3: exponent 9\r\n { symbol: \"T\" }, // tier 4: exponent 12\r\n { symbol: \"Qa\" }, // tier 5: exponent 15\r\n { symbol: \"Qi\" }, // tier 6: exponent 18\r\n { symbol: \"Sx\" }, // tier 7: exponent 21\r\n { symbol: \"Sp\" }, // tier 8: exponent 24\r\n { symbol: \"Oc\" }, // tier 9: exponent 27\r\n { symbol: \"No\" }, // tier 10: exponent 30\r\n]);\r\n","import { CLASSIC_UNITS } from \"../constants/units\";\r\nimport { type SuffixProvider, type UnitArray, type UnitNotationOptions } from \"../types/plugin\";\r\nimport { letterNotation } from \"./AlphabetNotation\";\r\nimport { SuffixNotationBase } from \"./SuffixNotationBase\";\r\n\r\n/**\r\n * Formats numbers using a tier-indexed array of named units\r\n * (e.g. `\"1.50 K\"`, `\"3.20 M\"`, `\"1.00 B\"`).\r\n *\r\n * The `units` array is indexed by tier (`Math.floor(exponent / 3)`), so lookup\r\n * is O(1) - no search required. A `undefined` entry means \"no unit for this tier\";\r\n * the fallback plugin handles it.\r\n *\r\n * @example\r\n * const notation = new UnitNotation({ units: CLASSIC_UNITS, separator: \" \" });\r\n * notation.format(1.5, 6, 2); // \"1.50 M\"\r\n *\r\n * @example\r\n * // Pre-built instance with space separator and letterNotation fallback:\r\n * number.toString(unitNotation); // \"1.50 K\"\r\n */\r\nexport class UnitNotation extends SuffixNotationBase {\r\n protected readonly fallback?: SuffixProvider;\r\n protected readonly units: UnitArray;\r\n\r\n /**\r\n * @param options - Tier-indexed unit array, optional suffix fallback plugin, and separator.\r\n * `separator` defaults to `\" \"` (a space between number and unit symbol).\r\n */\r\n public constructor(options: UnitNotationOptions) {\r\n super({ separator: \" \", ...options });\r\n this.units = options.units;\r\n this.fallback = options.fallback;\r\n }\r\n\r\n /**\r\n * Returns the suffix for the given tier: the own unit symbol if defined,\r\n * otherwise the fallback's suffix, otherwise `\"\"`.\r\n *\r\n * @param tier - The exponent tier (`Math.floor(exponent / 3)`).\r\n * @returns The suffix string, or `\"\"` if neither own units nor fallback cover this tier.\r\n */\r\n public override getSuffix(tier: number): string {\r\n return this.units[tier]?.symbol\r\n ?? this.fallback?.getSuffix(tier)\r\n ?? \"\";\r\n }\r\n}\r\n\r\n/**\r\n * Pre-built {@link UnitNotation} instance using {@link CLASSIC_UNITS} (K, M, B, T…)\r\n * with a space separator and {@link letterNotation} as fallback for very large numbers.\r\n */\r\nexport const unitNotation = new UnitNotation({\r\n units: CLASSIC_UNITS,\r\n fallback: letterNotation,\r\n});\r\n","import { ArbitraryNumber } from \"../core/ArbitraryNumber\";\r\nimport { type NormalizedNumber } from \"../types/core\";\r\n\r\n/**\r\n * Type-guard helpers for {@link ArbitraryNumber} and {@link NormalizedNumber}.\r\n *\r\n * @example\r\n * if (ArbitraryNumberGuard.isArbitraryNumber(value)) {\r\n * value.add(ArbitraryNumber.One);\r\n * }\r\n */\r\nexport class ArbitraryNumberGuard {\r\n /**\r\n * Returns `true` if `obj` is an instance of {@link ArbitraryNumber}.\r\n *\r\n * @param obj - The value to test.\r\n * @returns `true` when `obj instanceof ArbitraryNumber`.\r\n */\r\n public static isArbitraryNumber(obj: unknown): obj is ArbitraryNumber {\r\n return obj instanceof ArbitraryNumber;\r\n }\r\n\r\n /**\r\n * Returns `true` if `obj` has the shape of a {@link NormalizedNumber}\r\n * (i.e. has numeric `coefficient` and `exponent` properties).\r\n *\r\n * Note: both `ArbitraryNumber` instances and plain objects with the right\r\n * shape will pass this check. Use {@link isArbitraryNumber} when you need\r\n * to distinguish between the two.\r\n *\r\n * @param obj - The value to test.\r\n * @returns `true` when `obj` has `typeof coefficient === \"number\"` and\r\n * `typeof exponent === \"number\"`.\r\n */\r\n public static isNormalizedNumber(obj: unknown): obj is NormalizedNumber {\r\n return obj != null\r\n && typeof (obj as NormalizedNumber)?.coefficient === \"number\"\r\n && typeof (obj as NormalizedNumber)?.exponent === \"number\";\r\n }\r\n\r\n /**\r\n * Returns `true` if `obj` is an {@link ArbitraryNumber} with a value of zero.\r\n *\r\n * @param obj - The value to test.\r\n * @returns `true` when `obj` is an `ArbitraryNumber` and its `coefficient` is `0`.\r\n */\r\n public static isZero(obj: unknown): boolean {\r\n return ArbitraryNumberGuard.isArbitraryNumber(obj) && obj.coefficient === 0;\r\n }\r\n}\r\n","import { ArbitraryNumber } from \"../core/ArbitraryNumber\";\r\nimport type { ArbitraryNumberish } from \"../types/utility\";\r\n\r\n/**\r\n * Convenience helpers for mixed `number | ArbitraryNumber` inputs.\r\n *\r\n * Each method accepts either type and coerces plain `number` values via\r\n * {@link ArbitraryNumber.from} before delegating to the corresponding instance method.\r\n *\r\n * Prefer `ArbitraryNumber` instance methods directly on hot paths - this class is\r\n * intended for system boundaries (event handlers, serialisation, UI callbacks) where\r\n * the input type is unknown.\r\n *\r\n * @example\r\n * import { ArbitraryNumberOps as ops } from \"arbitrary-numbers\";\r\n * ops.add(1500, 2500) // ArbitraryNumber (4000)\r\n * ops.mul(an(2, 0), 5) // ArbitraryNumber (10)\r\n * ops.from(1_500_000) // ArbitraryNumber { coefficient: 1.5, exponent: 6 }\r\n */\r\nexport class ArbitraryNumberOps {\r\n /**\r\n * Converts `value` to an `ArbitraryNumber`, returning it unchanged if it already is one.\r\n *\r\n * @param value - A plain `number` or an existing `ArbitraryNumber`.\r\n * @returns The corresponding `ArbitraryNumber`.\r\n */\r\n public static from(value: ArbitraryNumberish): ArbitraryNumber {\r\n return value instanceof ArbitraryNumber ? value : ArbitraryNumber.from(value);\r\n }\r\n\r\n /**\r\n * Returns `left + right`, coercing both operands as needed.\r\n *\r\n * @param left - The augend.\r\n * @param right - The addend.\r\n * @example\r\n * ops.add(1500, 2500) // ArbitraryNumber (4000)\r\n */\r\n public static add(left: ArbitraryNumberish, right: ArbitraryNumberish): ArbitraryNumber {\r\n return ArbitraryNumberOps.from(left).add(ArbitraryNumberOps.from(right));\r\n }\r\n\r\n /**\r\n * Returns `left - right`, coercing both operands as needed.\r\n *\r\n * @param left - The minuend.\r\n * @param right - The subtrahend.\r\n * @example\r\n * ops.sub(5000, 1500) // ArbitraryNumber (3500)\r\n */\r\n public static sub(left: ArbitraryNumberish, right: ArbitraryNumberish): ArbitraryNumber {\r\n return ArbitraryNumberOps.from(left).sub(ArbitraryNumberOps.from(right));\r\n }\r\n\r\n /**\r\n * Returns `left * right`, coercing both operands as needed.\r\n *\r\n * @param left - The multiplicand.\r\n * @param right - The multiplier.\r\n * @example\r\n * ops.mul(an(1, 3), 5) // ArbitraryNumber (5000)\r\n */\r\n public static mul(left: ArbitraryNumberish, right: ArbitraryNumberish): ArbitraryNumber {\r\n return ArbitraryNumberOps.from(left).mul(ArbitraryNumberOps.from(right));\r\n }\r\n\r\n /**\r\n * Returns `left / right`, coercing both operands as needed.\r\n *\r\n * @param left - The dividend.\r\n * @param right - The divisor.\r\n * @throws `\"Division by zero\"` when `right` is zero.\r\n * @example\r\n * ops.div(an(1, 6), 1000) // ArbitraryNumber (1000)\r\n */\r\n public static div(left: ArbitraryNumberish, right: ArbitraryNumberish): ArbitraryNumber {\r\n return ArbitraryNumberOps.from(left).div(ArbitraryNumberOps.from(right));\r\n }\r\n\r\n /**\r\n * Compares `left` to `right`.\r\n *\r\n * @param left - The left operand.\r\n * @param right - The right operand.\r\n * @returns `1` if `left > right`, `-1` if `left < right`, `0` if equal.\r\n * @example\r\n * ops.compare(5000, 1500) // 1\r\n */\r\n public static compare(left: ArbitraryNumberish, right: ArbitraryNumberish): number {\r\n return ArbitraryNumberOps.from(left).compareTo(ArbitraryNumberOps.from(right));\r\n }\r\n\r\n /**\r\n * Clamps `value` to the inclusive range `[min, max]`, coercing all inputs as needed.\r\n *\r\n * @param value - The value to clamp.\r\n * @param min - The lower bound (inclusive).\r\n * @param max - The upper bound (inclusive).\r\n * @example\r\n * ops.clamp(500, 1000, 2000) // ArbitraryNumber (1000) - below min, returns min\r\n */\r\n public static clamp(value: ArbitraryNumberish, min: ArbitraryNumberish, max: ArbitraryNumberish): ArbitraryNumber {\r\n return ArbitraryNumber.clamp(\r\n ArbitraryNumberOps.from(value),\r\n ArbitraryNumberOps.from(min),\r\n ArbitraryNumberOps.from(max),\r\n );\r\n }\r\n}\r\n","import { ArbitraryNumber } from \"../core/ArbitraryNumber\";\r\nimport type { ArbitraryNumberish } from \"../types/utility\";\r\nimport { ArbitraryNumberOps } from \"./ArbitraryNumberOps\";\r\nimport { ArbitraryNumberInputError } from \"../errors\";\r\n\r\n/**\r\n * Domain-level helpers for common game and simulation patterns.\r\n *\r\n * These sit above the core arithmetic layer - each method accepts\r\n * mixed input (`number | ArbitraryNumber`) via\r\n * {@link ArbitraryNumberOps.from} so they work at system boundaries\r\n * where you may receive raw numbers.\r\n *\r\n * For hot-path code, use `ArbitraryNumber` methods directly.\r\n */\r\nexport class ArbitraryNumberHelpers {\r\n private static coerce(value: ArbitraryNumberish): ArbitraryNumber {\r\n return ArbitraryNumberOps.from(value);\r\n }\r\n\r\n /**\r\n * Returns `true` when `value >= threshold`.\r\n *\r\n * @param value - The value to test.\r\n * @param threshold - The minimum required value.\r\n * @returns `true` when `value >= threshold`.\r\n * @example\r\n * ArbitraryNumberHelpers.meetsOrExceeds(gold, upgradeCost)\r\n */\r\n public static meetsOrExceeds(value: ArbitraryNumberish, threshold: ArbitraryNumberish): boolean {\r\n return ArbitraryNumberHelpers.coerce(value)\r\n .greaterThanOrEqual(ArbitraryNumberHelpers.coerce(threshold));\r\n }\r\n\r\n /**\r\n * Returns the largest whole multiple count of `step` that fits into `total`.\r\n *\r\n * Equivalent to `floor(total / step)`.\r\n *\r\n * @param total - The total available amount.\r\n * @param step - The cost or size of one unit. Must be greater than zero.\r\n * @returns The number of whole units that fit, as an `ArbitraryNumber`.\r\n * @throws `\"step must be greater than zero\"` when `step <= 0`.\r\n * @example\r\n * const canBuy = ArbitraryNumberHelpers.wholeMultipleCount(gold, upgradeCost);\r\n */\r\n public static wholeMultipleCount(total: ArbitraryNumberish, step: ArbitraryNumberish): ArbitraryNumber {\r\n const numTotal = ArbitraryNumberHelpers.coerce(total);\r\n const numStep = ArbitraryNumberHelpers.coerce(step);\r\n\r\n if (numStep.lessThanOrEqual(ArbitraryNumber.Zero)) {\r\n throw new ArbitraryNumberInputError(\"step must be greater than zero\", numStep.toNumber());\r\n }\r\n\r\n if (numTotal.lessThanOrEqual(ArbitraryNumber.Zero)) {\r\n return ArbitraryNumber.Zero;\r\n }\r\n\r\n return numTotal.div(numStep).floor();\r\n }\r\n\r\n /**\r\n * Returns `value - delta`, clamped to a minimum of `floor` (default `0`).\r\n *\r\n * @param value - The starting value.\r\n * @param delta - The amount to subtract.\r\n * @param floor - The minimum result. Defaults to `ArbitraryNumber.Zero`.\r\n * @returns `max(value - delta, floor)`.\r\n * @example\r\n * health = ArbitraryNumberHelpers.subtractWithFloor(health, damage);\r\n */\r\n public static subtractWithFloor(\r\n value: ArbitraryNumberish,\r\n delta: ArbitraryNumberish,\r\n floor: ArbitraryNumberish = ArbitraryNumber.Zero,\r\n ): ArbitraryNumber {\r\n const numValue = ArbitraryNumberHelpers.coerce(value);\r\n const numDelta = ArbitraryNumberHelpers.coerce(delta);\r\n const numFloor = ArbitraryNumberHelpers.coerce(floor);\r\n\r\n return ArbitraryNumber.clamp(numValue.sub(numDelta), numFloor, numValue);\r\n }\r\n}\r\n"]}