@ricsam/formula-engine 0.0.1

package/dist/mjs/functions/index.mjs

@@ -0,0 +1,95 @@
+// src/functions/index.ts
+import { SEQUENCE } from "./array/sequence/sequence.mjs";
+import { INDEX } from "./lookup/index-lookup/index-lookup.mjs";
+import { MATCH } from "./lookup/match/match.mjs";
+import { COUNT } from "./lookup/count/count.mjs";
+import { COUNTIF } from "./lookup/count/countif.mjs";
+import { AVERAGE } from "./math/average/average.mjs";
+import { AVERAGEIF } from "./math/average/averageif.mjs";
+import { AVERAGEIFS } from "./math/average/averageifs.mjs";
+import { MAX } from "./math/max/max.mjs";
+import { MAXIFS } from "./math/max/maxifs.mjs";
+import { MIN } from "./math/min/min.mjs";
+import { MINIFS } from "./math/min/minifs.mjs";
+import { SUM } from "./math/sum/sum.mjs";
+import { SUMIF } from "./math/sum/sumif.mjs";
+import { SUMIFS } from "./math/sum/sumifs.mjs";
+import { COUNTIFS } from "./lookup/count/countifs.mjs";
+import { MAXIF } from "./math/max/maxif.mjs";
+import { MINIF } from "./math/min/minif.mjs";
+import { CEILING } from "./math/ceiling/ceiling.mjs";
+import { EXACT } from "./text/exact/exact.mjs";
+import { FIND } from "./text/find/find.mjs";
+import { LEFT } from "./text/left/left.mjs";
+import { MID } from "./text/mid/mid.mjs";
+import { LEN } from "./text/len/len.mjs";
+import { RIGHT } from "./text/right/right.mjs";
+import { CONCATENATE } from "./text/concatenate/concatenate.mjs";
+import { AND } from "./logical/and/and.mjs";
+import { IF } from "./logical/if/if.mjs";
+import { IFERROR } from "./logical/iferror/iferror.mjs";
+import { XLOOKUP } from "./lookup/xlookup/xlookup.mjs";
+import { OR } from "./logical/or/or.mjs";
+import { TEXTJOIN } from "./text/textjoin/textjoin.mjs";
+import { ROW } from "./information/row/row.mjs";
+import { COLUMN } from "./information/column/column.mjs";
+import { CELL } from "./information/cell/cell.mjs";
+import { ADDRESS } from "./reference/address/address.mjs";
+import { INDIRECT } from "./reference/indirect/indirect.mjs";
+import { OFFSET } from "./reference/offset/offset.mjs";
+var buildFunctionIndex = (functions) => {
+  return Object.fromEntries(Object.entries(functions).flatMap(([name, func]) => {
+    const base = [[name, func]];
+    if (func.aliases) {
+      func.aliases.forEach((alias) => {
+        base.push([alias, func]);
+      });
+    }
+    return base;
+  }));
+};
+var functions = buildFunctionIndex({
+  ADDRESS,
+  AND,
+  AVERAGE,
+  AVERAGEIF,
+  AVERAGEIFS,
+  CEILING,
+  CELL,
+  COLUMN,
+  CONCATENATE,
+  COUNT,
+  COUNTIF,
+  COUNTIFS,
+  EXACT,
+  FIND,
+  IF,
+  IFERROR,
+  INDEX,
+  INDIRECT,
+  LEFT,
+  LEN,
+  MATCH,
+  MAX,
+  MAXIF,
+  MAXIFS,
+  MID,
+  MIN,
+  MINIF,
+  MINIFS,
+  OFFSET,
+  OR,
+  RIGHT,
+  ROW,
+  SEQUENCE,
+  SUM,
+  SUMIF,
+  SUMIFS,
+  TEXTJOIN,
+  XLOOKUP
+});
+export {
+  functions
+};
+
+//# debugId=D3C4234AE873055B64756E2164756E21

