@ricsam/formula-engine 0.0.1

package/dist/cjs/core/workbook-renamer.cjs

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/core/workbook-renamer.ts
+var exports_workbook_renamer = {};
+__export(exports_workbook_renamer, {
+  renameWorkbookInFormula: () => renameWorkbookInFormula,
+  getReferencedWorkbookNames: () => getReferencedWorkbookNames,
+  formulaReferencesWorkbook: () => formulaReferencesWorkbook
+});
+module.exports = __toCommonJS(exports_workbook_renamer);
+var import_parser = require("../parser/parser.cjs");
+var import_formatter = require("../parser/formatter.cjs");
+var import_ast_traverser = require("./ast-traverser.cjs");
+function renameWorkbookInFormula(options) {
+  const { formula, oldWorkbookName, newWorkbookName } = options;
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const updatedAst = import_ast_traverser.transformAST(ast, (node) => {
+      if (node.type === "reference" && node.workbookName === oldWorkbookName) {
+        return {
+          ...node,
+          workbookName: newWorkbookName
+        };
+      }
+      if (node.type === "range" && node.workbookName === oldWorkbookName) {
+        return {
+          ...node,
+          workbookName: newWorkbookName
+        };
+      }
+      if (node.type === "named-expression" && node.workbookName === oldWorkbookName) {
+        return {
+          ...node,
+          workbookName: newWorkbookName
+        };
+      }
+      if (node.type === "structured-reference" && node.workbookName === oldWorkbookName) {
+        return {
+          ...node,
+          workbookName: newWorkbookName
+        };
+      }
+      if (node.type === "3d-range" && node.workbookName === oldWorkbookName) {
+        return {
+          ...node,
+          workbookName: newWorkbookName
+        };
+      }
+      return node;
+    });
+    return import_formatter.astToString(updatedAst);
+  } catch (error) {
+    return formula;
+  }
+}
+function formulaReferencesWorkbook(formula, workbookName) {
+  try {
+    const referencedWorkbooks = getReferencedWorkbookNames(formula);
+    return referencedWorkbooks.includes(workbookName);
+  } catch (error) {
+    return false;
+  }
+}
+function getReferencedWorkbookNames(formula) {
+  try {
+    const ast = import_parser.parseFormula(formula);
+    const workbookNames = new Set;
+    import_ast_traverser.transformAST(ast, (node) => {
+      if ((node.type === "reference" || node.type === "range" || node.type === "named-expression" || node.type === "structured-reference" || node.type === "3d-range") && node.workbookName) {
+        workbookNames.add(node.workbookName);
+      }
+      return node;
+    });
+    return Array.from(workbookNames);
+  } catch (error) {
+    return [];
+  }
+}
+
+//# debugId=49B5AEEF2A38001E64756E2164756E21

