exprify 1.0.0 → 1.0.1

package/src/utils/globalUnits.js

@@ -0,0 +1,217 @@
+export const globalUnits = {
+  // Length
+  length: {
+    m: { value: 1, unit: 'meter', symbol: 'm' },
+    cm: { value: 0.01, unit: 'centimeter', symbol: 'cm' },
+    mm: { value: 0.001, unit: 'millimeter', symbol: 'mm' },
+    km: { value: 1000, unit: 'kilometer', symbol: 'km' },
+    um: { value: 0.000001, unit: 'micrometer', symbol: 'um', note: 'also called micron' },
+    nm: { value: 0.000000001, unit: 'nanometer', symbol: 'nm' },
+    px: { value: 0.000264583, unit: 'pixel', symbol: 'px', note: '96dpi standard' },
+    em: { value: 0.000264583 * 16, unit: 'em', symbol: 'em', note: '1em = 16px by default' },
+    rem: { value: 0.000264583 * 16, unit: 'rem', symbol: 'rem', note: 'root em = 16px by default' },
+    pt: { value: 0.000352778, unit: 'point', symbol: 'pt', note: '1pt = 1/72 inch' },
+    pc: { value: 0.00423333, unit: 'pica', symbol: 'pc', note: '1pc = 12pt' },
+    inch: { value: 0.0254, unit: 'inch', symbol: 'in' },
+    ft: { value: 0.3048, unit: 'foot', symbol: 'ft' },
+    yd: { value: 0.9144, unit: 'yard', symbol: 'yd' },
+    mi: { value: 1609.344, unit: 'mile', symbol: 'mi' },
+    thou: { value: 0.0000254, unit: 'mil', symbol: 'thou', note: 'thousandth of an inch' },
+    furlong: { value: 201.168, unit: 'furlong', symbol: 'fur', note: '220 yards' },
+    nmi: { value: 1852, unit: 'nautical mile', symbol: 'nmi' },
+    fathom: { value: 1.8288, unit: 'fathom', symbol: 'fathom' },
+    au: { value: 1.496e11, unit: 'astronomical unit', symbol: 'AU' },
+    ly: { value: 9.4607e15, unit: 'light year', symbol: 'ly' },
+    pc: { value: 3.0857e16, unit: 'parsec', symbol: 'pc' }
+  },
+
+  // Weight / Mass
+  weight: {
+    mg: { value: 1e-6, unit: 'milligram', symbol: 'mg' },
+    g: { value: 0.001, unit: 'gram', symbol: 'g' },
+    kg: { value: 1, unit: 'kilogram', symbol: 'kg' },
+    t: { value: 1000, unit: 'tonne', symbol: 't', note: 'metric ton' },
+    lb: { value: 0.453592, unit: 'pound', symbol: 'lb' },
+    oz: { value: 0.0283495, unit: 'ounce', symbol: 'oz' },
+    stone: { value: 6.35029, unit: 'stone', symbol: 'st', note: '1 stone = 14 lb' }
+  },
+
+  // Time
+  time: {
+    s: { value: 1, unit: 'second', symbol: 's' },
+    min: { value: 60, unit: 'minute', symbol: 'min' },
+    h: { value: 3600, unit: 'hour', symbol: 'h' },
+    day: { value: 86400, unit: 'day', symbol: 'd' },
+    week: { value: 604800, unit: 'week', symbol: 'wk' },
+    month: { value: 2629800, unit: 'month', symbol: 'mo', note: 'average month = 30.44 days' },
+    year: { value: 31557600, unit: 'year', symbol: 'yr', note: 'average year = 365.25 days' }
+  },
+
+  // Voltage
+  voltage: {
+    V:      { value: 1, unit: 'volt', symbol: 'V' },
+    mV: { value: 0.001, unit: 'millivolt', symbol: 'mV' },
+    kV: { value: 1000, unit: 'kilovolt', symbol: 'kV' },
+    MV: { value: 1e6, unit: 'megavolt', symbol: 'MV' },
+    GV: { value: 1e9, unit: 'gigavolt', symbol: 'GV' },
+    statV: { value: 299.792458, unit: 'statvolt', symbol: 'statV', note: 'CGS unit' },
+    abV: { value: 1e-8, unit: 'abvolt', symbol: 'abV', note: 'CGS electromagnetic unit' }
+  },
+
+  // Frequency
+  frequency: {
+    Hz: { value: 1, unit: 'hertz', symbol: 'Hz', note: '1 cycle per second' },
+    kHz: { value: 1e3, unit: 'kilohertz', symbol: 'kHz' },
+    MHz: { value: 1e6, unit: 'megahertz', symbol: 'MHz' },
+    GHz: { value: 1e9, unit: 'gigahertz', symbol: 'GHz' },
+    THz: { value: 1e12, unit: 'terahertz', symbol: 'THz' }
+  },
+
+  // Power
+  power: {
+    W: { value: 1, unit: 'watt', symbol: 'W', note: '1 joule per second' },
+    mW: { value: 0.001, unit: 'milliwatt', symbol: 'mW' },
+    kW: { value: 1000, unit: 'kilowatt', symbol: 'kW' },
+    MW: { value: 1e6, unit: 'megawatt', symbol: 'MW' },
+    GW: { value: 1e9, unit: 'gigawatt', symbol: 'GW' },
+    HP: { value: 745.7, unit: 'horsepower', symbol: 'HP', note: 'mechanical HP = 745.7 W' },
+    kcal_per_h: { value: 1.163, unit: 'kilocalorie per hour', symbol: 'kcal/h', note: '= 1.163 W' },
+    BTU_per_h: { value: 0.29307107, unit: 'BTU per hour', symbol: 'BTU/h', note: '= 0.293 W' }
+  },
+
+  // Sound
+  sound: {
+    dB: { value: 1, unit: 'decibel', symbol: 'dB', note: 'logarithmic unit of sound intensity' },
+    dBA: { value: 1, unit: 'A-weighted decibel', symbol: 'dBA', note: 'Adjusted for human hearing' },
+    dBC: { value: 1, unit: 'C-weighted decibel', symbol: 'dBC', note: 'Flat weighting for high-level sounds' }
+  },
+
+  // Temperature
+  temperature: {
+    K: { value: 1, unit: 'kelvin', symbol: 'K' },
+    C: { value: 1, unit: 'Celsius', symbol: '°C', note: '°C → K: add 273.15' },
+    F: { value: 1, unit: 'Fahrenheit', symbol: '°F', note: '°F → K: (°F - 32) * 5/9 + 273.15' }
+  },
+
+  // Pressure
+  pressure: {
+    Pa: { value: 1, unit: 'pascal', symbol: 'Pa' },
+    kPa: { value: 1000, unit: 'kilopascal', symbol: 'kPa' },
+    MPa: { value: 1e6, unit: 'megapascal', symbol: 'MPa' },
+    bar: { value: 1e5, unit: 'bar', symbol: 'bar' },
+    atm: { value: 101325, unit: 'atmosphere', symbol: 'atm' },
+    psi: { value: 6894.757, unit: 'pound per square inch', symbol: 'psi' },
+    mmHg:{ value: 133.322, unit: 'millimeter of mercury', symbol: 'mmHg' }
+  },
+
+  // Energy
+  energy: {
+    J: { value: 1, unit: 'joule', symbol: 'J' },
+    kJ: { value: 1000, unit: 'kilojoule', symbol: 'kJ' },
+    cal: { value: 4.184, unit: 'calorie', symbol: 'cal' },
+    kcal:{ value: 4184, unit: 'kilocalorie', symbol: 'kcal' },
+    eV: { value: 1.60218e-19, unit: 'electronvolt', symbol: 'eV' },
+    BTU: { value: 1055.06, unit: 'BTU', symbol: 'BTU' }
+  },
+
+  // Force
+  force: {
+    N: { value: 1, unit: 'newton', symbol: 'N' },
+    kN: { value: 1000, unit: 'kilonewton', symbol: 'kN' },
+    lbf: { value: 4.44822, unit: 'pound-force', symbol: 'lbf' },
+    kgf: { value: 9.80665, unit: 'kilogram-force', symbol: 'kgf' },
+    dyne:{ value: 1e-5, unit: 'dyne', symbol: 'dyn' }
+  },
+
+  // Area
+  area: {
+    m2: { value: 1, unit: 'square meter', symbol: 'm²' },
+    cm2: { value: 0.0001, unit: 'square centimeter', symbol: 'cm²' },
+    km2: { value: 1e6, unit: 'square kilometer', symbol: 'km²' },
+    acre: { value: 4046.856, unit: 'acre', symbol: 'acre' },
+    hectare:{ value: 10000, unit: 'hectare', symbol: 'ha' },
+    ft2: { value: 0.092903, unit: 'square foot', symbol: 'ft²' },
+    yd2: { value: 0.836127, unit: 'square yard', symbol: 'yd²' }
+  },
+
+  // Volume
+  volume: {
+    m3: { value: 1, unit: 'cubic meter', symbol: 'm³' },
+    L: { value: 0.001, unit: 'liter', symbol: 'L' },
+    mL: { value: 1e-6, unit: 'milliliter', symbol: 'mL' },
+    gallon:{ value: 0.00378541, unit: 'US gallon', symbol: 'gal' },
+    pint: { value: 0.000473176, unit: 'US pint', symbol: 'pt' },
+    floz: { value: 2.9574e-5, unit: 'US fluid ounce', symbol: 'fl oz' }
+  },
+
+  // Electrical Current
+  current: {
+    A: { value: 1, unit: 'ampere', symbol: 'A' },
+    mA: { value: 0.001, unit: 'milliampere', symbol: 'mA' },
+    uA: { value: 0.000001, unit: 'microampere', symbol: 'uA' },
+    kA: { value: 1000, unit: 'kiloampere', symbol: 'kA' }
+  },
+
+  // Resistance / Conductance
+  resistance: {
+    ohm: { value: 1, unit: 'ohm' },
+    kohm: { value: 1000, unit: 'kiloohm'},
+    megaohm: { value: 1e6, unit: 'megaohm'},
+    S: { value: 1, unit: 'siemens', symbol: 'S', note: 'conductance' }
+  },
+
+  // Capacitance / Inductance
+  capacitance: {
+    F: { value: 1, unit: 'farad', symbol: 'F' },
+    mF: { value: 0.001, unit: 'millifarad'},
+    uF: { value: 0.000001, unit: 'microfarad' }
+  },
+  inductance: {
+    H: { value: 1, unit: 'henry', symbol: 'H' },
+    mH: { value: 0.001, unit: 'millihenry', symbol: 'mH' },
+    uH: { value: 0.000001, unit: 'microhenry', symbol: 'uH' }
+  },
+
+  // Luminous Intensity / Illuminance
+  light: {
+    cd: { value: 1, unit: 'candela', symbol: 'cd' },
+    lm: { value: 1, unit: 'lumen', symbol: 'lm' },
+    lx: { value: 1, unit: 'lux', symbol: 'lx' }
+  },
+
+  // Data / Digital Storage
+  data: {
+    bit: { value: 1, unit: 'bit', symbol: 'bit' },
+    B: { value: 8, unit: 'byte', symbol: 'B' },
+    KB: { value: 8e3, unit: 'kilobyte', symbol: 'KB' },
+    MB: { value: 8e6, unit: 'megabyte', symbol: 'MB' },
+    GB: { value: 8e9, unit: 'gigabyte', symbol: 'GB' },
+    TB: { value: 8e12, unit: 'terabyte', symbol: 'TB' }
+  },
+
+  // Angle
+  angle: {
+    deg: { value: 1, unit: 'degree', symbol: '°' },
+    rad: { value: 57.2958, unit: 'radian', symbol: 'rad', note: '1 rad = 57.2958°' },
+    grad:{ value: 0.9, unit: 'grad', symbol: 'grad', note: '1 grad = 0.9°' }
+  },
+  radiation: {
+    // Absorbed Dose
+    Gy: { value: 1, unit: 'gray', symbol: 'Gy', note: 'Absorbed dose: 1 Gy = 1 J/kg' },
+    mGy: { value: 0.001, unit: 'milligray', symbol: 'mGy' },
+    rad: { value: 0.01, unit: 'rad', symbol: 'rad', note: '1 rad = 0.01 Gy' },
+
+    // Dose Equivalent
+    Sv: { value: 1, unit: 'sievert', symbol: 'Sv', note: 'Biological effect dose equivalent' },
+    mSv: { value: 0.001, unit: 'millisievert', symbol: 'mSv' },
+    rem: { value: 0.01, unit: 'rem', symbol: 'rem', note: '1 rem = 0.01 Sv' },
+
+    // Radioactivity
+    Bq: { value: 1, unit: 'becquerel', symbol: 'Bq', note: '1 decay per second' },
+    kBq: { value: 1e3, unit: 'kilobecquerel', symbol: 'kBq' },
+    MBq: { value: 1e6, unit: 'megabecquerel', symbol: 'MBq' },
+    GBq: { value: 1e9, unit: 'gigabecquerel', symbol: 'GBq' },
+    Ci: { value: 3.7e10, unit: 'curie', symbol: 'Ci', note: '1 Ci = 3.7 x 10¹⁰ decays per second' },
+    mCi: { value: 3.7e7, unit: 'millicurie', symbol: 'mCi' }
+  }
+};

