@signpostmarv/intermediary-number 0.1.0 → 0.2.0

package/index.d.ts

@@ -0,0 +1,4 @@
+export * from './lib/IntermediaryNumber';
+export * from './lib/IntermediaryNumberTypes';
+export * from './lib/Numbers';
+export * from './lib/NumberStrings';

package/index.js

@@ -0,0 +1,4 @@
+export * from './lib/IntermediaryNumber';
+export * from './lib/IntermediaryNumberTypes';
+export * from './lib/Numbers';
+export * from './lib/NumberStrings';

package/lib/Docs.json.js

@@ -4,4 +4,3 @@ export class NotAnAmountString extends Error {
 export function is_string(maybe) {
     return 'string' === typeof maybe;
 }
-//# sourceMappingURL=Docs.json.js.map

package/lib/IntermediaryNumber.d.ts

@@ -4,7 +4,43 @@ import { amount_string } from './NumberStrings';
 import type { input_types, type_property_types, value_types } from './IntermediaryNumberTypes';
 export type math_types = operand_types | input_types;
 export declare const regex_recurring_number: RegExp;
-export type CanDoMath_result_types = IntermediaryNumber | IntermediaryCalculation;
+export type CanDoMath_result_types = IntermediaryNumber | IntermediaryCalculation | TokenScan;
+export type operation_types = '+' | '-' | '*' | 'x' | '/' | '%';
+export type operand_type_property_types = type_property_types | 'IntermediaryCalculation' | 'TokenScan';
+export type CanConvertTypeJson = {
+    type: 'IntermediaryNumber';
+    value: string;
+} | {
+    type: 'IntermediaryCalculation';
+    left: CanConvertTypeJson;
+    operation: operation_types;
+    right: CanConvertTypeJson;
+} | {
+    type: 'TokenScan';
+    value: string;
+};
+export type CanDoMathWithDispose_operator_types = 'divide' | 'minus' | 'modulo' | 'plus' | 'times';
+export type operand_types = IntermediaryNumber | IntermediaryCalculation | TokenScan;
+type TokenSpan_types = 'ignore' | 'nesting_open' | 'nesting_close' | 'numeric' | 'operation';
+type TokenSpan_types_part_baked = Exclude<TokenSpan_types, 'ignore'>;
+type TokenScan_internals = {
+    parsed: IntermediaryNumber | IntermediaryCalculation | undefined;
+    tokens: (TokenSpan<TokenSpan_types_part_baked>[]) | undefined;
+    valid: boolean | undefined;
+};
+type TokenScan_parsing_value = Omit<TokenScan, 'is_valid' | 'parsed'>;
+type TokenScan_tokenizer_operand_buffer = IntermediaryNumber | IntermediaryCalculation | undefined;
+type incomplete_operation = {
+    left_operand: Exclude<TokenScan_tokenizer_operand_buffer, undefined>;
+    operation: operation_types;
+};
+type TokenScan_tokenizer = {
+    outter_stack: (incomplete_operation | TokenSpan<'nesting_open'>)[];
+    left_operand: TokenScan_tokenizer_operand_buffer;
+    right_operand: TokenScan_tokenizer_operand_buffer;
+    operation: '' | operation_types;
+    operand_mode: 'left' | 'right';
+};
 interface HasType {
     get type(): operand_type_property_types;
 }
@@ -16,21 +52,12 @@ interface CanDoMath<ResultType extends CanDoMath_result_types = CanDoMath_result
     modulo(value: math_types): ResultType;
     plus(value: math_types): ResultType;
     times(value: math_types): ResultType;
-    abs(): (IntermediaryCalculation | IntermediaryNumber);
+    abs(): (operand_types);
     max(first: math_types, ...remaining: math_types[]): math_types;
 }
 interface CanResolveMath<T extends CanDoMath_result_types = CanDoMath_result_types> extends CanDoMath<T, string> {
     resolve(): IntermediaryNumber;
 }
