@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/math/sum/sumif.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/sum/sumif.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport {\n  processMultiCriteriaValues,\n  validateSingleCriteriaArgs,\n} from \"../../criteria-utils.cjs\";\nimport { parseCriteria, matchesParsedCriteria } from \"../../criteria-parser.cjs\";\nimport { performSummation } from \"./summation-utils.cjs\";\n\n/**\n * SUMIF function - Sums cells in a range that meet a criteria\n *\n * Usage: SUMIF(range, criteria, [sum_range])\n *\n * range: The range of cells to evaluate against the criteria\n * criteria: The criteria to match against. Can be:\n *   - Exact value: \"Apple\", 42\n *   - Comparison: \">10\", \"<=5\", \"<>0\"\n *   - Wildcards: \"App*\", \"?ruit\"\n * sum_range: Optional. The range to sum. If omitted, uses the range parameter\n *\n * Examples:\n *   SUMIF(A1:A10, \"Apple\") - sums cells in A1:A10 that contain \"Apple\"\n *   SUMIF(B1:B10, \">10\") - sums cells in B1:B10 with values greater than 10\n *   SUMIF(A1:A10, \"Apple\", B1:B10) - sums B1:B10 where A1:A10 contains \"Apple\"\n *\n * Note:\n * - Only numeric values are included in the sum\n * - Returns 0 if no values match the criteria\n */\nexport const SUMIF: FunctionDefinition = {\n  name: \"SUMIF\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments\n    const argError = validateSingleCriteriaArgs(\"SUMIF\", node.args.length, context);\n    if (argError) {\n      return argError;\n    }\n\n    // Evaluate criteria range (first argument)\n    const criteriaRangeResult = this.evaluateNode(node.args[0]!, context);\n    if (criteriaRangeResult.type === \"error\") {\n      return criteriaRangeResult;\n    }\n\n    // Evaluate criteria (second argument)\n    const criteriaResult = this.evaluateNode(node.args[1]!, context);\n    if (criteriaResult.type === \"error\") {\n      return criteriaResult;\n    }\n\n    if (criteriaResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"SUMIF criteria must be a single value\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Parse criteria\n    const parsedCriteria = parseCriteria(criteriaResult.result);\n    if (parsedCriteria.type === \"error\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: parsedCriteria.message,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Determine sum range (third argument if present, otherwise same as criteria range)\n    const sumRangeResult =\n      node.args.length === 3\n        ? this.evaluateNode(node.args[2]!, context)\n        : criteriaRangeResult;\n\n    if (sumRangeResult.type === \"error\") {\n      return sumRangeResult;\n    }\n\n    // Use shared summation utility\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      sumRangeResult,\n      [{ rangeResult: criteriaRangeResult, parsedCriteria }],\n      context,\n      \"col-major\"\n    );\n\n    if (matchingValues.type === \"error\" || matchingValues.type === \"awaiting-evaluation\") {\n      return matchingValues;\n    }\n\n    return performSummation(matchingValues.values);\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AASO,IAHP;AAIqD,IAArD;AACiC,IAAjC;AAuBO,IAAM,QAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,iDAA2B,SAAS,KAAK,KAAK,QAAQ,OAAO;AAAA,IAC9E,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IACpE,IAAI,oBAAoB,SAAS,SAAS;AAAA,MACxC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,iBAAiB,qCAAc,eAAe,MAAM;AAAA,IAC1D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,eAAe;AAAA,QACxB,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,iBACJ,KAAK,KAAK,WAAW,IACjB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO,IACxC;AAAA,IAEN,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,iDACrB,MACA,gBACA,CAAC,EAAE,aAAa,qBAAqB,eAAe,CAAC,GACrD,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,wCAAiB,eAAe,MAAM;AAAA;AAEjD;",
+  "debugId": "69F1440DE6A72EA864756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/sum/sumifs.cjs

@@ -0,0 +1,60 @@
+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/functions/math/sum/sumifs.ts
+var exports_sumifs = {};
+__export(exports_sumifs, {
+  SUMIFS: () => SUMIFS
+});
+module.exports = __toCommonJS(exports_sumifs);
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_summation_utils = require("./summation-utils.cjs");
+var SUMIFS = {
+  name: "SUMIFS",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.validateMultiCriteriaArgs("SUMIFS", node.args.length, context);
+    if (argError) {
+      return argError;
+    }
+    const sumRangeResult = this.evaluateNode(node.args[0], context);
+    if (sumRangeResult.type === "error") {
+      return sumRangeResult;
+    }
+    const criteriaPairsResult = import_criteria_utils.parseCriteriaPairs.call(this, node, context, this.evaluateNode, 1);
+    if ("type" in criteriaPairsResult) {
+      return criteriaPairsResult;
+    }
+    const matchingValues = import_criteria_utils.processMultiCriteriaValues(this, sumRangeResult, criteriaPairsResult, context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_summation_utils.performSummation(matchingValues.values);
+  }
+};
+
+//# debugId=57877E0CDCDA6CC964756E2164756E21

package/dist/cjs/functions/math/sum/sumifs.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/sum/sumifs.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport {\n  parseCriteriaPairs,\n  processMultiCriteriaValues,\n  validateMultiCriteriaArgs,\n} from \"../../criteria-utils.cjs\";\nimport { performSummation } from \"./summation-utils.cjs\";\n\n/**\n * SUMIFS function - Sums cells in a range that meet multiple criteria\n *\n * Usage: SUMIFS(sum_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)\n *\n * sum_range: The range of cells to sum\n * criteria_range1: The first range to evaluate against criteria1\n * criteria1: The first criteria to match against\n * criteria_range2, criteria2: Optional additional criteria pairs\n *\n * Examples:\n *   SUMIFS(B1:B10, A1:A10, \"Apple\") - sums B1:B10 where A1:A10 = \"Apple\"\n *   SUMIFS(C1:C10, A1:A10, \"Apple\", B1:B10, \">10\") - sums C1:C10 where A1:A10 = \"Apple\" AND B1:B10 > 10\n *\n * Note:\n * - All criteria must be satisfied for a value to be included\n * - Only numeric values are included in the sum\n * - Returns 0 if no values match all criteria (unlike other IFS functions that return error)\n */\nexport const SUMIFS: FunctionDefinition = {\n  name: \"SUMIFS\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments\n    const argError = validateMultiCriteriaArgs(\"SUMIFS\", node.args.length, context);\n    if (argError) {\n      return argError;\n    }\n\n    // Evaluate sum range (first argument)\n    const sumRangeResult = this.evaluateNode(node.args[0]!, context);\n    if (sumRangeResult.type === \"error\") {\n      return sumRangeResult;\n    }\n\n    // Parse criteria pairs starting from argument 1\n    const criteriaPairsResult = parseCriteriaPairs.call(\n      this,\n      node,\n      context,\n      this.evaluateNode,\n      1\n    );\n    if (\"type\" in criteriaPairsResult) {\n      return criteriaPairsResult;\n    }\n\n    // Use shared summation utility for standard cases\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      sumRangeResult,\n      criteriaPairsResult,\n      context,\n      \"col-major\"\n    );\n\n    if (matchingValues.type === \"error\" || matchingValues.type === \"awaiting-evaluation\") {\n      return matchingValues;\n    }\n\n    return performSummation(matchingValues.values);\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUO,IAJP;AAKiC,IAAjC;AAqBO,IAAM,SAA6B;AAAA,EACxC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,gDAA0B,UAAU,KAAK,KAAK,QAAQ,OAAO;AAAA,IAC9E,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,yCAAmB,KAC7C,MACA,MACA,SACA,KAAK,cACL,CACF;AAAA,IACA,IAAI,UAAU,qBAAqB;AAAA,MACjC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,iDACrB,MACA,gBACA,qBACA,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,wCAAiB,eAAe,MAAM;AAAA;AAEjD;",
+  "debugId": "57877E0CDCDA6CC964756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/sum/summation-utils.cjs

@@ -0,0 +1,57 @@
+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/functions/math/sum/summation-utils.ts
+var exports_summation_utils = {};
+__export(exports_summation_utils, {
+  performSummation: () => performSummation
+});
+module.exports = __toCommonJS(exports_summation_utils);
+function performSummation(results) {
+  let sum = 0;
+  let hasValues = false;
+  for (const result of results) {
+    if (result.type === "value") {
+      if (result.result.type === "number") {
+        sum += result.result.value;
+        hasValues = true;
+      } else if (result.result.type === "infinity") {
+        return {
+          type: "value",
+          result: result.result
+        };
+      } else {}
+    }
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: sum }
+  };
+}
+
+//# debugId=4EEB27F156A307EA64756E2164756E21