package/dist/cjs/core/workbook-renamer.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/core/workbook-renamer.ts"],
+  "sourcesContent": [
+    "/**\n * Workbook renamer utility for updating cross-workbook references in formulas\n */\n\nimport { parseFormula } from \"../parser/parser.cjs\";\nimport { astToString } from \"../parser/formatter.cjs\";\nimport { transformAST } from \"./ast-traverser.cjs\";\nimport type { ASTNode } from \"../parser/ast.cjs\";\n\n/**\n * Renames workbook references in a formula string\n * @param formula The formula string (without the leading =)\n * @param oldWorkbookName The old workbook name to replace\n * @param newWorkbookName The new workbook name to use\n * @returns The updated formula string\n */\nexport function renameWorkbookInFormula(options: {\n  formula: string;\n  oldWorkbookName: string;\n  newWorkbookName: string;\n}): string {\n  const { formula, oldWorkbookName, newWorkbookName } = options;\n  try {\n    const ast = parseFormula(formula);\n    \n    const updatedAst = transformAST(ast, (node) => {\n      // Handle cross-workbook references (e.g., [MyWorkbook]Sheet1!A1)\n      if (node.type === \"reference\" && node.workbookName === oldWorkbookName) {\n        return {\n          ...node,\n          workbookName: newWorkbookName,\n        };\n      }\n      \n      // Handle range references with workbook names (e.g., [MyWorkbook]Sheet1!A1:B2)\n      if (node.type === \"range\" && node.workbookName === oldWorkbookName) {\n        return {\n          ...node,\n          workbookName: newWorkbookName,\n        };\n      }\n      \n      // Handle named expressions with workbook names\n      if (node.type === \"named-expression\" && node.workbookName === oldWorkbookName) {\n        return {\n          ...node,\n          workbookName: newWorkbookName,\n        };\n      }\n      \n      // Handle structured references with workbook names (e.g., [MyWorkbook]Sheet1!Table1[Column1])\n      if (node.type === \"structured-reference\" && node.workbookName === oldWorkbookName) {\n        return {\n          ...node,\n          workbookName: newWorkbookName,\n        };\n      }\n      \n      // Handle 3D ranges with workbook names (e.g., [MyWorkbook]Sheet1:Sheet3!A1:C5)\n      if (node.type === \"3d-range\" && node.workbookName === oldWorkbookName) {\n        return {\n          ...node,\n          workbookName: newWorkbookName,\n        };\n      }\n      \n      return node;\n    });\n    \n    return astToString(updatedAst);\n  } catch (error) {\n    // If parsing fails, return the original formula\n    return formula;\n  }\n}\n\n/**\n * Checks if a formula references a specific workbook\n * @param formula The formula string (without the leading =)\n * @param workbookName The workbook name to check for\n * @returns True if the formula references the workbook\n */\nexport function formulaReferencesWorkbook(formula: string, workbookName: string): boolean {\n  try {\n    const referencedWorkbooks = getReferencedWorkbookNames(formula);\n    return referencedWorkbooks.includes(workbookName);\n  } catch (error) {\n    // If parsing fails, assume no reference\n    return false;\n  }\n}\n\n/**\n * Gets all workbook names referenced in a formula\n * @param formula The formula string (without the leading =)\n * @returns Array of unique workbook names referenced in the formula\n */\nexport function getReferencedWorkbookNames(formula: string): string[] {\n  try {\n    const ast = parseFormula(formula);\n    const workbookNames = new Set<string>();\n\n    transformAST(ast, (node) => {\n      // Handle cross-workbook references\n      if ((node.type === \"reference\" || \n           node.type === \"range\" || \n           node.type === \"named-expression\" || \n           node.type === \"structured-reference\" ||\n           node.type === \"3d-range\") && \n          node.workbookName) {\n        workbookNames.add(node.workbookName);\n      }\n      \n      return node;\n    });\n\n    return Array.from(workbookNames);\n  } catch (error) {\n    // If parsing fails, return empty array\n    return [];\n  }\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI6B,IAA7B;AAC4B,IAA5B;AAC6B,IAA7B;AAUO,SAAS,uBAAuB,CAAC,SAI7B;AAAA,EACT,QAAQ,SAAS,iBAAiB,oBAAoB;AAAA,EACtD,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAEhC,MAAM,aAAa,kCAAa,KAAK,CAAC,SAAS;AAAA,MAE7C,IAAI,KAAK,SAAS,eAAe,KAAK,iBAAiB,iBAAiB;AAAA,QACtE,OAAO;AAAA,aACF;AAAA,UACH,cAAc;AAAA,QAChB;AAAA,MACF;AAAA,MAGA,IAAI,KAAK,SAAS,WAAW,KAAK,iBAAiB,iBAAiB;AAAA,QAClE,OAAO;AAAA,aACF;AAAA,UACH,cAAc;AAAA,QAChB;AAAA,MACF;AAAA,MAGA,IAAI,KAAK,SAAS,sBAAsB,KAAK,iBAAiB,iBAAiB;AAAA,QAC7E,OAAO;AAAA,aACF;AAAA,UACH,cAAc;AAAA,QAChB;AAAA,MACF;AAAA,MAGA,IAAI,KAAK,SAAS,0BAA0B,KAAK,iBAAiB,iBAAiB;AAAA,QACjF,OAAO;AAAA,aACF;AAAA,UACH,cAAc;AAAA,QAChB;AAAA,MACF;AAAA,MAGA,IAAI,KAAK,SAAS,cAAc,KAAK,iBAAiB,iBAAiB;AAAA,QACrE,OAAO;AAAA,aACF;AAAA,UACH,cAAc;AAAA,QAChB;AAAA,MACF;AAAA,MAEA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,6BAAY,UAAU;AAAA,IAC7B,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AAUJ,SAAS,yBAAyB,CAAC,SAAiB,cAA+B;AAAA,EACxF,IAAI;AAAA,IACF,MAAM,sBAAsB,2BAA2B,OAAO;AAAA,IAC9D,OAAO,oBAAoB,SAAS,YAAY;AAAA,IAChD,OAAO,OAAO;AAAA,IAEd,OAAO;AAAA;AAAA;AASJ,SAAS,0BAA0B,CAAC,SAA2B;AAAA,EACpE,IAAI;AAAA,IACF,MAAM,MAAM,2BAAa,OAAO;AAAA,IAChC,MAAM,gBAAgB,IAAI;AAAA,IAE1B,kCAAa,KAAK,CAAC,SAAS;AAAA,MAE1B,KAAK,KAAK,SAAS,eACd,KAAK,SAAS,WACd,KAAK,SAAS,sBACd,KAAK,SAAS,0BACd,KAAK,SAAS,eACf,KAAK,cAAc;AAAA,QACrB,cAAc,IAAI,KAAK,YAAY;AAAA,MACrC;AAAA,MAEA,OAAO;AAAA,KACR;AAAA,IAED,OAAO,MAAM,KAAK,aAAa;AAAA,IAC/B,OAAO,OAAO;AAAA,IAEd,OAAO,CAAC;AAAA;AAAA;",
+  "debugId": "49B5AEEF2A38001E64756E2164756E21",
+  "names": []
+}

