exprify 1.0.0

package/README.md

@@ -0,0 +1,135 @@
+# Exprify — Math Expression Parser & Evaluator
+
+[![Exprify Social Banner](https://raw.githubusercontent.com/code-hemu/Exprify/refs/heads/main/src/assets/capture.jpg)](https://github.com/code-hemu/Exprify)
+
+Exprify is a JavaScript expression parser and evaluator supporting math operations, variables, and custom functions.
+
+## 🔧 Manual Build
+1. Clone the repository:
+   ```bash
+   git clone https://github.com/code-hemu/Exprify.git
+   cd Exprify
+
+2. Install dependencies and build:
+   ```bash
+   npm install
+   npm run build
+   
+The output will be generated in a dist/ folder.
+
+## 🚀 Quick Start
+### Node.js / ES Modules
+```Javascript
+import Exprify from "exprify";
+const expr = new Exprify();
+console.log(expr.evaluate("5 + 7 * 2")); 
+// → 19
+```
+### Browser (UMD)
+```html
+<script src="exprify.js"></script>
+<script>
+  const expr = new Exprify();
+  console.log(expr.evaluate("10 + 5 * 2"));
+</script>
+```
+## 🧠 Examples
+### ➕ Basic Math
+```Javascript
+expr.evaluate("10 + 5 * 2"); 
+// → 20
+```
+### 🧮 Parentheses
+```Javascript
+expr.evaluate("(10 + 5) * 2"); 
+// → 30
+```
+### 🔢 Variables
+```Javascript
+expr.setVariable("x", 10);
+expr.setVariable("y", 5);
+
+expr.evaluate("x + y * 2");
+// → 20
+```
+### 🔧 Custom Functions
+```Javascript
+expr.addFunction("double", (x) => x * 2);
+
+expr.evaluate("#double(5) + 3");
+// → 13
+```
+
+### 📊 Built-in Functions
+```Javascript
+expr.evaluate("#max(10, 25, 7)"); 
+// → 25
+
+expr.evaluate("#min(10, 25, 7)"); 
+// → 7
+```
+## 🤿 Other Examples
+```Javascript
+//Create a new Exprify object with Exprify class
+const expr = new Exprify();
+
+//Simple Expression evaluation
+console.log(expr.evaluate(`25+5*2`)); // → 35
+
+//Nested expression evaluation
+console.log(expr.evaluate(`((52/8+2)+56*((25/2)*4+(8-2)))*2`)); // → 6289
+
+//BigInt Expression evaluation
+console.log(expr.evaluate(`11n ^2n`)); // → 121n 
+
+//String concatenation: '+' Operator behaves as concatenation operator
+console.log(expr.evaluate(`"Hello " + "World"`)); // → "Hello World"
+
+//Invalid Expression: One operand is a string and another one is number
+console.log(expr.evaluate(`"45" + 5`)); // → datatype error
+
+//Invalid Expression: One operand is a number and another one is boolean
+console.log(expr.evaluate(`45 * true`)); // → datatype error
+
+//Invalid Expression: unclosed quoted text
+console.log(expr.evaluate(`"Hello World `)); // → unclosed error
+```
+
+## 🧩 Built-in Functions
+Exprify has some built-in functions, here is a complete list
+|  Function | Details | Example |
+| - | - |- |
+|**#max(...)**| #max() function returns the largest number of the provided numerical arguments | ```"#max(45,50,20, 4+9*(6+4))" //returns 94 ```|
+|**#min(...)**| #min() function returns the smallest number of the provided numerical arguments | ```"#min(45,50,20, 4+9*(6+4))" //returns 20 ```|
+|**#and(...)** <br> or <br> **#&&**| **#and()** or **#&&** tests each of its arguments , if all are true then it will return true | ```"#and(true , true, false)" //returns false ``` <br> <br> ```"#&&(true , true, false)" //returns false ```|
+|**#or(...)** <br> or <br> **#\|\|** | **#or()** or **#\|\|()** tests each of its arguments , if any of its arguments is true then it will return true | ```"#or(true , true, false)" //returns true ``` <br> <br> ```"#\|\|(true , true, false)" //returns true```|
+|**#not(x)** <br> or <br> **#!**| **#not()** or **#!()** changes 'true' value to a 'false' value and 'false' value to a 'true' value | ```"#not(true)" //returns false ``` <br> <br> ```"#!(true)" //returns false ``` |
+|**#greaterThan(...)** <br> or <br> **#>**| **#greaterThan()** or **#>()** takes 2 parameters and compare if that the 1st parameter is greater than the second parameter or not | ```"#greaterThan(67 , 5)" //returns true ``` <br> <br>```"#>(67 , 5)" //returns true ``` |
+|**#lessThan(...)** <br> or <br> **#<**| **#lessThan()** or **#<()** takes 2 parameters and compare if that the 1st parameter is less than the second parameter or not | ```"#lessThan(67 , 5)" //returns false ``` <br> <br>```"#<(67 , 5)" //returns false ``` |
+|**#isEqual(...)** <br> or <br> **#==**| **#isEqual()** or **#==()** takes 2 parameters and compare if that the both parameter is same numerical value or not | ```"#isEqual(60 , 50+10)" //returns true ``` <br> <br>```"#==(60 , 50+10)" //returns true ``` |
+|**#if(...)**| **#if()** takes 3 parameters. 1st parameter is a condition parameter, if the condition is true then it returns 2nd parameter otherwise it returns 3rd parameter (if the 3rd parameter is not specified then its default value false will be return) | ```"#if(true , 5, 80)" //returns 80 ``` <br> <br> ```"#if(#<(50,100) , '50 is less than 100', '100 is less than 50')" //returns '50 is less than 100' ```|
+
+
+## 📜 License
+Exprify is freely distributable under the terms of the GPL-3.0 License. Copyright (c) [Nirmal Paul](https://github.com/nirmalpaul383/) (N Paul).
+
+
+## 🤝 Contributing
+
+Contributions are welcome!
+
+1. Fork the repo
+
+2. Create your branch:
+   ```bash
+   git checkout -b feature/your-feature
+   
+3. Commit changes:
+   ```bash   
+   git commit -m "Add your feature"
+   
+4. Push and open a PR 🚀
+
+## ⭐ Support
+If you like [this project](https://github.com/code-hemu/Exprify), give it a ⭐ on GitHub! This project is originally made by [Nirmal Paul](https://github.com/nirmalpaul383/) (N Paul) and replicate by [ViewPoint](https://github.com/nirmalpaul383/ViewPoint). The Main Developer's (N Paul) [youtube page](https://www.youtube.com/channel/UCY6JY8bTlR7hZEvhy6Pldxg/), [facebook page](https://facebook.com/a.new.way.Technical/).
+

package/dist/exprify.cjs.js

@@ -0,0 +1,519 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function tokenize(expr, context) {
+    let tokens = [];
+    let current = "";
+    let quote = "";
+
+    for (let i = 0; i < expr.length; i++) {
+
+        let char = expr[i];
+
+        const isOperator =
+            char === '(' || char === ')' ||
+            char === '^' || char === '*' ||
+            char === '/' || char === '%' ||
+            char === '+' || char === '-';
+
+        const isQuote = char === '"' || char === "'" || char === "`";
+
+        if (isQuote) {
+            if (quote === "") {
+                quote = char;
+                current += char;
+            } else if (quote === char) {
+                current += char;
+                quote = "";
+
+                tokens.push(context.stringToJS(current, context.variablesDB));
+                current = "";
+            } else {
+                current += char;
+            }
+            continue;
+        }
+
+        if (quote !== "") {
+            current += char;
+            continue;
+        }
+
+        if (char === "#") {
+
+            let bracket = 0;
+            let funcName = "";
+            let arg = "";
+            let args = [];
+            let quoteFunc = "";
+
+            while (i < expr.length - 1) {
+                i++;
+                char = expr[i];
+
+                if (bracket === 0) {
+                    if (char === "(") {
+                        bracket++;
+                        continue;
+                    }
+
+                    if (char === " ")
+                        throw new Error("Function name cannot contain space");
+
+                    if (isQuote)
+                        throw new Error("Function name cannot contain quotes");
+
+                    if (funcName === "" && /[0-9.]/.test(char))
+                        throw new Error("Function name cannot start with number");
+
+                    funcName += char;
+                    continue;
+                }
+
+                if (isQuote) {
+                    if (quoteFunc === "") quoteFunc = char;
+                    else if (quoteFunc === char) quoteFunc = "";
+                }
+
+                if (quoteFunc === "") {
+
+                    if (char === "(") bracket++;
+                    else if (char === ")") {
+                        bracket--;
+
+                        if (bracket === 0) {
+                            if (arg !== "") args.push(arg);
+                            break;
+                        }
+                    }
+
+                    if (char === "," && bracket === 1) {
+                        if (arg === "")
+                            throw new Error(`Missing argument in #${funcName}()`);
+
+                        args.push(arg);
+                        arg = "";
+                        continue;
+                    }
+                }
+
+                arg += char;
+            }
+
+            args = args.map(a => context.evaluate(a));
+
+            let fn =
+                context.func_DB_intrnl[funcName] ||
+                context.func_DB_extrnl[funcName];
+
+            if (!fn) {
+                throw new Error(`#${funcName}() not defined`);
+            }
+
+            tokens.push(fn(...args));
+            continue;
+        }
+
+        if (isOperator) {
+
+            if (current !== "") {
+                tokens.push(context.stringToJS(current, context.variablesDB));
+                current = "";
+            }
+
+            tokens.push(char);
+            continue;
+        }
+
+        if (char === " ") {
+            if (current !== "") {
+                tokens.push(context.stringToJS(current, context.variablesDB));
+                current = "";
+            }
+            continue;
+        }
+
+        current += char;
+
+        if (i === expr.length - 1 && current !== "") {
+            tokens.push(context.stringToJS(current, context.variablesDB));
+        }
+    }
+
+    if (quote !== "") {
+        throw new Error("Unclosed string literal");
+    }
+
+    return tokens;
+}
+
+function infixToPostfix(tokens, operator_precedence) {
+    let output = [];
+    let stack = [];
+
+    for (let i = 0; i < tokens.length; i++) {
+
+        let token = tokens[i];
+
+        const isOperator =
+            token === '^' || token === '*' ||
+            token === '/' || token === '%' ||
+            token === '+' || token === '-';
+
+        const isLeftParen = token === "(";
+        const isRightParen = token === ")";
+
+        const isOperand = !isOperator && !isLeftParen && !isRightParen;
+
+        if (isOperand) {
+            output.push(token);
+        }
+
+        else if (isOperator) {
+
+            while (stack.length > 0) {
+
+                let top = stack[stack.length - 1];
+
+                if (top === "(") break;
+
+                let topPrec = operator_precedence[top] || 0;
+                let currPrec = operator_precedence[token];
+
+                // Right associativity for ^
+                if (
+                    (token === '^' && currPrec < topPrec) ||
+                    (token !== '^' && currPrec <= topPrec)
+                ) {
+                    output.push(stack.pop());
+                } else {
+                    break;
+                }
+            }
+
+            stack.push(token);
+        }
+
+        else if (isLeftParen) {
+            stack.push(token);
+        }
+
+        else if (isRightParen) {
+
+            while (stack.length > 0 && stack[stack.length - 1] !== "(") {
+                output.push(stack.pop());
+            }
+
+            if (stack.length === 0) {
+                throw new Error("Mismatched parentheses: missing '('");
+            }
+
+            stack.pop();
+        }
+    }
+
+    while (stack.length > 0) {
+
+        let top = stack.pop();
+
+        if (top === "(" || top === ")") {
+            throw new Error("Mismatched parentheses");
+        }
+
+        output.push(top);
+    }
+
+    return output;
+}
+
+function evaluatePostfix(postfix, mathOperations) {
+
+    let stack = [];
+
+    const isOperator = (val) =>
+        val === '^' || val === '*' ||
+        val === '/' || val === '%' ||
+        val === '+' || val === '-';
+
+    for (let i = 0; i < postfix.length; i++) {
+
+        let token = postfix[i];
+
+        if (!isOperator(token)) {
+            stack.push(token);
+            continue;
+        }
+
+        if (stack.length < 2) {
+            throw new Error("Invalid expression: insufficient operands");
+        }
+
+        let b = stack.pop(); // second
+        let a = stack.pop(); // first
+
+        let result;
+
+        switch (token) {
+            case '^':
+                result = mathOperations.power(a, b);
+                break;
+            case '*':
+                result = mathOperations.multiply(a, b);
+                break;
+            case '/':
+                result = mathOperations.divide(a, b);
+                break;
+            case '%':
+                result = mathOperations.modulus(a, b);
+                break;
+            case '+':
+                result = mathOperations.add(a, b);
+                break;
+            case '-':
+                result = mathOperations.subtract(a, b);
+                break;
+        }
+
+        stack.push(result);
+    }
+
+    if (stack.length !== 1) {
+        throw new Error("Invalid expression: leftover values in stack");
+    }
+
+    return stack[0];
+}
+
+const isValidNumberPair = (a, b) =>
+  (typeof a === typeof b) &&
+  (typeof a === 'number' || typeof a === 'bigint');
+
+const mathOperations = Object.freeze({
+
+  operator_precedence: {
+    '^': 4,
+    '*': 3,
+    '/': 3,
+    '%': 3,
+    '+': 1,
+    '-': 1,
+  },
+
+  power: function(a, b) {
+    if (isValidNumberPair(a, b)) return a ** b;
+    throw new Error("Invalid types for ^");
+  },
+
+  multiply: function(a, b) {
+    if (isValidNumberPair(a, b)) return a * b;
+    throw new Error("Invalid types for *");
+  },
+
+  divide: function(a, b) {
+    if (isValidNumberPair(a, b)) {
+      if (b === 0) throw new Error("Division by zero");
+      return a / b;
+    }
+    throw new Error("Invalid types for /");
+  },
+
+  add: function(a, b) {
+    if (isValidNumberPair(a, b)) return a + b;
+    if (typeof a === 'string' && typeof b === 'string') return a + b;
+    throw new Error("Invalid types for +");
+  },
+  subtract: function(a, b) {
+    if (isValidNumberPair(a, b)) return a - b;
+    throw new Error("Invalid types for -");
+  },
+
+  modulus: function(a, b) {
+    if (isValidNumberPair(a, b)) return a % b;
+    throw new Error("Invalid types for %");
+  }
+});
+
+const and = (...args) => args.every(Boolean);
+const or = (...args) => args.some(Boolean);
+const not = (val) => !val;
+
+const gt = (a, b) => a > b;
+const lt = (a, b) => a < b;
+const eq = (a, b) => a === b;
+const gte = (a, b) => a >= b;
+const lte = (a, b) => a <= b;
+
+const internalFunctions = Object.freeze({
+
+  max: (...args) => {
+    if (!args.every(v => typeof v === 'number')) {
+      throw new Error("max() expects numbers only");
+    }
+    return Math.max(...args);
+  },
+
+  min: (...args) => {
+    if (!args.every(v => typeof v === 'number')) {
+      throw new Error("min() expects numbers only");
+    }
+    return Math.min(...args);
+  },
+
+  and,
+  "&&": and,
+
+  or,
+  "||": or,
+
+  not,
+  "!": not,
+
+  greaterThan: gt,
+  ">": gt,
+
+  lessThan: lt,
+  "<": lt,
+
+  isEqual: eq,
+  "==": eq,
+
+  greaterThanOrEqual: gte,
+  ">=": gte,
+
+  lessThanOrEqual: lte,
+  "<=": lte,
+
+  if: (cond, t, f = false) => cond ? t : f
+
+});
+
+const externalFunctions = {};
+
+const variablesDB = {};
+
+function stringToJS(str, variablesDB) {
+    if (typeof str !== "string" || str.length === 0) {
+        throw new Error("Invalid input: expected a non-empty string.");
+    }
+
+    const firstChar = str[0];
+    const lastChar = str[str.length - 1];
+
+    // HEX (0x...)
+    if (/^0x[0-9a-fA-F]+n?$/.test(str)) {
+
+        // BigInt hex (0xFFn)
+        if (lastChar === 'n') {
+            return BigInt(str.slice(0, -1));
+        }
+
+        return Number(str);
+    }
+
+    if (/^[+-]?(\d+(\.\d+)?|\.\d+)(e[+-]?\d+)?n?$/i.test(str)) {
+
+        // BigInt
+        if (lastChar === 'n') {
+            const numPart = str.slice(0, -1);
+
+            if (numPart.includes('.') || /e/i.test(numPart)) {
+                throw new Error(`Invalid BigInt: ${str}`);
+            }
+
+            return BigInt(numPart);
+        }
+
+        return Number(str);
+    }
+
+    if (
+        (firstChar === '"' && lastChar === '"') ||
+        (firstChar === "'" && lastChar === "'") ||
+        (firstChar === '`' && lastChar === '`')
+    ) {
+        return str.slice(1, -1);
+    }
+
+    if (
+        firstChar === '"' ||
+        firstChar === "'" ||
+        firstChar === '`'
+    ) {
+        throw new Error(`Unmatched or missing quotes: ${str}`);
+    }
+
+    if (str === "true") return true;
+    if (str === "false") return false;
+
+    if (str in variablesDB) {
+        return variablesDB[str];
+    }
+
+    throw new Error(
+        `${str} is not defined. Use setVariable("${str}", value) first.`
+    );
+}
+
+class ViewPoint {
+
+    constructor() {
+        // Shared state
+        this.variablesDB = variablesDB;
+        this.func_DB_intrnl = internalFunctions;
+        this.func_DB_extrnl = externalFunctions;
+
+        this.operator_precedence = mathOperations.operator_precedence;
+    }
+
+    setVariable(name, value) {
+        this.variablesDB[name] = value;
+    }
+
+    addFunction(name, fn) {
+        this.func_DB_extrnl[name] = fn;
+    }
+
+    stringToJS(str) {
+        return stringToJS.call(this, str, this.variablesDB);
+    }
+
+    evaluate(expr) {
+
+        if (typeof expr !== "string") {
+            throw new Error("Expression must be a string");
+        }
+
+        const context = {
+            variablesDB: this.variablesDB,
+            func_DB_intrnl: this.func_DB_intrnl,
+            func_DB_extrnl: this.func_DB_extrnl,
+            stringToJS: this.stringToJS.bind(this),
+            evaluate: this.evaluate.bind(this)
+        };
+
+        // Step 1: Tokenize
+        const tokens = tokenize(expr, context);
+
+        // Step 2: Infix → Postfix
+        const postfix = infixToPostfix(
+            tokens,
+            this.operator_precedence
+        );
+
+        // Step 3: Evaluate Postfix
+        const result = evaluatePostfix(
+            postfix,
+            mathOperations
+        );
+
+        return result;
+    }
+}
+
+exports.Exprify = ViewPoint;
+exports.externalFunctions = externalFunctions;
+exports.internalFunctions = internalFunctions;
+exports.mathOperations = mathOperations;
+exports.variablesDB = variablesDB;
+