sci-calc-pro 1.0.0

package/README.md

@@ -0,0 +1,119 @@
+# sci-calc-pro
+
+Professional scientific calculator CLI for Node.js. Zero dependencies, pure JavaScript.
+
+## Install
+
+```bash
+npm install -g sci-calc-pro
+```
+
+Or use directly in a project:
+
+```bash
+npx sci-calc-pro "sin(45)"
+```
+
+## Usage
+
+### One-liner
+
+```bash
+sci-calc "2^10"
+sci-calc "sin(45) + cos(60)"
+sci-calc "sqrt(144)"
+sci-calc "fact(10)"
+sci-calc "log(1000)"
+sci-calc "C(10,3)"
+```
+
+### Interactive REPL
+
+```bash
+sci-calc --repl
+sci-calc
+```
+
+```
+sci> 2 + 3
+  = 5
+sci> sin(45)
+  = 0.707106781187
+sci> set x = 10
+sci> x^2
+  = 100
+sci> help
+sci> exit
+```
+
+## Functions
+
+| Category       | Functions                                           |
+| -------------- | --------------------------------------------------- |
+| Basic          | `sqrt`, `cbrt`, `abs`, `pow`, `mod`                |
+| Trigonometric  | `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2` |
+| Hyperbolic     | `sinh`, `cosh`, `tanh`, `asinh`, `acosh`, `atanh`  |
+| Logarithmic    | `log` (base 10), `ln` (natural), `log2`, `exp`, `exp2`, `exp10` |
+| Combinatorics  | `fact`/`factorial`, `perm`/`P`, `comb`/`C`         |
+| Rounding       | `round`, `floor`, `ceil`, `trunc`                   |
+| Aggregation    | `max`, `min`                                        |
+
+## Constants
+
+- `pi` - 3.14159265358979...
+- `e` - 2.71828182845904...
+- `phi` - Golden ratio (1.61803398874989...)
+
+## REPL Commands
+
+| Command           | Description                    |
+| ----------------- | ------------------------------ |
+| `help`            | Show help                      |
+| `list`            | List all functions             |
+| `vars`            | Show stored variables          |
+| `set x = expr`    | Store a variable               |
+| `history`         | Show calculation history       |
+| `unit deg`/`rad`  | Set angle unit                 |
+| `ms expr`         | Store to memory                |
+| `mr`              | Recall memory                  |
+| `mc`              | Clear memory                   |
+| `clear`           | Clear screen                   |
+| `exit`            | Quit                           |
+
+## Flags
+
+```
+sci-calc <expression>        Evaluate expression
+sci-calc --repl              Start interactive mode
+sci-calc --help              Show help
+sci-calc --version           Show version
+sci-calc --list              List functions
+sci-calc --unit <deg|rad>    Set angle unit for evaluation
+```
+
+## Examples
+
+```bash
+# Trig in degrees
+sci-calc "sin(30)"
+sci-calc "atan2(1,1)"
+
+# Factorials and combinations
+sci-calc "fact(20)"
+sci-calc "C(52,5)"          # 5-card poker hands
+
+# Complex expressions
+sci-calc "sqrt(e^2 + pi^2)"
+sci-calc "log(1000) + ln(e^5)"
+
+# Powers and roots
+sci-calc "2^128"
+sci-calc "cbrt(27)"
+
+# With angle unit
+sci-calc --unit rad "sin(1.5708)"
+```
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+'use strict';
+
+const readline = require('readline');
+const Parser = require('../lib/parser');
+const SciCalculator = require('../lib/calculator');
+
+const VERSION = '1.0.0';
+const BANNER = `
+  ╔═══════════════════════════════════════════╗
+  ║        SCI-CALC PRO v${VERSION}               ║
+  ║     Professional Scientific Calculator     ║
+  ╚═══════════════════════════════════════════╝
+`;
+
+const HELP = `
+USAGE:
+  sci-calc <expression>        Evaluate an expression
+  sci-calc --repl              Start interactive mode
+  sci-calc --help              Show this help
+  sci-calc --version           Show version
+  sci-calc --list              List available functions
+  sci-calc --unit <deg|rad>    Set angle unit
+
+FUNCTIONS:
+  Trig:      sin, cos, tan, asin, acos, atan, atan2
+  Hyperbolic: sinh, cosh, tanh, asinh, acosh, atanh
+  Log:       log (base10), ln (natural), log2, exp, exp2, exp10
+  Root:      sqrt, cbrt
+  Combin:    fact (factorial), perm, comb
+  Round:     round, floor, ceil, trunc
+  Other:     abs, pow, mod, max, min
+
+CONSTANTS:
+  pi, e, phi
+
+EXAMPLES:
+  sci-calc "sin(45)"
+  sci-calc "2^10"
+  sci-calc "sqrt(144) + ln(100)"
+  sci-calc "fact(10)"
+  sci-calc "C(10,3)"
+  sci-calc --repl
+`;
+
+function printResult(value, calc) {
+  console.log(`  = ${calc.format(value)}`);
+}
+
+function printError(msg) {
+  console.error(`  \x1b[31mError: ${msg}\x1b[0m`);
+}
+
+// ── Single expression mode ──
+function evaluateExpression(expr, parser) {
+  try {
+    const result = parser.parse(expr);
+    printResult(result, parser.calc);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+}
+
+// ── REPL mode ──
+function startREPL(angleUnit) {
+  console.log(BANNER);
+  console.log('  Type "help" for commands, "exit" to quit.\n');
+
+  const parser = new Parser();
+  parser.setAngleUnit(angleUnit);
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: `\x1b[36msci>\x1b[0m `,
+  });
+
+  rl.prompt();
+
+  rl.on('line', (line) => {
+    const input = line.trim();
+    if (!input) { rl.prompt(); return; }
+
+    const lower = input.toLowerCase();
+
+    if (lower === 'exit' || lower === 'quit' || lower === 'q') {
+      console.log('  Goodbye!');
+      rl.close();
+      return;
+    }
+
+    if (lower === 'help' || lower === 'h' || lower === '?') {
+      console.log(HELP);
+      rl.prompt();
+      return;
+    }
+
+    if (lower === 'list') {
+      console.log(HELP);
+      rl.prompt();
+      return;
+    }
+
+    if (lower === 'clear' || lower === 'cls') {
+      console.clear();
+      rl.prompt();
+      return;
+    }
+
+    if (lower === 'vars') {
+      console.log('  Variables:', JSON.stringify(parser.vars, null, 2));
+      rl.prompt();
+      return;
+    }
+
+    if (lower.startsWith('set ')) {
+      const parts = input.slice(4).split('=');
+      if (parts.length === 2) {
+        const varName = parts[0].trim();
+        const val = parser.parse(parts[1].trim());
+        parser.vars[varName] = val;
+        console.log(`  ${varName} = ${parser.calc.format(val)}`);
+      } else {
+        printError('Usage: set varname = expression');
+      }
+      rl.prompt();
+      return;
+    }
+
+    if (lower.startsWith('unit ')) {
+      const unit = lower.slice(5).trim();
+      try {
+        parser.setAngleUnit(unit);
+        console.log(`  Angle unit set to: ${unit}`);
+      } catch (e) {
+        printError(e.message);
+      }
+      rl.prompt();
+      return;
+    }
+
+    if (lower === 'history') {
+      const hist = parser.calc.history;
+      if (hist.length === 0) {
+        console.log('  No history yet.');
+      } else {
+        hist.slice(-20).forEach((h, i) => {
+          console.log(`  ${String(i + 1).padStart(3)}. ${h.expr} = ${parser.calc.format(h.result)}`);
+        });
+      }
+      rl.prompt();
+      return;
+    }
+
+    if (lower === 'mem' || lower === 'memory') {
+      console.log(`  Memory = ${parser.calc.format(parser.calc.memory)}`);
+      rl.prompt();
+      return;
+    }
+
+    if (lower.startsWith('ms ')) {
+      try {
+        const val = parser.parse(input.slice(3));
+        parser.calc.memStore(val);
+        console.log(`  Memory = ${parser.calc.format(val)}`);
+      } catch (e) { printError(e.message); }
+      rl.prompt();
+      return;
+    }
+
+    if (lower === 'mr') {
+      console.log(`  ${parser.calc.format(parser.calc.memRecall())}`);
+      rl.prompt();
+      return;
+    }
+
+    if (lower === 'mc') {
+      parser.calc.memClear();
+      console.log('  Memory cleared.');
+      rl.prompt();
+      return;
+    }
+
+    evaluateExpression(input, parser);
+    rl.prompt();
+  });
+
+  rl.on('close', () => process.exit(0));
+}
+
+// ── CLI entry ──
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    startREPL('deg');
+    return;
+  }
+
+  const flag = args[0].toLowerCase();
+
+  if (flag === '--help' || flag === '-h') {
+    console.log(HELP);
+    return;
+  }
+
+  if (flag === '--version' || flag === '-v') {
+    console.log(`sci-calc-pro v${VERSION}`);
+    return;
+  }
+
+  if (flag === '--list') {
+    console.log(HELP);
+    return;
+  }
+
+  if (flag === '--repl' || flag === '-r') {
+    const unit = args.includes('--rad') ? 'rad' : 'deg';
+    startREPL(unit);
+    return;
+  }
+
+  if (flag === '--unit') {
+    const unit = (args[1] || 'deg').toLowerCase();
+    const expression = args.slice(2).join(' ');
+    const parser = new Parser();
+    parser.setAngleUnit(unit);
+    if (!expression) { startREPL(unit); return; }
+    evaluateExpression(expression, parser);
+    return;
+  }
+
+  // Direct evaluation
+  const expression = args.join(' ');
+  const parser = new Parser();
+  evaluateExpression(expression, parser);
+}
+
+main();

