@ricsam/formula-engine 0.0.2 → 0.0.4

package/dist/mjs/evaluator/arithmetic/add/add.mjs

@@ -1,5 +1,5 @@
 // src/evaluator/arithmetic/add/add.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../../core/types.mjs";
 var add = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -49,4 +49,4 @@ export {
   add
 };
 
-//# debugId=57B591616CA184D264756E2164756E21
+//# debugId=401FA3E8F24F107664756E2164756E21

package/dist/mjs/evaluator/arithmetic/add/add.mjs.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.mjs\";\nimport { FormulaError } from \"../../../core/types.mjs\";\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": ";AACA;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,aAAa;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,aAAa;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,aAAa;AAAA,IAClB,SAAS,cAAc,KAAK,YAAY,MAAM;AAAA,IAC9C,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "57B591616CA184D264756E2164756E21",
+  "debugId": "401FA3E8F24F107664756E2164756E21",
   "names": []
 }

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

@@ -1,5 +1,5 @@
 // src/evaluator/arithmetic/divide/divide.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../../core/types.mjs";
 var divide = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -74,4 +74,4 @@ export {
   divide
 };
 
-//# debugId=3147263C3E0C663F64756E2164756E21
+//# debugId=8621814E1648C93A64756E2164756E21

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/arithmetic/multiply/multiply.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../../core/types.mjs";
 var multiply = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -60,4 +60,4 @@ export {
   multiply
 };
 
-//# debugId=E7E0C3547556EECC64756E2164756E21
+//# debugId=EA38E3D4111668F664756E2164756E21

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/arithmetic/power/power.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../../core/types.mjs";
 var power = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -92,4 +92,4 @@ export {
   power
 };
 
-//# debugId=73EB7E98B39E641064756E2164756E21
+//# debugId=4ED5745BD313697964756E2164756E21

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/arithmetic/subtract/subtract.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../../core/types.mjs";
 var subtract = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -51,4 +51,4 @@ export {
   subtract
 };
 
-//# debugId=34CCF9E55A81A93164756E2164756E21
+//# debugId=196553AFDCA5226964756E2164756E21

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

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/comparison/greater-than-or-equal.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../core/types.mjs";
 import { lessThan } from "./less-than.mjs";
 var greaterThanOrEqual = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
@@ -28,4 +28,4 @@ export {
   greaterThanOrEqual
 };
 
-//# debugId=9EE228EF14D03D4A64756E2164756E21
+//# debugId=A2F61B1B387F8A4364756E2164756E21

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/comparison/greater-than.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../core/types.mjs";
 import { lessThanOrEqual } from "./less-than-or-equal.mjs";
 var greaterThan = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
@@ -28,4 +28,4 @@ export {
   greaterThan
 };
 
