@ricsam/formula-engine 0.0.2 → 0.0.4

package/dist/cjs/evaluator/arithmetic/add/add.cjs

@@ -32,7 +32,7 @@ __export(exports_add, {
   add: () => add
 });
 module.exports = __toCommonJS(exports_add);
-var import_types = require("src/core/types");
+var import_types = require("../../../core/types.cjs");
 var add = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -79,4 +79,4 @@ var add = (left, right, context) => {
   };
 };
 
-//# debugId=9EE8E477C2D2AFC864756E2164756E21
+//# debugId=A5D0997DD7153D9764756E2164756E21

package/dist/cjs/evaluator/arithmetic/add/add.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../../src/evaluator/arithmetic/add/add.ts"],
   "sourcesContent": [
-    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\nexport const add: 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 add ${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\n    if (left.type === \"infinity\" && right.type === \"infinity\") {\n      if (left.sign === right.sign) {\n        // +∞ + +∞ = +∞, -∞ + -∞ = -∞\n        return { type: \"infinity\", sign: left.sign };\n      } else {\n        // +∞ + -∞ = NaN (undefined behavior)\n        return {\n          type: \"error\",\n          err: FormulaError.NUM,\n          message: \"Cannot add positive and negative infinity\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // One infinity, one number: infinity dominates\n    if (left.type === \"infinity\" && right.type === \"number\") {\n      return { type: \"infinity\", sign: left.sign };\n    } else if (right.type === \"infinity\" && left.type === \"number\") {\n      return { type: \"infinity\", sign: right.sign };\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 add ${left.type} and ${right.type}`,\n    errAddress: context.dependencyNode,\n  };\n};\n"
+    "import type { ArethmeticEvaluator } from \"../../../core/types.cjs\";\nimport { FormulaError } from \"../../../core/types.cjs\";\n\nexport const add: 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 add ${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\n    if (left.type === \"infinity\" && right.type === \"infinity\") {\n      if (left.sign === right.sign) {\n        // +∞ + +∞ = +∞, -∞ + -∞ = -∞\n        return { type: \"infinity\", sign: left.sign };\n      } else {\n        // +∞ + -∞ = NaN (undefined behavior)\n        return {\n          type: \"error\",\n          err: FormulaError.NUM,\n          message: \"Cannot add positive and negative infinity\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // One infinity, one number: infinity dominates\n    if (left.type === \"infinity\" && right.type === \"number\") {\n      return { type: \"infinity\", sign: left.sign };\n    } else if (right.type === \"infinity\" && left.type === \"number\") {\n      return { type: \"infinity\", sign: right.sign };\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 add ${left.type} and ${right.type}`,\n    errAddress: context.dependencyNode,\n  };\n};\n"
   ],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AAEO,IAAM,MAA2B,CAAC,MAAM,OAAO,YAAY;AAAA,EAEhE,IACG,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAC3C;AAAA,IACA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,cAAc,KAAK,YAAY,MAAM;AAAA,MAC9C,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,IAAI,KAAK,SAAS,MAAM,MAAM;AAAA,QAE5B,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA,MAC7C,EAAO;AAAA,QAEL,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA;AAAA,IAEJ;AAAA,IAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,UAAU;AAAA,MACvD,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA,IAC7C,EAAO,SAAI,MAAM,SAAS,cAAc,KAAK,SAAS,UAAU;AAAA,MAC9D,OAAO,EAAE,MAAM,YAAY,MAAM,MAAM,KAAK;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,cAAc,KAAK,YAAY,MAAM;AAAA,IAC9C,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "9EE8E477C2D2AFC864756E2164756E21",
+  "debugId": "A5D0997DD7153D9764756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/arithmetic/divide/divide.cjs

@@ -32,7 +32,7 @@ __export(exports_divide, {
   divide: () => divide
 });
 module.exports = __toCommonJS(exports_divide);
-var import_types = require("src/core/types");
+var import_types = require("../../../core/types.cjs");
 var divide = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -104,4 +104,4 @@ var divide = (left, right, context) => {
   };
 };
 
-//# debugId=B609DB91D7F80EE764756E2164756E21
+//# debugId=83AE6629862E4FBE64756E2164756E21

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

@@ -2,9 +2,9 @@
   "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"
+    "import type { ArethmeticEvaluator } from \"../../../core/types.cjs\";\nimport { FormulaError } from \"../../../core/types.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;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,0BAAa;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,0BAAa;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,0BAAa;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,0BAAa;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,0BAAa;AAAA,IAClB,SAAS,iBAAiB,KAAK,YAAY,MAAM;AAAA,IACjD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "B609DB91D7F80EE764756E2164756E21",
+  "debugId": "83AE6629862E4FBE64756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/arithmetic/multiply/multiply.cjs

@@ -32,7 +32,7 @@ __export(exports_multiply, {
   multiply: () => multiply
 });
 module.exports = __toCommonJS(exports_multiply);
-var import_types = require("src/core/types");
+var import_types = require("../../../core/types.cjs");
 var multiply = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -90,4 +90,4 @@ var multiply = (left, right, context) => {
   };
 };
 