-export type CanConvertTypeJson = {
-    type: 'IntermediaryNumber';
-    value: string;
-} | {
-    type: 'IntermediaryCalculation';
-    left: CanConvertTypeJson;
-    operation: operation_types;
-    right: CanConvertTypeJson;
-};
 export interface CanConvertType extends HasType {
     toAmountString(): amount_string;
     toBigNumber(): BigNumber;
@@ -43,7 +70,6 @@ export interface CanConvertType extends HasType {
     isZero(): boolean;
     toJSON(): CanConvertTypeJson;
 }
-type CanDoMathWithDispose_operator_types = 'divide' | 'minus' | 'modulo' | 'plus' | 'times';
 interface CanDoMathWithDispose<ResultType extends CanDoMath_result_types = CanDoMath_result_types, ResolveString extends string = type_property_types> extends CanConvertType, CanDoMath<ResultType, ResolveString> {
     do_math_then_dispose(operator: CanDoMathWithDispose_operator_types, right_operand: math_types): ResultType;
 }
@@ -76,6 +102,7 @@ export declare class IntermediaryNumber implements CanDoMathWithDispose {
     toFraction(): Fraction;
     toJSON(): CanConvertTypeJson;
     toString(): string;
+    toStringCalculation(): string;
     static create(input: input_types): IntermediaryNumber;
     static create_if_valid(input: string): operand_types | NotValid;
     static fromJson(json: CanConvertTypeJson): CanDoMath_result_types;
@@ -86,9 +113,6 @@ export declare class NotValid extends Error {
     readonly value: string;
     constructor(not_valid: string, reason: unknown);
 }
-export type operand_types = IntermediaryNumber | IntermediaryCalculation;
-export type operation_types = '+' | '-' | '*' | 'x' | '/' | '%';
-export type operand_type_property_types = type_property_types | 'IntermediaryCalculation';
 export declare class IntermediaryCalculation implements CanResolveMathWithDispose {
     readonly left_operand: operand_types;
     readonly operation: operation_types;
@@ -118,9 +142,64 @@ export declare class IntermediaryCalculation implements CanResolveMathWithDispos
     toFraction(): Fraction;
     toJSON(): CanConvertTypeJson;
     toString(): string;
+    toStringCalculation(): string;
     private operand_to_IntermediaryNumber;
     static fromString(input: Exclude<string, ''>): IntermediaryNumber | IntermediaryCalculation;
-    static maybe_reduce_operands(left: operand_types, operation: operation_types, right: operand_types): IntermediaryNumber;
+    static is(maybe: unknown): maybe is IntermediaryCalculation;
+    static maybe_reduce_operands(left: operand_types, operation: operation_types, right: operand_types): IntermediaryNumber | TokenScan;
+    static require_is(maybe: unknown): asserts maybe is IntermediaryCalculation;
     private static maybe_short_circuit;
 }
+declare class TokenSpan<T = TokenSpan_types> {
+    readonly from: number;
+    readonly to: number;
+    readonly type: T;
+    constructor(from: number, to: number, type: T);
+}
+export declare class TokenScanError extends Error {
+}
+export declare class TokenScanParseError extends Error {
+    readonly current?: TokenSpan<TokenSpan_types>;
+    readonly scan: TokenScan_parsing_value;
+    readonly state?: TokenScan_tokenizer;
+    constructor(message: string, scan: TokenScan_parsing_value, state: TokenScan_tokenizer, current?: TokenSpan<TokenSpan_types>);
+}
+export declare class TokenScan implements CanResolveMathWithDispose {
+    private readonly internal;
+    readonly value: string | [TokenScan, operation_types, math_types];
+    private constructor();
+    get parsed(): Exclude<TokenScan_internals['parsed'], undefined>;
+    get resolve_type(): string;
+    get tokens(): Exclude<TokenScan_internals['tokens'], undefined>;
+    get type(): operand_type_property_types;
+    get valid(): boolean;
+    abs(): operand_types;
+    compare(value: math_types): 0 | 1 | -1;
+    divide(value: math_types): TokenScan;
+    do_math_then_dispose(operator: CanDoMathWithDispose_operator_types, right_operand: math_types): CanDoMath_result_types;
+    isGreaterThan(value: math_types): boolean;
+    isLessThan(value: math_types): boolean;
+    isOne(): boolean;
+    isZero(): boolean;
+    max(first: math_types, ...remaining: math_types[]): math_types;
+    minus(value: math_types): TokenScan;
+    modulo(value: math_types): TokenScan;
+    plus(value: math_types): TokenScan;
+    resolve(): IntermediaryNumber;
+    times(value: math_types): TokenScan;
+    toAmountString(): amount_string;
+    toBigNumber(): BigNumber;
+    toBigNumberOrFraction(): BigNumber | Fraction;
+    toFraction(): Fraction;
+    toJSON(): CanConvertTypeJson;
+    toString(): string;
+    toStringCalculation(): string;
+    static create(value: string): TokenScan;
+    static is(maybe: unknown): maybe is TokenScan;
+    static require_is(maybe: unknown): asserts maybe is TokenScan;
+    private static determine_tokens_from_scan;
+    private static massage_part_baked_tokens;
+    private static parse_scan;
+    private static reduce;
+}
 export {};

package/lib/IntermediaryNumber.js

@@ -3,8 +3,9 @@ import BigNumber from 'bignumber.js';
 import Fraction from 'fraction.js';
 import { is_string, } from './Docs.json';
 import { NumberStrings, } from './NumberStrings';
-import { TokenScan, } from './TokenScan';
 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));
 }