package/dist/mjs/functions/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/index.ts"],
+  "sourcesContent": [
+    "import type { FunctionDefinition } from \"src/core/types\";\n// import { arrayFunctions } from \"./array/array-functions.mjs\";\n// import { infoFunctions } from \"./info/info-functions.mjs\";\n// import { logicalComparisonFunctions } from \"./logical/comparisons.mjs\";\n// import { logicalConditionFunctions } from \"./logical/conditions.mjs\";\n// import { lookupFunctions } from \"./lookup/lookup-functions.mjs\";\n// import { advancedMathFunctions } from \"./math/advanced.mjs\";\n// import { basicMathFunctions } from \"./math/basic.mjs\";\n// import { textFunctions } from \"./text/string-functions.mjs\";\nimport { SEQUENCE } from \"./array/sequence/sequence.mjs\";\nimport { INDEX } from \"./lookup/index-lookup/index-lookup.mjs\"; // Fixed import path\nimport { MATCH } from \"./lookup/match/match.mjs\";\nimport { COUNT } from \"./lookup/count/count.mjs\";\nimport { COUNTIF } from \"./lookup/count/countif.mjs\";\nimport { AVERAGE } from \"./math/average/average.mjs\";\nimport { AVERAGEIF } from \"./math/average/averageif.mjs\";\nimport { AVERAGEIFS } from \"./math/average/averageifs.mjs\";\nimport { MAX } from \"./math/max/max.mjs\";\nimport { MAXIFS } from \"./math/max/maxifs.mjs\";\nimport { MIN } from \"./math/min/min.mjs\";\nimport { MINIFS } from \"./math/min/minifs.mjs\";\nimport { SUM } from \"./math/sum/sum.mjs\";\nimport { SUMIF } from \"./math/sum/sumif.mjs\";\nimport { SUMIFS } from \"./math/sum/sumifs.mjs\";\nimport { COUNTIFS } from \"./lookup/count/countifs.mjs\";\nimport { MAXIF } from \"./math/max/maxif.mjs\";\nimport { MINIF } from \"./math/min/minif.mjs\";\nimport { CEILING } from \"./math/ceiling/ceiling.mjs\";\nimport { EXACT } from \"./text/exact/exact.mjs\";\nimport { FIND } from \"./text/find/find.mjs\";\nimport { LEFT } from \"./text/left/left.mjs\";\nimport { MID } from \"./text/mid/mid.mjs\";\nimport { LEN } from \"./text/len/len.mjs\";\nimport { RIGHT } from \"./text/right/right.mjs\";\nimport { CONCATENATE } from \"./text/concatenate/concatenate.mjs\";\nimport { AND } from \"./logical/and/and.mjs\";\nimport { IF } from \"./logical/if/if.mjs\";\nimport { IFERROR } from \"./logical/iferror/iferror.mjs\";\nimport { XLOOKUP } from \"./lookup/xlookup/xlookup.mjs\";\nimport { OR } from \"./logical/or/or.mjs\";\nimport { TEXTJOIN } from \"./text/textjoin/textjoin.mjs\";\nimport { ROW } from \"./information/row/row.mjs\";\nimport { COLUMN } from \"./information/column/column.mjs\";\nimport { CELL } from \"./information/cell/cell.mjs\";\nimport { ADDRESS } from \"./reference/address/address.mjs\";\nimport { INDIRECT } from \"./reference/indirect/indirect.mjs\";\nimport { OFFSET } from \"./reference/offset/offset.mjs\";\n\nconst buildFunctionIndex = (functions: Record<string, FunctionDefinition>) => {\n  return Object.fromEntries(\n    Object.entries(functions).flatMap(([name, func]) => {\n      const base: [string, FunctionDefinition][] = [[name, func]];\n      if (func.aliases) {\n        func.aliases.forEach((alias) => {\n          base.push([alias, func]);\n        });\n      }\n      return base;\n    })\n  );\n};\n\nexport const functions: Record<string, FunctionDefinition> = buildFunctionIndex(\n  {\n    ADDRESS,\n    AND,\n    AVERAGE,\n    AVERAGEIF,\n    AVERAGEIFS,\n    CEILING,\n    CELL,\n    COLUMN,\n    CONCATENATE,\n    COUNT,\n    COUNTIF,\n    COUNTIFS,\n    EXACT,\n    FIND,\n    IF,\n    IFERROR,\n    INDEX,\n    INDIRECT,\n    LEFT,\n    LEN,\n    MATCH,\n    MAX,\n    MAXIF,\n    MAXIFS,\n    MID,\n    MIN,\n    MINIF,\n    MINIFS,\n    OFFSET,\n    OR,\n    RIGHT,\n    ROW,\n    SEQUENCE,\n    SUM,\n    SUMIF,\n    SUMIFS,\n    TEXTJOIN,\n    XLOOKUP,\n  }\n);\n"
+  ],
+  "mappings": ";AASA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA,IAAM,qBAAqB,CAAC,cAAkD;AAAA,EAC5E,OAAO,OAAO,YACZ,OAAO,QAAQ,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU;AAAA,IAClD,MAAM,OAAuC,CAAC,CAAC,MAAM,IAAI,CAAC;AAAA,IAC1D,IAAI,KAAK,SAAS;AAAA,MAChB,KAAK,QAAQ,QAAQ,CAAC,UAAU;AAAA,QAC9B,KAAK,KAAK,CAAC,OAAO,IAAI,CAAC;AAAA,OACxB;AAAA,IACH;AAAA,IACA,OAAO;AAAA,GACR,CACH;AAAA;AAGK,IAAM,YAAgD,mBAC3D;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CACF;",
+  "debugId": "D3C4234AE873055B64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/information/cell/cell.mjs