package/dist/cjs/functions/math/sum/summation-utils.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/sum/summation-utils.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionEvaluationResult,\n  type SingleEvaluationResult,\n  type CellInfinity,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { FunctionNode } from \"src/parser/ast\";\n\n/**\n * Result type for processInfinity in sum functions\n */\nexport type ProcessInfinityResult<T> =\n  | { type: \"infinity\"; infinity: CellInfinity }\n  | { type: \"state\"; state: T };\n\n/**\n * Perform summation with error propagation\n * Used when errors should be propagated instead of skipped (e.g., SUM with direct error arguments)\n *\n * @param results - Iterator of SingleEvaluationResults to sum\n * @returns FunctionEvaluationResult with the sum, infinity, or first error encountered\n */\nexport function performSummation(\n  results: Iterable<SingleEvaluationResult>\n): FunctionEvaluationResult {\n  let sum = 0;\n  let hasValues = false;\n\n  for (const result of results) {\n    if (result.type === \"value\") {\n      if (result.result.type === \"number\") {\n        sum += result.result.value;\n        hasValues = true;\n      } else if (result.result.type === \"infinity\") {\n        // Infinity dominates - return immediately\n        return {\n          type: \"value\",\n          result: result.result,\n        };\n      } else {\n        // Non-numeric values (strings, booleans) are ignored in summation\n      }\n    }\n  }\n\n  return {\n    type: \"value\",\n    result: { type: \"number\", value: sum },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwBO,SAAS,gBAAgB,CAC9B,SAC0B;AAAA,EAC1B,IAAI,MAAM;AAAA,EACV,IAAI,YAAY;AAAA,EAEhB,WAAW,UAAU,SAAS;AAAA,IAC5B,IAAI,OAAO,SAAS,SAAS;AAAA,MAC3B,IAAI,OAAO,OAAO,SAAS,UAAU;AAAA,QACnC,OAAO,OAAO,OAAO;AAAA,QACrB,YAAY;AAAA,MACd,EAAO,SAAI,OAAO,OAAO,SAAS,YAAY;AAAA,QAE5C,OAAO;AAAA,UACL,MAAM;AAAA,UACN,QAAQ,OAAO;AAAA,QACjB;AAAA,MACF,EAAO;AAAA,IAGT;AAAA,EACF;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,EAAE,MAAM,UAAU,OAAO,IAAI;AAAA,EACvC;AAAA;",
+  "debugId": "4EEB27F156A307EA64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/reference/address/address.cjs