-//# debugId=585A61464147AE4264756E2164756E21
+//# debugId=ABD8ABB75C54A53864756E2164756E21

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

@@ -2,9 +2,9 @@
   "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};"
+    "import type { ArethmeticEvaluator } from \"../../../core/types.cjs\";\nimport { FormulaError } from \"../../../core/types.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,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,0BAAa;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,0BAAa;AAAA,IAClB,SAAS,mBAAmB,KAAK,YAAY,MAAM;AAAA,IACnD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "585A61464147AE4264756E2164756E21",
+  "debugId": "ABD8ABB75C54A53864756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/arithmetic/power/power.cjs

@@ -32,7 +32,7 @@ __export(exports_power, {
   power: () => power
 });
 module.exports = __toCommonJS(exports_power);
-var import_types = require("src/core/types");
+var import_types = require("../../../core/types.cjs");
 var power = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -122,4 +122,4 @@ var power = (left, right, context) => {
   };
 };
 
-//# debugId=73FDE97BE41666D364756E2164756E21
+//# debugId=A0C3BAD00C89A1D864756E2164756E21

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

@@ -2,9 +2,9 @@
   "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};"
+    "import type { ArethmeticEvaluator } from \"../../../core/types.cjs\";\nimport { FormulaError } from \"../../../core/types.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;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,0BAAa;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,0BAAa;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,0BAAa;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,0BAAa;AAAA,IAClB,SAAS,uBAAuB,KAAK,YAAY,MAAM;AAAA,IACvD,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "73FDE97BE41666D364756E2164756E21",
+  "debugId": "A0C3BAD00C89A1D864756E2164756E21",
   "names": []
 }

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

@@ -32,7 +32,7 @@ __export(exports_subtract, {
   subtract: () => subtract
 });
 module.exports = __toCommonJS(exports_subtract);
-var import_types = require("src/core/types");
+var import_types = require("../../../core/types.cjs");
 var subtract = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -81,4 +81,4 @@ var subtract = (left, right, context) => {
   };
 };
 
-//# debugId=4D18B735805E07BC64756E2164756E21
+//# debugId=45C1B6DFFA94BBEA64756E2164756E21

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

@@ -2,9 +2,9 @@
   "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};"
+    "import type { ArethmeticEvaluator } from \"../../../core/types.cjs\";\nimport { FormulaError } from \"../../../core/types.cjs\";\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",
+  "debugId": "45C1B6DFFA94BBEA64756E2164756E21",
   "names": []
 }

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

@@ -2,7 +2,7 @@
   "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"
+    "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\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",

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

@@ -32,7 +32,7 @@ __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_types = require("../../core/types.cjs");
 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") {
@@ -58,4 +58,4 @@ var greaterThanOrEqual = (left, right, context) => {
   };
 };
 
-//# debugId=C316B0C029C623B064756E2164756E21
+//# debugId=73E0122E9857568264756E2164756E21

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

@@ -2,9 +2,9 @@
   "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"
+    "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\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",
+  "debugId": "73E0122E9857568264756E2164756E21",
   "names": []
 }

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

@@ -32,7 +32,7 @@ __export(exports_greater_than, {
   greaterThan: () => greaterThan
 });
 module.exports = __toCommonJS(exports_greater_than);
-var import_types = require("src/core/types");
+var import_types = require("../../core/types.cjs");
 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") {
@@ -58,4 +58,4 @@ var greaterThan = (left, right, context) => {
   };
 };
 
-//# debugId=10C8313A792287E064756E2164756E21
+//# debugId=54C39A2F0592101E64756E2164756E21

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

@@ -2,9 +2,9 @@
   "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"
+    "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\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",
+  "debugId": "54C39A2F0592101E64756E2164756E21",
   "names": []
 }

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

@@ -32,7 +32,7 @@ __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_types = require("../../core/types.cjs");
 var import_less_than = require("./less-than.cjs");
 var import_equals = require("./equals.cjs");
 var lessThanOrEqual = (left, right, context) => {
@@ -66,4 +66,4 @@ var lessThanOrEqual = (left, right, context) => {
   };
 };
 