@@ -0,0 +1,168 @@
+// src/functions/information/cell/cell.ts
+import {
+  FormulaError
+} from "src/core/types";
+import { isCellAddress, isRangeAddress } from "src/core/utils";
+var CELL = {
+  name: "CELL",
+  evaluate: function(node, context) {
+    if (node.args.length === 0 || node.args.length > 2) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "CELL function requires 1 or 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const infoTypeResult = this.evaluateNode(node.args[0], context);
+    if (infoTypeResult.type === "error" || infoTypeResult.type === "awaiting-evaluation") {
+      return infoTypeResult;
+    }
+    if (infoTypeResult.type !== "value" || infoTypeResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "CELL function info_type must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    const infoType = infoTypeResult.result.value.toLowerCase();
+    let referenceCell = context.cellAddress;
+    let referenceValue = null;
+    if (node.args.length === 2) {
+      const refArg = node.args[1];
+      const refResult = this.evaluateNode(refArg, context);
+      if (refResult.type === "error" || refResult.type === "awaiting-evaluation") {
+        return refResult;
+      }
+      const cellOrRange = refResult.type === "spilled-values" ? refResult.sourceCell ?? refResult.sourceRange : refResult.sourceCell;
+      if (!cellOrRange) {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "CELL function requires a cell or range reference",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (isCellAddress(cellOrRange)) {
+        referenceCell = cellOrRange;
+      } else if (isRangeAddress(cellOrRange)) {
+        referenceCell = {
+          sheetName: cellOrRange.sheetName,
+          workbookName: cellOrRange.workbookName,
+          colIndex: cellOrRange.range.start.col,
+          rowIndex: cellOrRange.range.start.row
+        };
+      } else {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "CELL function requires a cell or range reference",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (infoType === "contents" || infoType === "type") {
+        if (refResult.type === "value") {
+          referenceValue = refResult.result;
+        } else if (refResult.type === "spilled-values") {
+          const cellResult = refResult.evaluate({ x: 0, y: 0 }, context);
+          if (cellResult && cellResult.type === "value") {
+            referenceValue = cellResult.result;
+          }
+        }
+      }
+    }
+    switch (infoType) {
+      case "row":
+        return {
+          type: "value",
+          result: { type: "number", value: referenceCell.rowIndex + 1 }
+        };
+      case "col":
+        return {
+          type: "value",
+          result: { type: "number", value: referenceCell.colIndex + 1 }
+        };
+      case "address": {
+        const col = columnNumberToLetter(referenceCell.colIndex + 1);
+        const row = referenceCell.rowIndex + 1;
+        let address = `$${col}$${row}`;
+        if (referenceCell.sheetName !== context.cellAddress.sheetName) {
+          address = `${referenceCell.sheetName}!${address}`;
+        }
+        return {
+          type: "value",
+          result: { type: "string", value: address }
+        };
+      }
+      case "contents":
+        if (referenceValue !== null) {
+          if (referenceValue.type === "string" && referenceValue.value === "") {
+            return {
+              type: "value",
+              result: { type: "number", value: 0 }
+            };
+          }
+          return {
+            type: "value",
+            result: referenceValue
+          };
+        }
+        return {
+          type: "value",
+          result: { type: "number", value: 0 }
+        };
+      case "type": {
+        if (referenceValue === null) {
+          return {
+            type: "value",
+            result: { type: "string", value: "b" }
+          };
+        }
+        if (referenceValue.type === "string" && referenceValue.value === "") {
+          return {
+            type: "value",
+            result: { type: "string", value: "b" }
+          };
+        }
+        if (referenceValue.type === "string") {
+          return {
+            type: "value",
+            result: { type: "string", value: "l" }
+          };
+        }
+        if (referenceValue.type === "number") {
+          return {
+            type: "value",
+            result: { type: "string", value: "v" }
+          };
+        }
+        return {
+          type: "value",
+          result: { type: "string", value: "v" }
+        };
+      }
+      default:
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: `CELL function unknown info_type: "${infoType}"`,
+          errAddress: context.dependencyNode
+        };
+    }
+  }
+};
+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;
+}
+export {
+  CELL
+};
+
+//# debugId=9DFD0FB10A5CBED864756E2164756E21

package/dist/mjs/functions/information/cell/cell.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/information/cell/cell.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 type { ReferenceNode } from \"src/parser/ast\";\nimport { isCellAddress, isRangeAddress } from \"src/core/utils\";\n\n/**\n * CELL function - Returns information about the formatting, location, or contents of a cell\n * \n * Usage: CELL(info_type, [reference])\n * \n * info_type: Text value that specifies what type of cell information you want\n * reference: The cell or range to get information about (defaults to current cell if omitted)\n * \n * Supported info_types:\n * - \"address\" - Returns the reference of the first cell in reference, as text\n * - \"col\" - Returns the column number of the cell\n * - \"row\" - Returns the row number of the cell\n * - \"contents\" - Returns the value of the upper-left cell\n * - \"type\" - Returns \"b\" for blank, \"l\" for label (text), \"v\" for value (number)\n * - \"width\" - Returns the column width\n * - \"filename\" - Returns the filename (including full path) of the file\n * \n * Examples:\n * - CELL(\"address\", A1) returns \"$A$1\"\n * - CELL(\"row\", B5) returns 5\n * - CELL(\"col\", C3) returns 3\n */\nexport const CELL: FunctionDefinition = {\n  name: \"CELL\",\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: \"CELL function requires 1 or 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the info_type argument\n    const infoTypeResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      infoTypeResult.type === \"error\" ||\n      infoTypeResult.type === \"awaiting-evaluation\"\n    ) {\n      return infoTypeResult;\n    }\n\n    if (infoTypeResult.type !== \"value\" || infoTypeResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"CELL function info_type must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const infoType = infoTypeResult.result.value.toLowerCase();\n\n    // Determine the reference cell\n    let referenceCell: CellAddress = context.cellAddress;\n    let referenceValue: CellValue | null = null;\n    \n    if (node.args.length === 2) {\n      const refArg = node.args[1]!;\n      \n      // Evaluate the reference argument\n      const refResult = this.evaluateNode(refArg, context);\n      if (\n        refResult.type === \"error\" ||\n        refResult.type === \"awaiting-evaluation\"\n      ) {\n        return refResult;\n      }\n      \n      // Check if we have a cell or range reference\n      const cellOrRange =\n        refResult.type === \"spilled-values\"\n          ? (refResult.sourceCell ?? refResult.sourceRange)\n          : refResult.sourceCell;\n      \n      if (!cellOrRange) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"CELL function requires a cell or range reference\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      \n      // Extract the cell address\n      if (isCellAddress(cellOrRange)) {\n        // It's a CellAddress\n        referenceCell = cellOrRange;\n      } else if (isRangeAddress(cellOrRange)) {\n        // It's a RangeAddress - use the upper-left cell\n        referenceCell = {\n          sheetName: cellOrRange.sheetName,\n          workbookName: cellOrRange.workbookName,\n          colIndex: cellOrRange.range.start.col,\n          rowIndex: cellOrRange.range.start.row,\n        };\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"CELL function requires a cell or range reference\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      \n      // For \"contents\" and \"type\", we need to get the cell value\n      if (infoType === \"contents\" || infoType === \"type\") {\n        if (refResult.type === \"value\") {\n          referenceValue = refResult.result;\n        } else if (refResult.type === \"spilled-values\") {\n          const cellResult = refResult.evaluate({ x: 0, y: 0 }, context);\n          if (cellResult && cellResult.type === \"value\") {\n            referenceValue = cellResult.result;\n          }\n        }\n      }\n    }\n\n    // Handle different info types (return 1-based row/column numbers)\n    switch (infoType) {\n      case \"row\":\n        return {\n          type: \"value\",\n          result: { type: \"number\", value: referenceCell.rowIndex + 1 },\n        };\n      \n      case \"col\":\n        return {\n          type: \"value\",\n          result: { type: \"number\", value: referenceCell.colIndex + 1 },\n        };\n      \n      case \"address\": {\n        // Return the cell address as text in A1 format\n        const col = columnNumberToLetter(referenceCell.colIndex + 1);\n        const row = referenceCell.rowIndex + 1;\n        let address = `$${col}$${row}`;\n        \n        // Include sheet name if it's different from current sheet\n        if (referenceCell.sheetName !== context.cellAddress.sheetName) {\n          address = `${referenceCell.sheetName}!${address}`;\n        }\n        \n        return {\n          type: \"value\",\n          result: { type: \"string\", value: address },\n        };\n      }\n      \n      case \"contents\":\n        // Return the value of the cell\n        if (referenceValue !== null) {\n          // Empty string counts as empty cell in Excel\n          if (referenceValue.type === \"string\" && referenceValue.value === \"\") {\n            return {\n              type: \"value\",\n              result: { type: \"number\", value: 0 },\n            };\n          }\n          return {\n            type: \"value\",\n            result: referenceValue,\n          };\n        }\n        // If we couldn't get the value, return 0 (empty cell)\n        return {\n          type: \"value\",\n          result: { type: \"number\", value: 0 },\n        };\n      \n      case \"type\": {\n        // Return \"b\" for blank, \"l\" for label (text), \"v\" for value (number)\n        if (referenceValue === null) {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"b\" },\n          };\n        }\n        // Empty string counts as blank cell in Excel\n        if (referenceValue.type === \"string\" && referenceValue.value === \"\") {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"b\" },\n          };\n        }\n        if (referenceValue.type === \"string\") {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"l\" },\n          };\n        }\n        if (referenceValue.type === \"number\") {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"v\" },\n          };\n        }\n        // Boolean or other types default to \"v\"\n        return {\n          type: \"value\",\n          result: { type: \"string\", value: \"v\" },\n        };\n      }\n      \n      default:\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: `CELL function unknown info_type: \"${infoType}\"`,\n          errAddress: context.dependencyNode,\n        };\n    }\n  },\n};\n\n/**\n * Helper function to convert column number (1-based) 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": "9DFD0FB10A5CBED864756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/information/column/column.mjs

@@ -0,0 +1,120 @@
+// src/functions/information/column/column.ts
+import {
+  FormulaError
+} from "src/core/types";
+import { EvaluationError } from "src/evaluator/evaluation-error";
+import {
+  getRangeIntersection,
+  isCellAddress,
+  isRangeAddress
+} from "src/core/utils";
+var COLUMN = {
+  name: "COLUMN",
+  evaluate: function(node, context) {
+    if (node.args.length === 0) {
+      context.addContextDependency("col");
+      return {
+        type: "value",
+        result: { type: "number", value: context.cellAddress.colIndex + 1 }
+      };
+    }
+    if (node.args.length > 1) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "COLUMN function takes at most 1 argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    const argNode = node.args[0];
+    const argResult = this.evaluateNode(argNode, context);
+    if (argResult.type === "error" || argResult.type === "awaiting-evaluation") {
+      return argResult;
+    }
+    const cellOrRange = argResult.type === "spilled-values" ? argResult.sourceCell ?? argResult.sourceRange : argResult.sourceCell;
+    if (!cellOrRange) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "COLUMN function requires a cell or range reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (isCellAddress(cellOrRange)) {
+      return {
+        type: "value",
+        result: { type: "number", value: cellOrRange.colIndex + 1 }
+      };
+    }
+    if (isRangeAddress(cellOrRange) && argResult.type === "spilled-values") {
+      const sourceRange = cellOrRange.range;
+      return {
+        type: "spilled-values",
+        spillArea: (origin) => argResult.spillArea(origin),
+        sourceRange: cellOrRange,
+        source: "COLUMN with range/array argument",
+        evaluate: (spillOffset, evalContext) => {
+          if (sourceRange) {
+            const actualCol2 = sourceRange.start.col + spillOffset.x;
+            return {
+              type: "value",
+              result: { type: "number", value: actualCol2 + 1 }
+            };
+          }
+          const spillArea = argResult.spillArea(evalContext.cellAddress);
+          const actualCol = spillArea.start.col + spillOffset.x;
+          return {
+            type: "value",
+            result: { type: "number", value: actualCol + 1 }
+          };
+        },
+        evaluateAllCells: ({ evaluate, intersection, context: context2, origin }) => {
+          let rangeToEvaluate = cellOrRange.range;
+          if (intersection) {
+            const newRange = getRangeIntersection(rangeToEvaluate, intersection);
+            if (!newRange) {
+              return {
+                type: "error",
+                err: FormulaError.VALUE,
+                message: "Invalid intersection range for COLUMN function",
+                errAddress: context2.dependencyNode
+              };
+            }
+            rangeToEvaluate = newRange;
+          }
+          if (rangeToEvaluate.end.row.type === "infinity" || rangeToEvaluate.end.col.type === "infinity") {
+            throw new EvaluationError(FormulaError.VALUE, "COLUMN function cannot evaluate all cells over an infinite range");
+          }
+          const startCol = rangeToEvaluate.start.col;
+          const endCol = rangeToEvaluate.end.col.value;
+          const colSet = new Set;
+          for (let col = startCol;col <= endCol; col++) {
+            colSet.add(col + 1);
+          }
+          const cols = Array.from(colSet).sort((a, b) => a - b);
+          const results = [];
+          for (let i = 0;i < cols.length; i++) {
+            const relativePos = { x: i, y: 0 };
+            const evaled = evaluate(relativePos, context2);
+            results.push({
+              result: evaled,
+              relativePos
+            });
+          }
+          return { type: "values", values: results };
+        }
+      };
+    }
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "COLUMN function requires a cell or range reference",
+      errAddress: context.dependencyNode
+    };
+  }
+};
+export {
+  COLUMN
+};
+
+//# debugId=91F1BE814E596E1D64756E2164756E21