@@ -0,0 +1,163 @@
+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/functions/reference/address/address.ts
+var exports_address = {};
+__export(exports_address, {
+  ADDRESS: () => ADDRESS
+});
+module.exports = __toCommonJS(exports_address);
+var import_types = require("src/core/types");
+var ADDRESS = {
+  name: "ADDRESS",
+  evaluate: function(node, context) {
+    if (node.args.length < 2 || node.args.length > 5) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "ADDRESS function requires 2 to 5 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const rowResult = this.evaluateNode(node.args[0], context);
+    if (rowResult.type === "error" || rowResult.type === "awaiting-evaluation") {
+      return rowResult;
+    }
+    if (rowResult.type !== "value" || rowResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "ADDRESS function row_num must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    const colResult = this.evaluateNode(node.args[1], context);
+    if (colResult.type === "error" || colResult.type === "awaiting-evaluation") {
+      return colResult;
+    }
+    if (colResult.type !== "value" || colResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "ADDRESS function column_num must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    const rowNum = Math.floor(rowResult.result.value);
+    const colNum = Math.floor(colResult.result.value);
+    if (rowNum < 1 || colNum < 1) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "ADDRESS function row and column numbers must be positive",
+        errAddress: context.dependencyNode
+      };
+    }
+    let absNum = 1;
+    let a1Style = true;
+    let sheetText = "";
+    if (node.args.length >= 3) {
+      const absResult = this.evaluateNode(node.args[2], context);
+      if (absResult.type === "error" || absResult.type === "awaiting-evaluation") {
+        return absResult;
+      }
+      if (absResult.type === "value" && absResult.result.type === "number") {
+        absNum = Math.floor(absResult.result.value);
+        if (absNum < 1 || absNum > 4) {
+          return {
+            type: "error",
+            err: import_types.FormulaError.VALUE,
+            message: "ADDRESS function abs_num must be between 1 and 4",
+            errAddress: context.dependencyNode
+          };
+        }
+      }
+    }
+    if (node.args.length >= 4) {
+      const a1Result = this.evaluateNode(node.args[3], context);
+      if (a1Result.type === "error" || a1Result.type === "awaiting-evaluation") {
+        return a1Result;
+      }
+      if (a1Result.type === "value" && a1Result.result.type === "boolean") {
+        a1Style = a1Result.result.value;
+      }
+    }
+    if (node.args.length === 5) {
+      const sheetResult = this.evaluateNode(node.args[4], context);
+      if (sheetResult.type === "error" || sheetResult.type === "awaiting-evaluation") {
+        return sheetResult;
+      }
+      if (sheetResult.type === "value" && sheetResult.result.type === "string") {
+        sheetText = sheetResult.result.value;
+      }
+    }
+    let address = "";
+    if (a1Style) {
+      const colLetter = columnNumberToLetter(colNum);
+      switch (absNum) {
+        case 1:
+          address = `$${colLetter}$${rowNum}`;
+          break;
+        case 2:
+          address = `${colLetter}$${rowNum}`;
+          break;
+        case 3:
+          address = `$${colLetter}${rowNum}`;
+          break;
+        case 4:
+          address = `${colLetter}${rowNum}`;
+          break;
+      }
+    } else {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "ADDRESS function R1C1 style not yet implemented",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (sheetText) {
+      address = `${sheetText}!${address}`;
+    }
+    return {
+      type: "value",
+      result: { type: "string", value: address }
+    };
+  }
+};
+function columnNumberToLetter(num) {
+  let letter = "";
+  while (num > 0) {
+    const remainder = (num - 1) % 26;
+    letter = String.fromCharCode(65 + remainder) + letter;
+    num = Math.floor((num - 1) / 26);
+  }
+  return letter;
+}
+
+//# debugId=B4DE59D824ED7B5064756E2164756E21

package/dist/cjs/functions/reference/address/address.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/reference/address/address.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * ADDRESS function - Creates a cell reference as text given row and column numbers\n * \n * Usage: ADDRESS(row_num, column_num, [abs_num], [a1], [sheet_text])\n * \n * row_num: The row number to use in the cell reference\n * column_num: The column number to use in the cell reference\n * abs_num: (optional) Type of reference to return (1=absolute, 2=absolute row/relative col, 3=relative row/absolute col, 4=relative)\n * a1: (optional) A logical value that specifies the A1 or R1C1 reference style (TRUE or omitted = A1 style)\n * sheet_text: (optional) The name of the worksheet to be used as the external reference\n * \n * Examples:\n * - ADDRESS(2, 3) returns \"$C$2\"\n * - ADDRESS(2, 3, 4) returns \"C2\"\n * - ADDRESS(2, 3, 1, TRUE, \"Sheet2\") returns \"Sheet2!$C$2\"\n */\nexport const ADDRESS: FunctionDefinition = {\n  name: \"ADDRESS\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 2 || node.args.length > 5) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ADDRESS function requires 2 to 5 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate row_num\n    const rowResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      rowResult.type === \"error\" ||\n      rowResult.type === \"awaiting-evaluation\"\n    ) {\n      return rowResult;\n    }\n\n    if (rowResult.type !== \"value\" || rowResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ADDRESS function row_num must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate column_num\n    const colResult = this.evaluateNode(node.args[1]!, context);\n    if (\n      colResult.type === \"error\" ||\n      colResult.type === \"awaiting-evaluation\"\n    ) {\n      return colResult;\n    }\n\n    if (colResult.type !== \"value\" || colResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ADDRESS function column_num must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const rowNum = Math.floor(rowResult.result.value);\n    const colNum = Math.floor(colResult.result.value);\n\n    if (rowNum < 1 || colNum < 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ADDRESS function row and column numbers must be positive\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Default values\n    let absNum = 1; // Absolute reference by default\n    let a1Style = true;\n    let sheetText = \"\";\n\n    // Optional abs_num parameter\n    if (node.args.length >= 3) {\n      const absResult = this.evaluateNode(node.args[2]!, context);\n      if (\n        absResult.type === \"error\" ||\n        absResult.type === \"awaiting-evaluation\"\n      ) {\n        return absResult;\n      }\n\n      if (absResult.type === \"value\" && absResult.result.type === \"number\") {\n        absNum = Math.floor(absResult.result.value);\n        if (absNum < 1 || absNum > 4) {\n          return {\n            type: \"error\",\n            err: FormulaError.VALUE,\n            message: \"ADDRESS function abs_num must be between 1 and 4\",\n            errAddress: context.dependencyNode,\n          };\n        }\n      }\n    }\n\n    // Optional a1 parameter\n    if (node.args.length >= 4) {\n      const a1Result = this.evaluateNode(node.args[3]!, context);\n      if (\n        a1Result.type === \"error\" ||\n        a1Result.type === \"awaiting-evaluation\"\n      ) {\n        return a1Result;\n      }\n\n      if (a1Result.type === \"value\" && a1Result.result.type === \"boolean\") {\n        a1Style = a1Result.result.value;\n      }\n    }\n\n    // Optional sheet_text parameter\n    if (node.args.length === 5) {\n      const sheetResult = this.evaluateNode(node.args[4]!, context);\n      if (\n        sheetResult.type === \"error\" ||\n        sheetResult.type === \"awaiting-evaluation\"\n      ) {\n        return sheetResult;\n      }\n\n      if (sheetResult.type === \"value\" && sheetResult.result.type === \"string\") {\n        sheetText = sheetResult.result.value;\n      }\n    }\n\n    // Build the address string\n    let address = \"\";\n\n    if (a1Style) {\n      // A1 style reference\n      const colLetter = columnNumberToLetter(colNum);\n      \n      switch (absNum) {\n        case 1: // $A$1\n          address = `$${colLetter}$${rowNum}`;\n          break;\n        case 2: // A$1\n          address = `${colLetter}$${rowNum}`;\n          break;\n        case 3: // $A1\n          address = `$${colLetter}${rowNum}`;\n          break;\n        case 4: // A1\n          address = `${colLetter}${rowNum}`;\n          break;\n      }\n    } else {\n      // R1C1 style reference\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ADDRESS function R1C1 style not yet implemented\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Add sheet prefix if provided\n    if (sheetText) {\n      address = `${sheetText}!${address}`;\n    }\n\n    return {\n      type: \"value\",\n      result: { type: \"string\", value: address },\n    };\n  },\n};\n\n/**\n * Helper function to convert column number to letter(s)\n */\nfunction columnNumberToLetter(num: number): string {\n  let letter = \"\";\n  while (num > 0) {\n    const remainder = (num - 1) % 26;\n    letter = String.fromCharCode(65 + remainder) + letter;\n    num = Math.floor((num - 1) / 26);\n  }\n  return letter;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "B4DE59D824ED7B5064756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/reference/indirect/indirect.cjs

@@ -0,0 +1,102 @@
+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/functions/reference/indirect/indirect.ts
+var exports_indirect = {};
+__export(exports_indirect, {
+  INDIRECT: () => INDIRECT
+});
+module.exports = __toCommonJS(exports_indirect);
+var import_types = require("src/core/types");
+var import_parser = require("src/parser/parser");
+var INDIRECT = {
+  name: "INDIRECT",
+  evaluate: function(node, context) {
+    if (node.args.length === 0 || node.args.length > 2) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "INDIRECT function requires 1 or 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const refTextResult = this.evaluateNode(node.args[0], context);
+    if (refTextResult.type === "error" || refTextResult.type === "awaiting-evaluation") {
+      return refTextResult;
+    }
+    if (refTextResult.type !== "value" || refTextResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "INDIRECT function ref_text must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    const refText = refTextResult.result.value.trim();
+    let a1Style = true;
+    if (node.args.length === 2) {
+      const a1Result = this.evaluateNode(node.args[1], context);
+      if (a1Result.type === "error" || a1Result.type === "awaiting-evaluation") {
+        return a1Result;
+      }
+      if (a1Result.type === "value" && a1Result.result.type === "boolean") {
+        a1Style = a1Result.result.value;
+      }
+    }
+    if (!a1Style) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "INDIRECT function does not yet support R1C1 style references",
+        errAddress: context.dependencyNode
+      };
+    }
+    try {
+      const ast = import_parser.parseFormula(refText);
+      if (ast.type !== "reference" && ast.type !== "range" && ast.type !== "named-expression") {
+        return {
+          type: "error",
+          err: import_types.FormulaError.REF,
+          message: `INDIRECT requires a valid cell or range reference, got: ${refText}`,
+          errAddress: context.dependencyNode
+        };
+      }
+      const result = this.evaluateNode(ast, context);
+      return result;
+    } catch (error) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.REF,
+        message: `INDIRECT could not parse reference: ${refText}`,
+        errAddress: context.dependencyNode
+      };
+    }
+  }
+};
+
+//# debugId=FCB69448559D685164756E2164756E21

