@ricsam/formula-engine 0.0.1

package/dist/mjs/evaluator/arithmetic/divide/divide.mjs

@@ -0,0 +1,77 @@
+// src/evaluator/arithmetic/divide/divide.ts
+import { FormulaError } from "src/core/types";
+var divide = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot divide ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "infinity") {
+      return {
+        type: "error",
+        err: FormulaError.NUM,
+        message: "Cannot divide infinity by infinity",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      if (right.value === 0) {
+        return {
+          type: "error",
+          err: FormulaError.NUM,
+          message: "Cannot divide infinity by zero",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (right.value > 0) {
+        return { type: "infinity", sign: left.sign };
+      } else {
+        const resultSign = left.sign === "positive" ? "negative" : "positive";
+        return { type: "infinity", sign: resultSign };
+      }
+    }
+    if (left.type === "number" && right.type === "infinity") {
+      return { type: "number", value: 0 };
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    if (right.value === 0) {
+      if (left.value === 0) {
+        return {
+          type: "error",
+          err: FormulaError.NUM,
+          message: "0 / 0 is undefined",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (left.value > 0) {
+        return { type: "infinity", sign: "positive" };
+      } else {
+        return { type: "infinity", sign: "negative" };
+      }
+    }
+    const result = left.value / right.value;
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: `Cannot divide ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  divide
+};
+
+//# debugId=3147263C3E0C663F64756E2164756E21

package/dist/mjs/evaluator/arithmetic/divide/divide.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/evaluator/arithmetic/divide/divide.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\nexport const divide: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if (\n    (left.type !== \"number\" && left.type !== \"infinity\") ||\n    (right.type !== \"number\" && right.type !== \"infinity\")\n  ) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot divide ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Handle infinity cases\n  if (left.type === \"infinity\" || right.type === \"infinity\") {\n    // Both infinity: ∞ / ∞ = indeterminate\n    if (left.type === \"infinity\" && right.type === \"infinity\") {\n      return {\n        type: \"error\",\n        err: FormulaError.NUM,\n        message: \"Cannot divide infinity by infinity\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Infinity divided by number: sign rules apply\n    if (left.type === \"infinity\" && right.type === \"number\") {\n      if (right.value === 0) {\n        return {\n          type: \"error\",\n          err: FormulaError.NUM,\n          message: \"Cannot divide infinity by zero\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (right.value > 0) {\n        return { type: \"infinity\", sign: left.sign };\n      } else {\n        const resultSign = left.sign === \"positive\" ? \"negative\" : \"positive\";\n        return { type: \"infinity\", sign: resultSign };\n      }\n    }\n\n    // Number divided by infinity: approaches zero\n    if (left.type === \"number\" && right.type === \"infinity\") {\n      return { type: \"number\", value: 0 };\n    }\n  }\n\n  // Both numbers\n  if (left.type === \"number\" && right.type === \"number\") {\n    // Division by zero\n    if (right.value === 0) {\n      if (left.value === 0) {\n        // 0 / 0 = indeterminate\n        return {\n          type: \"error\",\n          err: FormulaError.NUM,\n          message: \"0 / 0 is undefined\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      // n / 0 = ±∞ depending on sign of n\n      if (left.value > 0) {\n        return { type: \"infinity\", sign: \"positive\" };\n      } else {\n        return { type: \"infinity\", sign: \"negative\" };\n      }\n    }\n\n    const result = left.value / right.value;\n\n    // Check for overflow to infinity\n    if (result === Infinity) {\n      return { type: \"infinity\", sign: \"positive\" };\n    }\n    if (result === -Infinity) {\n      return { type: \"infinity\", sign: \"negative\" };\n    }\n\n    return { type: \"number\", value: result };\n  }\n\n  // This should never be reached due to the type check at the beginning\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: `Cannot divide ${left.type} and ${right.type}`,\n    errAddress: context.dependencyNode,\n  };\n};\n"
+  ],
+  "mappings": ";AACA;AAEO,IAAM,SAA8B,CAAC,MAAM,OAAO,YAAY;AAAA,EAEnE,IACG,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAC3C;AAAA,IACA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,iBAAiB,KAAK,YAAY,MAAM;AAAA,MACjD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAEzD,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MACzD,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,UAAU;AAAA,MACvD,IAAI,MAAM,UAAU,GAAG;AAAA,QACrB,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,aAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA,MACF;AAAA,MAEA,IAAI,MAAM,QAAQ,GAAG;AAAA,QACnB,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA,MAC7C,EAAO;AAAA,QACL,MAAM,aAAa,KAAK,SAAS,aAAa,aAAa;AAAA,QAC3D,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA;AAAA,IAEhD;AAAA,IAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,YAAY;AAAA,MACvD,OAAO,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,IACpC;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IAErD,IAAI,MAAM,UAAU,GAAG;AAAA,MACrB,IAAI,KAAK,UAAU,GAAG;AAAA,QAEpB,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,aAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA,MACF;AAAA,MAGA,IAAI,KAAK,QAAQ,GAAG;AAAA,QAClB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,MAC9C,EAAO;AAAA,QACL,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA;AAAA,IAEhD;AAAA,IAEA,MAAM,SAAS,KAAK,QAAQ,MAAM;AAAA,IAGlC,IAAI,WAAW,UAAU;AAAA,MACvB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IACA,IAAI,WAAW,WAAW;AAAA,MACxB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAEA,OAAO,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,EACzC;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS,iBAAiB,KAAK,YAAY,MAAM;AAAA,IACjD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "3147263C3E0C663F64756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/arithmetic/multiply/multiply.mjs

@@ -0,0 +1,63 @@
+// src/evaluator/arithmetic/multiply/multiply.ts
+import { FormulaError } from "src/core/types";
+var multiply = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot multiply ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "number" && right.value === 0 || left.type === "number" && left.value === 0 && right.type === "infinity") {
+      return {
+        type: "error",
+        err: FormulaError.NUM,
+        message: "Cannot multiply infinity by zero",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (left.type === "infinity" && right.type === "infinity") {
+      const resultSign = left.sign === right.sign ? "positive" : "negative";
+      return { type: "infinity", sign: resultSign };
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      if (right.value > 0) {
+        return { type: "infinity", sign: left.sign };
+      } else if (right.value < 0) {
+        const resultSign = left.sign === "positive" ? "negative" : "positive";
+        return { type: "infinity", sign: resultSign };
+      }
+    }
+    if (left.type === "number" && right.type === "infinity") {
+      if (left.value > 0) {
+        return { type: "infinity", sign: right.sign };
+      } else if (left.value < 0) {
+        const resultSign = right.sign === "positive" ? "negative" : "positive";
+        return { type: "infinity", sign: resultSign };
+      }
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    const result = left.value * right.value;
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: `Cannot multiply ${left.type} and ${right.type} /2`,
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  multiply
+};
+
+//# debugId=E7E0C3547556EECC64756E2164756E21

package/dist/mjs/evaluator/arithmetic/multiply/multiply.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/evaluator/arithmetic/multiply/multiply.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\nexport const multiply: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot multiply ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Handle infinity cases\n  if (left.type === \"infinity\" || right.type === \"infinity\") {\n    \n    // Handle infinity * 0 = NaN (indeterminate)\n    if ((left.type === \"infinity\" && right.type === \"number\" && right.value === 0) ||\n        (left.type === \"number\" && left.value === 0 && right.type === \"infinity\")) {\n      return {\n        type: \"error\",\n        err: FormulaError.NUM,\n        message: \"Cannot multiply infinity by zero\",\n        errAddress: context.dependencyNode,\n      };\n    }\n    \n    // Both infinity: sign rules apply\n    if (left.type === \"infinity\" && right.type === \"infinity\") {\n      const resultSign = left.sign === right.sign ? \"positive\" : \"negative\";\n      return { type: \"infinity\", sign: resultSign };\n    }\n    \n    // Infinity * number: determine sign based on number's sign\n    if (left.type === \"infinity\" && right.type === \"number\") {\n      if (right.value > 0) {\n        return { type: \"infinity\", sign: left.sign };\n      } else if (right.value < 0) {\n        const resultSign = left.sign === \"positive\" ? \"negative\" : \"positive\";\n        return { type: \"infinity\", sign: resultSign };\n      }\n      // right.value === 0 is handled above\n    }\n    \n    // Number * infinity: determine sign based on number's sign\n    if (left.type === \"number\" && right.type === \"infinity\") {\n      if (left.value > 0) {\n        return { type: \"infinity\", sign: right.sign };\n      } else if (left.value < 0) {\n        const resultSign = right.sign === \"positive\" ? \"negative\" : \"positive\";\n        return { type: \"infinity\", sign: resultSign };\n      }\n      // left.value === 0 is handled above\n    }\n  }\n  \n  // Both numbers\n  if (left.type === \"number\" && right.type === \"number\") {\n    const result = left.value * right.value;\n    \n    // Check for overflow to infinity\n    if (result === Infinity) {\n      return { type: \"infinity\", sign: \"positive\" };\n    }\n    if (result === -Infinity) {\n      return { type: \"infinity\", sign: \"negative\" };\n    }\n    \n    return { type: \"number\", value: result };\n  }\n  \n  // This should never be reached due to the type check at the beginning\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: `Cannot multiply ${left.type} and ${right.type} /2`,\n    errAddress: context.dependencyNode,\n  };\n};"
+  ],
+  "mappings": ";AACA;AAEO,IAAM,WAAgC,CAAC,MAAM,OAAO,YAAY;AAAA,EAErE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,mBAAmB,KAAK,YAAY,MAAM;AAAA,MACnD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAGzD,IAAK,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY,MAAM,UAAU,KACvE,KAAK,SAAS,YAAY,KAAK,UAAU,KAAK,MAAM,SAAS,YAAa;AAAA,MAC7E,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MACzD,MAAM,aAAa,KAAK,SAAS,MAAM,OAAO,aAAa;AAAA,MAC3D,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,UAAU;AAAA,MACvD,IAAI,MAAM,QAAQ,GAAG;AAAA,QACnB,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA,MAC7C,EAAO,SAAI,MAAM,QAAQ,GAAG;AAAA,QAC1B,MAAM,aAAa,KAAK,SAAS,aAAa,aAAa;AAAA,QAC3D,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,MAC9C;AAAA,IAEF;AAAA,IAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,YAAY;AAAA,MACvD,IAAI,KAAK,QAAQ,GAAG;AAAA,QAClB,OAAO,EAAE,MAAM,YAAY,MAAM,MAAM,KAAK;AAAA,MAC9C,EAAO,SAAI,KAAK,QAAQ,GAAG;AAAA,QACzB,MAAM,aAAa,MAAM,SAAS,aAAa,aAAa;AAAA,QAC5D,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,MAC9C;AAAA,IAEF;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IACrD,MAAM,SAAS,KAAK,QAAQ,MAAM;AAAA,IAGlC,IAAI,WAAW,UAAU;AAAA,MACvB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IACA,IAAI,WAAW,WAAW;AAAA,MACxB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAEA,OAAO,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,EACzC;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS,mBAAmB,KAAK,YAAY,MAAM;AAAA,IACnD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "E7E0C3547556EECC64756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/arithmetic/power/power.mjs

@@ -0,0 +1,95 @@
+// src/evaluator/arithmetic/power/power.ts
+import { FormulaError } from "src/core/types";
+var power = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot exponentiate ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "infinity") {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      if (right.value === 0) {
+        return { type: "number", value: 1 };
+      }
+      if (right.value > 0) {
+        if (left.sign === "positive") {
+          return { type: "infinity", sign: "positive" };
+        } else {
+          if (Number.isInteger(right.value)) {
+            const isEven = right.value % 2 === 0;
+            return { type: "infinity", sign: isEven ? "positive" : "negative" };
+          } else {
+            return {
+              type: "error",
+              err: FormulaError.NUM,
+              message: "Cannot raise negative infinity to non-integer power",
+              errAddress: context.dependencyNode
+            };
+          }
+        }
+      } else {
+        return { type: "number", value: 0 };
+      }
+    }
+    if (left.type === "number" && right.type === "infinity") {
+      const absBase = Math.abs(left.value);
+      if (absBase === 1) {
+        return { type: "number", value: 1 };
+      }
+      if (absBase > 1) {
+        if (right.sign === "positive") {
+          return { type: "infinity", sign: "positive" };
+        } else {
+          return { type: "number", value: 0 };
+        }
+      } else {
+        if (right.sign === "positive") {
+          return { type: "number", value: 0 };
+        } else {
+          return { type: "infinity", sign: "positive" };
+        }
+      }
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    if (left.value === 0 && right.value === 0) {
+      return { type: "number", value: 1 };
+    }
+    if (left.value === 0 && right.value < 0) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (left.value < 0 && !Number.isInteger(right.value)) {
+      return {
+        type: "error",
+        err: FormulaError.NUM,
+        message: "Cannot raise negative number to non-integer power",
+        errAddress: context.dependencyNode
+      };
+    }
+    const result = Math.pow(left.value, right.value);
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: `Cannot exponentiate ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  power
+};
+
+//# debugId=73EB7E98B39E641064756E2164756E21

package/dist/mjs/evaluator/arithmetic/power/power.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/evaluator/arithmetic/power/power.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\nexport const power: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot exponentiate ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Handle infinity cases\n  if (left.type === \"infinity\" || right.type === \"infinity\") {\n    \n    // Special cases for infinity exponentiation\n    if (left.type === \"infinity\" && right.type === \"infinity\") {\n      // ∞^∞ = +∞ (mathematical convention)\n      return { type: \"infinity\", sign: \"positive\" };\n    }\n    \n    // Infinity raised to a power\n    if (left.type === \"infinity\" && right.type === \"number\") {\n      if (right.value === 0) {\n        // ∞^0 = 1 (mathematical convention)\n        return { type: \"number\", value: 1 };\n      }\n      \n      if (right.value > 0) {\n        // ∞^(positive) = ∞, (-∞)^(positive) depends on whether exponent is even/odd\n        if (left.sign === \"positive\") {\n          return { type: \"infinity\", sign: \"positive\" };\n        } else {\n          // For negative infinity, we need to check if exponent is integer and even/odd\n          if (Number.isInteger(right.value)) {\n            const isEven = right.value % 2 === 0;\n            return { type: \"infinity\", sign: isEven ? \"positive\" : \"negative\" };\n          } else {\n            // Non-integer exponent with negative base is complex\n            return {\n              type: \"error\",\n              err: FormulaError.NUM,\n              message: \"Cannot raise negative infinity to non-integer power\",\n              errAddress: context.dependencyNode,\n            };\n          }\n        }\n      } else {\n        // ∞^(negative) = 0\n        return { type: \"number\", value: 0 };\n      }\n    }\n    \n    // Number raised to infinity\n    if (left.type === \"number\" && right.type === \"infinity\") {\n      const absBase = Math.abs(left.value);\n      \n      if (absBase === 1) {\n        // 1^∞ = 1, (-1)^∞ is indeterminate but we'll return 1\n        return { type: \"number\", value: 1 };\n      }\n      \n      if (absBase > 1) {\n        if (right.sign === \"positive\") {\n          // |base| > 1: base^(+∞) = +∞\n          return { type: \"infinity\", sign: \"positive\" };\n        } else {\n          // |base| > 1: base^(-∞) = 0\n          return { type: \"number\", value: 0 };\n        }\n      } else {\n        // 0 < |base| < 1\n        if (right.sign === \"positive\") {\n          // 0 < |base| < 1: base^(+∞) = 0\n          return { type: \"number\", value: 0 };\n        } else {\n          // 0 < |base| < 1: base^(-∞) = +∞\n          return { type: \"infinity\", sign: \"positive\" };\n        }\n      }\n    }\n  }\n  \n  // Both numbers\n  if (left.type === \"number\" && right.type === \"number\") {\n    // Special cases\n    if (left.value === 0 && right.value === 0) {\n      // 0^0 is indeterminate, return 1 by convention\n      return { type: \"number\", value: 1 };\n    }\n    \n    if (left.value === 0 && right.value < 0) {\n      // 0^(negative) = infinity\n      return { type: \"infinity\", sign: \"positive\" };\n    }\n    \n    if (left.value < 0 && !Number.isInteger(right.value)) {\n      // Negative base with non-integer exponent produces complex numbers\n      return {\n        type: \"error\",\n        err: FormulaError.NUM,\n        message: \"Cannot raise negative number to non-integer power\",\n        errAddress: context.dependencyNode,\n      };\n    }\n    \n    const result = Math.pow(left.value, right.value);\n    \n    // Check for overflow to infinity\n    if (result === Infinity) {\n      return { type: \"infinity\", sign: \"positive\" };\n    }\n    if (result === -Infinity) {\n      return { type: \"infinity\", sign: \"negative\" };\n    }\n    \n    return { type: \"number\", value: result };\n  }\n  \n  // This should never be reached due to the type check at the beginning\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: `Cannot exponentiate ${left.type} and ${right.type}`,\n    errAddress: context.dependencyNode,\n  };\n};"
+  ],
+  "mappings": ";AACA;AAEO,IAAM,QAA6B,CAAC,MAAM,OAAO,YAAY;AAAA,EAElE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,uBAAuB,KAAK,YAAY,MAAM;AAAA,MACvD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAGzD,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MAEzD,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,UAAU;AAAA,MACvD,IAAI,MAAM,UAAU,GAAG;AAAA,QAErB,OAAO,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,MACpC;AAAA,MAEA,IAAI,MAAM,QAAQ,GAAG;AAAA,QAEnB,IAAI,KAAK,SAAS,YAAY;AAAA,UAC5B,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,QAC9C,EAAO;AAAA,UAEL,IAAI,OAAO,UAAU,MAAM,KAAK,GAAG;AAAA,YACjC,MAAM,SAAS,MAAM,QAAQ,MAAM;AAAA,YACnC,OAAO,EAAE,MAAM,YAAY,MAAM,SAAS,aAAa,WAAW;AAAA,UACpE,EAAO;AAAA,YAEL,OAAO;AAAA,cACL,MAAM;AAAA,cACN,KAAK,aAAa;AAAA,cAClB,SAAS;AAAA,cACT,YAAY,QAAQ;AAAA,YACtB;AAAA;AAAA;AAAA,MAGN,EAAO;AAAA,QAEL,OAAO,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA;AAAA,IAEtC;AAAA,IAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,YAAY;AAAA,MACvD,MAAM,UAAU,KAAK,IAAI,KAAK,KAAK;AAAA,MAEnC,IAAI,YAAY,GAAG;AAAA,QAEjB,OAAO,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,MACpC;AAAA,MAEA,IAAI,UAAU,GAAG;AAAA,QACf,IAAI,MAAM,SAAS,YAAY;AAAA,UAE7B,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,QAC9C,EAAO;AAAA,UAEL,OAAO,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA;AAAA,MAEtC,EAAO;AAAA,QAEL,IAAI,MAAM,SAAS,YAAY;AAAA,UAE7B,OAAO,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,QACpC,EAAO;AAAA,UAEL,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA;AAAA;AAAA,IAGlD;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IAErD,IAAI,KAAK,UAAU,KAAK,MAAM,UAAU,GAAG;AAAA,MAEzC,OAAO,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,IACpC;AAAA,IAEA,IAAI,KAAK,UAAU,KAAK,MAAM,QAAQ,GAAG;AAAA,MAEvC,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAEA,IAAI,KAAK,QAAQ,KAAK,CAAC,OAAO,UAAU,MAAM,KAAK,GAAG;AAAA,MAEpD,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,SAAS,KAAK,IAAI,KAAK,OAAO,MAAM,KAAK;AAAA,IAG/C,IAAI,WAAW,UAAU;AAAA,MACvB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IACA,IAAI,WAAW,WAAW;AAAA,MACxB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAEA,OAAO,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,EACzC;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS,uBAAuB,KAAK,YAAY,MAAM;AAAA,IACvD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "73EB7E98B39E641064756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/arithmetic/subtract/subtract.mjs

@@ -0,0 +1,54 @@
+// src/evaluator/arithmetic/subtract/subtract.ts
+import { FormulaError } from "src/core/types";
+var subtract = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot subtract ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "infinity") {
+      if (left.sign === right.sign) {
+        return {
+          type: "error",
+          err: FormulaError.NUM,
+          message: "Cannot subtract infinity from same-signed infinity",
+          errAddress: context.dependencyNode
+        };
+      } else {
+        return { type: "infinity", sign: left.sign };
+      }
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      return { type: "infinity", sign: left.sign };
+    }
+    if (left.type === "number" && right.type === "infinity") {
+      const resultSign = right.sign === "positive" ? "negative" : "positive";
+      return { type: "infinity", sign: resultSign };
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    const result = left.value - right.value;
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: `Cannot subtract ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  subtract
+};
+
+//# debugId=34CCF9E55A81A93164756E2164756E21

package/dist/mjs/evaluator/arithmetic/subtract/subtract.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/evaluator/arithmetic/subtract/subtract.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\nexport const subtract: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot subtract ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Handle infinity cases\n  if (left.type === \"infinity\" || right.type === \"infinity\") {\n    \n    // Both infinity\n    if (left.type === \"infinity\" && right.type === \"infinity\") {\n      if (left.sign === right.sign) {\n        // +∞ - +∞ = undefined, -∞ - -∞ = undefined\n        return {\n          type: \"error\",\n          err: FormulaError.NUM,\n          message: \"Cannot subtract infinity from same-signed infinity\",\n          errAddress: context.dependencyNode,\n        };\n      } else {\n        // +∞ - -∞ = +∞, -∞ - +∞ = -∞\n        return { type: \"infinity\", sign: left.sign };\n      }\n    }\n    \n    // Left infinity, right number: ∞ - n = ∞\n    if (left.type === \"infinity\" && right.type === \"number\") {\n      return { type: \"infinity\", sign: left.sign };\n    }\n    \n    // Left number, right infinity: n - ∞ = -∞, n - -∞ = +∞\n    if (left.type === \"number\" && right.type === \"infinity\") {\n      const resultSign = right.sign === \"positive\" ? \"negative\" : \"positive\";\n      return { type: \"infinity\", sign: resultSign };\n    }\n  }\n  \n  // Both numbers\n  if (left.type === \"number\" && right.type === \"number\") {\n    const result = left.value - right.value;\n    \n    // Check for overflow to infinity\n    if (result === Infinity) {\n      return { type: \"infinity\", sign: \"positive\" };\n    }\n    if (result === -Infinity) {\n      return { type: \"infinity\", sign: \"negative\" };\n    }\n    \n    return { type: \"number\", value: result };\n  }\n  \n  // This should never be reached due to the type check at the beginning\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: `Cannot subtract ${left.type} and ${right.type}`,\n    errAddress: context.dependencyNode,\n  };\n};"
+  ],
+  "mappings": ";AACA;AAEO,IAAM,WAAgC,CAAC,MAAM,OAAO,YAAY;AAAA,EAErE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,mBAAmB,KAAK,YAAY,MAAM;AAAA,MACnD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAGzD,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MACzD,IAAI,KAAK,SAAS,MAAM,MAAM;AAAA,QAE5B,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,aAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA,MACF,EAAO;AAAA,QAEL,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA;AAAA,IAE/C;AAAA,IAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,UAAU;AAAA,MACvD,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA,IAC7C;AAAA,IAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,YAAY;AAAA,MACvD,MAAM,aAAa,MAAM,SAAS,aAAa,aAAa;AAAA,MAC5D,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IACrD,MAAM,SAAS,KAAK,QAAQ,MAAM;AAAA,IAGlC,IAAI,WAAW,UAAU;AAAA,MACvB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IACA,IAAI,WAAW,WAAW;AAAA,MACxB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAEA,OAAO,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,EACzC;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS,mBAAmB,KAAK,YAAY,MAAM;AAAA,IACnD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "34CCF9E55A81A93164756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/comparison/equals.mjs

@@ -0,0 +1,34 @@
+// src/evaluator/comparison/equals.ts
+var equals = (left, right) => {
+  if (left.type !== right.type) {
+    return { type: "boolean", value: false };
+  }
+  switch (left.type) {
+    case "number":
+      if (right.type === "number") {
+        return { type: "boolean", value: left.value === right.value };
+      }
+      break;
+    case "string":
+      if (right.type === "string") {
+        return { type: "boolean", value: left.value === right.value };
+      }
+      break;
+    case "boolean":
+      if (right.type === "boolean") {
+        return { type: "boolean", value: left.value === right.value };
+      }
+      break;
+    case "infinity":
+      if (right.type === "infinity") {
+        return { type: "boolean", value: left.sign === right.sign };
+      }
+      break;
+  }
+  return { type: "boolean", value: false };
+};
+export {
+  equals
+};
+
+//# debugId=324F1224A95AFC9B64756E2164756E21

package/dist/mjs/evaluator/comparison/equals.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/comparison/equals.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\n/**\n * Equals operator (=) - Returns TRUE if both values are exactly equal\n * Strict type checking: both type and value must match\n */\nexport const equals: ArethmeticEvaluator = (left, right) => {\n  // Check type equality first\n  if (left.type !== right.type) {\n    return { type: \"boolean\", value: false };\n  }\n\n  // Handle each type specifically\n  switch (left.type) {\n    case \"number\":\n      if (right.type === \"number\") {\n        return { type: \"boolean\", value: left.value === right.value };\n      }\n      break;\n    \n    case \"string\":\n      if (right.type === \"string\") {\n        return { type: \"boolean\", value: left.value === right.value };\n      }\n      break;\n    \n    case \"boolean\":\n      if (right.type === \"boolean\") {\n        return { type: \"boolean\", value: left.value === right.value };\n      }\n      break;\n    \n    case \"infinity\":\n      if (right.type === \"infinity\") {\n        return { type: \"boolean\", value: left.sign === right.sign };\n      }\n      break;\n  }\n\n  // This should never be reached due to type check above\n  return { type: \"boolean\", value: false };\n};\n"
+  ],
+  "mappings": ";AAOO,IAAM,SAA8B,CAAC,MAAM,UAAU;AAAA,EAE1D,IAAI,KAAK,SAAS,MAAM,MAAM;AAAA,IAC5B,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,EACzC;AAAA,EAGA,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,IAAI,MAAM,SAAS,UAAU;AAAA,QAC3B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,UAAU;AAAA,QAC3B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,WAAW;AAAA,QAC5B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,UAAU,MAAM,MAAM;AAAA,MAC9D;AAAA,MACA;AAAA,SAEG;AAAA,MACH,IAAI,MAAM,SAAS,YAAY;AAAA,QAC7B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,SAAS,MAAM,KAAK;AAAA,MAC5D;AAAA,MACA;AAAA;AAAA,EAIJ,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA;",
+  "debugId": "324F1224A95AFC9B64756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/comparison/greater-than-or-equal.mjs

@@ -0,0 +1,31 @@
+// src/evaluator/comparison/greater-than-or-equal.ts
+import { FormulaError } from "src/core/types";
+import { lessThan } from "./less-than.mjs";
+var greaterThanOrEqual = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot compare ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  const ltResult = lessThan(left, right, context);
+  if (ltResult.type === "error" || ltResult.type === "awaiting-evaluation") {
+    return ltResult;
+  }
+  if (ltResult.type === "boolean") {
+    return { type: "boolean", value: !ltResult.value };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: "Invalid comparison result",
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  greaterThanOrEqual
+};
+
+//# debugId=9EE228EF14D03D4A64756E2164756E21

package/dist/mjs/evaluator/comparison/greater-than-or-equal.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/comparison/greater-than-or-equal.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\nimport { lessThan } from \"./less-than.mjs\";\n\n/**\n * Greater than or equal operator (>=) - Returns TRUE if left >= right\n * Implemented as NOT (left < right)\n */\nexport const greaterThanOrEqual: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const ltResult = lessThan(left, right, context);\n  if (ltResult.type === \"error\" || ltResult.type === \"awaiting-evaluation\") {\n    return ltResult;\n  }\n  \n  if (ltResult.type === \"boolean\") {\n    return { type: \"boolean\", value: !ltResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid comparison result\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
+  ],
+  "mappings": ";AACA;AACA;AAMO,IAAM,qBAA0C,CAAC,MAAM,OAAO,YAAY;AAAA,EAE/E,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,SAAS,MAAM,OAAO,OAAO;AAAA,EAC9C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,WAAW;AAAA,IAC/B,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,SAAS,MAAM;AAAA,EACnD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "9EE228EF14D03D4A64756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/comparison/greater-than.mjs

@@ -0,0 +1,31 @@
+// src/evaluator/comparison/greater-than.ts
+import { FormulaError } from "src/core/types";
+import { lessThanOrEqual } from "./less-than-or-equal.mjs";
+var greaterThan = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot compare ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  const lteResult = lessThanOrEqual(left, right, context);
+  if (lteResult.type === "error" || lteResult.type === "awaiting-evaluation") {
+    return lteResult;
+  }
+  if (lteResult.type === "boolean") {
+    return { type: "boolean", value: !lteResult.value };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: "Invalid comparison result",
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  greaterThan
+};
+
+//# debugId=17D7656F1842B2D864756E2164756E21

package/dist/mjs/evaluator/comparison/greater-than.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/comparison/greater-than.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\nimport { lessThanOrEqual } from \"./less-than-or-equal.mjs\";\n\n/**\n * Greater than operator (>) - Returns TRUE if left > right\n * Implemented as NOT (left <= right)\n */\nexport const greaterThan: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const lteResult = lessThanOrEqual(left, right, context);\n  if (lteResult.type === \"error\" || lteResult.type === \"awaiting-evaluation\") {\n    return lteResult;\n  }\n  \n  if (lteResult.type === \"boolean\") {\n    return { type: \"boolean\", value: !lteResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid comparison result\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
+  ],
+  "mappings": ";AACA;AACA;AAMO,IAAM,cAAmC,CAAC,MAAM,OAAO,YAAY;AAAA,EAExE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,YAAY,gBAAgB,MAAM,OAAO,OAAO;AAAA,EACtD,IAAI,UAAU,SAAS,WAAW,UAAU,SAAS,uBAAuB;AAAA,IAC1E,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,UAAU,SAAS,WAAW;AAAA,IAChC,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,UAAU,MAAM;AAAA,EACpD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "17D7656F1842B2D864756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/comparison/less-than-or-equal.mjs

@@ -0,0 +1,39 @@
+// src/evaluator/comparison/less-than-or-equal.ts
+import { FormulaError } from "src/core/types";
+import { lessThan } from "./less-than.mjs";
+import { equals } from "./equals.mjs";
+var lessThanOrEqual = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot compare ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  const ltResult = lessThan(left, right, context);
+  if (ltResult.type === "error" || ltResult.type === "awaiting-evaluation") {
+    return ltResult;
+  }
+  if (ltResult.type === "boolean" && ltResult.value === true) {
+    return { type: "boolean", value: true };
+  }
+  const eqResult = equals(left, right, context);
+  if (eqResult.type === "error" || eqResult.type === "awaiting-evaluation") {
+    return eqResult;
+  }
+  if (eqResult.type === "boolean") {
+    return { type: "boolean", value: eqResult.value };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: "Invalid comparison result",
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  lessThanOrEqual
+};
+
+//# debugId=45ABC02E5249FA7264756E2164756E21

package/dist/mjs/evaluator/comparison/less-than-or-equal.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/comparison/less-than-or-equal.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\nimport { lessThan } from \"./less-than.mjs\";\nimport { equals } from \"./equals.mjs\";\n\n/**\n * Less than or equal operator (<=) - Returns TRUE if left <= right\n * Uses lessThan OR equals logic\n */\nexport const lessThanOrEqual: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  const ltResult = lessThan(left, right, context);\n  if (ltResult.type === \"error\" || ltResult.type === \"awaiting-evaluation\") {\n    return ltResult;\n  }\n  \n  if (ltResult.type === \"boolean\" && ltResult.value === true) {\n    return { type: \"boolean\", value: true };\n  }\n  \n  // Check equality\n  const eqResult = equals(left, right, context);\n  if (eqResult.type === \"error\" || eqResult.type === \"awaiting-evaluation\") {\n    return eqResult;\n  }\n  \n  if (eqResult.type === \"boolean\") {\n    return { type: \"boolean\", value: eqResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid comparison result\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
+  ],
+  "mappings": ";AACA;AACA;AACA;AAMO,IAAM,kBAAuC,CAAC,MAAM,OAAO,YAAY;AAAA,EAE5E,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,SAAS,MAAM,OAAO,OAAO;AAAA,EAC9C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,aAAa,SAAS,UAAU,MAAM;AAAA,IAC1D,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,EACxC;AAAA,EAGA,MAAM,WAAW,OAAO,MAAM,OAAO,OAAO;AAAA,EAC5C,IAAI,SAAS,SAAS,WAAW,SAAS,SAAS,uBAAuB;AAAA,IACxE,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,SAAS,SAAS,WAAW;AAAA,IAC/B,OAAO,EAAE,MAAM,WAAW,OAAO,SAAS,MAAM;AAAA,EAClD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "45ABC02E5249FA7264756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/comparison/less-than.mjs

@@ -0,0 +1,38 @@
+// src/evaluator/comparison/less-than.ts
+import { FormulaError } from "src/core/types";
+var lessThan = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: `Cannot compare ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" && right.type === "infinity") {
+    if (left.sign === "negative" && right.sign === "positive") {
+      return { type: "boolean", value: true };
+    }
+    return { type: "boolean", value: false };
+  }
+  if (left.type === "infinity") {
+    return { type: "boolean", value: left.sign === "negative" };
+  }
+  if (right.type === "infinity") {
+    return { type: "boolean", value: right.sign === "positive" };
+  }
+  if (left.type === "number" && right.type === "number") {
+    return { type: "boolean", value: left.value < right.value };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: `Cannot compare ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  lessThan
+};
+
+//# debugId=6D26981236A613EF64756E2164756E21

package/dist/mjs/evaluator/comparison/less-than.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/comparison/less-than.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\n/**\n * Less than operator (<) - Returns TRUE if left < right\n * Only works with numbers and infinity\n */\nexport const lessThan: ArethmeticEvaluator = (left, right, context) => {\n  // Only allow number and infinity types\n  if ((left.type !== \"number\" && left.type !== \"infinity\") ||\n      (right.type !== \"number\" && right.type !== \"infinity\")) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `Cannot compare ${left.type} and ${right.type}`,\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Handle infinity cases\n  if (left.type === \"infinity\" && right.type === \"infinity\") {\n    // -∞ < +∞ is true, otherwise false (same infinities are equal)\n    if (left.sign === \"negative\" && right.sign === \"positive\") {\n      return { type: \"boolean\", value: true };\n    }\n    return { type: \"boolean\", value: false };\n  }\n  \n  if (left.type === \"infinity\") {\n    // +∞ is never less than anything, -∞ is less than any number\n    return { type: \"boolean\", value: left.sign === \"negative\" };\n  }\n  \n  if (right.type === \"infinity\") {\n    // Any number is less than +∞, no number is less than -∞\n    return { type: \"boolean\", value: right.sign === \"positive\" };\n  }\n  \n  // Both are numbers\n  if (left.type === \"number\" && right.type === \"number\") {\n    return { type: \"boolean\", value: left.value < right.value };\n  }\n  \n  // This should never be reached\n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: `Cannot compare ${left.type} and ${right.type}`,\n    errAddress: context.dependencyNode,\n  };\n};\n"
+  ],
+  "mappings": ";AACA;AAMO,IAAM,WAAgC,CAAC,MAAM,OAAO,YAAY;AAAA,EAErE,IAAK,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAAa;AAAA,IAC1D,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,aAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAEzD,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MACzD,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,IACxC;AAAA,IACA,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,EACzC;AAAA,EAEA,IAAI,KAAK,SAAS,YAAY;AAAA,IAE5B,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,SAAS,WAAW;AAAA,EAC5D;AAAA,EAEA,IAAI,MAAM,SAAS,YAAY;AAAA,IAE7B,OAAO,EAAE,MAAM,WAAW,OAAO,MAAM,SAAS,WAAW;AAAA,EAC7D;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IACrD,OAAO,EAAE,MAAM,WAAW,OAAO,KAAK,QAAQ,MAAM,MAAM;AAAA,EAC5D;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,IAClD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "6D26981236A613EF64756E2164756E21",
+  "names": []
+}