nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/classes/parser/Token.d.ts

@@ -0,0 +1,58 @@
+import { TOKEN } from './constants';
+import type { Operator } from '../../common/common';
+export declare const ALLOWED_CHARACTERS: string[];
+export declare const operatorArray: string[];
+export declare let operatorRegex: RegExp;
+/** Refreshes tokenizer operator symbols after the shared operator registry changes. */
+export declare function refreshOperatorSymbols(): void;
+export declare const bracketRegex: RegExp;
+export declare const variableRegex: RegExp;
+export declare const digitRegex: RegExp;
+export declare const dotOrDigitRegex: RegExp;
+export interface TokenBuffer {
+    tokenType: string;
+    chars: string[];
+    inputString: string;
+    scientificNumber: boolean;
+    last(): string | undefined;
+    next(at: number): string;
+    prev(at: number): string;
+    is(tokenType: string): boolean;
+}
+export declare class Token {
+    static readonly BRACKET = "BKT";
+    static readonly CHARACTER = "CHR";
+    static readonly FUNCTION = "FUN";
+    static readonly NUMBER = "NUM";
+    static readonly OPERATOR = "OPR";
+    static readonly PREFIX = "PFX";
+    static readonly SPACE = "SPC";
+    static readonly UNDEFINED = "UND";
+    static readonly VARIABLE = "VAR";
+    dataType: typeof TOKEN;
+    position: number;
+    /** Operator metadata selected from syntax when one source token has multiple roles. */
+    resolvedOperator?: Operator;
+    type?: string;
+    value: string;
+    constructor(value: string | number | Token, type: string, position: number);
+    static getCharType(ch: string, at: number, buffer: TokenBuffer): "BKT" | "CHR" | "NUM" | "OPR" | "SPC" | "VAR";
+    static isToken(obj: unknown): obj is Token;
+    /**
+     * Helper function for creating an operator token
+     *
+     * @param value
+     * @returns
+     */
+    static O(value: string): Token;
+    /**
+     * Helper function for creating an variable token
+     *
+     * @param value
+     * @returns
+     */
+    static V(value: string): Token;
+    is(type: string): boolean;
+    text(): string;
+    toString(): string;
+}