@@ -85,6 +86,34 @@ function max(first, second, ...remaining) {
     }
     return IntermediaryNumber.reuse_or_create(max);
 }
+//#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_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');
@@ -242,6 +271,9 @@ export class IntermediaryNumber {
         }
         return this.value.toString();
     }
+    toStringCalculation() {
+        return this.toString();
+    }
     static create(input) {
         if ('' === input) {
             return IntermediaryNumber.Zero;
@@ -281,7 +313,7 @@ export class IntermediaryNumber {
             return IntermediaryNumber.create(maybe);
         }
         else if (/^(\d+|\d*\.\d+)\s*[+/*x%-]\s*(\d+|\d*\.\d+)$/.test(maybe)) {
-            return (new TokenScan(input)).parsed;
+            return TokenScan.create(input).parsed;
         }
         const scientific = /^(-?\d+(?:\.\d+))e([+-])(\d+)$/.exec(maybe);
         if (scientific) {
@@ -299,15 +331,21 @@ export class IntermediaryNumber {
         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 IntermediaryCalculation)
+            || (input instanceof TokenScan))
             ? input
             : this.create(input));
     }
 }
+//#endregion
+//#region IntermediaryCalculation
 export class NotValid extends Error {
     reason;
     value;
@@ -474,8 +512,16 @@ export class IntermediaryCalculation {
         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)) {
+        if ((operand instanceof IntermediaryCalculation)
+            || (operand instanceof TokenScan)) {
             return operand.resolve();
         }
         else if ('amount_string' === operand.type
@@ -487,7 +533,10 @@ export class IntermediaryCalculation {
         return operand;
     }
     static fromString(input) {
-        return (new TokenScan(input)).parsed;
+        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);
@@ -499,6 +548,11 @@ export class IntermediaryCalculation {
         }
         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 ('+' === operation) {
@@ -526,4 +580,401 @@ export class IntermediaryCalculation {
         return value;
     }
 }
-//# sourceMappingURL=IntermediaryNumber.js.map
+//#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() {
+        if (undefined === this.internal.parsed) {
+            this.internal.parsed = TokenScan.parse_scan(this);
+        }
+        return this.internal.parsed;
+    }
+    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.parsed;
+                this.internal.valid = true;
+            }
+            catch (err) {
+                this.internal.valid = false;
+            }
+        }
+        return this.internal.valid;
+    }
+    abs() {
+        return this.parsed.abs();
+    }
+    compare(value) {
+        return this.parsed.compare(value);
+    }
+    divide(value) {
+        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);
+    }
+    minus(value) {
+        return new TokenScan([
+            this,
+            '-',
+            value,
+        ]);
+    }
+    modulo(value) {
+        return new TokenScan([
+            this,
+            '%',
+            value,
+        ]);
+    }
+    plus(value) {
+        return new TokenScan([
+            this,
+            '+',
+            value,
+        ]);
+    }
+    resolve() {
+        const parsed = this.parsed;
+        return IntermediaryCalculation.is(parsed) ? parsed.resolve() : parsed;
+    }
+    times(value) {
+        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];
+            return `${(left_operand.parsed instanceof IntermediaryNumber)
+                ? left_operand.toString()
+                : `(${left_operand.toStringCalculation()})`} ${this.value[1]} ${IntermediaryNumber.reuse_or_create(this.value[2]).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'));
+        }
+        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)) {
+            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

package/lib/IntermediaryNumberTypes.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=IntermediaryNumberTypes.js.map

package/lib/NumberStrings.js

@@ -51,4 +51,3 @@ export class NumberStrings {
         }
     }
 }
-//# sourceMappingURL=NumberStrings.js.map

package/lib/Numbers.js

@@ -47,4 +47,3 @@ export class Numbers {
         return result;
     }
 }
-//# sourceMappingURL=Numbers.js.map

package/package.json

@@ -8,24 +8,25 @@
 		"url": "git+https://github.com/SignpostMarv/Intermediary-Number.git"
 	},
 	"funding": "https://github.com/SignpostMarv/Intermediary-Number?sponsor=1",
+	"exports": "./index.js",
 	"devDependencies": {
-		"@eslint/js": "^9.0.0",
+		"@eslint/js": "^9.4.0",
 		"@stdlib/types": "^0.3.2",
-		"@types/eslint": "^8.56.9",
-		"@types/node": "^20.12.7",
+		"@types/eslint": "^8.56.10",
+		"@types/node": "^20.14.2",
 		"c8": "^9.1.0",
 		"eslint": "^8.57.0",
-		"glob": "^10.3.12",
-		"prettier": "^3.2.5",
+		"glob": "^10.4.1",
+		"prettier": "^3.3.2",
 		"ts-node": "^10.9.2",
-		"tslib": "^2.6.2",
+		"tslib": "^2.6.3",
 		"typescript": "^5.4.5",
-		"typescript-eslint": "^7.7.0"
+		"typescript-eslint": "^7.13.0"
 	},
 	"dependencies": {
-		"@satisfactory-clips-archive/custom-assert": "^0.1.0",
+		"@satisfactory-clips-archive/custom-assert": "^0.1.2",
 		"bignumber.js": "^9.1.2",
 		"fraction.js": "^4.3.7"
 	},
-	"version": "0.1.0"
+	"version": "0.2.0"
 }

package/lib/TokenScan.d.ts

@@ -1,48 +0,0 @@
-import { IntermediaryCalculation, IntermediaryNumber, operation_types } from './IntermediaryNumber';
-type TokenSpan_types = 'ignore' | 'nesting_open' | 'nesting_close' | 'numeric' | 'operation';
-type TokenSpan_types_part_baked = Exclude<TokenSpan_types, 'ignore'>;
-declare class TokenSpan<T = TokenSpan_types> {
-    readonly from: number;
-    readonly to: number;
-    readonly type: T;
-    constructor(from: number, to: number, type: T);
-}
-export declare class TokenScanError extends Error {
-}
-export declare class TokenScanParseError extends Error {
-    readonly current?: TokenSpan<TokenSpan_types>;
-    readonly scan: TokenScan_parsing_value;
-    readonly state?: TokenScan_tokenizer;
-    constructor(message: string, scan: TokenScan_parsing_value, state: TokenScan_tokenizer, current?: TokenSpan<TokenSpan_types>);
-}
-type TokenScan_internals = {
-    parsed: IntermediaryNumber | IntermediaryCalculation | undefined;
-    tokens: (TokenSpan<TokenSpan_types_part_baked>[]) | undefined;
-    valid: boolean | undefined;
-};
-type TokenScan_parsing_value = Omit<TokenScan, 'is_valid' | 'parsed'>;
-export declare class TokenScan {
-    private readonly internal;
-    readonly value: string;
-    constructor(value: string);
-    get parsed(): Exclude<TokenScan_internals['parsed'], undefined>;
-    get tokens(): Exclude<TokenScan_internals['tokens'], undefined>;
-    get valid(): boolean;
-    private static determine_tokens_from_scan;
-    private static massage_part_baked_tokens;
-    private static parse_scan;
-    private static reduce;
-}
-type TokenScan_tokenizer_operand_buffer = IntermediaryNumber | IntermediaryCalculation | undefined;
-type incomplete_operation = {
-    left_operand: Exclude<TokenScan_tokenizer_operand_buffer, undefined>;
-    operation: operation_types;
-};
-type TokenScan_tokenizer = {
-    outter_stack: (incomplete_operation | TokenSpan<'nesting_open'>)[];
-    left_operand: TokenScan_tokenizer_operand_buffer;
-    right_operand: TokenScan_tokenizer_operand_buffer;
-    operation: '' | operation_types;
-    operand_mode: 'left' | 'right';
-};
-export {};

package/lib/TokenScan.js

@@ -1,302 +0,0 @@
-import { IntermediaryCalculation, IntermediaryNumber, } from './IntermediaryNumber';
-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() {
-        if (undefined === this.internal.parsed) {
-            this.internal.parsed = TokenScan.parse_scan(this);
-        }
-        return this.internal.parsed;
-    }
-    get tokens() {
-        if (undefined === this.internal.tokens) {
-            this.internal.tokens = TokenScan.determine_tokens_from_scan(this);
-        }
-        return this.internal.tokens;
-    }
-    get valid() {
-        if (undefined === this.internal.valid) {
-            try {
-                this.parsed;
-                this.internal.valid = true;
-            }
-            catch (err) {
-                this.internal.valid = false;
-            }
-        }
-        return this.internal.valid;
-    }
-    static determine_tokens_from_scan(scan) {
-        let tokens = [];
-        for (const entry of scan.value.matchAll(/([\s]+)/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'ignore'));
-        }
-        for (const entry of scan.value.matchAll(regex_numeric)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'numeric'));
-        }
-        for (const entry of scan.value.matchAll(/([+/*x%-])/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'operation'));
-        }
-        for (const entry of scan.value.matchAll(/(\()/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'nesting_open'));
-        }
-        for (const entry of scan.value.matchAll(/(\))/g)) {
-            tokens.push(new TokenSpan(entry.index, entry.index + entry[0].length, 'nesting_close'));
-        }
-        tokens = tokens.sort((a, b) => {
-            return a.from - b.from;
-        });
-        const recursive_numerics = tokens.filter(maybe => ('numeric' === maybe.type
-            && /[()]/.test(scan.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 (scan.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 = [];
-        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 = scan.value.substring(previous.from, previous.to);
-                const current_value = scan.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
-            && '-' === scan.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
-                && '-' === scan.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) {
-        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)) {
-            if ('left' === was.operand_mode) {
-                was.left_operand = IntermediaryNumber.create(scan.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(scan.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 = scan.value.substring(is.from, is.to);
-            is_operation_value(maybe);
-            was.operation = maybe;
-        }
-        else {
-            throw new TokenScanParseError('not implemented', scan, was, is);
-        }
-        return was;
-    }
-}
-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_operation_value(maybe) {
-    if (!(maybe.length === 1
-        && '+-/x*%'.includes(maybe))) {
-        throw new TokenScanError(`Expected operation value, found "${maybe}"`);
-    }
-}
-//# sourceMappingURL=TokenScan.js.map