package/dist/mjs/functions/information/column/column.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/information/column/column.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  type CellInRangeResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { ReferenceNode, RangeNode } from \"src/parser/ast\";\nimport { EvaluationError } from \"src/evaluator/evaluation-error\";\nimport {\n  getRangeIntersection,\n  isCellAddress,\n  isRangeAddress,\n} from \"src/core/utils\";\n\n/**\n * COLUMN function - Returns the column number of a reference\n *\n * Usage: COLUMN([reference])\n *\n * If reference is omitted, returns the column number of the cell in which the formula appears.\n *\n * Examples:\n * - COLUMN() returns the column number of the current cell\n * - COLUMN(C5) returns 3\n * - COLUMN(A1:E1) returns an array of column numbers {1,2,3,4,5}\n */\nexport const COLUMN: FunctionDefinition = {\n  name: \"COLUMN\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // If no arguments, return the column of the current cell (1-based)\n    if (node.args.length === 0) {\n      context.addContextDependency(\"col\");\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: context.cellAddress.colIndex + 1 },\n      };\n    }\n\n    if (node.args.length > 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"COLUMN function takes at most 1 argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const argNode = node.args[0]!;\n\n    // Evaluate the argument\n    const argResult = this.evaluateNode(argNode, context);\n\n    // Handle errors and awaiting evaluation\n    if (\n      argResult.type === \"error\" ||\n      argResult.type === \"awaiting-evaluation\"\n    ) {\n      return argResult;\n    }\n\n    // Check if we have a cell or range reference\n    const cellOrRange =\n      argResult.type === \"spilled-values\"\n        ? (argResult.sourceCell ?? argResult.sourceRange)\n        : argResult.sourceCell;\n\n    // If we don't have a sourceCell or sourceRange, the argument is invalid\n    if (!cellOrRange) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"COLUMN function requires a cell or range reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // If we have a sourceCell (single cell reference), return its column\n    if (isCellAddress(cellOrRange)) {\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: cellOrRange.colIndex + 1 },\n      };\n    }\n\n    // If we have a sourceRange, return spilled column numbers\n    if (isRangeAddress(cellOrRange) && argResult.type === \"spilled-values\") {\n      const sourceRange = cellOrRange.range;\n\n      // Return as spilled values - evaluate returns column numbers based on position\n      return {\n        type: \"spilled-values\",\n        spillArea: (origin) => argResult.spillArea(origin),\n        sourceRange: cellOrRange,\n        source: \"COLUMN with range/array argument\",\n        evaluate: (spillOffset, evalContext) => {\n          // If we have a sourceRange, use it to get the actual column number\n          if (sourceRange) {\n            const actualCol = sourceRange.start.col + spillOffset.x;\n            return {\n              type: \"value\",\n              result: { type: \"number\", value: actualCol + 1 }, // 1-based\n            };\n          }\n\n          // Otherwise, use spillArea to get the column number relative to where it appears\n          const spillArea = argResult.spillArea(evalContext.cellAddress);\n          const actualCol = spillArea.start.col + spillOffset.x;\n          return {\n            type: \"value\",\n            result: { type: \"number\", value: actualCol + 1 }, // 1-based\n          };\n        },\n        evaluateAllCells: ({ evaluate, intersection, context, origin }) => {\n          // Determine the actual range to evaluate\n          let rangeToEvaluate = cellOrRange.range;\n\n          // Apply intersection if provided\n          if (intersection) {\n            // Use the intersection range\n            const newRange = getRangeIntersection(\n              rangeToEvaluate,\n              intersection\n            );\n            if (!newRange) {\n              return {\n                type: \"error\",\n                err: FormulaError.VALUE,\n                message:\n                  \"Invalid intersection range for COLUMN function\",\n                errAddress: context.dependencyNode,\n              };\n            }\n            rangeToEvaluate = newRange;\n          }\n\n          // Check if the range is infinite\n          if (\n            rangeToEvaluate.end.row.type === \"infinity\" ||\n            rangeToEvaluate.end.col.type === \"infinity\"\n          ) {\n            throw new EvaluationError(\n              FormulaError.VALUE,\n              \"COLUMN function cannot evaluate all cells over an infinite range\"\n            );\n          }\n\n          // Extract unique column numbers from the range\n          const startCol = rangeToEvaluate.start.col;\n          const endCol = rangeToEvaluate.end.col.value;\n\n          const colSet = new Set<number>();\n          for (let col = startCol; col <= endCol; col++) {\n            colSet.add(col + 1); // 1-based\n          }\n          const cols = Array.from(colSet).sort((a, b) => a - b);\n\n          const results: CellInRangeResult[] = [];\n          for (let i = 0; i < cols.length; i++) {\n            const relativePos = { x: i, y: 0 };\n            const evaled = evaluate(relativePos, context);\n            results.push({\n              result: evaled!,\n              relativePos,\n            });\n          }\n          return { type: \"values\", values: results };\n        },\n      };\n    }\n\n    // If we reach here, cellOrRange type is unknown\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"COLUMN function requires a cell or range reference\",\n      errAddress: context.dependencyNode,\n    };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "91F1BE814E596E1D64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/information/row/row.mjs