package/output/core/classes/parser/Token.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = exports.dotOrDigitRegex = exports.digitRegex = exports.variableRegex = exports.bracketRegex = exports.operatorRegex = exports.operatorArray = exports.ALLOWED_CHARACTERS = void 0;
+exports.refreshOperatorSymbols = refreshOperatorSymbols;
+const common_1 = require("../../common/common");
+const functions_1 = require("../../common/functions/functions");
+const constants_1 = require("./constants");
+// Additional characters allowed in the parser which haven't already been defined
+exports.ALLOWED_CHARACTERS = [];
+exports.operatorArray = (0, functions_1.getOperatorSymbolArray)();
+exports.operatorRegex = new RegExp(`[${exports.operatorArray.join('')}]`);
+/** Refreshes tokenizer operator symbols after the shared operator registry changes. */
+function refreshOperatorSymbols() {
+    exports.operatorArray.splice(0, exports.operatorArray.length, ...(0, functions_1.getOperatorSymbolArray)());
+    exports.operatorRegex = new RegExp(`[${exports.operatorArray.join('')}]`);
+}
+exports.bracketRegex = new RegExp(`[${Object.keys(common_1.brackets).join('\\')}]`);
+exports.variableRegex = /[a-z_αAβBγΓδΔϵEζZηHθΘιIκKλΛμMνNξΞoOπΠρPσΣτTυϒϕΦχXψΨωΩ∞]/i;
+exports.digitRegex = /\d/;
+exports.dotOrDigitRegex = /\d|\./;
+class Token {
+    static BRACKET = 'BKT';
+    static CHARACTER = 'CHR';
+    static FUNCTION = 'FUN';
+    static NUMBER = 'NUM';
+    // args?: any;
+    static OPERATOR = 'OPR';
+    static PREFIX = 'PFX';
+    static SPACE = 'SPC';
+    static UNDEFINED = 'UND';
+    static VARIABLE = 'VAR';
+    dataType;
+    position;
+    /** Operator metadata selected from syntax when one source token has multiple roles. */
+    resolvedOperator;
+    type;
+    value;
+    constructor(value, type, position) {
+        this.dataType = constants_1.TOKEN;
+        // Where was start of the token found
+        this.position = position;
+        // What type of token is it
+        this.type = type;
+        // The actual contents
+        this.value = String(value);
+    }
+    static getCharType(ch, at, buffer) {
+        // If it's a number.
+        if (exports.digitRegex.test(ch)) {
+            // If the number or underscore comes after a variable then it belongs to the variable
+            if (buffer.tokenType === Token.VARIABLE) {
+                return Token.VARIABLE;
+            }
+            return Token.NUMBER;
+        }
+        else if (ch === constants_1.SPACE) {
+            return Token.SPACE;
+        }
+        // It's a decimal and belongs to a number.
+        else if (ch === constants_1.DOT) {
+            // If the "." comes after a variable then we make it an operator to allow for dot notation at some point
+            if (buffer.tokenType === Token.VARIABLE) {
+                return Token.OPERATOR;
+            }
+            return Token.NUMBER;
+        }
+        // Scientific numbers
+        else if ((ch === 'e' || ch === 'E') && buffer.tokenType === Token.NUMBER) {
+            const prev = buffer.prev(at);
+            const next = buffer.next(at);
+            if (next === constants_1.PLUS ||
+                next === constants_1.MINUS ||
+                (exports.dotOrDigitRegex.test(prev) && exports.digitRegex.test(next))) {
+                buffer.scientificNumber = true;
+                return Token.NUMBER;
+            }
+            return Token.VARIABLE;
+        }
+        // If it's a letter.
+        else if (exports.variableRegex.test(ch) || exports.ALLOWED_CHARACTERS.includes(ch)) {
+            return Token.VARIABLE;
+        }
+        // It's a bracket
+        else if (exports.bracketRegex.test(ch)) {
+            return Token.BRACKET;
+        }
+        // It's an operator
+        else if (exports.operatorRegex.test(ch)) {
+            const last = buffer.last();
+            // Bypass the + and - for scientific numbers
+            if (buffer.tokenType === Token.NUMBER &&
+                (ch === constants_1.PLUS || ch === constants_1.MINUS) &&
+                (last === 'e' || last === 'E')) {
+                return Token.NUMBER;
+            }
+            return Token.OPERATOR;
+        }
+        // All else
+        else {
+            return Token.CHARACTER;
+        }
+    }
+    static isToken(obj) {
+        return (0, common_1.isNerdamerNativeType)(obj, constants_1.TOKEN);
+    }
+    /**
+     * Helper function for creating an operator token
+     *
+     * @param value
+     * @returns
+     */
+    static O(value) {
+        return new Token(value, Token.OPERATOR, -1);
+    }
+    /**
+     * Helper function for creating an variable token
+     *
+     * @param value
+     * @returns
+     */
+    static V(value) {
+        return new Token(value, Token.VARIABLE, -1);
+    }
+    is(type) {
+        return this.type === type;
+    }
+    text() {
+        return this.value;
+    }
+    toString() {
+        if (this.type === Token.PREFIX) {
+            return '`' + this.value;
+        }
+        return this.value;
+    }
+}
+exports.Token = Token;

