@signpostmarv/intermediary-number 0.6.2 → 0.6.3

package/lib/IntermediaryNumber.js

@@ -1,1126 +0,0 @@
-import assert from 'assert';
-import BigNumber from 'bignumber.js';
-import Fraction from 'fraction.js';
-import { is_string, } from './Docs.json';
-import { NumberStrings, } from './NumberStrings';
-export const regex_recurring_number = /^-?(\d+\.)(\d+r|\d*\[\d+\]r?|\d*\(\d+\)r?)$/;
-//#endregion
-//#region utility functions
-function do_math(left_operand, operator, right_operand) {
-    return IntermediaryCalculation.maybe_reduce_operands(left_operand, operator, IntermediaryNumber.reuse_or_create(right_operand));
-}
-function abs(value) {
-    if (value.isZero()) {
-        return value;
-    }
-    return (value.isLessThan(0)
-        ? IntermediaryNumber.Zero.minus(value)
-        : value);
-}
-function compare(value, to) {
-    if (value instanceof IntermediaryNumberInfinity
-        && to instanceof IntermediaryNumberInfinity) {
-        return 0;
-    }
-    else if (value instanceof IntermediaryNumberInfinity) {
-        return 1;
-    }
-    else if (to instanceof IntermediaryNumberInfinity) {
-        return -1;
-    }
-    const comparable = IntermediaryNumber.reuse_or_create(value).toBigNumberOrFraction();
-    let result;
-    if (comparable instanceof BigNumber) {
-        result = to.toBigNumber().comparedTo(comparable);
-    }
-    else {
-        result = to.toFraction().compare(comparable);
-    }
-    assert.strictEqual((-1 === result
-        || 0 === result
-        || 1 === result), true, `Expecting -1, 0, or 1, receieved ${JSON.stringify(result)}`);
-    return result;
-}
-const conversion_cache = new class {
-    toAmountString_cache;
-    toBigNumber_cache;
-    toFraction_cache;
-    toString_cache;
-    get AmountString() {
-        if (!this.toAmountString_cache) {
-            this.toAmountString_cache = new WeakMap();
-        }
-        return this.toAmountString_cache;
-    }
-    get BigNumber() {
-        if (!this.toBigNumber_cache) {
-            this.toBigNumber_cache = new WeakMap();
-        }
-        return this.toBigNumber_cache;
-    }
-    get Fraction() {
-        if (!this.toFraction_cache) {
-            this.toFraction_cache = new WeakMap();
-        }
-        return this.toFraction_cache;
-    }
-    get String() {
-        if (!this.toString_cache) {
-            this.toString_cache = new WeakMap();
-        }
-        return this.toString_cache;
-    }
-    dispose(of) {
-        for (const cache of [
-            this.toAmountString_cache,
-            this.toBigNumber_cache,
-            this.toFraction_cache,
-            this.toString_cache,
-        ]) {
-            if (cache) {
-                cache.delete(of);
-            }
-        }
-    }
-};
-export function dispose(value) {
-    conversion_cache.dispose(value);
-}
-function max(first, second, ...remaining) {
-    let max = IntermediaryNumber.reuse_or_create(first);
-    for (const entry of [second, ...remaining]) {
-        const maybe = IntermediaryNumber.reuse_or_create(entry);
-        if (-1 === max.compare(maybe)) {
-            max = maybe;
-        }
-    }
-    return IntermediaryNumber.reuse_or_create(max);
-}
-function min(first, second, ...remaining) {
-    let min = IntermediaryNumber.reuse_or_create(first);
-    for (const entry of [second, ...remaining]) {
-        const maybe = IntermediaryNumber.reuse_or_create(entry);
-        if (-1 === maybe.compare(min)) {
-            min = maybe;
-        }
-    }
-    return IntermediaryNumber.reuse_or_create(min);
-}
-//#region TokenScan utility functions
-function default_tokenizer_state() {
-    return {
-        outter_stack: [],
-        left_operand: undefined,
-        operation: '',
-        right_operand: undefined,
-        operand_mode: 'left',
-    };
-}
-function is_nesting_open(maybe) {
-    return 'nesting_open' === maybe.type;
-}
-function is_nesting_close(maybe) {
-    return 'nesting_close' === maybe.type;
-}
-function is_numeric(maybe) {
-    return 'numeric' === maybe.type;
-}
-function is_infinity(maybe) {
-    return 'Infinity' === maybe.type;
-}
-export function is_operation_value(maybe) {
-    if (!(maybe.length === 1
-        && '+-/x*%'.includes(maybe))) {
-        throw new TokenScanError(`Expected operation value, found "${maybe}"`);
-    }
-}
-//#endregion
-//#endregion
-//#region IntermediaryNumber
-export class IntermediaryNumber {
-    value;
-    static One = new this('1');
-    static Zero = new this('0');
-    constructor(value) {
-        this.value = value;
-    }
-    get resolve_type() {
-        return this.type;
-    }
-    get type() {
-        if (this.value instanceof BigNumber) {
-            return 'BigNumber';
-        }
-        else if (this.value instanceof Fraction) {
-            return 'Fraction';
-        }
-        else if (NumberStrings.is_amount_string(this.value)) {
-            return 'amount_string';
-        }
-        return 'numeric_string';
-    }
-    abs() {
-        return abs(this);
-    }
-    compare(value) {
-        return compare(value, this);
-    }
-    divide(value) {
-        return do_math(this, '/', value);
-    }
-    do_math_then_dispose(operator, right_operand) {
-        const result = this[operator](right_operand);
-        if (result !== this) {
-            dispose(this);
-        }
-        return result;
-    }
-    isGreaterThan(value) {
-        return 1 === this.compare(value);
-    }
-    isLessThan(value) {
-        return -1 === this.compare(value);
-    }
-    isOne() {
-        return 0 === this.compare(1);
-    }
-    isZero() {
-        return 0 === this.compare(0);
-    }
-    max(first, ...remaining) {
-        return max(this, first, ...remaining);
-    }
-    min(first, ...remaining) {
-        return min(this, first, ...remaining);
-    }
-    minus(value) {
-        return do_math(this, '-', value);
-    }
-    modulo(value) {
-        return do_math(this, '%', value);
-    }
-    plus(value) {
-        if (this.isZero()) {
-            return IntermediaryNumber.reuse_or_create(value);
-        }
-        return do_math(this, '+', value);
-    }
-    times(value) {
-        return do_math(this, 'x', value);
-    }
-    toAmountString() {
-        if (NumberStrings.is_amount_string(this.value)) {
-            return this.value;
-        }
-        return NumberStrings.round_off(this.toBigNumberOrFraction());
-    }
-    toBigNumber() {
-        if (this.value instanceof BigNumber) {
-            return this.value;
-        }
-        else if (this.value instanceof Fraction) {
-            return BigNumber(this.value.valueOf());
-        }
-        const cache = conversion_cache.BigNumber;
-        if (cache.has(this)) {
-            return cache.get(this);
-        }
-        const value = BigNumber(this.value);
-        cache.set(this, value);
-        return value;
-    }
-    toBigNumberOrFraction() {
-        return ('Fraction' === this.type)
-            ? this.toFraction()
-            : this.toBigNumber();
-    }
-    toFraction() {
-        if (this.value instanceof Fraction) {
-            return this.value;
-        }
-        const cache = conversion_cache.Fraction;
-        if (cache.has(this)) {
-            return cache.get(this);
-        }
-        const value = new Fraction(this.toString());
-        cache.set(this, value);
-        return value;
-    }
-    toJSON() {
-        if (this.isOne()) {
-            return {
-                type: 'IntermediaryNumber',
-                value: '1',
-            };
-        }
-        else if (this.isZero()) {
-            return {
-                type: 'IntermediaryNumber',
-                value: '0',
-            };
-        }
-        if (this.value instanceof Fraction) {
-            const [left, right] = this.value.toFraction().split('/');
-            if (undefined === right) {
-                return {
-                    type: 'IntermediaryNumber',
-                    value: left,
-                };
-            }
-            return {
-                type: 'IntermediaryCalculation',
-                left: {
-                    type: 'IntermediaryNumber',
-                    value: left,
-                },
-                operation: '/',
-                right: {
-                    type: 'IntermediaryNumber',
-                    value: right,
-                },
-            };
-        }
-        else if (this.value instanceof BigNumber) {
-            return {
-                type: 'IntermediaryNumber',
-                value: this.value.toFixed(),
-            };
-        }
-        return {
-            type: 'IntermediaryNumber',
-            value: this.value,
-        };
-    }
-    toString() {
-        if (this.value instanceof BigNumber) {
-            return this.value.toFixed();
-        }
-        return this.value.toString();
-    }
-    toStringCalculation() {
-        return this.toString();
-    }
-    static create(input) {
-        if ('' === input) {
-            return IntermediaryNumber.Zero;
-        }
-        if (input instanceof Fraction) {
-            return new this(input.simplify(1 / (2 ** 52)));
-        }
-        if (input instanceof BigNumber
-            || NumberStrings.is_numeric_string(input)) {
-            return new this(input);
-        }
-        else if ('number' === typeof input) {
-            return new this(BigNumber(input));
-        }
-        else if (is_string(input) && regex_recurring_number.test(input)) {
-            let only_last_digit_recurring = false;
-            if (/^\d*\.\d+r$/.test(input)) {
-                only_last_digit_recurring = true;
-            }
-            if (input.endsWith('r')) {
-                input = input.substring(0, input.length - 1);
-            }
-            if (only_last_digit_recurring) {
-                input = input.replace(/(\d)$/, '($1)');
-            }
-            else if (input.includes('[')) {
-                input = input.replace(/\[(\d+)\]/, '($1)');
-            }
-            return new this(new Fraction(input));
-        }
-        else if ('Infinity' === input) {
-            return new IntermediaryNumberInfinity(new BigNumber('Infinity'));
-        }
-        throw new Error('Unsupported argument specified!');
-    }
-    static create_if_valid(input) {
-        const maybe = input.trim();
-        if (NumberStrings.is_amount_string(maybe)
-            || NumberStrings.is_numeric_string(maybe)) {
-            return IntermediaryNumber.create(maybe);
-        }
-        else if (/^(\d+|\d*\.\d+)\s*[+/*x%-]\s*(\d+|\d*\.\d+)$/.test(maybe)) {
-            return TokenScan.create(input).parsed;
-        }
-        const scientific = /^(-?\d+(?:\.\d+))e([+-])(\d+)$/.exec(maybe);
-        if (scientific) {
-            const calc = new IntermediaryCalculation(IntermediaryNumber.Zero, scientific[2], IntermediaryNumber.create(scientific[3])).toBigNumber();
-            return IntermediaryNumber.create(scientific[1]).times((new BigNumber(10)).pow(calc));
-        }
-        try {
-            return IntermediaryCalculation.fromString(maybe);
-        }
-        catch (err) {
-            return new NotValid(maybe, err);
-        }
-    }
-    static fromJson(json) {
-        if ('IntermediaryNumber' === json.type) {
-            return this.create(json.value);
-        }
-        else if ('TokenScan' === json.type) {
-            return TokenScan.create(json.value);
-        }
-        return new IntermediaryCalculation(this.fromJson(json.left), json.operation, this.fromJson(json.right));
-    }
-    static reuse_or_create(input) {
-        return (((input instanceof IntermediaryNumber)
-            || (input instanceof IntermediaryCalculation)
-            || (input instanceof TokenScan))
-            ? input
-            : this.create(input));
-    }
-}
-//#endregion
-//#region IntermediaryNumberInfinity
-export class IntermediaryNumberInfinity extends IntermediaryNumber {
-    static One = new this(new BigNumber('Infinity'));
-    static Zero = new this(new BigNumber('Infinity'));
-    isOne() {
-        return false;
-    }
-    isZero() {
-        return false;
-    }
-    toFraction() {
-        throw new Error('Cannot convert infinity to Fraction');
-    }
-    toString() {
-        return 'Infinity';
-    }
-    toStringCalculation() {
-        return 'Infinity';
-    }
-}
-//#endregion
-//#region IntermediaryCalculation
-export class NotValid extends Error {
-    reason;
-    value;
-    constructor(not_valid, reason) {
-        super('Value given was not valid!');
-        this.value = not_valid;
-        this.reason = reason;
-    }
-}
-const BigNumber_operation_map = {
-    '+': (a, b) => a.plus(b),
-    '-': (a, b) => a.minus(b),
-    'x': (a, b) => a.times(b),
-    '*': (a, b) => a.times(b),
-    '%': (a, b) => a.modulo(b),
-};
-const Fraction_operation_map = {
-    '+': (a, b) => a.add(b),
-    '-': (a, b) => a.sub(b),
-    'x': (a, b) => a.mul(b),
-    '*': (a, b) => a.mul(b),
-    '/': (a, b) => a.div(b),
-    '%': (a, b) => a.mod(b),
-};
-export class IntermediaryCalculation {
-    left_operand;
-    operation;
-    right_operand;
-    constructor(left, operation, right) {
-        this.left_operand = left;
-        this.operation = operation;
-        this.right_operand = right;
-    }
-    get has_infinity() {
-        return (this.left_operand instanceof IntermediaryNumberInfinity
-            || this.right_operand instanceof IntermediaryNumberInfinity);
-    }
-    get left_type() {
-        if (this.left_operand instanceof IntermediaryCalculation) {
-            return 'IntermediaryCalculation';
-        }
-        return this.left_operand.type;
-    }
-    get resolve_type() {
-        return `${this.left_type} ${this.operation} ${this.right_type}`;
-    }
-    get right_type() {
-        if (this.right_operand instanceof IntermediaryCalculation) {
-            return 'IntermediaryCalculation';
-        }
-        return this.right_operand.type;
-    }
-    get type() {
-        return 'IntermediaryCalculation';
-    }
-    abs() {
-        return abs(this);
-    }
-    compare(value) {
-        return compare(value, this);
-    }
-    divide(value) {
-        return do_math(this, '/', value);
-    }
-    do_math_then_dispose(operator, right_operand) {
-        const result = this[operator](right_operand);
-        if (result !== this) {
-            dispose(this);
-        }
-        return result;
-    }
-    isGreaterThan(value) {
-        return 1 === this.compare(value);
-    }
-    isLessThan(value) {
-        return -1 === this.compare(value);
-    }
-    isOne() {
-        return 0 === this.compare(1);
-    }
-    isZero() {
-        return 0 === this.compare(0);
-    }
-    max(first, ...remaining) {
-        return max(this, first, ...remaining);
-    }
-    min(first, ...remaining) {
-        return min(this, first, ...remaining);
-    }
-    minus(value) {
-        return do_math(this, '-', value);
-    }
-    modulo(value) {
-        return do_math(this, '%', value);
-    }
-    plus(value) {
-        if (this.isZero()) {
-            return IntermediaryNumber.reuse_or_create(value);
-        }
-        return do_math(this, '+', value);
-    }
-    resolve() {
-        const reduced = IntermediaryCalculation.maybe_short_circuit(this.left_operand, this.operation, this.right_operand);
-        if (reduced instanceof IntermediaryNumber) {
-            return reduced;
-        }
-        const left_operand = this.operand_to_IntermediaryNumber(this.left_operand);
-        const right_operand = this.operand_to_IntermediaryNumber(this.right_operand);
-        const left = left_operand.toBigNumberOrFraction();
-        const right = right_operand.toBigNumberOrFraction();
-        if ('/' === this.operation
-            || left instanceof Fraction
-            || right instanceof Fraction) {
-            if (left_operand instanceof IntermediaryNumberInfinity) {
-                return left_operand;
-            }
-            else if (right_operand instanceof IntermediaryNumberInfinity) {
-                return right_operand;
-            }
-            return IntermediaryNumber.create(Fraction_operation_map[this.operation](((left instanceof BigNumber)
-                ? left_operand.toFraction()
-                : left), ((right instanceof BigNumber)
-                ? right_operand.toFraction()
-                : right)));
-        }
-        return IntermediaryNumber.create(BigNumber_operation_map[this.operation](left, right));
-    }
-    times(value) {
-        return do_math(this, 'x', value);
-    }
-    toAmountString() {
-        const cache = conversion_cache.AmountString;
-        if (cache.has(this)) {
-            return cache.get(this);
-        }
-        const value = this.resolve().toAmountString();
-        cache.set(this, value);
-        return value;
-    }
-    toBigNumber() {
-        const cache = conversion_cache.BigNumber;
-        if (cache.has(this)) {
-            return cache.get(this);
-        }
-        const value = this.resolve().toBigNumber();
-        cache.set(this, value);
-        return value;
-    }
-    toBigNumberOrFraction() {
-        return this.resolve().toBigNumberOrFraction();
-    }
-    toFraction() {
-        const cache = conversion_cache.Fraction;
-        if (cache.has(this)) {
-            return cache.get(this);
-        }
-        const value = this.resolve().toFraction();
-        cache.set(this, value);
-        return value;
-    }
-    toJSON() {
-        const left = (this.left_operand instanceof IntermediaryCalculation
-            && this.left_operand.has_infinity)
-            ? this.left_operand
-            : this.operand_to_IntermediaryNumber(this.left_operand);
-        const right = (this.right_operand instanceof IntermediaryCalculation
-            && this.right_operand.has_infinity)
-            ? this.right_operand
-            : this.operand_to_IntermediaryNumber(this.right_operand);
-        const maybe = IntermediaryCalculation.maybe_short_circuit(left, this.operation, right);
-        if (maybe) {
-            return maybe.toJSON();
-        }
-        return {
-            type: 'IntermediaryCalculation',
-            left: left.toJSON(),
-            operation: this.operation,
-            right: right.toJSON(),
-        };
-    }
-    toString() {
-        const cache = conversion_cache.String;
-        if (cache.has(this)) {
-            return cache.get(this);
-        }
-        const value = this.resolve().toString();
-        cache.set(this, value);
-        return value;
-    }
-    toStringCalculation() {
-        return `${(this.left_operand instanceof IntermediaryCalculation)
-            ? `(${this.left_operand.toStringCalculation()})`
-            : this.left_operand.toString()} ${this.operation} ${(this.right_operand instanceof IntermediaryCalculation)
-            ? `(${this.right_operand.toStringCalculation()})`
-            : this.right_operand.toString()}`;
-    }
-    operand_to_IntermediaryNumber(operand) {
-        if ((operand instanceof IntermediaryCalculation)
-            || (operand instanceof TokenScan)) {
-            return operand.resolve();
-        }
-        else if ('amount_string' === operand.type
-            || 'numeric_string' === operand.type) {
-            return IntermediaryNumber.create('/' === this.operation
-                ? operand.toFraction()
-                : operand.toBigNumberOrFraction());
-        }
-        return operand;
-    }
-    static fromString(input) {
-        return TokenScan.create(input).parsed;
-    }
-    static is(maybe) {
-        return maybe instanceof this;
-    }
-    static maybe_reduce_operands(left, operation, right) {
-        let value = this.maybe_short_circuit(left, operation, right);
-        if (undefined === value) {
-            value = new IntermediaryCalculation(left, operation, right);
-        }
-        if (value instanceof IntermediaryCalculation) {
-            return value.resolve();
-        }
-        return value;
-    }
-    static require_is(maybe) {
-        if (!this.is(maybe)) {
-            throw new Error('Argument is not an instanceof IntermediaryCalculation');
-        }
-    }
-    static maybe_short_circuit(left, operation, right) {
-        let value = undefined;
-        if (left instanceof IntermediaryNumberInfinity
-            && right instanceof IntermediaryNumberInfinity) {
-            if ('+' === operation
-                || '*' === operation) {
-                // infinity plus or multiplied by infintiy is infinity
-                return left;
-            }
-            else if ('-' === operation) {
-                return IntermediaryNumber.Zero;
-            }
-            else if ('/' === operation) {
-                return IntermediaryNumber.One;
-            }
-        }
-        if (left instanceof IntermediaryCalculation
-            && left.has_infinity
-            && (('+' === left.operation
-                && '-' === operation)
-                || ('-' === left.operation
-                    && '+' === operation))
-            && (right instanceof IntermediaryNumberInfinity)
-            && (!(left.left_operand instanceof IntermediaryNumberInfinity)
-                || !(left.right_operand instanceof IntermediaryNumberInfinity))) {
-            return (left.left_operand instanceof IntermediaryNumberInfinity
-                ? left.right_operand
-                : left.left_operand);
-        }
-        else if (right instanceof IntermediaryCalculation
-            && right.has_infinity
-            && (('+' === right.operation
-                && '-' === operation)
-                || ('-' === right.operation
-                    && '+' === operation))
-            && (left instanceof IntermediaryNumberInfinity)
-            && (!(right.left_operand instanceof IntermediaryNumberInfinity)
-                || !(right.right_operand instanceof IntermediaryNumberInfinity))) {
-            return (right.left_operand instanceof IntermediaryNumberInfinity
-                ? right.right_operand
-                : right.left_operand);
-        }
-        else if ('/' === operation
-            && !right.isOne()
-            && left instanceof IntermediaryCalculation
-            && left.has_infinity
-            && !(left.left_operand instanceof IntermediaryNumberInfinity)
-            && '*x'.includes(left.operation)
-            && right instanceof IntermediaryNumberInfinity) {
-            return left.left_operand;
-        }
-        if ('+' === operation) {
-            if (left.isZero()) {
-                value = right;
-            }
-            else if (right.isZero()) {
-                value = left;
-            }
-        }
-        else if ('-' === operation && right.isZero()) {
-            value = left;
-        }
-        else if ('*x'.includes(operation)) {
-            if (left.isZero() || right.isOne()) {
-                value = left;
-            }
-            else if (right.isZero() || left.isOne()) {
-                value = right;
-            }
-        }
-        else if ('/' === operation && right.isOne()) {
-            value = left;
-        }
-        return value;
-    }
-}
-//#endregion
-//#region TokenScan
-class TokenSpan {
-    from;
-    to;
-    type;
-    constructor(from, to, type) {
-        this.from = from;
-        this.to = to;
-        this.type = type;
-    }
-}
-export class TokenScanError extends Error {
-}
-export class TokenScanParseError extends Error {
-    current;
-    scan;
-    state;
-    constructor(message, scan, state, current) {
-        super(message);
-        this.scan = scan;
-        this.state = state;
-        this.current = current;
-    }
-}
-const regex_numeric = (/(?:\d*\.\d*\(\d+\)r?|\d*\.\d*\[\d+\]r?|\d+(?:\.\d+r)?|\.\d+r?)/g);
-export class TokenScan {
-    internal = {
-        parsed: undefined,
-        tokens: undefined,
-        valid: undefined,
-    };
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-    get parsed() {
-        return this.#parse();
-    }
-    get resolve_type() {
-        return this.parsed.resolve_type;
-    }
-    get tokens() {
-        if (undefined === this.internal.tokens) {
-            this.internal.tokens = TokenScan.determine_tokens_from_scan(this);
-        }
-        return this.internal.tokens;
-    }
-    get type() {
-        return 'TokenScan';
-    }
-    get valid() {
-        if (undefined === this.internal.valid) {
-            try {
-                this.#parse();
-                this.internal.valid = true;
-            }
-            catch {
-                this.internal.valid = false;
-            }
-        }
-        return this.internal.valid;
-    }
-    #parse() {
-        if (undefined === this.internal.parsed) {
-            this.internal.parsed = TokenScan.parse_scan(this);
-        }
-        return this.internal.parsed;
-    }
-    abs() {
-        return this.parsed.abs();
-    }
-    compare(value) {
-        return this.parsed.compare(value);
-    }
-    divide(value) {
-        if (IntermediaryNumber.reuse_or_create(value).isOne()) {
-            return this;
-        }
-        return new TokenScan([
-            this,
-            '/',
-            value,
-        ]);
-    }
-    do_math_then_dispose(operator, right_operand) {
-        const result = this.parsed.do_math_then_dispose(operator, right_operand);
-        this.internal.parsed = undefined;
-        return result;
-    }
-    isGreaterThan(value) {
-        return this.parsed.isGreaterThan(value);
-    }
-    isLessThan(value) {
-        return this.parsed.isLessThan(value);
-    }
-    isOne() {
-        return ((is_string(this.value)
-            && '1' === this.value.trim())
-            || this.parsed.isOne());
-    }
-    isZero() {
-        return ((is_string(this.value)
-            && '0' === this.value.trim())
-            || this.parsed.isZero());
-    }
-    max(first, ...remaining) {
-        return this.parsed.max(first, ...remaining);
-    }
-    min(first, ...remaining) {
-        return this.parsed.min(first, ...remaining);
-    }
-    minus(value) {
-        if (IntermediaryNumber.reuse_or_create(value).isZero()) {
-            return this;
-        }
-        return new TokenScan([
-            this,
-            '-',
-            value,
-        ]);
-    }
-    modulo(value) {
-        return new TokenScan([
-            this,
-            '%',
-            value,
-        ]);
-    }
-    plus(value) {
-        if (IntermediaryNumber.reuse_or_create(value).isZero()) {
-            return this;
-        }
-        return new TokenScan([
-            this,
-            '+',
-            value,
-        ]);
-    }
-    resolve() {
-        const parsed = this.parsed;
-        return IntermediaryCalculation.is(parsed) ? parsed.resolve() : parsed;
-    }
-    times(value) {
-        if (IntermediaryNumber.reuse_or_create(value).isOne()) {
-            return this;
-        }
-        return new TokenScan([
-            this,
-            'x',
-            value,
-        ]);
-    }
-    toAmountString() {
-        return this.parsed.toAmountString();
-    }
-    toBigNumber() {
-        return this.parsed.toBigNumber();
-    }
-    toBigNumberOrFraction() {
-        return this.parsed.toBigNumberOrFraction();
-    }
-    toFraction() {
-        return this.parsed.toFraction();
-    }
-    toJSON() {
-        return {
-            type: 'TokenScan',
-            value: this.toStringCalculation(),
-        };
-    }
-    toString() {
-        return this.parsed.toString();
-    }
-    toStringCalculation() {
-        if (this.value instanceof Array) {
-            const left_operand = this.value[0];
-            const right_operand = IntermediaryNumber.reuse_or_create(this.value[2]);
-            return `${(left_operand.parsed instanceof IntermediaryNumber)
-                ? left_operand.toString()
-                : `(${left_operand.toStringCalculation()})`} ${this.value[1]} ${(right_operand instanceof IntermediaryNumber)
-                ? right_operand.toStringCalculation()
-                : `(${right_operand.toStringCalculation()})`}`;
-        }
-        return this.value;
-    }
-    static create(value) {
-        return new TokenScan(value);
-    }
-    static is(maybe) {
-        return maybe instanceof TokenScan;
-    }
-    static require_is(maybe) {
-        if (!this.is(maybe)) {
-            throw new Error('Argument is not an instanceof TokenScan');
-        }
-    }
-    static determine_tokens_from_scan(scan) {
-        let tokens = [];
-        const value = scan.toStringCalculation();
-        for (const entry of value.matchAll(/([\s]+)/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'ignore'));
-        }
-        for (const entry of value.matchAll(regex_numeric)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'numeric'));
-        }
-        for (const entry of value.matchAll(/([+/*x%-])/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'operation'));
-        }
-        for (const entry of value.matchAll(/(\()/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'nesting_open'));
-        }
-        for (const entry of value.matchAll(/(\))/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'nesting_close'));
-        }
-        for (const entry of value.matchAll(/(\bInfinity\b)/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'Infinity'));
-        }
-        tokens = tokens.sort((a, b) => {
-            return a.from - b.from;
-        });
-        const recursive_numerics = tokens.filter(maybe => ('numeric' === maybe.type
-            && /[()]/.test(value.substring(maybe.from, maybe.to))));
-        tokens = tokens.filter((maybe) => {
-            if ('nesting_open' === maybe.type
-                || 'nesting_close' === maybe.type) {
-                return !recursive_numerics.find(maybe_numeric => (maybe.from >= maybe_numeric.from
-                    && maybe.to <= maybe_numeric.to));
-            }
-            return true;
-        });
-        if (tokens.length < 1) {
-            throw new TokenScanError('No tokens found!');
-        }
-        else if (0 !== tokens[0].from) {
-            throw new TokenScanError('First token not at index 0!');
-        }
-        else if (value.length !== tokens[tokens.length - 1].to) {
-            throw new TokenScanError('Last token does not end at end of string!');
-        }
-        let nesting_balance = 0;
-        for (let index = 0; index < tokens.length; ++index) {
-            const token = tokens[index];
-            if ('nesting_open' === token.type) {
-                nesting_balance += (token.to - token.from);
-            }
-            else if ('nesting_close' === token.type) {
-                nesting_balance -= (token.to - token.from);
-            }
-            if (index > 0
-                && tokens[index - 1].to !== token.from) {
-                console.error(tokens, index);
-                throw new TokenScanError(`Token expected to be found at index ${index}`);
-            }
-        }
-        if (0 !== nesting_balance) {
-            throw new TokenScanError('Imbalanced nesting in string!');
-        }
-        return this.massage_part_baked_tokens(scan, tokens.filter((maybe) => 'ignore' !== maybe.type));
-    }
-    static massage_part_baked_tokens(scan, tokens) {
-        const smoosh_numerics = [];
-        const value = scan.toStringCalculation();
-        for (let token_index = tokens.length - 1; token_index > 0; --token_index) {
-            const previous = tokens[token_index - 1];
-            const current = tokens[token_index];
-            if ('numeric' === previous.type) {
-                const previous_value = value.substring(previous.from, previous.to);
-                const current_value = value.substring(current.from, current.to);
-                if (current_value.startsWith('.')
-                    && /^\d+$/.test(previous_value)) {
-                    smoosh_numerics.push(token_index);
-                }
-            }
-        }
-        for (const index of smoosh_numerics) {
-            tokens.splice(index - 1, 2, new TokenSpan(tokens[index - 1].from, tokens[index].to, 'numeric'));
-        }
-        const convert_to_negative = [];
-        if (tokens.length >= 2
-            && 'operation' === tokens[0].type
-            && '-' === value[tokens[0].from]
-            && 'numeric' === tokens[1].type) {
-            convert_to_negative.push(0);
-        }
-        for (let token_index = 0; token_index < tokens.length; ++token_index) {
-            const token = tokens[token_index];
-            const next = tokens[token_index + 1];
-            const after = tokens[token_index + 2];
-            if (('nesting_open' === token.type
-                || 'operation' === token.type)
-                && next
-                && after
-                && 'operation' === next.type
-                && '-' === value[next.from]
-                && 'numeric' === after.type) {
-                convert_to_negative.push(token_index + 1);
-                token_index += 2;
-                continue;
-            }
-        }
-        for (const index of convert_to_negative.reverse()) {
-            tokens.splice(index, 2, new TokenSpan(tokens[index].from, tokens[index + 1].to, 'numeric'));
-        }
-        return tokens;
-    }
-    static parse_scan(scan) {
-        const reduced = scan.tokens.reduce((was, is, index) => TokenScan.reduce(scan, was, is, index), default_tokenizer_state());
-        if (undefined !== reduced.left_operand
-            && '' === reduced.operation
-            && undefined === reduced.right_operand
-            && 0 === reduced.outter_stack.length) {
-            return reduced.left_operand;
-        }
-        throw new TokenScanParseError('Parse in unsupported state!', scan, reduced);
-    }
-    static reduce(scan, was, is, index) {
-        const value = scan.toStringCalculation();
-        if (is_nesting_open(is)) {
-            if ('right' === was.operand_mode) {
-                if (undefined === was.left_operand) {
-                    if (!(was.outter_stack.length > 0
-                        && !(was.outter_stack[was.outter_stack.length - 1] instanceof TokenSpan))) {
-                        throw new TokenScanParseError(
-                        // eslint-disable-next-line max-len
-                        'Nesting opened without left operand to push into stack!', scan, was);
-                    }
-                    return was;
-                }
-                else if ('' === was.operation) {
-                    throw new TokenScanParseError('Nesting opened without operation to push into stack!', scan, was, is);
-                }
-                was.outter_stack.push({
-                    left_operand: was.left_operand,
-                    operation: was.operation,
-                });
-                was.left_operand = undefined;
-                was.operation = '';
-                was.operand_mode = 'left';
-            }
-            else {
-                was.outter_stack.push(is);
-            }
-        }
-        else if (is_nesting_close(is)) {
-            const popped = was.outter_stack.pop();
-            if (popped instanceof TokenSpan) {
-                if ('nesting_open' === popped.type
-                    && '' === was.operation
-                    && undefined !== was.left_operand
-                    && undefined === was.right_operand) {
-                    // no-op, deliberately do nothing
-                }
-                else {
-                    throw new TokenScanParseError(
-                    // eslint-disable-next-line max-len
-                    'token span popping in this context not yet implemented', scan, was, is);
-                }
-            }
-            else if (undefined === popped) {
-                if (index !== (scan.tokens.length - 1)
-                    && ('' !== was.operation
-                        || undefined !== was.right_operand)) {
-                    throw new TokenScanParseError('Token scan finished with incomplete parse!', scan, was, is);
-                }
-            }
-            else {
-                if ('' === was.operation
-                    && undefined !== was.left_operand
-                    && undefined === was.right_operand) {
-                    was.left_operand = new IntermediaryCalculation(popped.left_operand, popped.operation, was.left_operand);
-                    was.operation = '';
-                    was.operand_mode = 'right';
-                }
-                else {
-                    throw new TokenScanParseError(
-                    // eslint-disable-next-line max-len
-                    'token span popping in this context not yet implemented', scan, was, is);
-                }
-            }
-        }
-        else if (is_numeric(is) || is_infinity(is)) {
-            if ('left' === was.operand_mode) {
-                was.left_operand = IntermediaryNumber.create(value.substring(is.from, is.to));
-                was.operand_mode = 'right';
-            }
-            else {
-                if ('' === was.operation) {
-                    throw new TokenScanParseError('Right operand detected without operation!', scan, was, is);
-                }
-                else if (undefined === was.left_operand) {
-                    throw new TokenScanParseError('Right operand detected without left operand!', scan, was, is);
-                }
-                let resolved = new IntermediaryCalculation(was.left_operand, was.operation, IntermediaryNumber.create(value.substring(is.from, is.to)));
-                if (was.outter_stack.length > 0
-                    && !(was.outter_stack[was.outter_stack.length - 1] instanceof TokenSpan)) {
-                    const previous = (was.outter_stack.pop());
-                    resolved = new IntermediaryCalculation(previous.left_operand, previous.operation, resolved);
-                }
-                was.left_operand = resolved;
-                was.operation = '';
-                was.right_operand = undefined;
-            }
-        }
-        else if ('operation' === is.type) {
-            if (undefined === was.left_operand) {
-                throw new TokenScanParseError('Operation detected without left operand!', scan, was, is);
-            }
-            else if ('' !== was.operation) {
-                throw new TokenScanParseError(`Cannot set operation when operation already set to "${was.operation}"`, scan, was, is);
-            }
-            const maybe = value.substring(is.from, is.to);
-            is_operation_value(maybe);
-            was.operation = maybe;
-        }
-        else {
-            throw new TokenScanParseError('not implemented', scan, was, is);
-        }
-        return was;
-    }
-}
-//#endregion