@ricsam/formula-engine 0.0.1

package/dist/cjs/evaluator/arithmetic/power/power.cjs.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": "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",
+  "debugId": "73FDE97BE41666D364756E2164756E21",
+  "names": []
+}

package/dist/cjs/evaluator/arithmetic/subtract/subtract.cjs

@@ -0,0 +1,84 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/arithmetic/subtract/subtract.ts
+var exports_subtract = {};
+__export(exports_subtract, {
+  subtract: () => subtract
+});
+module.exports = __toCommonJS(exports_subtract);
+var import_types = require("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: import_types.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: import_types.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: import_types.FormulaError.VALUE,
+    message: `Cannot subtract ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=4D18B735805E07BC64756E2164756E21

package/dist/cjs/evaluator/arithmetic/subtract/subtract.cjs.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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;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,0BAAa;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,0BAAa;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,0BAAa;AAAA,IAClB,SAAS,mBAAmB,KAAK,YAAY,MAAM;AAAA,IACnD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "4D18B735805E07BC64756E2164756E21",
+  "names": []
+}

package/dist/cjs/evaluator/comparison/equals.cjs

@@ -0,0 +1,64 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/comparison/equals.ts
+var exports_equals = {};
+__export(exports_equals, {
+  equals: () => equals
+});
+module.exports = __toCommonJS(exports_equals);
+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 };
+};
+
+//# debugId=2C4AFBAA566A87C564756E2164756E21

package/dist/cjs/evaluator/comparison/equals.cjs.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": "2C4AFBAA566A87C564756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/comparison/greater-than-or-equal.ts
+var exports_greater_than_or_equal = {};
+__export(exports_greater_than_or_equal, {
+  greaterThanOrEqual: () => greaterThanOrEqual
+});
+module.exports = __toCommonJS(exports_greater_than_or_equal);
+var import_types = require("src/core/types");
+var import_less_than = require("./less-than.cjs");
+var greaterThanOrEqual = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `Cannot compare ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  const ltResult = import_less_than.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: import_types.FormulaError.VALUE,
+    message: "Invalid comparison result",
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=C316B0C029C623B064756E2164756E21

package/dist/cjs/evaluator/comparison/greater-than-or-equal.cjs.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.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACyB,IAAzB;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,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,0BAAS,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,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "C316B0C029C623B064756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/comparison/greater-than.ts
+var exports_greater_than = {};
+__export(exports_greater_than, {
+  greaterThan: () => greaterThan
+});
+module.exports = __toCommonJS(exports_greater_than);
+var import_types = require("src/core/types");
+var import_less_than_or_equal = require("./less-than-or-equal.cjs");
+var greaterThan = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `Cannot compare ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  const lteResult = import_less_than_or_equal.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: import_types.FormulaError.VALUE,
+    message: "Invalid comparison result",
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=10C8313A792287E064756E2164756E21

package/dist/cjs/evaluator/comparison/greater-than.cjs.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.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACgC,IAAhC;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,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,YAAY,0CAAgB,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,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "10C8313A792287E064756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,69 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/comparison/less-than-or-equal.ts
+var exports_less_than_or_equal = {};
+__export(exports_less_than_or_equal, {
+  lessThanOrEqual: () => lessThanOrEqual
+});
+module.exports = __toCommonJS(exports_less_than_or_equal);
+var import_types = require("src/core/types");
+var import_less_than = require("./less-than.cjs");
+var import_equals = require("./equals.cjs");
+var lessThanOrEqual = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `Cannot compare ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  const ltResult = import_less_than.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 = import_equals.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: import_types.FormulaError.VALUE,
+    message: "Invalid comparison result",
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=1A7D257FB02E5A2764756E2164756E21

package/dist/cjs/evaluator/comparison/less-than-or-equal.cjs.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.cjs\";\nimport { equals } from \"./equals.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACyB,IAAzB;AACuB,IAAvB;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,0BAAa;AAAA,MAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,MAClD,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,MAAM,WAAW,0BAAS,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,qBAAO,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,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "1A7D257FB02E5A2764756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/comparison/less-than.ts
+var exports_less_than = {};
+__export(exports_less_than, {
+  lessThan: () => lessThan
+});
+module.exports = __toCommonJS(exports_less_than);
+var import_types = require("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: import_types.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: import_types.FormulaError.VALUE,
+    message: `Cannot compare ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=0FA7831C844593F364756E2164756E21

package/dist/cjs/evaluator/comparison/less-than.cjs.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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;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,0BAAa;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,0BAAa;AAAA,IAClB,SAAS,kBAAkB,KAAK,YAAY,MAAM;AAAA,IAClD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "0FA7831C844593F364756E2164756E21",
+  "names": []
+}

package/dist/cjs/evaluator/comparison/not-equals.cjs

@@ -0,0 +1,53 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/comparison/not-equals.ts
+var exports_not_equals = {};
+__export(exports_not_equals, {
+  notEquals: () => notEquals
+});
+module.exports = __toCommonJS(exports_not_equals);
+var import_types = require("src/core/types");
+var import_equals = require("./equals.cjs");
+var notEquals = (left, right, context) => {
+  const equalsResult = import_equals.equals(left, right, context);
+  if (equalsResult.type === "error" || equalsResult.type === "awaiting-evaluation") {
+    return equalsResult;
+  }
+  if (equalsResult.type === "boolean") {
+    return { type: "boolean", value: !equalsResult.value };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.VALUE,
+    message: "Invalid result from equals comparison",
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=D72C2C9D0BCFD09E64756E2164756E21

package/dist/cjs/evaluator/comparison/not-equals.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/comparison/not-equals.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\nimport { equals } from \"./equals.cjs\";\n\n/**\n * Not equals operator (<>) - Returns TRUE if values are not equal\n * Uses the equals operator and negates the result\n */\nexport const notEquals: ArethmeticEvaluator = (left, right, context) => {\n  const equalsResult = equals(left, right, context);\n  \n  if (equalsResult.type === \"error\" || equalsResult.type === \"awaiting-evaluation\") {\n    return equalsResult;\n  }\n  \n  if (equalsResult.type === \"boolean\") {\n    return { type: \"boolean\", value: !equalsResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid result from equals comparison\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AACuB,IAAvB;AAMO,IAAM,YAAiC,CAAC,MAAM,OAAO,YAAY;AAAA,EACtE,MAAM,eAAe,qBAAO,MAAM,OAAO,OAAO;AAAA,EAEhD,IAAI,aAAa,SAAS,WAAW,aAAa,SAAS,uBAAuB;AAAA,IAChF,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,aAAa,SAAS,WAAW;AAAA,IACnC,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,aAAa,MAAM;AAAA,EACvD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "D72C2C9D0BCFD09E64756E2164756E21",
+  "names": []
+}