package/output/core/classes/parser/constants.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Some helper constants
+ */
+export declare const MINUS = "-";
+export declare const PLUS = "+";
+export declare const MULTIPLY = "*";
+export declare const DIVIDE = "/";
+export declare const DOT = ".";
+export declare const COMMA = ",";
+export declare const ASSIGN = ":";
+export declare const SPACE = " ";
+export declare const BLANK = "";
+export declare const NEWLINE = "\n";
+export declare const TAB = "\t";
+export declare const LINEFEED = "\f";
+export declare const RETURN = "\r";
+export declare const OPEN_PAREN = "(";
+export declare const CLOSE_PAREN = ")";
+export declare const WRAP = "";
+export declare const TOKEN = "Token";
+export declare const INDEXED_REFERENCE = "INDEXED_REF";
+export declare const KEY_VALUE_PAIR = "KEY_VALUE_PAIR";
+export declare const RATIONAL = "RAT";
+export declare const SCOPE = "SCP";
+export declare const EXPRESSION = "EXP";
+export declare const COLLECTION = "COL";
+export declare const VECTOR = "VEC";
+export declare const MATRIX = "MAT";
+export declare const EQUATION = "EQN";
+export declare const POLYNOMIAL = "POL";
+export declare const TERM = "TRM";
+export declare const GFPOLY = "GFP";
+export declare const SET = "SET";
+export declare const SOLUTIONS_SET = "SOL";
+export declare const DICTIONARY = "DIC";
+export declare const ASSUMPTION = "ASSUMPTION";
+export declare const dataTypes: {
+    [key: string]: string;
+};
+/**
+ * The base types supported by the parser. All other types are a form of these
+ */
+export declare const EXPRESSION_TYPES: {
+    NUM: number;
+    VAR: number;
+    EXP: number;
+    FUN: number;
+    GRP: number;
+    PRD: number;
+    SUM: number;
+    INF: number;
+    VEC: number;
+    MAT: number;
+};
+/**
+ * The ranking used when evaluating types
+ */
+export declare const RANK: {
+    [key: string]: number;
+};
+export declare const E = "e";
+export declare const PI_NAME = "pi";
+export declare const PI_SYMBOL = "\u03C0";
+export declare const DEFAULT_IMAGINARY = "i";
+export declare const INDEX_VARIABLE = "_n";
+export declare const ALL_SYMBOL = "all";
+export declare const ALIASES: Record<string, string>;
+export declare const PI: string[];
+export declare const INFINITY: string[];
+export declare const PARSER_CONSTANTS: {
+    pi: () => string;
+    π: () => string;
+    e: () => string;
+};
+export declare const SYMBOLIC_ACCESSOR = "__accessor__";
+export declare const FACTORIAL = "fact";
+export declare const DOUBLE_FACTORIAL = "dfact";
+export declare const FIB = "fib";
+export declare const SQRT = "sqrt";
+export declare const ABS = "abs";
+export declare const MOD = "mod";
+export declare const GAMMA = "gamma";
+export declare const DIRAC = "delta";
+export declare const HEAVISIDE = "heaviside";
+export declare const LOG = "log";
+export declare const SGN = "sign";
+export declare const CSGN = "csgn";
+export declare const CBRT = "cbrt";
+export declare const CEIL = "ceil";
+export declare const CHI = "Chi";
+export declare const CI = "Ci";
+export declare const CONJUGATE = "conjugate";
+export declare const CONTAINS = "contains";
+export declare const CONTENT = "content";
+export declare const COUNT = "count";
+export declare const CROSS = "cross";
+export declare const DEFINT = "defint";
+export declare const DEG = "deg";
+export declare const DIFF = "diff";
+export declare const DOT_PRODUCT = "dot";
+export declare const EI = "Ei";
+export declare const ERF = "erf";
+export declare const FACTOR = "factor";
+export declare const FLOOR = "floor";
+export declare const FRESNEL_C = "C";
+export declare const FRESNEL_S = "S";
+export declare const GCD = "gcd";
+export declare const ILAPLACE = "ilaplace";
+export declare const IMAGPART = "imagpart";
+export declare const IMATRIX = "imatrix";
+export declare const INTEGRATE = "integrate";
+export declare const ISPRIME = "isprime";
+export declare const LAPLACE = "laplace";
+export declare const LI = "Li";
+export declare const LIMIT = "limit";
+export declare const LN = "ln";
+export declare const MAX = "max";
+export declare const MIN = "min";
+export declare const NTHROOT = "nthroot";
+export declare const PRODUCT_FUNCTION = "product";
+export declare const REALPART = "realpart";
+export declare const ROUND = "round";
+export declare const SIZE = "size";
+export declare const TRUNC = "trunc";
+export declare const SHI = "Shi";
+export declare const SI = "Si";
+export declare const SINC = "sinc";
+export declare const SUM_FUNCTION = "sum";
+export declare const TRIG_FUNCTION_NAMES: {
+    COS: string;
+    SIN: string;
+    TAN: string;
+    SEC: string;
+    CSC: string;
+    COT: string;
+    ACOS: string;
+    ASIN: string;
+    ATAN: string;
+    ASEC: string;
+    ACSC: string;
+    ACOT: string;
+    ATAN2: string;
+    SINH: string;
+    COSH: string;
+    TANH: string;
+    SECH: string;
+    CSCH: string;
+    COTH: string;
+    ACOSH: string;
+    ASINH: string;
+    ATANH: string;
+    ASECH: string;
+    ACSCH: string;
+    ACOTH: string;
+};
+export declare const COS: string, SIN: string, TAN: string, ASIN: string, ACOS: string, SEC: string, CSC: string, COT: string, ATAN: string, ASEC: string, ACSC: string, ACOT: string, ATAN2: string, SINH: string, COSH: string, TANH: string, SECH: string, CSCH: string, COTH: string, ACOSH: string, ASINH: string, ATANH: string, ASECH: string, ACSCH: string, ACOTH: string;
+export declare const TRIG: string[];
+export declare const INVERSE_TRIG: string[];
+export declare const HYPERBOLIC_TRIG: string[];
+export declare const INVERSE_HYPERBOLIC_TRIG: string[];