package/dist/cjs/debug/flags.cjs

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/debug/flags.ts
+var exports_flags = {};
+__export(exports_flags, {
+  flags: () => flags
+});
+module.exports = __toCommonJS(exports_flags);
+var PROFILED_CALL = 943;
+var MAX_EVALUATION_CALLS = PROFILED_CALL + 1;
+var flags = {
+  isProfiling: false,
+  stopEvaluation: false,
+  profilingNamespaces: {},
+  numEvaluationCalls: 0,
+  profiledCall: PROFILED_CALL,
+  maxEvaluationCalls: MAX_EVALUATION_CALLS,
+  prevSize: 0
+};
+
+//# debugId=3D5BE1A46AB2F1FF64756E2164756E21

package/dist/cjs/debug/flags.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/debug/flags.ts"],
+  "sourcesContent": [
+    "type DebugFlags = {\n  isProfiling: boolean;\n  stopEvaluation: boolean;\n  profilingNamespaces: Record<string, boolean>;\n  numEvaluationCalls: number;\n  profiledCall: number;\n  maxEvaluationCalls: number;\n  prevSize: number;\n};\n\nconst PROFILED_CALL = 943;\nconst MAX_EVALUATION_CALLS = PROFILED_CALL + 1;\n\nexport const flags: DebugFlags = {\n  isProfiling: false,\n  stopEvaluation: false,\n  profilingNamespaces: {},\n  numEvaluationCalls: 0,\n  profiledCall: PROFILED_CALL,\n  maxEvaluationCalls: MAX_EVALUATION_CALLS,\n  prevSize: 0,\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUA,IAAM,gBAAgB;AACtB,IAAM,uBAAuB,gBAAgB;AAEtC,IAAM,QAAoB;AAAA,EAC/B,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,qBAAqB,CAAC;AAAA,EACtB,oBAAoB;AAAA,EACpB,cAAc;AAAA,EACd,oBAAoB;AAAA,EACpB,UAAU;AACZ;",
+  "debugId": "3D5BE1A46AB2F1FF64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/arithmetic/add/add.ts
+var exports_add = {};
+__export(exports_add, {
+  add: () => add
+});
+module.exports = __toCommonJS(exports_add);
+var import_types = require("src/core/types");
+var add = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `Cannot add ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "infinity") {
+      if (left.sign === right.sign) {
+        return { type: "infinity", sign: left.sign };
+      } else {
+        return {
+          type: "error",
+          err: import_types.FormulaError.NUM,
+          message: "Cannot add positive and negative infinity",
+          errAddress: context.dependencyNode
+        };
+      }
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      return { type: "infinity", sign: left.sign };
+    } else if (right.type === "infinity" && left.type === "number") {
+      return { type: "infinity", sign: right.sign };
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    const result = left.value + right.value;
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.VALUE,
+    message: `Cannot add ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=9EE8E477C2D2AFC864756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "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"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC6B,IAA7B;AAEO,IAAM,MAA2B,CAAC,MAAM,OAAO,YAAY;AAAA,EAEhE,IACG,KAAK,SAAS,YAAY,KAAK,SAAS,cACxC,MAAM,SAAS,YAAY,MAAM,SAAS,YAC3C;AAAA,IACA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS,cAAc,KAAK,YAAY,MAAM;AAAA,MAC9C,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,IAEzD,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,YAAY;AAAA,MACzD,IAAI,KAAK,SAAS,MAAM,MAAM;AAAA,QAE5B,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA,MAC7C,EAAO;AAAA,QAEL,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA;AAAA,IAEJ;AAAA,IAGA,IAAI,KAAK,SAAS,cAAc,MAAM,SAAS,UAAU;AAAA,MACvD,OAAO,EAAE,MAAM,YAAY,MAAM,KAAK,KAAK;AAAA,IAC7C,EAAO,SAAI,MAAM,SAAS,cAAc,KAAK,SAAS,UAAU;AAAA,MAC9D,OAAO,EAAE,MAAM,YAAY,MAAM,MAAM,KAAK;AAAA,IAC9C;AAAA,EACF;AAAA,EAGA,IAAI,KAAK,SAAS,YAAY,MAAM,SAAS,UAAU;AAAA,IACrD,MAAM,SAAS,KAAK,QAAQ,MAAM;AAAA,IAGlC,IAAI,WAAW,UAAU;AAAA,MACvB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IACA,IAAI,WAAW,WAAW;AAAA,MACxB,OAAO,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,IAC9C;AAAA,IAEA,OAAO,EAAE,MAAM,UAAU,OAAO,OAAO;AAAA,EACzC;AAAA,EAGA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,0BAAa;AAAA,IAClB,SAAS,cAAc,KAAK,YAAY,MAAM;AAAA,IAC9C,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "9EE8E477C2D2AFC864756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/arithmetic/divide/divide.ts
+var exports_divide = {};
+__export(exports_divide, {
+  divide: () => divide
+});
+module.exports = __toCommonJS(exports_divide);
+var import_types = require("src/core/types");
+var divide = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `Cannot divide ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "infinity") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.NUM,
+        message: "Cannot divide infinity by infinity",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      if (right.value === 0) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.NUM,
+          message: "Cannot divide infinity by zero",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (right.value > 0) {
+        return { type: "infinity", sign: left.sign };
+      } else {
+        const resultSign = left.sign === "positive" ? "negative" : "positive";
+        return { type: "infinity", sign: resultSign };
+      }
+    }
+    if (left.type === "number" && right.type === "infinity") {
+      return { type: "number", value: 0 };
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    if (right.value === 0) {
+      if (left.value === 0) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.NUM,
+          message: "0 / 0 is undefined",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (left.value > 0) {
+        return { type: "infinity", sign: "positive" };
+      } else {
+        return { type: "infinity", sign: "negative" };
+      }
+    }
+    const result = left.value / right.value;
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.VALUE,
+    message: `Cannot divide ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=B609DB91D7F80EE764756E2164756E21

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

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

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

@@ -0,0 +1,93 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/arithmetic/multiply/multiply.ts
+var exports_multiply = {};
+__export(exports_multiply, {
+  multiply: () => multiply
+});
+module.exports = __toCommonJS(exports_multiply);
+var import_types = require("src/core/types");
+var multiply = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `Cannot multiply ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "number" && right.value === 0 || left.type === "number" && left.value === 0 && right.type === "infinity") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.NUM,
+        message: "Cannot multiply infinity by zero",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (left.type === "infinity" && right.type === "infinity") {
+      const resultSign = left.sign === right.sign ? "positive" : "negative";
+      return { type: "infinity", sign: resultSign };
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      if (right.value > 0) {
+        return { type: "infinity", sign: left.sign };
+      } else if (right.value < 0) {
+        const resultSign = left.sign === "positive" ? "negative" : "positive";
+        return { type: "infinity", sign: resultSign };
+      }
+    }
+    if (left.type === "number" && right.type === "infinity") {
+      if (left.value > 0) {
+        return { type: "infinity", sign: right.sign };
+      } else if (left.value < 0) {
+        const resultSign = right.sign === "positive" ? "negative" : "positive";
+        return { type: "infinity", sign: resultSign };
+      }
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    const result = left.value * right.value;
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.VALUE,
+    message: `Cannot multiply ${left.type} and ${right.type} /2`,
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=585A61464147AE4264756E2164756E21

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

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

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

@@ -0,0 +1,125 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/evaluator/arithmetic/power/power.ts
+var exports_power = {};
+__export(exports_power, {
+  power: () => power
+});
+module.exports = __toCommonJS(exports_power);
+var import_types = require("src/core/types");
+var power = (left, right, context) => {
+  if (left.type !== "number" && left.type !== "infinity" || right.type !== "number" && right.type !== "infinity") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: `Cannot exponentiate ${left.type} and ${right.type}`,
+      errAddress: context.dependencyNode
+    };
+  }
+  if (left.type === "infinity" || right.type === "infinity") {
+    if (left.type === "infinity" && right.type === "infinity") {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (left.type === "infinity" && right.type === "number") {
+      if (right.value === 0) {
+        return { type: "number", value: 1 };
+      }
+      if (right.value > 0) {
+        if (left.sign === "positive") {
+          return { type: "infinity", sign: "positive" };
+        } else {
+          if (Number.isInteger(right.value)) {
+            const isEven = right.value % 2 === 0;
+            return { type: "infinity", sign: isEven ? "positive" : "negative" };
+          } else {
+            return {
+              type: "error",
+              err: import_types.FormulaError.NUM,
+              message: "Cannot raise negative infinity to non-integer power",
+              errAddress: context.dependencyNode
+            };
+          }
+        }
+      } else {
+        return { type: "number", value: 0 };
+      }
+    }
+    if (left.type === "number" && right.type === "infinity") {
+      const absBase = Math.abs(left.value);
+      if (absBase === 1) {
+        return { type: "number", value: 1 };
+      }
+      if (absBase > 1) {
+        if (right.sign === "positive") {
+          return { type: "infinity", sign: "positive" };
+        } else {
+          return { type: "number", value: 0 };
+        }
+      } else {
+        if (right.sign === "positive") {
+          return { type: "number", value: 0 };
+        } else {
+          return { type: "infinity", sign: "positive" };
+        }
+      }
+    }
+  }
+  if (left.type === "number" && right.type === "number") {
+    if (left.value === 0 && right.value === 0) {
+      return { type: "number", value: 1 };
+    }
+    if (left.value === 0 && right.value < 0) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (left.value < 0 && !Number.isInteger(right.value)) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.NUM,
+        message: "Cannot raise negative number to non-integer power",
+        errAddress: context.dependencyNode
+      };
+    }
+    const result = Math.pow(left.value, right.value);
+    if (result === Infinity) {
+      return { type: "infinity", sign: "positive" };
+    }
+    if (result === -Infinity) {
+      return { type: "infinity", sign: "negative" };
+    }
+    return { type: "number", value: result };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.VALUE,
+    message: `Cannot exponentiate ${left.type} and ${right.type}`,
+    errAddress: context.dependencyNode
+  };
+};
+
+//# debugId=73FDE97BE41666D364756E2164756E21