-//# debugId=1A7D257FB02E5A2764756E2164756E21
+//# debugId=9E5011BF96D756C964756E2164756E21

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

@@ -2,9 +2,9 @@
   "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"
+    "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\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",
+  "debugId": "9E5011BF96D756C964756E2164756E21",
   "names": []
 }

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

@@ -32,7 +32,7 @@ __export(exports_less_than, {
   lessThan: () => lessThan
 });
 module.exports = __toCommonJS(exports_less_than);
-var import_types = require("src/core/types");
+var import_types = require("../../core/types.cjs");
 var lessThan = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -65,4 +65,4 @@ var lessThan = (left, right, context) => {
   };
 };
 
-//# debugId=0FA7831C844593F364756E2164756E21
+//# debugId=E05D3E66898EA2FC64756E2164756E21

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

@@ -2,9 +2,9 @@
   "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"
+    "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\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",
+  "debugId": "E05D3E66898EA2FC64756E2164756E21",
   "names": []
 }

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

@@ -32,7 +32,7 @@ __export(exports_not_equals, {
   notEquals: () => notEquals
 });
 module.exports = __toCommonJS(exports_not_equals);
-var import_types = require("src/core/types");
+var import_types = require("../../core/types.cjs");
 var import_equals = require("./equals.cjs");
 var notEquals = (left, right, context) => {
   const equalsResult = import_equals.equals(left, right, context);
@@ -50,4 +50,4 @@ var notEquals = (left, right, context) => {
   };
 };
 
-//# debugId=D72C2C9D0BCFD09E64756E2164756E21
+//# debugId=A9B57AE1A701EDB164756E2164756E21

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

@@ -2,9 +2,9 @@
   "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"
+    "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\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",
+  "debugId": "A9B57AE1A701EDB164756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/concatenation/concatenate.cjs

@@ -32,7 +32,7 @@ __export(exports_concatenate, {
   concatenate: () => concatenate
 });
 module.exports = __toCommonJS(exports_concatenate);