package/output/core/classes/parser/constants.js

@@ -0,0 +1,227 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FIB = exports.DOUBLE_FACTORIAL = exports.FACTORIAL = exports.SYMBOLIC_ACCESSOR = exports.PARSER_CONSTANTS = exports.INFINITY = exports.PI = exports.ALIASES = exports.ALL_SYMBOL = exports.INDEX_VARIABLE = exports.DEFAULT_IMAGINARY = exports.PI_SYMBOL = exports.PI_NAME = exports.E = exports.RANK = exports.EXPRESSION_TYPES = exports.dataTypes = exports.ASSUMPTION = exports.DICTIONARY = exports.SOLUTIONS_SET = exports.SET = exports.GFPOLY = exports.TERM = exports.POLYNOMIAL = exports.EQUATION = exports.MATRIX = exports.VECTOR = exports.COLLECTION = exports.EXPRESSION = exports.SCOPE = exports.RATIONAL = exports.KEY_VALUE_PAIR = exports.INDEXED_REFERENCE = exports.TOKEN = exports.WRAP = exports.CLOSE_PAREN = exports.OPEN_PAREN = exports.RETURN = exports.LINEFEED = exports.TAB = exports.NEWLINE = exports.BLANK = exports.SPACE = exports.ASSIGN = exports.COMMA = exports.DOT = exports.DIVIDE = exports.MULTIPLY = exports.PLUS = exports.MINUS = void 0;
+exports.SUM_FUNCTION = exports.SINC = exports.SI = exports.SHI = exports.TRUNC = exports.SIZE = exports.ROUND = exports.REALPART = exports.PRODUCT_FUNCTION = exports.NTHROOT = exports.MIN = exports.MAX = exports.LN = exports.LIMIT = exports.LI = exports.LAPLACE = exports.ISPRIME = exports.INTEGRATE = exports.IMATRIX = exports.IMAGPART = exports.ILAPLACE = exports.GCD = exports.FRESNEL_S = exports.FRESNEL_C = exports.FLOOR = exports.FACTOR = exports.ERF = exports.EI = exports.DOT_PRODUCT = exports.DIFF = exports.DEG = exports.DEFINT = exports.CROSS = exports.COUNT = exports.CONTENT = exports.CONTAINS = exports.CONJUGATE = exports.CI = exports.CHI = exports.CEIL = exports.CBRT = exports.CSGN = exports.SGN = exports.LOG = exports.HEAVISIDE = exports.DIRAC = exports.GAMMA = exports.MOD = exports.ABS = exports.SQRT = void 0;
+exports.INVERSE_HYPERBOLIC_TRIG = exports.HYPERBOLIC_TRIG = exports.INVERSE_TRIG = exports.TRIG = exports.ACOTH = exports.ACSCH = exports.ASECH = exports.ATANH = exports.ASINH = exports.ACOSH = exports.COTH = exports.CSCH = exports.SECH = exports.TANH = exports.COSH = exports.SINH = exports.ATAN2 = exports.ACOT = exports.ACSC = exports.ASEC = exports.ATAN = exports.COT = exports.CSC = exports.SEC = exports.ACOS = exports.ASIN = exports.TAN = exports.SIN = exports.COS = exports.TRIG_FUNCTION_NAMES = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+/**
+ * Some helper constants
+ */
+exports.MINUS = '-';
+exports.PLUS = '+';
+exports.MULTIPLY = '*';
+exports.DIVIDE = '/';
+exports.DOT = '.';
+exports.COMMA = ',';
+exports.ASSIGN = ':';
+exports.SPACE = ' ';
+exports.BLANK = '';
+exports.NEWLINE = '\n';
+exports.TAB = '\t';
+exports.LINEFEED = '\f';
+exports.RETURN = '\r';
+exports.OPEN_PAREN = '(';
+exports.CLOSE_PAREN = ')';
+exports.WRAP = '';
+// Data types
+// export const EXPRESSION = 'EX';
+exports.TOKEN = 'Token';
+exports.INDEXED_REFERENCE = 'INDEXED_REF';
+exports.KEY_VALUE_PAIR = 'KEY_VALUE_PAIR';
+exports.RATIONAL = 'RAT';
+exports.SCOPE = 'SCP';
+exports.EXPRESSION = 'EXP';
+exports.COLLECTION = 'COL';
+exports.VECTOR = 'VEC';
+exports.MATRIX = 'MAT';
+exports.EQUATION = 'EQN';
+exports.POLYNOMIAL = 'POL';
+exports.TERM = 'TRM';
+exports.GFPOLY = 'GFP';
+exports.SET = 'SET';
+exports.SOLUTIONS_SET = 'SOL';
+exports.DICTIONARY = 'DIC';
+exports.ASSUMPTION = 'ASSUMPTION';
+// The data type name
+exports.dataTypes = {
+    [exports.TOKEN]: 'Token',
+    [exports.INDEXED_REFERENCE]: 'IndexedReference',
+    [exports.KEY_VALUE_PAIR]: 'KeyValuePair',
+    [exports.RATIONAL]: 'Rational',
+    [exports.SCOPE]: 'Scope',
+    [exports.EXPRESSION]: 'Expression',
+    [exports.COLLECTION]: 'Collection',
+    [exports.VECTOR]: 'Vector',
+    [exports.MATRIX]: 'Matrix',
+    [exports.EQUATION]: 'Equation',
+    [exports.POLYNOMIAL]: 'Polynomial',
+    [exports.TERM]: 'Term',
+    [exports.GFPOLY]: 'GFPolynomial',
+    [exports.SET]: 'ValuesSet',
+    [exports.SOLUTIONS_SET]: 'SolutionSet',
+    [exports.DICTIONARY]: 'Dictionary',
+    [exports.ASSUMPTION]: 'Assumption',
+};
+/**
+ * The base types supported by the parser. All other types are a form of these
+ */
+exports.EXPRESSION_TYPES = {
+    // Numbers,
+    NUM: 6,
+    // Any variable e.g. x
+    VAR: 2,
+    // An exponential
+    EXP: 1,
+    // Any function
+    FUN: 3,
+    // Any type of the same variable
+    GRP: 4,
+    // Any expression with terms bound by multiplication or division
+    PRD: 7,
+    // Any expression bound by division or subtraction
+    SUM: 5,
+    // Infinity
+    INF: 8,
+    // Vectors
+    VEC: 9,
+    // Matrices
+    MAT: 10,
+};
+/**
+ * The ranking used when evaluating types
+ */
+exports.RANK = {
+    // Numbers,
+    [exports.EXPRESSION_TYPES.NUM]: 1,
+    // Any variable e.g. x
+    [exports.EXPRESSION_TYPES.VAR]: 2,
+    // An exponential
+    [exports.EXPRESSION_TYPES.EXP]: 3,
+    // Any function
+    [exports.EXPRESSION_TYPES.FUN]: 4,
+    // Any type of the same variable
+    [exports.EXPRESSION_TYPES.GRP]: 5,
+    // Any expression with terms bound by multiplication or division
+    [exports.EXPRESSION_TYPES.PRD]: 6,
+    // Any expression bound by division or subtraction
+    [exports.EXPRESSION_TYPES.SUM]: 7,
+    // Infinity
+    [exports.EXPRESSION_TYPES.INF]: 8,
+};
+// Parser Constants
+exports.E = 'e';
+exports.PI_NAME = 'pi';
+exports.PI_SYMBOL = 'π';
+exports.DEFAULT_IMAGINARY = 'i';
+exports.INDEX_VARIABLE = '_n';
+exports.ALL_SYMBOL = 'all';
+exports.ALIASES = {
+    [exports.PI_SYMBOL]: exports.PI_NAME,
+    '∞': 'Inf',
+};
+exports.PI = [exports.PI_NAME, exports.PI_SYMBOL];
+exports.INFINITY = ['Inf', 'Infinity', '∞'];
+// Parser Constants
+exports.PARSER_CONSTANTS = {
+    [exports.PI_NAME]: () => {
+        return decimal_js_1.default.acos(-1).toString();
+    },
+    [exports.PI_SYMBOL]: () => {
+        return decimal_js_1.default.acos(-1).toString();
+    },
+    [exports.E]: () => {
+        return decimal_js_1.default.exp(1).toString();
+    },
+};
+// Functions
+// Internal function name used to carry symbolic bracket access inside an Expression.
+exports.SYMBOLIC_ACCESSOR = '__accessor__';
+exports.FACTORIAL = 'fact';
+exports.DOUBLE_FACTORIAL = 'dfact';
+exports.FIB = 'fib';
+exports.SQRT = 'sqrt';
+exports.ABS = 'abs';
+exports.MOD = 'mod';
+exports.GAMMA = 'gamma';
+exports.DIRAC = 'delta';
+exports.HEAVISIDE = 'heaviside';
+exports.LOG = 'log';
+exports.SGN = 'sign';
+exports.CSGN = 'csgn';
+exports.CBRT = 'cbrt';
+exports.CEIL = 'ceil';
+exports.CHI = 'Chi';
+exports.CI = 'Ci';
+exports.CONJUGATE = 'conjugate';
+exports.CONTAINS = 'contains';
+exports.CONTENT = 'content';
+exports.COUNT = 'count';
+exports.CROSS = 'cross';
+exports.DEFINT = 'defint';
+exports.DEG = 'deg';
+exports.DIFF = 'diff';
+exports.DOT_PRODUCT = 'dot';
+exports.EI = 'Ei';
+exports.ERF = 'erf';
+exports.FACTOR = 'factor';
+exports.FLOOR = 'floor';
+exports.FRESNEL_C = 'C';
+exports.FRESNEL_S = 'S';
+exports.GCD = 'gcd';
+exports.ILAPLACE = 'ilaplace';
+exports.IMAGPART = 'imagpart';
+exports.IMATRIX = 'imatrix';
+exports.INTEGRATE = 'integrate';
+exports.ISPRIME = 'isprime';
+exports.LAPLACE = 'laplace';
+exports.LI = 'Li';
+exports.LIMIT = 'limit';
+exports.LN = 'ln';
+exports.MAX = 'max';
+exports.MIN = 'min';
+exports.NTHROOT = 'nthroot';
+exports.PRODUCT_FUNCTION = 'product';
+exports.REALPART = 'realpart';
+exports.ROUND = 'round';
+exports.SIZE = 'size';
+exports.TRUNC = 'trunc';
+exports.SHI = 'Shi';
+exports.SI = 'Si';
+exports.SINC = 'sinc';
+exports.SUM_FUNCTION = 'sum';
+// Trigonometric functions
+exports.TRIG_FUNCTION_NAMES = {
+    COS: 'cos',
+    SIN: 'sin',
+    TAN: 'tan',
+    SEC: 'sec',
+    CSC: 'csc',
+    COT: 'cot',
+    ACOS: 'acos',
+    ASIN: 'asin',
+    ATAN: 'atan',
+    ASEC: 'asec',
+    ACSC: 'acsc',
+    ACOT: 'acot',
+    ATAN2: 'atan2',
+    SINH: 'sinh',
+    COSH: 'cosh',
+    TANH: 'tanh',
+    SECH: 'sech',
+    CSCH: 'csch',
+    COTH: 'coth',
+    ACOSH: 'acosh',
+    ASINH: 'asinh',
+    ATANH: 'atanh',
+    ASECH: 'asech',
+    ACSCH: 'acsch',
+    ACOTH: 'acoth',
+};
+exports.COS = exports.TRIG_FUNCTION_NAMES.COS, exports.SIN = exports.TRIG_FUNCTION_NAMES.SIN, exports.TAN = exports.TRIG_FUNCTION_NAMES.TAN, exports.ASIN = exports.TRIG_FUNCTION_NAMES.ASIN, exports.ACOS = exports.TRIG_FUNCTION_NAMES.ACOS, exports.SEC = exports.TRIG_FUNCTION_NAMES.SEC, exports.CSC = exports.TRIG_FUNCTION_NAMES.CSC, exports.COT = exports.TRIG_FUNCTION_NAMES.COT, exports.ATAN = exports.TRIG_FUNCTION_NAMES.ATAN, exports.ASEC = exports.TRIG_FUNCTION_NAMES.ASEC, exports.ACSC = exports.TRIG_FUNCTION_NAMES.ACSC, exports.ACOT = exports.TRIG_FUNCTION_NAMES.ACOT, exports.ATAN2 = exports.TRIG_FUNCTION_NAMES.ATAN2, exports.SINH = exports.TRIG_FUNCTION_NAMES.SINH, exports.COSH = exports.TRIG_FUNCTION_NAMES.COSH, exports.TANH = exports.TRIG_FUNCTION_NAMES.TANH, exports.SECH = exports.TRIG_FUNCTION_NAMES.SECH, exports.CSCH = exports.TRIG_FUNCTION_NAMES.CSCH, exports.COTH = exports.TRIG_FUNCTION_NAMES.COTH, exports.ACOSH = exports.TRIG_FUNCTION_NAMES.ACOSH, exports.ASINH = exports.TRIG_FUNCTION_NAMES.ASINH, exports.ATANH = exports.TRIG_FUNCTION_NAMES.ATANH, exports.ASECH = exports.TRIG_FUNCTION_NAMES.ASECH, exports.ACSCH = exports.TRIG_FUNCTION_NAMES.ACSCH, exports.ACOTH = exports.TRIG_FUNCTION_NAMES.ACOTH;
+exports.TRIG = [exports.COS, exports.SIN, exports.TAN, exports.SEC, exports.CSC, exports.COT];
+exports.INVERSE_TRIG = [exports.ACOS, exports.ASIN, exports.ATAN, exports.ASEC, exports.ACSC, exports.ACOT];
+exports.HYPERBOLIC_TRIG = [exports.COSH, exports.SINH, exports.TANH, exports.SECH, exports.CSCH, exports.COTH];
+exports.INVERSE_HYPERBOLIC_TRIG = [exports.ACOSH, exports.ASINH, exports.ATANH, exports.ASECH, exports.ACSCH, exports.ACOTH];