package/lib/calculator.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+
+class SciCalculator {
+  constructor(angleUnit = 'deg') {
+    this.angleUnit = angleUnit;
+    this.memory = 0;
+    this.history = [];
+  }
+
+  _toRad(angle) {
+    return this.angleUnit === 'deg' ? angle * DEG_TO_RAD : angle;
+  }
+
+  _fromRad(rad) {
+    return this.angleUnit === 'deg' ? rad * RAD_TO_DEG : rad;
+  }
+
+  _record(expr, result) {
+    this.history.push({ expr, result, time: new Date() });
+    if (this.history.length > 100) this.history.shift();
+    return result;
+  }
+
+  // Basic arithmetic
+  add(a, b) { return this._record(`${a} + ${b}`, a + b); }
+  sub(a, b) { return this._record(`${a} - ${b}`, a - b); }
+  mul(a, b) { return this._record(`${a} × ${b}`, a * b); }
+  div(a, b) {
+    if (b === 0) throw new Error('Division by zero');
+    return this._record(`${a} ÷ ${b}`, a / b);
+  }
+  mod(a, b) { return this._record(`${a} mod ${b}`, a % b); }
+  pow(a, b) { return this._record(`${a} ^ ${b}`, Math.pow(a, b)); }
+  sqrt(a) {
+    if (a < 0) throw new Error('Square root of negative number');
+    return this._record(`√(${a})`, Math.sqrt(a));
+  }
+  cbrt(a) { return this._record(`∛(${a})`, Math.cbrt(a)); }
+  abs(a) { return this._record(`|${a}|`, Math.abs(a)); }
+  factorial(a) {
+    if (a < 0 || !Number.isInteger(a)) throw new Error('Factorial requires a non-negative integer');
+    if (a > 170) throw new Error('Factorial overflow (max 170)');
+    let result = 1;
+    for (let i = 2; i <= a; i++) result *= i;
+    return this._record(`${a}!`, result);
+  }
+
+  // Trigonometric functions
+  sin(a) { return this._record(`sin(${a})`, Math.sin(this._toRad(a))); }
+  cos(a) { return this._record(`cos(${a})`, Math.cos(this._toRad(a))); }
+  tan(a) {
+    const rad = this._toRad(a);
+    if (Math.abs(Math.cos(rad)) < 1e-15) throw new Error('tan: undefined (asymptote)');
+    return this._record(`tan(${a})`, Math.tan(rad));
+  }
+  asin(a) {
+    if (a < -1 || a > 1) throw new Error('asin: domain error [-1, 1]');
+    return this._record(`asin(${a})`, this._fromRad(Math.asin(a)));
+  }
+  acos(a) {
+    if (a < -1 || a > 1) throw new Error('acos: domain error [-1, 1]');
+    return this._record(`acos(${a})`, this._fromRad(Math.acos(a)));
+  }
+  atan(a) { return this._record(`atan(${a})`, this._fromRad(Math.atan(a))); }
+  atan2(y, x) { return this._record(`atan2(${y}, ${x})`, this._fromRad(Math.atan2(y, x))); }
+
+  // Hyperbolic functions
+  sinh(a) { return this._record(`sinh(${a})`, Math.sinh(this._toRad(a))); }
+  cosh(a) { return this._record(`cosh(${a})`, Math.cosh(this._toRad(a))); }
+  tanh(a) { return this._record(`tanh(${a})`, Math.tanh(this._toRad(a))); }
+  asinh(a) { return this._record(`asinh(${a})`, this._fromRad(Math.asinh(a))); }
+  acosh(a) {
+    if (a < 1) throw new Error('acosh: domain error [1, ∞)');
+    return this._record(`acosh(${a})`, this._fromRad(Math.acosh(a)));
+  }
+  atanh(a) {
+    if (a <= -1 || a >= 1) throw new Error('atanh: domain error (-1, 1)');
+    return this._record(`atanh(${a})`, this._fromRad(Math.atanh(a)));
+  }
+
+  // Logarithmic & exponential
+  log(a) { return this._record(`log(${a})`, Math.log10(a)); }
+  ln(a) { return this._record(`ln(${a})`, Math.log(a)); }
+  log2(a) { return this._record(`log2(${a})`, Math.log2(a)); }
+  exp(a) { return this._record(`exp(${a})`, Math.exp(a)); }
+  exp2(a) { return this._record(`2^${a}`, Math.pow(2, a)); }
+  exp10(a) { return this._record(`10^${a}`, Math.pow(10, a)); }
+
+  // Combinatorics
+  perm(n, r) {
+    if (n < 0 || r < 0 || r > n) throw new Error('P(n,r): invalid arguments');
+    let result = 1;
+    for (let i = 0; i < r; i++) result *= (n - i);
+    return this._record(`P(${n},${r})`, result);
+  }
+  comb(n, r) {
+    if (n < 0 || r < 0 || r > n) throw new Error('C(n,r): invalid arguments');
+    let result = 1;
+    for (let i = 0; i < r; i++) result = result * (n - i) / (i + 1);
+    return this._record(`C(${n},${r})`, Math.round(result));
+  }
+
+  // Constants
+  pi() { return Math.PI; }
+  e() { return Math.E; }
+  phi() { return (1 + Math.sqrt(5)) / 2; }
+
+  // Memory
+  memStore(v) { this.memory = v; return this.memory; }
+  memRecall() { return this.memory; }
+  memAdd(v) { this.memory += v; return this.memory; }
+  memSub(v) { this.memory -= v; return this.memory; }
+  memClear() { this.memory = 0; return 0; }
+
+  // Rounding
+  round(a, d = 0) { return this._record(`round(${a},${d})`, Number(a.toFixed(d))); }
+  floor(a) { return this._record(`floor(${a})`, Math.floor(a)); }
+  ceil(a) { return this._record(`ceil(${a})`, Math.ceil(a)); }
+  truncate(a) { return this._record(`trunc(${a})`, Math.trunc(a)); }
+
+  // Format result
+  format(value) {
+    if (typeof value !== 'number' || isNaN(value)) return 'NaN';
+    if (!isFinite(value)) return value > 0 ? 'Infinity' : '-Infinity';
+    if (Number.isInteger(value) && Math.abs(value) < 1e15) return value.toString();
+    if (Math.abs(value) < 1e-10 || Math.abs(value) >= 1e15) return value.toExponential(10);
+    const str = value.toPrecision(12);
+    return parseFloat(str).toString();
+  }
+}
+
+module.exports = SciCalculator;