@@ -0,0 +1,126 @@
+// src/functions/information/row/row.ts
+import {
+  FormulaError
+} from "src/core/types";
+import { EvaluationError } from "src/evaluator/evaluation-error";
+import {
+  getRangeIntersection,
+  isCellAddress,
+  isRangeAddress
+} from "src/core/utils";
+var ROW = {
+  name: "ROW",
+  evaluate: function(node, context) {
+    if (node.args.length === 0) {
+      context.addContextDependency("row");
+      return {
+        type: "value",
+        result: {
+          type: "number",
+          value: context.cellAddress.rowIndex + 1
+        }
+      };
+    }
+    if (node.args.length > 1) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "ROW function takes at most 1 argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    const argNode = node.args[0];
+    const argResult = this.evaluateNode(argNode, context);
+    if (argResult.type === "error" || argResult.type === "awaiting-evaluation") {
+      return argResult;
+    }
+    const cellOrRange = argResult.type === "spilled-values" ? argResult.sourceCell ?? argResult.sourceRange : argResult.sourceCell;
+    if (!cellOrRange) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "ROW function requires a cell or range reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (isCellAddress(cellOrRange)) {
+      return {
+        type: "value",
+        result: { type: "number", value: cellOrRange.rowIndex + 1 }
+      };
+    }
+    if (isRangeAddress(cellOrRange) && argResult.type === "spilled-values") {
+      const sourceRange = cellOrRange.range;
+      return {
+        type: "spilled-values",
+        spillArea: (origin) => argResult.spillArea(origin),
+        sourceRange: cellOrRange,
+        source: "ROW with range/array argument",
+        evaluate: (spillOffset, evalContext) => {
+          if (sourceRange) {
+            const actualRow2 = sourceRange.start.row + spillOffset.y;
+            return {
+              type: "value",
+              result: { type: "number", value: actualRow2 + 1 }
+            };
+          }
+          const spillArea = argResult.spillArea(evalContext.cellAddress);
+          const actualRow = spillArea.start.row + spillOffset.y;
+          return {
+            type: "value",
+            result: { type: "number", value: actualRow + 1 }
+          };
+        },
+        evaluateAllCells: ({ evaluate, intersection, context: context2, origin }) => {
+          let rangeToEvaluate = cellOrRange.range;
+          if (intersection) {
+            const newRange = getRangeIntersection(rangeToEvaluate, intersection);
+            if (!newRange) {
+              return {
+                type: "error",
+                err: FormulaError.VALUE,
+                message: "Intersection range is not valid",
+                errAddress: context2.dependencyNode
+              };
+            }
+            rangeToEvaluate = newRange;
+          }
+          if (rangeToEvaluate.end.row.type === "infinity" || rangeToEvaluate.end.col.type === "infinity") {
+            throw new EvaluationError(FormulaError.VALUE, "ROW function cannot evaluate all cells over an infinite range");
+          }
+          const startRow = rangeToEvaluate.start.row;
+          const endRow = rangeToEvaluate.end.row.value;
+          const rowSet = new Set;
+          for (let row = startRow;row <= endRow; row++) {
+            rowSet.add(row + 1);
+          }
+          const rows = Array.from(rowSet).sort((a, b) => a - b);
+          const results = [];
+          for (let i = 0;i < rows.length; i++) {
+            const relativePos = { x: 0, y: i };
+            const evaled = evaluate(relativePos, context2);
+            results.push({
+              result: evaled,
+              relativePos
+            });
+          }
+          return {
+            type: "values",
+            values: results
+          };
+        }
+      };
+    }
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "ROW function requires a cell or range reference",
+      errAddress: context.dependencyNode
+    };
+  }
+};
+export {
+  ROW
+};
+
+//# debugId=ADEBBFCCA4FAED8764756E2164756E21