package/output/core/classes/parser/helpers.d.ts

@@ -0,0 +1,21 @@
+import { scopedBlock } from '../../Settings';
+import { Expression } from '../expression/Expression';
+import type { ExpressionInput, StructuredEntityType } from '../../types';
+import type { ParserValuesObject } from './types';
+export { scopedBlock };
+/**
+ * Forces the expression to be evaluated
+ *
+ * @param expression The expression to be evaluated
+ * @param values The values to be substituted
+ * @returns
+ */
+export declare function evaluate(expression: string, values?: ParserValuesObject): import("../../types").ParserEntity;
+export declare function inert(expression: string): import("../../types").ParserEntity;
+export declare function _(expr: ExpressionInput): Expression;
+/**
+ * Returns true if the object is a structured entity
+ * @param obj
+ * @returns
+ */
+export declare function isStructuredEntity(obj: unknown): obj is StructuredEntityType;

package/output/core/classes/parser/helpers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scopedBlock = void 0;
+exports.evaluate = evaluate;
+exports.inert = inert;
+exports._ = _;
+exports.isStructuredEntity = isStructuredEntity;
+const Settings_1 = require("../../Settings");
+Object.defineProperty(exports, "scopedBlock", { enumerable: true, get: function () { return Settings_1.scopedBlock; } });
+const Expression_1 = require("../expression/Expression");
+const Parser_1 = require("./Parser");
+/**
+ * Forces the expression to be evaluated
+ *
+ * @param expression The expression to be evaluated
+ * @param values The values to be substituted
+ * @returns
+ */
+function evaluate(expression, values) {
+    return Parser_1.Parser.evaluate(expression, values);
+}
+function inert(expression) {
+    return (0, Settings_1.scopedBlock)('EVALUATE', false, () => {
+        return (0, Settings_1.scopedBlock)('SUBSTITUTE', false, () => {
+            return Parser_1.Parser.parse(expression);
+        });
+    });
+}
+function _(expr) {
+    return Expression_1.Expression.create(expr);
+}
+/**
+ * Returns true if the object is a structured entity
+ * @param obj
+ * @returns
+ */
+function isStructuredEntity(obj) {
+    if (typeof obj === 'undefined') {
+        return false;
+    }
+    return obj.isEnumerable;
+}

package/output/core/classes/parser/operations/add.d.ts

@@ -0,0 +1,15 @@
+import { Expression } from '../../expression/Expression';
+export declare function add(a: Expression, b: Expression): Expression;
+export declare function addPrefix(a: Expression): Expression;
+/**
+ * This method is not designed for cases where a = b; This should be handled before getting here.
+ * This method only does element wise addition for powers of 1. For all else it just creates a new expression
+ * and puts them in a new container.
+ *
+ * @param a
+ * @param b
+ * @param action
+ * @param skipAction
+ * @returns
+ */
+export declare function join(a: Expression, b: Expression, isGroup?: boolean): Expression;