package/lib/parser.js

@@ -0,0 +1,251 @@
+'use strict';
+
+const SciCalculator = require('./calculator');
+
+class Parser {
+  constructor() {
+    this.calc = new SciCalculator();
+    this.vars = { pi: Math.PI, e: Math.E, phi: (1 + Math.sqrt(5)) / 2 };
+  }
+
+  setAngleUnit(unit) {
+    if (unit !== 'deg' && unit !== 'rad') throw new Error('Angle unit must be "deg" or "rad"');
+    this.calc.angleUnit = unit;
+  }
+
+  parse(input) {
+    const cleaned = input
+      .trim()
+      .replace(/×/g, '*')
+      .replace(/÷/g, '/')
+      .replace(/\^/g, '**')
+      .replace(/\s+/g, ' ')
+      .replace(/√\(/g, 'sqrt(')
+      .replace(/∛\(/g, 'cbrt(');
+
+    const result = this._eval(cleaned, { pos: 0 });
+    return result;
+  }
+
+  _eval(input, state) {
+    let result = this._parseAddSub(input, state);
+    return result;
+  }
+
+  _parseAddSub(input, state) {
+    let left = this._parseMulDiv(input, state);
+    while (state.pos < input.length) {
+      this._skipSpaces(input, state);
+      const ch = input[state.pos];
+      if (ch === '+') {
+        state.pos++;
+        const right = this._parseMulDiv(input, state);
+        left = left + right;
+      } else if (ch === '-' && (state.pos === 0 || '+-*/(^,'.includes(input[state.pos - 1]))) {
+        state.pos++;
+        const right = this._parseMulDiv(input, state);
+        left = left - right;
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+
+  _parseMulDiv(input, state) {
+    let left = this._parsePower(input, state);
+    while (state.pos < input.length) {
+      this._skipSpaces(input, state);
+      const ch = input[state.pos];
+      if (ch === '*') {
+        state.pos++;
+        if (input[state.pos] === '*') { state.pos++; }
+        const right = this._parsePower(input, state);
+        left = left * right;
+      } else if (ch === '/') {
+        state.pos++;
+        const right = this._parsePower(input, state);
+        left = left / right;
+      } else if (ch === '%') {
+        state.pos++;
+        const right = this._parsePower(input, state);
+        left = left % right;
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+
+  _parsePower(input, state) {
+    let base = this._parseUnary(input, state);
+    this._skipSpaces(input, state);
+    if (state.pos < input.length && input[state.pos] === '*') {
+      if (input[state.pos + 1] === '*') {
+        state.pos += 2;
+        const exp = this._parseUnary(input, state);
+        return Math.pow(base, exp);
+      }
+    }
+    return base;
+  }
+
+  _parseUnary(input, state) {
+    this._skipSpaces(input, state);
+    if (state.pos < input.length && input[state.pos] === '-') {
+      state.pos++;
+      return -this._parseAtom(input, state);
+    }
+    if (state.pos < input.length && input[state.pos] === '+') {
+      state.pos++;
+    }
+    return this._parseAtom(input, state);
+  }
+
+  _parseAtom(input, state) {
+    this._skipSpaces(input, state);
+
+    if (state.pos >= input.length) throw new Error('Unexpected end of expression');
+
+    // Parentheses
+    if (input[state.pos] === '(') {
+      state.pos++;
+      const result = this._eval(input, state);
+      this._skipSpaces(input, state);
+      if (state.pos < input.length && input[state.pos] === ')') state.pos++;
+      return result;
+    }
+
+    // Number
+    if (this._isDigit(input[state.pos]) || input[state.pos] === '.') {
+      return this._parseNumber(input, state);
+    }
+
+    // Function or variable
+    if (this._isAlpha(input[state.pos])) {
+      return this._parseFunctionOrVar(input, state);
+    }
+
+    throw new Error(`Unexpected character: '${input[state.pos]}' at position ${state.pos}`);
+  }
+
+  _parseNumber(input, state) {
+    const start = state.pos;
+    while (state.pos < input.length && (this._isDigit(input[state.pos]) || input[state.pos] === '.')) {
+      state.pos++;
+    }
+    // Scientific notation: 1e10, 1E-5
+    if (state.pos < input.length && (input[state.pos] === 'e' || input[state.pos] === 'E')) {
+      if (state.pos + 1 < input.length && (input[state.pos + 1] === '-' || input[state.pos + 1] === '+')) {
+        state.pos += 2;
+        while (state.pos < input.length && this._isDigit(input[state.pos])) state.pos++;
+      } else if (state.pos + 1 < input.length && this._isDigit(input[state.pos + 1])) {
+        state.pos += 2;
+        while (state.pos < input.length && this._isDigit(input[state.pos])) state.pos++;
+      }
+    }
+    const numStr = input.slice(start, state.pos);
+    const num = parseFloat(numStr);
+    if (isNaN(num)) throw new Error(`Invalid number: ${numStr}`);
+    return num;
+  }
+
+  _parseFunctionOrVar(input, state) {
+    const start = state.pos;
+    while (state.pos < input.length && this._isAlphaNum(input[state.pos])) state.pos++;
+    const name = input.slice(start, state.pos);
+
+    this._skipSpaces(input, state);
+
+    // Function call
+    if (state.pos < input.length && input[state.pos] === '(') {
+      state.pos++;
+      const args = this._parseArgs(input, state);
+      this._skipSpaces(input, state);
+      if (state.pos < input.length && input[state.pos] === ')') state.pos++;
+      return this._callFunction(name, args);
+    }
+
+    // Variable
+    if (name in this.vars) return this.vars[name];
+    throw new Error(`Unknown variable: ${name}`);
+  }
+
+  _parseArgs(input, state) {
+    const args = [];
+    this._skipSpaces(input, state);
+    if (state.pos < input.length && input[state.pos] === ')') return args;
+
+    args.push(this._eval(input, state));
+    while (state.pos < input.length && input[state.pos] === ',') {
+      state.pos++;
+      args.push(this._eval(input, state));
+    }
+    return args;
+  }
+
+  _callFunction(name, args) {
+    const c = this.calc;
+    switch (name.toLowerCase()) {
+      // Basic
+      case 'sqrt': return c.sqrt(args[0]);
+      case 'cbrt': return c.cbrt(args[0]);
+      case 'abs': return c.abs(args[0]);
+      case 'fact': case 'factorial': return c.factorial(args[0]);
+      case 'mod': return c.mod(args[0], args[1]);
+
+      // Trig
+      case 'sin': return c.sin(args[0]);
+      case 'cos': return c.cos(args[0]);
+      case 'tan': return c.tan(args[0]);
+      case 'asin': return c.asin(args[0]);
+      case 'acos': return c.acos(args[0]);
+      case 'atan': return c.atan(args[0]);
+      case 'atan2': return c.atan2(args[0], args[1]);
+
+      // Hyperbolic
+      case 'sinh': return c.sinh(args[0]);
+      case 'cosh': return c.cosh(args[0]);
+      case 'tanh': return c.tanh(args[0]);
+      case 'asinh': return c.asinh(args[0]);
+      case 'acosh': return c.acosh(args[0]);
+      case 'atanh': return c.atanh(args[0]);
+
+      // Log
+      case 'log': case 'log10': return c.log(args[0]);
+      case 'ln': return c.ln(args[0]);
+      case 'log2': return c.log2(args[0]);
+      case 'exp': return c.exp(args[0]);
+      case 'exp2': return c.exp2(args[0]);
+      case 'exp10': return c.exp10(args[0]);
+
+      // Combinatorics
+      case 'perm': case 'permutation': case 'p': return c.perm(args[0], args[1]);
+      case 'comb': case 'combination': case 'choose': case 'c': return c.comb(args[0], args[1]);
+
+      // Rounding
+      case 'round': return c.round(args[0], args[1] || 0);
+      case 'floor': return c.floor(args[0]);
+      case 'ceil': return c.ceil(args[0]);
+      case 'trunc': return c.truncate(args[0]);
+
+      // Misc
+      case 'pow': return c.pow(args[0], args[1]);
+      case 'max': return Math.max(...args);
+      case 'min': return Math.min(...args);
+
+      default:
+        throw new Error(`Unknown function: ${name}`);
+    }
+  }
+
+  _skipSpaces(input, state) {
+    while (state.pos < input.length && input[state.pos] === ' ') state.pos++;
+  }
+
+  _isDigit(ch) { return ch >= '0' && ch <= '9'; }
+  _isAlpha(ch) { return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch === '_'; }
+  _isAlphaNum(ch) { return this._isAlpha(ch) || this._isDigit(ch); }
+}
+
+module.exports = Parser;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "sci-calc-pro",
+  "version": "1.0.0",
+  "description": "Professional scientific calculator CLI for Node.js",
+  "main": "lib/calculator.js",
+  "bin": {
+    "sci-calc": "bin/cli.js",
+    "sci-calc-pro": "bin/cli.js"
+  },
+  "scripts": {
+    "start": "node bin/cli.js --repl",
+    "calc": "node bin/cli.js"
+  },
+  "keywords": [
+    "calculator",
+    "scientific",
+    "cli",
+    "math",
+    "trigonometry",
+    "logarithm",
+    "algebra"
+  ],
+  "author": "IIEE",
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}