package/src/utils/store.js

@@ -0,0 +1,178 @@
+export function createUnitsStore(initial = {}) {
+  let units = { ...initial};
+
+  // ---------- Helpers ----------
+
+  function getAllUnitsFlat() {
+    const result = new Set();
+
+    for (const type in units) {
+      for (const key in units[type]) {
+        const u = units[type][key];
+
+        const keyLower = key.toLowerCase();
+        result.add(keyLower);
+
+        // Unit name
+        if (u.unit) {
+          const unitLower = u.unit.toLowerCase();
+
+          // Avoid duplicate like "m" vs "meter"
+          if (unitLower !== keyLower) {
+            // Optional: only single-word units
+            if (unitLower.split(/\s+/).length === 1) {
+              result.add(unitLower);
+            }
+          }
+        }
+
+        // Symbol
+        if (u.symbol) {
+          const symbolLower = u.symbol.toLowerCase();
+
+          // Avoid duplicate with unit name
+          if (!u.unit || symbolLower !== u.unit.toLowerCase()) {
+            result.add(symbolLower);
+          }
+        }
+      }
+    }
+
+    return Array.from(result);
+  }
+
+  function findUnit(input) {
+    input = input.toLowerCase();
+
+    for (const type in units) {
+      for (const key in units[type]) {
+        const u = units[type][key];
+
+        if (
+          key.toLowerCase() === input ||
+          u.unit?.toLowerCase() === input ||
+          u.symbol?.toLowerCase() === input
+        ) {
+          return { type, key , data: u};
+        }
+      }
+    }
+
+    return null;
+  }
+
+  // ---------- Core Convert ----------
+
+  function convert(value, fromUnit, toUnit) {
+      const from = findUnit(fromUnit);
+      const to = findUnit(toUnit);
+
+      if (!from) throw new Error(`Unknown unit: ${fromUnit}`);
+      if (!to) throw new Error(`Unknown unit: ${toUnit}`);
+
+      if (from.type !== to.type) {
+        throw new Error(`Cannot convert ${fromUnit} to ${toUnit} (${to.data.unit || to.key}). ${from.data.unit || from.key} conversion units like ${Object.keys(units[from.type]).join(", ")}`);
+      }
+
+      const result = value * (from.data.value / to.data.value);
+
+      return { value: result, unit: to.key };
+    }
+
+  // ---------- Public API ----------
+
+  return {
+    // Get all units
+    getUnits: () => units,
+
+    // Replace all units
+    setUnits: (newUnits) => {
+      units = { ...newUnits };
+    },
+
+    // Update single type
+    updateType: (type, data) => {
+      units[type] = { ...units[type], ...data };
+    },
+
+    // Add new unit
+    addUnit: (type, key, unitObj) => {
+      if (!units[type]) units[type] = {};
+      units[type][key] = unitObj;
+    },
+    compute(op, left, right) {
+
+      const isUnit = (v) =>
+        v && typeof v === "object" && "value" in v && "unit" in v;
+
+      const apply = (a, b) => {
+        switch (op) {
+          case "+": return a + b;
+          case "-": return a - b;
+          case "*": return a * b;
+          case "/": return a / b;
+          case "%": return a % b;
+          case "^": return Math.pow(a, b);
+        }
+      };
+
+      // BOTH UNIT
+      if (isUnit(left) && isUnit(right)) {
+
+        const from = this.findUnit(right.unit);
+        const to = this.findUnit(left.unit);
+
+        if (from.type !== to.type) {
+          throw new Error(`Cannot operate on different unit types`);
+        }
+
+        // convert right → left unit
+        const r = right.value * (from.data.value / to.data.value);
+
+        const result = apply(left.value, r);
+
+        // multiplication/division produce compound units
+        if (op === "*") {
+          return { value: result, unit: left.unit };
+        }
+
+        if (op === "/") {
+          return { value: result, unit: left.unit };
+        }
+
+        if (op === "^") {
+          return { value: result, unit: left.unit };
+        }
+
+        return { value: result, unit: left.unit };
+      }
+
+      // ================= LEFT UNIT =================
+      if (isUnit(left) && !isUnit(right)) {
+        const result = apply(left.value, right);
+
+        return { value: result, unit: left.unit };
+      }
+
+      // ================= RIGHT UNIT =================
+      if (!isUnit(left) && isUnit(right)) {
+        const result = apply(left, right.value);
+
+        if (op === "/") {
+          return { value: result, unit: right.unit };
+        }
+
+        return { value: result, unit: right.unit };
+      }
+
+      // ================= NORMAL =================
+      return apply(left, right);
+    },
+    // Convert
+    convert,
+
+    // Search helpers
+    getAllUnitsFlat,
+    findUnit
+  };
+}