-//# debugId=17D7656F1842B2D864756E2164756E21
+//# debugId=057838CDDA31538164756E2164756E21

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/comparison/less-than-or-equal.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../core/types.mjs";
 import { lessThan } from "./less-than.mjs";
 import { equals } from "./equals.mjs";
 var lessThanOrEqual = (left, right, context) => {
@@ -36,4 +36,4 @@ export {
   lessThanOrEqual
 };
 
-//# debugId=45ABC02E5249FA7264756E2164756E21
+//# debugId=D0F8BFAD47B2EC7F64756E2164756E21

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/comparison/less-than.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../core/types.mjs";
 var lessThan = (left, right, context) => {
   if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
     return {
@@ -35,4 +35,4 @@ export {
   lessThan
 };
 
-//# debugId=6D26981236A613EF64756E2164756E21
+//# debugId=0164935D7400CA1A64756E2164756E21

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

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

@@ -1,5 +1,5 @@
 // src/evaluator/comparison/not-equals.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../core/types.mjs";
 import { equals } from "./equals.mjs";
 var notEquals = (left, right, context) => {
   const equalsResult = equals(left, right, context);
@@ -20,4 +20,4 @@ export {
   notEquals
 };
 
-//# debugId=9A012BC6637AA0F864756E2164756E21
+//# debugId=81E223B9040DC7BA64756E2164756E21

package/dist/mjs/evaluator/comparison/not-equals.mjs.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.mjs\";\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.mjs\";\nimport { FormulaError } from \"../../core/types.mjs\";\nimport { equals } from \"./equals.mjs\";\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": ";AACA;AACA;AAMO,IAAM,YAAiC,CAAC,MAAM,OAAO,YAAY;AAAA,EACtE,MAAM,eAAe,OAAO,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,aAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
-  "debugId": "9A012BC6637AA0F864756E2164756E21",
+  "debugId": "81E223B9040DC7BA64756E2164756E21",
   "names": []
 }

package/dist/mjs/evaluator/concatenation/concatenate.mjs

@@ -1,5 +1,5 @@
 // src/evaluator/concatenation/concatenate.ts
-import { FormulaError } from "src/core/types";
+import { FormulaError } from "../../core/types.mjs";
 var concatenate = (left, right, context) => {
   let leftStr;
   let rightStr;
@@ -39,4 +39,4 @@ export {
   concatenate
 };
 
-//# debugId=C41F339E88A3533764756E2164756E21
+//# debugId=26D4A8D188AC33A064756E2164756E21

package/dist/mjs/evaluator/concatenation/concatenate.mjs.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.mjs\";\nimport { FormulaError } from \"../../core/types.mjs\";\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": ";AACA;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,aAAa;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,aAAa;AAAA,QAClB,SAAS,sBAAsB,MAAM;AAAA,QACrC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAGJ,OAAO,EAAE,MAAM,UAAU,OAAO,UAAU,SAAS;AAAA;",
-  "debugId": "C41F339E88A3533764756E2164756E21",
+  "debugId": "26D4A8D188AC33A064756E2164756E21",
   "names": []
 }

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

@@ -1,5 +1,5 @@
 // src/evaluator/dependency-nodes/ast-evaluation-node.ts
-import { astToString } from "src/parser/formatter";
+import { astToString } from "../../parser/formatter.mjs";
 import { BaseEvalNode } from "./base-eval-node.mjs";
 
 class AstEvaluationNode extends BaseEvalNode {
@@ -25,4 +25,4 @@ export {
   AstEvaluationNode
 };
 
-//# debugId=72758B35AE24D18964756E2164756E21
+//# debugId=DF2C97E3765B0A0664756E2164756E21

package/dist/mjs/evaluator/dependency-nodes/ast-evaluation-node.mjs.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.mjs\";\nimport { BaseEvalNode } from \"./base-eval-node.mjs\";\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.mjs\";\nimport type { ASTNode } from \"../../parser/ast.mjs\";\nimport { astToString } from \"../../parser/formatter.mjs\";\nimport type { ContextDependency } from \"../evaluation-context.mjs\";\nimport { BaseEvalNode } from \"./base-eval-node.mjs\";\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": ";AAEA;AAEA;AAAA;AAEO,MAAM,0BAA0B,aAAuC;AAAA,EAGnE;AAAA,EAFD;AAAA,EACR,WAAW,CACF,KACP,mBACA;AAAA,IACA,MAAM,MAAM,OAAO,YAAY,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": "72758B35AE24D18964756E2164756E21",
+  "debugId": "DF2C97E3765B0A0664756E2164756E21",
   "names": []
 }

package/dist/mjs/evaluator/dependency-nodes/base-eval-node.mjs.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.mjs\";\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.mjs\";\nimport type { SpillMetaNode } from \"./spill-meta-node.mjs\";\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": "7D7A4F1893384B5164756E2164756E21",
   "names": []
 }

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

@@ -1,5 +1,5 @@
 // src/evaluator/dependency-nodes/cell-value-node.ts
-import { getCellReference, keyToCellAddress } from "src/core/utils";
+import { getCellReference, keyToCellAddress } from "../../core/utils.mjs";
 import { BaseEvalNode } from "./base-eval-node.mjs";
 
 class CellValueNode extends BaseEvalNode {
@@ -21,4 +21,4 @@ export {
   CellValueNode
 };
 
-//# debugId=D70C954EBA7519EF64756E2164756E21
+//# debugId=9E60FD247839AAE964756E2164756E21

package/dist/mjs/evaluator/dependency-nodes/cell-value-node.mjs.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.mjs\";\nimport type { SpillMetaNode } from \"./spill-meta-node.mjs\";\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.mjs\";\nimport { getCellReference, keyToCellAddress } from \"../../core/utils.mjs\";\nimport { BaseEvalNode } from \"./base-eval-node.mjs\";\nimport type { SpillMetaNode } from \"./spill-meta-node.mjs\";\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": ";AAOA;AACA;AAAA;AAGO,MAAM,sBAAsB,aAAqC;AAAA,EACtD;AAAA,EAEhB,WAAW,CAAC,KAAa;AAAA,IACvB,MAAM,cAAc,iBAAiB,GAAG;AAAA,IACxC,MAAM,GAAG;AAAA,IAET,KAAK,cAAc;AAAA;AAAA,EAGL,QAAQ,GAAW;AAAA,IACjC,OAAO,iBAAiB,KAAK,WAAW;AAAA;AAAA,EAG1C;AAAA,EAEA,gBAAgB,CAAC,MAAqB;AAAA,IACpC,KAAK,YAAY;AAAA;AAErB;",
-  "debugId": "D70C954EBA7519EF64756E2164756E21",
+  "debugId": "9E60FD247839AAE964756E2164756E21",
   "names": []
 }

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

@@ -1,6 +1,6 @@
 // src/evaluator/dependency-nodes/empty-cell-evaluation-node.ts
-import { FrontierDependencyManager } from "src/core/managers/frontier-dependency-manager";
-import { getCellReference, keyToCellAddress } from "src/core/utils";
+import { FrontierDependencyManager } from "../../core/managers/frontier-dependency-manager.mjs";
+import { getCellReference, keyToCellAddress } from "../../core/utils.mjs";
 
 class EmptyCellEvaluationNode extends FrontierDependencyManager {
   emptyCellKey;
@@ -75,4 +75,4 @@ export {
   EmptyCellEvaluationNode
 };
 
-//# debugId=E999CDF7A08C7F3A64756E2164756E21
+//# debugId=ED6EA7BCEB16F2A764756E2164756E21

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

@@ -2,9 +2,9 @@
   "version": 3,
   "sources": ["../../../../src/evaluator/dependency-nodes/empty-cell-evaluation-node.ts"],
   "sourcesContent": [
-    "import type { DependencyManager } from \"src/core/managers/dependency-manager\";\nimport { FrontierDependencyManager } from \"src/core/managers/frontier-dependency-manager\";\nimport type { WorkbookManager } from \"src/core/managers/workbook-manager\";\nimport type {\n  CellAddress,\n  RangeAddress,\n  SingleEvaluationResult,\n} from \"src/core/types\";\nimport { getCellReference, keyToCellAddress } from \"src/core/utils\";\n\nexport class EmptyCellEvaluationNode extends FrontierDependencyManager {\n  public key: string;\n  public cellAddress: CellAddress;\n  private _evaluationResult: SingleEvaluationResult;\n\n  constructor(\n    public emptyCellKey: string,\n    evaluationManager: DependencyManager,\n    workbookManager: WorkbookManager\n  ) {\n    const cellAddress = keyToCellAddress(emptyCellKey);\n    const emptyCellRange: RangeAddress = {\n      range: {\n        start: {\n          col: cellAddress.colIndex,\n          row: cellAddress.rowIndex,\n        },\n        end: {\n          col: { type: \"number\", value: cellAddress.colIndex },\n          row: { type: \"number\", value: cellAddress.rowIndex },\n        },\n      },\n      sheetName: cellAddress.sheetName,\n      workbookName: cellAddress.workbookName,\n    };\n\n    super(emptyCellRange, workbookManager, evaluationManager);\n\n    this.cellAddress = cellAddress;\n    this.key = emptyCellKey.replace(/^cell:/, \"empty:\");\n    this._evaluationResult = {\n      type: \"awaiting-evaluation\",\n      waitingFor: this,\n      errAddress: this,\n    };\n  }\n\n  public setEvaluationResult(result: SingleEvaluationResult) {\n    this._evaluationResult = result;\n  }\n\n  public get evaluationResult(): SingleEvaluationResult {\n    return this._evaluationResult;\n  }\n\n  public override resolve() {\n    if (this.canResolve()) {\n      super.resolve();\n    }\n  }\n\n  public override canResolve() {\n    return (\n      super.canResolve() && this.evaluationResult.type !== \"awaiting-evaluation\"\n    );\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        frontierDependencies: [],\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      frontierDependencies: Array.from(this.getFrontierDependencies()).map(\n        (node) => node.toJSON(visitor)\n      ),\n    };\n  }\n\n  public override toString(): string {\n    return getCellReference(this.cellAddress);\n  }\n}\n"
+    "import type { DependencyManager } from \"../../core/managers/dependency-manager.mjs\";\nimport { FrontierDependencyManager } from \"../../core/managers/frontier-dependency-manager.mjs\";\nimport type { WorkbookManager } from \"../../core/managers/workbook-manager.mjs\";\nimport type {\n  CellAddress,\n  RangeAddress,\n  SingleEvaluationResult,\n} from \"../../core/types.mjs\";\nimport { getCellReference, keyToCellAddress } from \"../../core/utils.mjs\";\n\nexport class EmptyCellEvaluationNode extends FrontierDependencyManager {\n  public key: string;\n  public cellAddress: CellAddress;\n  private _evaluationResult: SingleEvaluationResult;\n\n  constructor(\n    public emptyCellKey: string,\n    evaluationManager: DependencyManager,\n    workbookManager: WorkbookManager\n  ) {\n    const cellAddress = keyToCellAddress(emptyCellKey);\n    const emptyCellRange: RangeAddress = {\n      range: {\n        start: {\n          col: cellAddress.colIndex,\n          row: cellAddress.rowIndex,\n        },\n        end: {\n          col: { type: \"number\", value: cellAddress.colIndex },\n          row: { type: \"number\", value: cellAddress.rowIndex },\n        },\n      },\n      sheetName: cellAddress.sheetName,\n      workbookName: cellAddress.workbookName,\n    };\n\n    super(emptyCellRange, workbookManager, evaluationManager);\n\n    this.cellAddress = cellAddress;\n    this.key = emptyCellKey.replace(/^cell:/, \"empty:\");\n    this._evaluationResult = {\n      type: \"awaiting-evaluation\",\n      waitingFor: this,\n      errAddress: this,\n    };\n  }\n\n  public setEvaluationResult(result: SingleEvaluationResult) {\n    this._evaluationResult = result;\n  }\n\n  public get evaluationResult(): SingleEvaluationResult {\n    return this._evaluationResult;\n  }\n\n  public override resolve() {\n    if (this.canResolve()) {\n      super.resolve();\n    }\n  }\n\n  public override canResolve() {\n    return (\n      super.canResolve() && this.evaluationResult.type !== \"awaiting-evaluation\"\n    );\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        frontierDependencies: [],\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      frontierDependencies: Array.from(this.getFrontierDependencies()).map(\n        (node) => node.toJSON(visitor)\n      ),\n    };\n  }\n\n  public override toString(): string {\n    return getCellReference(this.cellAddress);\n  }\n}\n"
   ],
   "mappings": ";AACA;AAOA;AAAA;AAEO,MAAM,gCAAgC,0BAA0B;AAAA,EAM5D;AAAA,EALF;AAAA,EACA;AAAA,EACC;AAAA,EAER,WAAW,CACF,cACP,mBACA,iBACA;AAAA,IACA,MAAM,cAAc,iBAAiB,YAAY;AAAA,IACjD,MAAM,iBAA+B;AAAA,MACnC,OAAO;AAAA,QACL,OAAO;AAAA,UACL,KAAK,YAAY;AAAA,UACjB,KAAK,YAAY;AAAA,QACnB;AAAA,QACA,KAAK;AAAA,UACH,KAAK,EAAE,MAAM,UAAU,OAAO,YAAY,SAAS;AAAA,UACnD,KAAK,EAAE,MAAM,UAAU,OAAO,YAAY,SAAS;AAAA,QACrD;AAAA,MACF;AAAA,MACA,WAAW,YAAY;AAAA,MACvB,cAAc,YAAY;AAAA,IAC5B;AAAA,IAEA,MAAM,gBAAgB,iBAAiB,iBAAiB;AAAA,IApBjD;AAAA,IAsBP,KAAK,cAAc;AAAA,IACnB,KAAK,MAAM,aAAa,QAAQ,UAAU,QAAQ;AAAA,IAClD,KAAK,oBAAoB;AAAA,MACvB,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA;AAAA,EAGK,mBAAmB,CAAC,QAAgC;AAAA,IACzD,KAAK,oBAAoB;AAAA;AAAA,MAGhB,gBAAgB,GAA2B;AAAA,IACpD,OAAO,KAAK;AAAA;AAAA,EAGE,OAAO,GAAG;AAAA,IACxB,IAAI,KAAK,WAAW,GAAG;AAAA,MACrB,MAAM,QAAQ;AAAA,IAChB;AAAA;AAAA,EAGc,UAAU,GAAG;AAAA,IAC3B,OACE,MAAM,WAAW,KAAK,KAAK,iBAAiB,SAAS;AAAA;AAAA,EAIzD,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,QACf,sBAAsB,CAAC;AAAA,MACzB;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,MACA,sBAAsB,MAAM,KAAK,KAAK,wBAAwB,CAAC,EAAE,IAC/D,CAAC,SAAS,KAAK,OAAO,OAAO,CAC/B;AAAA,IACF;AAAA;AAAA,EAGc,QAAQ,GAAW;AAAA,IACjC,OAAO,iBAAiB,KAAK,WAAW;AAAA;AAE5C;",
-  "debugId": "E999CDF7A08C7F3A64756E2164756E21",
+  "debugId": "ED6EA7BCEB16F2A764756E2164756E21",
   "names": []
 }