package/dist/cjs/functions/reference/indirect/indirect.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/reference/indirect/indirect.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport { parseFormula } from \"src/parser/parser\";\n\n/**\n * INDIRECT function - Returns the reference specified by a text string\n * \n * Usage: INDIRECT(ref_text, [a1])\n * \n * ref_text: A reference to a cell that contains an A1-style reference, an R1C1-style reference,\n *           a name defined as a reference, or a reference to a cell as a text string\n * a1: (optional) A logical value that specifies what type of reference is in ref_text\n *     TRUE or omitted = A1-style reference\n *     FALSE = R1C1-style reference\n * \n * Examples:\n * - INDIRECT(\"A1\") returns the value in cell A1\n * - INDIRECT(\"B\" & ROW()) returns the value in column B of the current row\n * - INDIRECT(\"Sheet2!A1\") returns the value in cell A1 of Sheet2\n * \n * Note: This function is volatile - it recalculates whenever the worksheet recalculates\n */\nexport const INDIRECT: FunctionDefinition = {\n  name: \"INDIRECT\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length === 0 || node.args.length > 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"INDIRECT function requires 1 or 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate ref_text\n    const refTextResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      refTextResult.type === \"error\" ||\n      refTextResult.type === \"awaiting-evaluation\"\n    ) {\n      return refTextResult;\n    }\n\n    if (refTextResult.type !== \"value\" || refTextResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"INDIRECT function ref_text must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const refText = refTextResult.result.value.trim();\n\n    // Optional a1 parameter\n    let a1Style = true;\n    if (node.args.length === 2) {\n      const a1Result = this.evaluateNode(node.args[1]!, context);\n      if (\n        a1Result.type === \"error\" ||\n        a1Result.type === \"awaiting-evaluation\"\n      ) {\n        return a1Result;\n      }\n\n      if (a1Result.type === \"value\" && a1Result.result.type === \"boolean\") {\n        a1Style = a1Result.result.value;\n      }\n    }\n\n    // R1C1 style not yet supported\n    if (!a1Style) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"INDIRECT function does not yet support R1C1 style references\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Parse the reference string as a formula (without the = sign)\n    try {\n      const ast = parseFormula(refText);\n      \n      // The parsed result should be a reference, range, or named expression\n      if (ast.type !== \"reference\" && ast.type !== \"range\" && ast.type !== \"named-expression\") {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: `INDIRECT requires a valid cell or range reference, got: ${refText}`,\n          errAddress: context.dependencyNode,\n        };\n      }\n      \n      // Evaluate the parsed reference\n      const result = this.evaluateNode(ast, context);\n      return result;\n      \n    } catch (error) {\n      return {\n        type: \"error\",\n        err: FormulaError.REF,\n        message: `INDIRECT could not parse reference: ${refText}`,\n        errAddress: context.dependencyNode,\n      };\n    }\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWO,IAXP;AAa6B,IAA7B;AAoBO,IAAM,WAA+B;AAAA,EAC1C,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,KAAK,KAAK,KAAK,SAAS,GAAG;AAAA,MAClD,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,gBAAgB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC9D,IACE,cAAc,SAAS,WACvB,cAAc,SAAS,uBACvB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,cAAc,SAAS,WAAW,cAAc,OAAO,SAAS,UAAU;AAAA,MAC5E,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,UAAU,cAAc,OAAO,MAAM,KAAK;AAAA,IAGhD,IAAI,UAAU;AAAA,IACd,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,MAAM,WAAW,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,MACzD,IACE,SAAS,SAAS,WAClB,SAAS,SAAS,uBAClB;AAAA,QACA,OAAO;AAAA,MACT;AAAA,MAEA,IAAI,SAAS,SAAS,WAAW,SAAS,OAAO,SAAS,WAAW;AAAA,QACnE,UAAU,SAAS,OAAO;AAAA,MAC5B;AAAA,IACF;AAAA,IAGA,IAAI,CAAC,SAAS;AAAA,MACZ,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,IAAI;AAAA,MACF,MAAM,MAAM,2BAAa,OAAO;AAAA,MAGhC,IAAI,IAAI,SAAS,eAAe,IAAI,SAAS,WAAW,IAAI,SAAS,oBAAoB;AAAA,QACvF,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS,2DAA2D;AAAA,UACpE,YAAY,QAAQ;AAAA,QACtB;AAAA,MACF;AAAA,MAGA,MAAM,SAAS,KAAK,aAAa,KAAK,OAAO;AAAA,MAC7C,OAAO;AAAA,MAEP,OAAO,OAAO;AAAA,MACd,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS,uCAAuC;AAAA,QAChD,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA;AAGN;",
+  "debugId": "FCB69448559D685164756E2164756E21",
+  "names": []
+}