package/src/variables/store.js

@@ -0,0 +1,75 @@
+const validVarName = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
+export function createVarStore(initial = {}) {
+  let store = Object.create(null);
+  
+
+  for (const key in initial) {
+    store[key] = initial[key];
+  }
+
+  return {
+    set(name, value, { override = true } = {}) {
+
+      // Name validation
+      if (typeof name !== "string" || !name) {
+        throw new Error("Variable name must be a non-empty string");
+      }
+
+      if (!validVarName.test(name)) {
+        throw new Error(`Variable Name Error: '${name}' is not a valid variable name`);
+      }
+
+      // Value validation
+      if (value === undefined) {
+        throw new Error(`Variable Value Error: '${name}' cannot be undefined`);
+      }
+
+      // Prevent overwrite (optional)
+      if (!override && name in variablesDB) {
+        throw new Error(`Variable '${name}' already exists`);
+      }
+
+      store[name] = value;
+    },
+
+    //get variable
+    get(name) {
+      return store[name];
+    },
+
+    // check existence
+    has(name) {
+      return Object.prototype.hasOwnProperty.call(store, name);
+    },
+
+    // remove variable
+    remove(name) {
+      delete store[name];
+    },
+
+    // get all variables (snapshot)
+    all() {
+      return { ...store };
+    },
+
+    // clear all
+    clear() {
+      store = Object.create(null);
+    },
+
+    // merge multiple variables
+    merge(obj = {}) {
+      for (const key in obj) {
+        store[key] = obj[key];
+      }
+    },
+
+    // clone store (for scoped instances) 
+    clone() {
+      return createVarStore(store);
+    }
+  };
+}
+
+export default { createVarStore };