-var import_types = require("src/core/types");
+var import_types = require("../../core/types.cjs");
 var concatenate = (left, right, context) => {
   let leftStr;
   let rightStr;
@@ -69,4 +69,4 @@ var concatenate = (left, right, context) => {
   return { type: "string", value: leftStr + rightStr };
 };
 
-//# debugId=C23CBACF7D30CE7B64756E2164756E21
+//# debugId=4D4ACC1ED63C125264756E2164756E21

package/dist/cjs/evaluator/concatenation/concatenate.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/evaluator/concatenation/concatenate.ts"],
   "sourcesContent": [
-    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\n/**\n * Concatenation operator (&) - Concatenates two values as strings\n * Works with numbers and strings only\n */\nexport const concatenate: ArethmeticEvaluator = (left, right, context) => {\n  // Convert each value to string based on type\n  let leftStr: string;\n  let rightStr: string;\n\n  // Handle left operand\n  switch (left.type) {\n    case \"string\":\n      leftStr = left.value;\n      break;\n    case \"number\":\n      leftStr = left.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${left.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  // Handle right operand\n  switch (right.type) {\n    case \"string\":\n      rightStr = right.value;\n      break;\n    case \"number\":\n      rightStr = right.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${right.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  return { type: \"string\", value: leftStr + rightStr };\n};\n"
+    "import type { ArethmeticEvaluator } from \"../../core/types.cjs\";\nimport { FormulaError } from \"../../core/types.cjs\";\n\n/**\n * Concatenation operator (&) - Concatenates two values as strings\n * Works with numbers and strings only\n */\nexport const concatenate: ArethmeticEvaluator = (left, right, context) => {\n  // Convert each value to string based on type\n  let leftStr: string;\n  let rightStr: string;\n\n  // Handle left operand\n  switch (left.type) {\n    case \"string\":\n      leftStr = left.value;\n      break;\n    case \"number\":\n      leftStr = left.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${left.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  // Handle right operand\n  switch (right.type) {\n    case \"string\":\n      rightStr = right.value;\n      break;\n    case \"number\":\n      rightStr = right.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${right.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  return { type: \"string\", value: leftStr + rightStr };\n};\n"
   ],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AAMO,IAAM,cAAmC,CAAC,MAAM,OAAO,YAAY;AAAA,EAExE,IAAI;AAAA,EACJ,IAAI;AAAA,EAGJ,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,UAAU,KAAK;AAAA,MACf;AAAA,SACG;AAAA,MACH,UAAU,KAAK,MAAM,SAAS;AAAA,MAC9B;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,sBAAsB,KAAK;AAAA,QACpC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAIJ,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,WAAW,MAAM;AAAA,MACjB;AAAA,SACG;AAAA,MACH,WAAW,MAAM,MAAM,SAAS;AAAA,MAChC;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,sBAAsB,MAAM;AAAA,QACrC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAGJ,OAAO,EAAE,MAAM,UAAU,OAAO,UAAU,SAAS;AAAA;",
-  "debugId": "C23CBACF7D30CE7B64756E2164756E21",
+  "debugId": "4D4ACC1ED63C125264756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/dependency-nodes/ast-evaluation-node.cjs

@@ -32,7 +32,7 @@ __export(exports_ast_evaluation_node, {
   AstEvaluationNode: () => AstEvaluationNode
 });
 module.exports = __toCommonJS(exports_ast_evaluation_node);
-var import_formatter = require("src/parser/formatter");
+var import_formatter = require("../../parser/formatter.cjs");
 var import_base_eval_node = require("./base-eval-node.cjs");
 
 class AstEvaluationNode extends import_base_eval_node.BaseEvalNode {
@@ -55,4 +55,4 @@ class AstEvaluationNode extends import_base_eval_node.BaseEvalNode {
   }
 }
 
-//# debugId=7611448A774E9E8F64756E2164756E21
+//# debugId=1EE9A66B1752F00264756E2164756E21

package/dist/cjs/evaluator/dependency-nodes/ast-evaluation-node.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/evaluator/dependency-nodes/ast-evaluation-node.ts"],
   "sourcesContent": [
-    "import type { FunctionEvaluationResult } from \"src/core/types\";\nimport type { ASTNode } from \"src/parser/ast\";\nimport { astToString } from \"src/parser/formatter\";\nimport type { ContextDependency } from \"../evaluation-context.cjs\";\nimport { BaseEvalNode } from \"./base-eval-node.cjs\";\n\nexport class AstEvaluationNode extends BaseEvalNode<FunctionEvaluationResult> {\n  private _contextDependency: ContextDependency;\n  constructor(\n    public ast: ASTNode,\n    contextDependency: ContextDependency\n  ) {\n    const key = `ast:${astToString(ast)}`;\n    super(key);\n    this._contextDependency = contextDependency;\n  }\n\n  public override toString(): string {\n    return this.key;\n  }\n\n  getContextDependency() {\n    return this._contextDependency;\n  }\n\n  setContextDependency(contextDependency: ContextDependency) {\n    this._contextDependency = contextDependency;\n  }\n}\n"
+    "import type { FunctionEvaluationResult } from \"../../core/types.cjs\";\nimport type { ASTNode } from \"../../parser/ast.cjs\";\nimport { astToString } from \"../../parser/formatter.cjs\";\nimport type { ContextDependency } from \"../evaluation-context.cjs\";\nimport { BaseEvalNode } from \"./base-eval-node.cjs\";\n\nexport class AstEvaluationNode extends BaseEvalNode<FunctionEvaluationResult> {\n  private _contextDependency: ContextDependency;\n  constructor(\n    public ast: ASTNode,\n    contextDependency: ContextDependency\n  ) {\n    const key = `ast:${astToString(ast)}`;\n    super(key);\n    this._contextDependency = contextDependency;\n  }\n\n  public override toString(): string {\n    return this.key;\n  }\n\n  getContextDependency() {\n    return this._contextDependency;\n  }\n\n  setContextDependency(contextDependency: ContextDependency) {\n    this._contextDependency = contextDependency;\n  }\n}\n"
   ],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAE4B,IAA5B;AAE6B,IAA7B;AAAA;AAEO,MAAM,0BAA0B,mCAAuC;AAAA,EAGnE;AAAA,EAFD;AAAA,EACR,WAAW,CACF,KACP,mBACA;AAAA,IACA,MAAM,MAAM,OAAO,6BAAY,GAAG;AAAA,IAClC,MAAM,GAAG;AAAA,IAJF;AAAA,IAKP,KAAK,qBAAqB;AAAA;AAAA,EAGZ,QAAQ,GAAW;AAAA,IACjC,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,GAAG;AAAA,IACrB,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,CAAC,mBAAsC;AAAA,IACzD,KAAK,qBAAqB;AAAA;AAE9B;",
-  "debugId": "7611448A774E9E8F64756E2164756E21",
+  "debugId": "1EE9A66B1752F00264756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/dependency-nodes/base-eval-node.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/evaluator/dependency-nodes/base-eval-node.ts"],
   "sourcesContent": [
-    "import { type DependencyNode } from \"src/core/managers/dependency-node\";\nimport type {\n  DoesNotSpillResult,\n  FunctionEvaluationResult,\n  SpilledValuesEvaluationResult,\n} from \"src/core/types\";\nimport type { SpillMetaNode } from \"./spill-meta-node.cjs\";\n\nexport class BaseEvalNode<T> {\n  public key: string;\n  private _dependencies: Set<DependencyNode> = new Set();\n  private _lastDependencies: Set<DependencyNode> = new Set();\n  public _evaluationResult: T;\n  private _resolved: boolean = false;\n\n  constructor(key: string) {\n    this.key = key;\n    this._evaluationResult = {\n      type: \"awaiting-evaluation\",\n      waitingFor: this,\n      errAddress: this,\n    } as any;\n  }\n\n  public addDependency(dep: DependencyNode) {\n    if (this._dependencies.has(dep)) {\n      return;\n    }\n    this._dependencies.add(dep);\n  }\n\n  public get directDepsUpdated() {\n    return (\n      !this._lastDependencies.isSubsetOf(this._dependencies) ||\n      this._dependencies.size !== this._lastDependencies.size\n    );\n  }\n\n  public resolve() {\n    if (this.canResolve()) {\n      this._resolved = true;\n    }\n  }\n\n  public canResolve() {\n    return (\n      (this.evaluationResult as any).type !== \"awaiting-evaluation\" &&\n      !this.directDepsUpdated\n    );\n  }\n\n  public get resolved() {\n    return this._resolved;\n  }\n\n  public get evaluationResult(): T {\n    return this._evaluationResult;\n  }\n\n  public setEvaluationResult(result: T) {\n    this._evaluationResult = result;\n  }\n\n  public resetDirectDepsUpdated() {\n    if (this._resolved) {\n      return;\n    }\n    this._lastDependencies = new Set(this._dependencies);\n    this._dependencies = new Set();\n  }\n\n  /**\n   * Get the direct dependencies of the node, either RangeEvaluationNode or DependencyNode\n   */\n  public getDependencies() {\n    return this._dependencies;\n  }\n\n  /**\n   * Just to mirror the method in RangeEvaluationNode\n   */\n  public getAllDependencies() {\n    return this.getDependencies();\n  }\n\n  /**\n   * Just to mirror the method in RangeEvaluationNode\n   */\n  public getFrontierDependencies(): Set<SpillMetaNode> {\n    return new Set();\n  }\n\n  toJSON(visitor: Set<string> = new Set()): any {\n    const hasVisited = visitor?.has(this.key);\n    if (hasVisited) {\n      return {\n        key: this.key,\n        resolved: this.resolved,\n        cycle: true,\n        dependencies: [],\n      };\n    }\n    visitor?.add(this.key);\n    return {\n      key: this.key,\n      resolved: this.resolved,\n      evaluationResult: this.evaluationResult,\n      dependencies: Array.from(this.getDependencies()).map((node) =>\n        node.toJSON(visitor)\n      ),\n    };\n  }\n}\n"
+    "import { type DependencyNode } from \"../../core/managers/dependency-node.cjs\";\nimport type { SpillMetaNode } from \"./spill-meta-node.cjs\";\n\nexport class BaseEvalNode<T> {\n  public key: string;\n  private _dependencies: Set<DependencyNode> = new Set();\n  private _lastDependencies: Set<DependencyNode> = new Set();\n  public _evaluationResult: T;\n  private _resolved: boolean = false;\n\n  constructor(key: string) {\n    this.key = key;\n    this._evaluationResult = {\n      type: \"awaiting-evaluation\",\n      waitingFor: this,\n      errAddress: this,\n    } as any;\n  }\n\n  public addDependency(dep: DependencyNode) {\n    if (this._dependencies.has(dep)) {\n      return;\n    }\n    this._dependencies.add(dep);\n  }\n\n  public get directDepsUpdated() {\n    return (\n      !this._lastDependencies.isSubsetOf(this._dependencies) ||\n      this._dependencies.size !== this._lastDependencies.size\n    );\n  }\n\n  public resolve() {\n    if (this.canResolve()) {\n      this._resolved = true;\n    }\n  }\n\n  public canResolve() {\n    return (\n      (this.evaluationResult as any).type !== \"awaiting-evaluation\" &&\n      !this.directDepsUpdated\n    );\n  }\n\n  public get resolved() {\n    return this._resolved;\n  }\n\n  public get evaluationResult(): T {\n    return this._evaluationResult;\n  }\n\n  public setEvaluationResult(result: T) {\n    this._evaluationResult = result;\n  }\n\n  public resetDirectDepsUpdated() {\n    if (this._resolved) {\n      return;\n    }\n    this._lastDependencies = new Set(this._dependencies);\n    this._dependencies = new Set();\n  }\n\n  /**\n   * Get the direct dependencies of the node, either RangeEvaluationNode or DependencyNode\n   */\n  public getDependencies() {\n    return this._dependencies;\n  }\n\n  /**\n   * Just to mirror the method in RangeEvaluationNode\n   */\n  public getAllDependencies() {\n    return this.getDependencies();\n  }\n\n  /**\n   * Just to mirror the method in RangeEvaluationNode\n   */\n  public getFrontierDependencies(): Set<SpillMetaNode> {\n    return new Set();\n  }\n\n  toJSON(visitor: Set<string> = new Set()): any {\n    const hasVisited = visitor?.has(this.key);\n    if (hasVisited) {\n      return {\n        key: this.key,\n        resolved: this.resolved,\n        cycle: true,\n        dependencies: [],\n      };\n    }\n    visitor?.add(this.key);\n    return {\n      key: this.key,\n      resolved: this.resolved,\n      evaluationResult: this.evaluationResult,\n      dependencies: Array.from(this.getDependencies()).map((node) =>\n        node.toJSON(visitor)\n      ),\n    };\n  }\n}\n"
   ],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAQO,MAAM,aAAgB;AAAA,EACpB;AAAA,EACC,gBAAqC,IAAI;AAAA,EACzC,oBAAyC,IAAI;AAAA,EAC9C;AAAA,EACC,YAAqB;AAAA,EAE7B,WAAW,CAAC,KAAa;AAAA,IACvB,KAAK,MAAM;AAAA,IACX,KAAK,oBAAoB;AAAA,MACvB,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA;AAAA,EAGK,aAAa,CAAC,KAAqB;AAAA,IACxC,IAAI,KAAK,cAAc,IAAI,GAAG,GAAG;AAAA,MAC/B;AAAA,IACF;AAAA,IACA,KAAK,cAAc,IAAI,GAAG;AAAA;AAAA,MAGjB,iBAAiB,GAAG;AAAA,IAC7B,OACE,CAAC,KAAK,kBAAkB,WAAW,KAAK,aAAa,KACrD,KAAK,cAAc,SAAS,KAAK,kBAAkB;AAAA;AAAA,EAIhD,OAAO,GAAG;AAAA,IACf,IAAI,KAAK,WAAW,GAAG;AAAA,MACrB,KAAK,YAAY;AAAA,IACnB;AAAA;AAAA,EAGK,UAAU,GAAG;AAAA,IAClB,OACG,KAAK,iBAAyB,SAAS,yBACxC,CAAC,KAAK;AAAA;AAAA,MAIC,QAAQ,GAAG;AAAA,IACpB,OAAO,KAAK;AAAA;AAAA,MAGH,gBAAgB,GAAM;AAAA,IAC/B,OAAO,KAAK;AAAA;AAAA,EAGP,mBAAmB,CAAC,QAAW;AAAA,IACpC,KAAK,oBAAoB;AAAA;AAAA,EAGpB,sBAAsB,GAAG;AAAA,IAC9B,IAAI,KAAK,WAAW;AAAA,MAClB;AAAA,IACF;AAAA,IACA,KAAK,oBAAoB,IAAI,IAAI,KAAK,aAAa;AAAA,IACnD,KAAK,gBAAgB,IAAI;AAAA;AAAA,EAMpB,eAAe,GAAG;AAAA,IACvB,OAAO,KAAK;AAAA;AAAA,EAMP,kBAAkB,GAAG;AAAA,IAC1B,OAAO,KAAK,gBAAgB;AAAA;AAAA,EAMvB,uBAAuB,GAAuB;AAAA,IACnD,OAAO,IAAI;AAAA;AAAA,EAGb,MAAM,CAAC,UAAuB,IAAI,KAAY;AAAA,IAC5C,MAAM,aAAa,SAAS,IAAI,KAAK,GAAG;AAAA,IACxC,IAAI,YAAY;AAAA,MACd,OAAO;AAAA,QACL,KAAK,KAAK;AAAA,QACV,UAAU,KAAK;AAAA,QACf,OAAO;AAAA,QACP,cAAc,CAAC;AAAA,MACjB;AAAA,IACF;AAAA,IACA,SAAS,IAAI,KAAK,GAAG;AAAA,IACrB,OAAO;AAAA,MACL,KAAK,KAAK;AAAA,MACV,UAAU,KAAK;AAAA,MACf,kBAAkB,KAAK;AAAA,MACvB,cAAc,MAAM,KAAK,KAAK,gBAAgB,CAAC,EAAE,IAAI,CAAC,SACpD,KAAK,OAAO,OAAO,CACrB;AAAA,IACF;AAAA;AAEJ;",
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGO,MAAM,aAAgB;AAAA,EACpB;AAAA,EACC,gBAAqC,IAAI;AAAA,EACzC,oBAAyC,IAAI;AAAA,EAC9C;AAAA,EACC,YAAqB;AAAA,EAE7B,WAAW,CAAC,KAAa;AAAA,IACvB,KAAK,MAAM;AAAA,IACX,KAAK,oBAAoB;AAAA,MACvB,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA;AAAA,EAGK,aAAa,CAAC,KAAqB;AAAA,IACxC,IAAI,KAAK,cAAc,IAAI,GAAG,GAAG;AAAA,MAC/B;AAAA,IACF;AAAA,IACA,KAAK,cAAc,IAAI,GAAG;AAAA;AAAA,MAGjB,iBAAiB,GAAG;AAAA,IAC7B,OACE,CAAC,KAAK,kBAAkB,WAAW,KAAK,aAAa,KACrD,KAAK,cAAc,SAAS,KAAK,kBAAkB;AAAA;AAAA,EAIhD,OAAO,GAAG;AAAA,IACf,IAAI,KAAK,WAAW,GAAG;AAAA,MACrB,KAAK,YAAY;AAAA,IACnB;AAAA;AAAA,EAGK,UAAU,GAAG;AAAA,IAClB,OACG,KAAK,iBAAyB,SAAS,yBACxC,CAAC,KAAK;AAAA;AAAA,MAIC,QAAQ,GAAG;AAAA,IACpB,OAAO,KAAK;AAAA;AAAA,MAGH,gBAAgB,GAAM;AAAA,IAC/B,OAAO,KAAK;AAAA;AAAA,EAGP,mBAAmB,CAAC,QAAW;AAAA,IACpC,KAAK,oBAAoB;AAAA;AAAA,EAGpB,sBAAsB,GAAG;AAAA,IAC9B,IAAI,KAAK,WAAW;AAAA,MAClB;AAAA,IACF;AAAA,IACA,KAAK,oBAAoB,IAAI,IAAI,KAAK,aAAa;AAAA,IACnD,KAAK,gBAAgB,IAAI;AAAA;AAAA,EAMpB,eAAe,GAAG;AAAA,IACvB,OAAO,KAAK;AAAA;AAAA,EAMP,kBAAkB,GAAG;AAAA,IAC1B,OAAO,KAAK,gBAAgB;AAAA;AAAA,EAMvB,uBAAuB,GAAuB;AAAA,IACnD,OAAO,IAAI;AAAA;AAAA,EAGb,MAAM,CAAC,UAAuB,IAAI,KAAY;AAAA,IAC5C,MAAM,aAAa,SAAS,IAAI,KAAK,GAAG;AAAA,IACxC,IAAI,YAAY;AAAA,MACd,OAAO;AAAA,QACL,KAAK,KAAK;AAAA,QACV,UAAU,KAAK;AAAA,QACf,OAAO;AAAA,QACP,cAAc,CAAC;AAAA,MACjB;AAAA,IACF;AAAA,IACA,SAAS,IAAI,KAAK,GAAG;AAAA,IACrB,OAAO;AAAA,MACL,KAAK,KAAK;AAAA,MACV,UAAU,KAAK;AAAA,MACf,kBAAkB,KAAK;AAAA,MACvB,cAAc,MAAM,KAAK,KAAK,gBAAgB,CAAC,EAAE,IAAI,CAAC,SACpD,KAAK,OAAO,OAAO,CACrB;AAAA,IACF;AAAA;AAEJ;",
   "debugId": "730E16EF65AFBFF564756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/dependency-nodes/cell-value-node.cjs

@@ -32,7 +32,7 @@ __export(exports_cell_value_node, {
   CellValueNode: () => CellValueNode
 });
 module.exports = __toCommonJS(exports_cell_value_node);
-var import_utils = require("src/core/utils");
+var import_utils = require("../../core/utils.cjs");
 var import_base_eval_node = require("./base-eval-node.cjs");
 
 class CellValueNode extends import_base_eval_node.BaseEvalNode {
@@ -51,4 +51,4 @@ class CellValueNode extends import_base_eval_node.BaseEvalNode {
   }
 }
 
-//# debugId=B4C45C0F9C22A36E64756E2164756E21
+//# debugId=A03B8D9FD71C213A64756E2164756E21

package/dist/cjs/evaluator/dependency-nodes/cell-value-node.cjs.map

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/evaluator/dependency-nodes/cell-value-node.ts"],
   "sourcesContent": [
-    "import type {\n  AwaitingEvaluationResult,\n  CellAddress,\n  ErrorEvaluationResult,\n  SingleEvaluationResult,\n  SpilledValuesEvaluationResult,\n} from \"src/core/types\";\nimport { getCellReference, keyToCellAddress } from \"src/core/utils\";\nimport { BaseEvalNode } from \"./base-eval-node.cjs\";\nimport type { SpillMetaNode } from \"./spill-meta-node.cjs\";\n\nexport class CellValueNode extends BaseEvalNode<SingleEvaluationResult> {\n  public readonly cellAddress: CellAddress;\n\n  constructor(key: string) {\n    const cellAddress = keyToCellAddress(key);\n    super(key);\n\n    this.cellAddress = cellAddress;\n  }\n\n  public override toString(): string {\n    return getCellReference(this.cellAddress);\n  }\n\n  spillMeta: SpillMetaNode | undefined;\n\n  setSpillMetaNode(node: SpillMetaNode) {\n    this.spillMeta = node;\n  }\n}\n"
+    "import type {\n  AwaitingEvaluationResult,\n  CellAddress,\n  ErrorEvaluationResult,\n  SingleEvaluationResult,\n  SpilledValuesEvaluationResult,\n} from \"../../core/types.cjs\";\nimport { getCellReference, keyToCellAddress } from \"../../core/utils.cjs\";\nimport { BaseEvalNode } from \"./base-eval-node.cjs\";\nimport type { SpillMetaNode } from \"./spill-meta-node.cjs\";\n\nexport class CellValueNode extends BaseEvalNode<SingleEvaluationResult> {\n  public readonly cellAddress: CellAddress;\n\n  constructor(key: string) {\n    const cellAddress = keyToCellAddress(key);\n    super(key);\n\n    this.cellAddress = cellAddress;\n  }\n\n  public override toString(): string {\n    return getCellReference(this.cellAddress);\n  }\n\n  spillMeta: SpillMetaNode | undefined;\n\n  setSpillMetaNode(node: SpillMetaNode) {\n    this.spillMeta = node;\n  }\n}\n"
   ],
   "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOmD,IAAnD;AAC6B,IAA7B;AAAA;AAGO,MAAM,sBAAsB,mCAAqC;AAAA,EACtD;AAAA,EAEhB,WAAW,CAAC,KAAa;AAAA,IACvB,MAAM,cAAc,8BAAiB,GAAG;AAAA,IACxC,MAAM,GAAG;AAAA,IAET,KAAK,cAAc;AAAA;AAAA,EAGL,QAAQ,GAAW;AAAA,IACjC,OAAO,8BAAiB,KAAK,WAAW;AAAA;AAAA,EAG1C;AAAA,EAEA,gBAAgB,CAAC,MAAqB;AAAA,IACpC,KAAK,YAAY;AAAA;AAErB;",
-  "debugId": "B4C45C0F9C22A36E64756E2164756E21",
+  "debugId": "A03B8D9FD71C213A64756E2164756E21",
   "names": []
 }

package/dist/cjs/evaluator/dependency-nodes/empty-cell-evaluation-node.cjs

@@ -32,8 +32,8 @@ __export(exports_empty_cell_evaluation_node, {
   EmptyCellEvaluationNode: () => EmptyCellEvaluationNode
 });
 module.exports = __toCommonJS(exports_empty_cell_evaluation_node);
-var import_frontier_dependency_manager = require("src/core/managers/frontier-dependency-manager");
-var import_utils = require("src/core/utils");
+var import_frontier_dependency_manager = require("../../core/managers/frontier-dependency-manager.cjs");
+var import_utils = require("../../core/utils.cjs");
 
 class EmptyCellEvaluationNode extends import_frontier_dependency_manager.FrontierDependencyManager {
   emptyCellKey;
@@ -105,4 +105,4 @@ class EmptyCellEvaluationNode extends import_frontier_dependency_manager.Frontie
   }
 }
 
-//# debugId=AF20722CA24C355764756E2164756E21
+//# debugId=6556C3EFCDECEA7164756E2164756E21