package/dist/mjs/functions/information/row/row.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/information/row/row.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  type CellInRangeResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { ReferenceNode, RangeNode } from \"src/parser/ast\";\nimport { EvaluationError } from \"src/evaluator/evaluation-error\";\nimport {\n  getRangeIntersection,\n  isCellAddress,\n  isRangeAddress,\n} from \"src/core/utils\";\n\n/**\n * ROW function - Returns the row number of a reference\n *\n * Usage: ROW([reference])\n *\n * If reference is omitted, returns the row number of the cell in which the formula appears.\n *\n * Examples:\n * - ROW() returns the row number of the current cell\n * - ROW(A5) returns 5\n * - ROW(A5:A10) returns an array of row numbers {5;6;7;8;9;10}\n */\nexport const ROW: FunctionDefinition = {\n  name: \"ROW\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // If no arguments, return the row of the current cell (1-based)\n    if (node.args.length === 0) {\n      context.addContextDependency(\"row\");\n      return {\n        type: \"value\",\n        result: {\n          type: \"number\",\n          value: context.cellAddress.rowIndex + 1,\n        },\n      };\n    }\n\n    if (node.args.length > 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ROW function takes at most 1 argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const argNode = node.args[0]!;\n\n    // Evaluate the argument\n    const argResult = this.evaluateNode(argNode, context);\n\n    // Handle errors and awaiting evaluation\n    if (\n      argResult.type === \"error\" ||\n      argResult.type === \"awaiting-evaluation\"\n    ) {\n      return argResult;\n    }\n\n    // Check if we have a cell or range reference\n    const cellOrRange =\n      argResult.type === \"spilled-values\"\n        ? (argResult.sourceCell ?? argResult.sourceRange)\n        : argResult.sourceCell;\n\n    // If we don't have a sourceCell or sourceRange, the argument is invalid\n    if (!cellOrRange) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"ROW function requires a cell or range reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // If we have a sourceCell (single cell reference), return its row\n    if (isCellAddress(cellOrRange)) {\n      return {\n        type: \"value\",\n        result: { type: \"number\", value: cellOrRange.rowIndex + 1 },\n      };\n    }\n\n    // If we have a sourceRange, return spilled row numbers\n    if (isRangeAddress(cellOrRange) && argResult.type === \"spilled-values\") {\n      const sourceRange = cellOrRange.range;\n\n      // Return as spilled values - evaluate returns row numbers based on position\n      return {\n        type: \"spilled-values\",\n        spillArea: (origin) => argResult.spillArea(origin),\n        sourceRange: cellOrRange,\n        source: \"ROW with range/array argument\",\n        evaluate: (spillOffset, evalContext) => {\n          // If we have a sourceRange, use it to get the actual row number\n          if (sourceRange) {\n            const actualRow = sourceRange.start.row + spillOffset.y;\n            return {\n              type: \"value\",\n              result: { type: \"number\", value: actualRow + 1 }, // 1-based\n            };\n          }\n\n          // Otherwise, use spillArea to get the row number relative to where it appears\n          const spillArea = argResult.spillArea(evalContext.cellAddress);\n          const actualRow = spillArea.start.row + spillOffset.y;\n          return {\n            type: \"value\",\n            result: { type: \"number\", value: actualRow + 1 }, // 1-based\n          };\n        },\n        evaluateAllCells: ({ evaluate, intersection, context, origin }) => {\n          // Determine the actual range to evaluate\n          let rangeToEvaluate = cellOrRange.range;\n\n          // Apply intersection if provided\n          if (intersection) {\n            // Use the intersection range\n            const newRange = getRangeIntersection(\n              rangeToEvaluate,\n              intersection\n            );\n            if (!newRange) {\n              return {\n                type: \"error\",\n                err: FormulaError.VALUE,\n                message: \"Intersection range is not valid\",\n                errAddress: context.dependencyNode,\n              };\n            }\n            rangeToEvaluate = newRange;\n          }\n\n          // Check if the range is infinite\n          if (\n            rangeToEvaluate.end.row.type === \"infinity\" ||\n            rangeToEvaluate.end.col.type === \"infinity\"\n          ) {\n            throw new EvaluationError(\n              FormulaError.VALUE,\n              \"ROW function cannot evaluate all cells over an infinite range\"\n            );\n          }\n\n          // Extract unique row numbers from the range\n          const startRow = rangeToEvaluate.start.row;\n          const endRow = rangeToEvaluate.end.row.value;\n\n          const rowSet = new Set<number>();\n          for (let row = startRow; row <= endRow; row++) {\n            rowSet.add(row + 1); // 1-based\n          }\n          const rows = Array.from(rowSet).sort((a, b) => a - b);\n\n          const results: CellInRangeResult[] = [];\n          for (let i = 0; i < rows.length; i++) {\n            const relativePos = { x: 0, y: i };\n            const evaled = evaluate(relativePos, context);\n            results.push({\n              result: evaled,\n              relativePos,\n            });\n          }\n          return {\n            type: \"values\",\n            values: results,\n          };\n        },\n      };\n    }\n\n    // If we reach here, cellOrRange type is unknown\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"ROW function requires a cell or range reference\",\n      errAddress: context.dependencyNode,\n    };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "ADEBBFCCA4FAED8764756E2164756E21",
+  "names": []
+}