package/test/browser.html

@@ -0,0 +1,23 @@
+<script src="../dist/exprify.js"></script>
+<script>
+  const expr = new Exprify();   // ✅ no namespace needed (usually)
+  // console.log(expr.parse("5 + 7 * 2")); // 19
+  // console.log(expr.evaluate("5 + 7 * 2")); // 19
+  console.log(expr.parse("max(5, 2)")); // 19
+  // console.log(expr.evaluate("max('5' + 7 * 2)")); // 19
+
+
+// const exprify = new Exprify();
+// const exprFn = exprify.compile("or(a, b)");
+// console.log(exprFn({ a: true, b: false })); // 22
+// console.log(exprFn({ a: 7, b: 3 }));  // 17
+
+console.log(expr.parse("5 px to em")); // 19
+console.log(expr.evaluate("5 px to em")); // 19
+
+// console.log(expr.parse("value |> double |> sqrt")); // 19
+// console.log(expr.evaluate("value |> double |> sqrt")); // 19
+
+
+  
+</script>

package/test/exprify.test.js

@@ -0,0 +1,140 @@
+import Exprify from "../src/core/Exprify.js";
+
+describe("Exprify Engine - Extended Tests", () => {
+  let expr;
+
+  beforeEach(() => {
+    expr = new Exprify();
+  });
+
+  /* ================= BASIC ================= */
+  test("addition", () => {
+    expect(expr.evaluate("2 + 3 + 5")).toBe(10);
+  });
+
+  test("operator precedence", () => {
+    expect(expr.evaluate("2 + 3 * 4")).toBe(14);
+  });
+
+  test("parentheses override precedence", () => {
+    expect(expr.evaluate("(2 + 3) * 4")).toBe(20);
+  });
+
+  test("mixed parentheses", () => {
+    expect(expr.evaluate("(1 + 2) * (3 + 4)")).toBe(21);
+  });
+
+  /* ================= NESTED ================= */
+  test("nested parentheses", () => {
+    expect(expr.evaluate("((2 + 3) * (4 + 1))")).toBe(25);
+  });
+
+  test("deep nesting", () => {
+    expect(expr.evaluate("(((1 + 1) + 1) + 1)")).toBe(4);
+  });
+
+  /* ================= UNARY ================= */
+  test("unary minus", () => {
+    expect(expr.evaluate("-5 + 10")).toBe(5);
+  });
+
+  test("double unary", () => {
+    expect(expr.evaluate("--5")).toBe(5);
+  });
+
+  /* ================= POWER ================= */
+  test("power operator", () => {
+    expect(expr.evaluate("2 ^ 3")).toBe(8);
+  });
+
+  test("power precedence", () => {
+    expect(expr.evaluate("2 + 2 ^ 3")).toBe(10);
+  });
+
+  /* ================= LOGICAL ================= */
+  test("logical AND", () => {
+    expect(expr.evaluate("true && false")).toBe(false);
+  });
+
+  test("logical OR", () => {
+    expect(expr.evaluate("true || false")).toBe(true);
+  });
+
+  /* ================= FUNCTION ================= */
+  test("function call", () => {
+    expect(expr.evaluate("max(2, 5, 3)")).toBe(5);
+  });
+
+  test("nested function", () => {
+    expect(expr.evaluate("max(2, min(5, 3))")).toBe(3);
+  });
+
+  test("matrix determinant with semicolon rows", () => {
+    expect(expr.evaluate("det([-1, 2; 3, 1])")).toBe(-7);
+  });
+
+  /* ================= STRING ================= */
+  test("string concat", () => {
+    expect(expr.evaluate('"Hello " + "World"')).toBe("Hello World");
+  });
+
+  /* ================= BIGINT ================= */
+  test("bigint power", () => {
+    expect(expr.evaluate("11n ^ 2n")).toBe(121n);
+  });
+
+  /* ================= UNIT ================= */
+  test("unit conversion", () => {
+    expect(expr.evaluate("2 inch to cm")).toBe("5.08 cm");
+  });
+
+  test("unit addition", () => {
+    expect(expr.evaluate("5 cm + 2 inch")).toBe("10.08 cm");
+  });
+
+  /* ================= EDGE CASE ================= */
+  test("division", () => {
+    expect(expr.evaluate("10 / 2")).toBe(5);
+  });
+
+  test("modulus", () => {
+    expect(expr.evaluate("10 % 3")).toBe(1);
+  });
+
+  test("invalid expression", () => {
+    expect(() => expr.evaluate("(2 + 3")).toThrow();
+  });
+
+  
+  test("set and use variable", () => {
+    expr.setVariable("x", 5);
+    expr.setVariable("y", 3);
+    expect(expr.evaluate("x + y")).toBe(8);
+    expect(expr.evaluate("x * y + 2")).toBe(17); // 5*3=15 +2=17
+  });
+
+    test("variable in parentheses", () => {
+    expr.setVariable("a", 2);
+    expr.setVariable("b", 4);
+    expect(expr.evaluate("(a + b) * 3")).toBe(18); // (2+4)*3=18
+  });
+
+  test("add and use external function", () => {
+    // Example: double(n) returns n*2
+    expr.addFunction("double", (n) => n * 2);
+    expect(expr.evaluate("double(4)")).toBe(8);
+    expect(expr.evaluate("2 + double(5)")).toBe(12); // 2+10=12
+  });
+
+  test("external function with multiple arguments", () => {
+    expr.addFunction("sumThree", (a, b, c) => a + b + c);
+    expect(expr.evaluate("sumThree(2, 3, 5)")).toBe(10);
+  });
+
+  test("nested function calls", () => {
+    expr.addFunction("double", (n) => n * 2);
+    expr.addFunction("addTen", (n) => n + 10);
+    expect(expr.evaluate("addTen(double(5))")).toBe(20); // double(5)=10 → addTen(10)=20
+  });
+  
+});

package/src/functions/externalFunctions.js

@@ -1,19 +0,0 @@
-export const externalFunctions = {};
-
-// Add user-defined function
-export function addFunction(name, fn) {
-
-  if (typeof name !== "string" || name.trim() === "") {
-    throw new Error("Function name must be a non-empty string");
-  }
-
-  if (typeof fn !== "function") {
-    throw new Error("Function must be a valid function");
-  }
-
-  if (name in externalFunctions) {
-    throw new Error(`Function '${name}' already exists`);
-  }
-
-  externalFunctions[name] = fn;
-}