@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/reference/offset/offset.cjs

@@ -0,0 +1,233 @@
+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/offset/offset.ts
+var exports_offset = {};
+__export(exports_offset, {
+  OFFSET: () => OFFSET
+});
+module.exports = __toCommonJS(exports_offset);
+var import_types = require("src/core/types");
+var import_utils = require("src/core/utils");
+var OFFSET = {
+  name: "OFFSET",
+  evaluate: function(node, context) {
+    if (node.args.length < 3 || node.args.length > 5) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "OFFSET function requires 3 to 5 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const refResult = this.evaluateNode(node.args[0], context);
+    if (refResult.type === "error" || refResult.type === "awaiting-evaluation") {
+      return refResult;
+    }
+    const rowsResult = this.evaluateNode(node.args[1], context);
+    if (rowsResult.type === "error" || rowsResult.type === "awaiting-evaluation") {
+      return rowsResult;
+    }
+    if (rowsResult.type !== "value" || rowsResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "OFFSET function rows must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    const colsResult = this.evaluateNode(node.args[2], context);
+    if (colsResult.type === "error" || colsResult.type === "awaiting-evaluation") {
+      return colsResult;
+    }
+    if (colsResult.type !== "value" || colsResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "OFFSET function cols must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    const rowsOffset = Math.floor(rowsResult.result.value);
+    const colsOffset = Math.floor(colsResult.result.value);
+    let height;
+    if (node.args.length >= 4) {
+      const heightResult = this.evaluateNode(node.args[3], context);
+      if (heightResult.type === "error" || heightResult.type === "awaiting-evaluation") {
+        return heightResult;
+      }
+      if (heightResult.type === "value" && heightResult.result.type === "number") {
+        height = Math.floor(heightResult.result.value);
+        if (height < 1) {
+          return {
+            type: "error",
+            err: import_types.FormulaError.VALUE,
+            message: "OFFSET function height must be positive",
+            errAddress: context.dependencyNode
+          };
+        }
+      }
+    }
+    let width;
+    if (node.args.length === 5) {
+      const widthResult = this.evaluateNode(node.args[4], context);
+      if (widthResult.type === "error" || widthResult.type === "awaiting-evaluation") {
+        return widthResult;
+      }
+      if (widthResult.type === "value" && widthResult.result.type === "number") {
+        width = Math.floor(widthResult.result.value);
+        if (width < 1) {
+          return {
+            type: "error",
+            err: import_types.FormulaError.VALUE,
+            message: "OFFSET function width must be positive",
+            errAddress: context.dependencyNode
+          };
+        }
+      }
+    }
+    let baseRange;
+    let baseSheetName = context.cellAddress.sheetName;
+    let baseWorkbookName = context.cellAddress.workbookName;
+    const cellOrRange = refResult.type === "spilled-values" ? refResult.sourceCell ?? refResult.sourceRange : refResult.sourceCell;
+    if (!cellOrRange) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "OFFSET function requires a cell or range reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (import_utils.isCellAddress(cellOrRange)) {
+      baseSheetName = cellOrRange.sheetName;
+      baseWorkbookName = cellOrRange.workbookName;
+      baseRange = {
+        start: {
+          col: cellOrRange.colIndex,
+          row: cellOrRange.rowIndex
+        },
+        end: {
+          col: { type: "number", value: cellOrRange.colIndex },
+          row: { type: "number", value: cellOrRange.rowIndex }
+        }
+      };
+    } else if (import_utils.isRangeAddress(cellOrRange)) {
+      baseSheetName = cellOrRange.sheetName;
+      baseWorkbookName = cellOrRange.workbookName;
+      baseRange = cellOrRange.range;
+    } else {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "OFFSET function requires a cell or range reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    const offsetStartCol = baseRange.start.col + colsOffset;
+    const offsetStartRow = baseRange.start.row + rowsOffset;
+    if (offsetStartCol < 0 || offsetStartRow < 0) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.REF,
+        message: "OFFSET function resulted in invalid cell reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    let offsetEndCol;
+    let offsetEndRow;
+    if (width !== undefined) {
+      offsetEndCol = offsetStartCol + width - 1;
+    } else if (baseRange.end.col.type === "number") {
+      offsetEndCol = offsetStartCol + (baseRange.end.col.value - baseRange.start.col);
+    } else {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "OFFSET function requires finite reference when width is omitted",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (height !== undefined) {
+      offsetEndRow = offsetStartRow + height - 1;
+    } else if (baseRange.end.row.type === "number") {
+      offsetEndRow = offsetStartRow + (baseRange.end.row.value - baseRange.start.row);
+    } else {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "OFFSET function requires finite reference when height is omitted",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (offsetEndCol < 0 || offsetEndRow < 0) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.REF,
+        message: "OFFSET function resulted in invalid cell reference",
+        errAddress: context.dependencyNode
+      };
+    }
+    const offsetRange = {
+      start: {
+        col: offsetStartCol,
+        row: offsetStartRow
+      },
+      end: {
+        col: { type: "number", value: offsetEndCol },
+        row: { type: "number", value: offsetEndRow }
+      }
+    };
+    if (offsetStartCol === offsetEndCol && offsetStartRow === offsetEndRow) {
+      return this.evaluateReference({
+        type: "reference",
+        address: {
+          colIndex: offsetStartCol,
+          rowIndex: offsetStartRow
+        },
+        sheetName: baseSheetName,
+        workbookName: baseWorkbookName,
+        isAbsolute: {
+          col: true,
+          row: true
+        }
+      }, context);
+    }
+    return this.evaluateRange({
+      type: "range",
+      range: offsetRange,
+      sheetName: baseSheetName,
+      workbookName: baseWorkbookName,
+      isAbsolute: {
+        start: { col: true, row: true },
+        end: { col: true, row: true }
+      }
+    }, context);
+  }
+};
+
+//# debugId=AD2C698E06ACDA8C64756E2164756E21

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/reference/offset/offset.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 SpreadsheetRangeEnd,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { ReferenceNode, RangeNode } from \"src/parser/ast\";\nimport { isCellAddress, isRangeAddress } from \"src/core/utils\";\n\n/**\n * OFFSET function - Returns a reference offset from a given reference\n * \n * Usage: OFFSET(reference, rows, cols, [height], [width])\n * \n * reference: The reference from which you want to base the offset\n * rows: The number of rows, up or down, that you want the upper-left cell to refer to\n * cols: The number of columns, left or right, that you want the upper-left cell to refer to\n * height: (optional) The height, in number of rows, that you want the returned reference to be\n * width: (optional) The width, in number of columns, that you want the returned reference to be\n * \n * Examples:\n * - OFFSET(A1, 2, 3) returns the value in cell D3 (2 rows down, 3 columns right from A1)\n * - OFFSET(A1, 0, 0, 3, 1) returns the range A1:A3\n * - OFFSET(A1, 1, 1, 2, 2) returns the range B2:C3\n * \n * Notes:\n * - If rows or cols offset reference from the edge of the worksheet, returns #REF! error\n * - Height and width must be positive\n * - If height or width is omitted, the same height or width as reference is used\n */\nexport const OFFSET: FunctionDefinition = {\n  name: \"OFFSET\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 3 || node.args.length > 5) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"OFFSET function requires 3 to 5 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate reference\n    const refResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      refResult.type === \"error\" ||\n      refResult.type === \"awaiting-evaluation\"\n    ) {\n      return refResult;\n    }\n\n    // Evaluate rows offset\n    const rowsResult = this.evaluateNode(node.args[1]!, context);\n    if (\n      rowsResult.type === \"error\" ||\n      rowsResult.type === \"awaiting-evaluation\"\n    ) {\n      return rowsResult;\n    }\n\n    if (rowsResult.type !== \"value\" || rowsResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"OFFSET function rows must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate cols offset\n    const colsResult = this.evaluateNode(node.args[2]!, context);\n    if (\n      colsResult.type === \"error\" ||\n      colsResult.type === \"awaiting-evaluation\"\n    ) {\n      return colsResult;\n    }\n\n    if (colsResult.type !== \"value\" || colsResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"OFFSET function cols must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const rowsOffset = Math.floor(rowsResult.result.value);\n    const colsOffset = Math.floor(colsResult.result.value);\n\n    // Optional height parameter\n    let height: number | undefined;\n    if (node.args.length >= 4) {\n      const heightResult = this.evaluateNode(node.args[3]!, context);\n      if (\n        heightResult.type === \"error\" ||\n        heightResult.type === \"awaiting-evaluation\"\n      ) {\n        return heightResult;\n      }\n\n      if (heightResult.type === \"value\" && heightResult.result.type === \"number\") {\n        height = Math.floor(heightResult.result.value);\n        if (height < 1) {\n          return {\n            type: \"error\",\n            err: FormulaError.VALUE,\n            message: \"OFFSET function height must be positive\",\n            errAddress: context.dependencyNode,\n          };\n        }\n      }\n    }\n\n    // Optional width parameter\n    let width: number | undefined;\n    if (node.args.length === 5) {\n      const widthResult = this.evaluateNode(node.args[4]!, context);\n      if (\n        widthResult.type === \"error\" ||\n        widthResult.type === \"awaiting-evaluation\"\n      ) {\n        return widthResult;\n      }\n\n      if (widthResult.type === \"value\" && widthResult.result.type === \"number\") {\n        width = Math.floor(widthResult.result.value);\n        if (width < 1) {\n          return {\n            type: \"error\",\n            err: FormulaError.VALUE,\n            message: \"OFFSET function width must be positive\",\n            errAddress: context.dependencyNode,\n          };\n        }\n      }\n    }\n\n    // Get the base cell/range from the evaluated reference\n    let baseRange: SpreadsheetRange;\n    let baseSheetName: string = context.cellAddress.sheetName;\n    let baseWorkbookName: string = context.cellAddress.workbookName;\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: \"OFFSET function requires a cell or range reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Extract the base range from sourceCell or sourceRange\n    if (isCellAddress(cellOrRange)) {\n      // It's a CellAddress\n      baseSheetName = cellOrRange.sheetName;\n      baseWorkbookName = cellOrRange.workbookName;\n      baseRange = {\n        start: {\n          col: cellOrRange.colIndex,\n          row: cellOrRange.rowIndex,\n        },\n        end: {\n          col: { type: \"number\", value: cellOrRange.colIndex },\n          row: { type: \"number\", value: cellOrRange.rowIndex },\n        },\n      };\n    } else if (isRangeAddress(cellOrRange)) {\n      // It's a RangeAddress\n      baseSheetName = cellOrRange.sheetName;\n      baseWorkbookName = cellOrRange.workbookName;\n      baseRange = cellOrRange.range;\n    } else {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"OFFSET function requires a cell or range reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Calculate the offset range\n    const offsetStartCol = baseRange.start.col + colsOffset;\n    const offsetStartRow = baseRange.start.row + rowsOffset;\n\n    // Validate bounds (assuming reasonable spreadsheet size)\n    if (offsetStartCol < 0 || offsetStartRow < 0) {\n      return {\n        type: \"error\",\n        err: FormulaError.REF,\n        message: \"OFFSET function resulted in invalid cell reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Calculate end position based on height/width or original range size\n    let offsetEndCol: number;\n    let offsetEndRow: number;\n\n    if (width !== undefined) {\n      offsetEndCol = offsetStartCol + width - 1;\n    } else if (baseRange.end.col.type === \"number\") {\n      offsetEndCol = offsetStartCol + (baseRange.end.col.value - baseRange.start.col);\n    } else {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"OFFSET function requires finite reference when width is omitted\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (height !== undefined) {\n      offsetEndRow = offsetStartRow + height - 1;\n    } else if (baseRange.end.row.type === \"number\") {\n      offsetEndRow = offsetStartRow + (baseRange.end.row.value - baseRange.start.row);\n    } else {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"OFFSET function requires finite reference when height is omitted\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Validate the end bounds\n    if (offsetEndCol < 0 || offsetEndRow < 0) {\n      return {\n        type: \"error\",\n        err: FormulaError.REF,\n        message: \"OFFSET function resulted in invalid cell reference\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Create the offset range\n    const offsetRange: SpreadsheetRange = {\n      start: {\n        col: offsetStartCol,\n        row: offsetStartRow,\n      },\n      end: {\n        col: { type: \"number\", value: offsetEndCol },\n        row: { type: \"number\", value: offsetEndRow },\n      },\n    };\n\n    // If it's a single cell, return its value\n    if (offsetStartCol === offsetEndCol && offsetStartRow === offsetEndRow) {\n      return this.evaluateReference(\n        {\n          type: \"reference\",\n          address: {\n            colIndex: offsetStartCol,\n            rowIndex: offsetStartRow,\n          },\n          sheetName: baseSheetName,\n          workbookName: baseWorkbookName,\n          isAbsolute: {\n            col: true,\n            row: true,\n          },\n        },\n        context\n      );\n    }\n\n    // Otherwise, return a range reference (spilled values)\n    return this.evaluateRange(\n      {\n        type: \"range\",\n        range: offsetRange,\n        sheetName: baseSheetName,\n        workbookName: baseWorkbookName,\n        isAbsolute: {\n          start: { col: true, row: true },\n          end: { col: true, row: true },\n        },\n      },\n      context\n    );\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYO,IAZP;AAe8C,IAA9C;AAuBO,IAAM,SAA6B;AAAA,EACxC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,SAAS,KAAK,KAAK,KAAK,SAAS,GAAG;AAAA,MAChD,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,YAAY,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC1D,IACE,UAAU,SAAS,WACnB,UAAU,SAAS,uBACnB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,aAAa,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC3D,IACE,WAAW,SAAS,WACpB,WAAW,SAAS,uBACpB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,WAAW,SAAS,WAAW,WAAW,OAAO,SAAS,UAAU;AAAA,MACtE,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,aAAa,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC3D,IACE,WAAW,SAAS,WACpB,WAAW,SAAS,uBACpB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,WAAW,SAAS,WAAW,WAAW,OAAO,SAAS,UAAU;AAAA,MACtE,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,aAAa,KAAK,MAAM,WAAW,OAAO,KAAK;AAAA,IACrD,MAAM,aAAa,KAAK,MAAM,WAAW,OAAO,KAAK;AAAA,IAGrD,IAAI;AAAA,IACJ,IAAI,KAAK,KAAK,UAAU,GAAG;AAAA,MACzB,MAAM,eAAe,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,MAC7D,IACE,aAAa,SAAS,WACtB,aAAa,SAAS,uBACtB;AAAA,QACA,OAAO;AAAA,MACT;AAAA,MAEA,IAAI,aAAa,SAAS,WAAW,aAAa,OAAO,SAAS,UAAU;AAAA,QAC1E,SAAS,KAAK,MAAM,aAAa,OAAO,KAAK;AAAA,QAC7C,IAAI,SAAS,GAAG;AAAA,UACd,OAAO;AAAA,YACL,MAAM;AAAA,YACN,KAAK,0BAAa;AAAA,YAClB,SAAS;AAAA,YACT,YAAY,QAAQ;AAAA,UACtB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IAGA,IAAI;AAAA,IACJ,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,MAAM,cAAc,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,MAC5D,IACE,YAAY,SAAS,WACrB,YAAY,SAAS,uBACrB;AAAA,QACA,OAAO;AAAA,MACT;AAAA,MAEA,IAAI,YAAY,SAAS,WAAW,YAAY,OAAO,SAAS,UAAU;AAAA,QACxE,QAAQ,KAAK,MAAM,YAAY,OAAO,KAAK;AAAA,QAC3C,IAAI,QAAQ,GAAG;AAAA,UACb,OAAO;AAAA,YACL,MAAM;AAAA,YACN,KAAK,0BAAa;AAAA,YAClB,SAAS;AAAA,YACT,YAAY,QAAQ;AAAA,UACtB;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IAGA,IAAI;AAAA,IACJ,IAAI,gBAAwB,QAAQ,YAAY;AAAA,IAChD,IAAI,mBAA2B,QAAQ,YAAY;AAAA,IAGnD,MAAM,cACJ,UAAU,SAAS,mBACd,UAAU,cAAc,UAAU,cACnC,UAAU;AAAA,IAEhB,IAAI,CAAC,aAAa;AAAA,MAChB,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,IAAI,2BAAc,WAAW,GAAG;AAAA,MAE9B,gBAAgB,YAAY;AAAA,MAC5B,mBAAmB,YAAY;AAAA,MAC/B,YAAY;AAAA,QACV,OAAO;AAAA,UACL,KAAK,YAAY;AAAA,UACjB,KAAK,YAAY;AAAA,QACnB;AAAA,QACA,KAAK;AAAA,UACH,KAAK,EAAE,MAAM,UAAU,OAAO,YAAY,SAAS;AAAA,UACnD,KAAK,EAAE,MAAM,UAAU,OAAO,YAAY,SAAS;AAAA,QACrD;AAAA,MACF;AAAA,IACF,EAAO,SAAI,4BAAe,WAAW,GAAG;AAAA,MAEtC,gBAAgB,YAAY;AAAA,MAC5B,mBAAmB,YAAY;AAAA,MAC/B,YAAY,YAAY;AAAA,IAC1B,EAAO;AAAA,MACL,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,IAIF,MAAM,iBAAiB,UAAU,MAAM,MAAM;AAAA,IAC7C,MAAM,iBAAiB,UAAU,MAAM,MAAM;AAAA,IAG7C,IAAI,iBAAiB,KAAK,iBAAiB,GAAG;AAAA,MAC5C,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,IAAI;AAAA,IACJ,IAAI;AAAA,IAEJ,IAAI,UAAU,WAAW;AAAA,MACvB,eAAe,iBAAiB,QAAQ;AAAA,IAC1C,EAAO,SAAI,UAAU,IAAI,IAAI,SAAS,UAAU;AAAA,MAC9C,eAAe,kBAAkB,UAAU,IAAI,IAAI,QAAQ,UAAU,MAAM;AAAA,IAC7E,EAAO;AAAA,MACL,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,IAGF,IAAI,WAAW,WAAW;AAAA,MACxB,eAAe,iBAAiB,SAAS;AAAA,IAC3C,EAAO,SAAI,UAAU,IAAI,IAAI,SAAS,UAAU;AAAA,MAC9C,eAAe,kBAAkB,UAAU,IAAI,IAAI,QAAQ,UAAU,MAAM;AAAA,IAC7E,EAAO;AAAA,MACL,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,IAIF,IAAI,eAAe,KAAK,eAAe,GAAG;AAAA,MACxC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,cAAgC;AAAA,MACpC,OAAO;AAAA,QACL,KAAK;AAAA,QACL,KAAK;AAAA,MACP;AAAA,MACA,KAAK;AAAA,QACH,KAAK,EAAE,MAAM,UAAU,OAAO,aAAa;AAAA,QAC3C,KAAK,EAAE,MAAM,UAAU,OAAO,aAAa;AAAA,MAC7C;AAAA,IACF;AAAA,IAGA,IAAI,mBAAmB,gBAAgB,mBAAmB,cAAc;AAAA,MACtE,OAAO,KAAK,kBACV;AAAA,QACE,MAAM;AAAA,QACN,SAAS;AAAA,UACP,UAAU;AAAA,UACV,UAAU;AAAA,QACZ;AAAA,QACA,WAAW;AAAA,QACX,cAAc;AAAA,QACd,YAAY;AAAA,UACV,KAAK;AAAA,UACL,KAAK;AAAA,QACP;AAAA,MACF,GACA,OACF;AAAA,IACF;AAAA,IAGA,OAAO,KAAK,cACV;AAAA,MACE,MAAM;AAAA,MACN,OAAO;AAAA,MACP,WAAW;AAAA,MACX,cAAc;AAAA,MACd,YAAY;AAAA,QACV,OAAO,EAAE,KAAK,MAAM,KAAK,KAAK;AAAA,QAC9B,KAAK,EAAE,KAAK,MAAM,KAAK,KAAK;AAAA,MAC9B;AAAA,IACF,GACA,OACF;AAAA;AAEJ;",
+  "debugId": "AD2C698E06ACDA8C64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/text/concatenate/concatenate.cjs

@@ -0,0 +1,167 @@
+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/text/concatenate/concatenate.ts
+var exports_concatenate = {};
+__export(exports_concatenate, {
+  CONCATENATE: () => CONCATENATE
+});
+module.exports = __toCommonJS(exports_concatenate);
+var import_types = require("src/core/types");
+function coerceToString(result, context) {
+  if (result.type !== "value") {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Invalid argument type",
+      errAddress: context.dependencyNode
+    };
+  }
+  switch (result.result.type) {
+    case "string":
+      return result.result.value;
+    case "number":
+      if (result.result.value === Infinity) {
+        return "INFINITY";
+      } else if (result.result.value === -Infinity) {
+        return "-INFINITY";
+      } else if (isNaN(result.result.value)) {
+        return "NaN";
+      } else {
+        return result.result.value.toString();
+      }
+    case "boolean":
+      return result.result.value ? "TRUE" : "FALSE";
+    default:
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Cannot convert argument to string",
+        errAddress: context.dependencyNode
+      };
+  }
+}
+function concatenateOperation(textResults, context) {
+  let result = "";
+  for (const textResult of textResults) {
+    const stringValue = coerceToString(textResult, context);
+    if (typeof stringValue === "object" && stringValue.type === "error") {
+      return stringValue;
+    }
+    result += stringValue;
+  }
+  return { type: "value", result: { type: "string", value: result } };
+}
+function createConcatenateSpilledResult({
+  textResults,
+  context
+}) {
+  const spilledResults = textResults.filter((result) => result.type === "spilled-values");
+  if (spilledResults.length === 0) {
+    throw new Error("createConcatenateSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      let spillArea;
+      for (const result of textResults) {
+        if (result.type === "spilled-values") {
+          const currentSpillArea = result.spillArea(origin);
+          if (!spillArea) {
+            spillArea = currentSpillArea;
+          } else {
+            spillArea = this.unionRanges(this.projectRange(spillArea, origin), this.projectRange(currentSpillArea, origin));
+          }
+        }
+      }
+      if (!spillArea) {
+        throw new Error("No spilled values found");
+      }
+      return spillArea;
+    },
+    source: "CONCATENATE with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spilledTextResults = [];
+      for (const textResult of textResults) {
+        if (textResult.type === "spilled-values") {
+          const spillResult = textResult.evaluate(spilledCell, evalContext);
+          if (spillResult === undefined) {
+            return {
+              type: "error",
+              err: import_types.FormulaError.REF,
+              message: "The spilled results have not been evaluated",
+              errAddress: context.dependencyNode
+            };
+          }
+          if (spillResult.type === "error") {
+            return spillResult;
+          }
+          spilledTextResults.push(spillResult);
+        } else {
+          spilledTextResults.push(textResult);
+        }
+      }
+      return concatenateOperation(spilledTextResults, context);
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for CONCATENATE is not implemented");
+    }
+  };
+}
+var CONCATENATE = {
+  name: "CONCATENATE",
+  evaluate: function(node, context) {
+    if (node.args.length < 1) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "CONCATENATE function requires at least 1 argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    const textResults = [];
+    for (const arg of node.args) {
+      const result = this.evaluateNode(arg, context);
+      if (result.type === "error" || result.type === "awaiting-evaluation") {
+        return result;
+      }
+      textResults.push(result);
+    }
+    const hasSpilledValues = textResults.some((result) => result.type === "spilled-values");
+    if (hasSpilledValues) {
+      return createConcatenateSpilledResult.call(this, {
+        textResults,
+        context
+      });
+    }
+    return concatenateOperation(textResults, context);
+  },
+  aliases: ["CONCAT"]
+};
+
+//# debugId=7B1EBEDB06EBEB6364756E2164756E21

package/dist/cjs/functions/text/concatenate/concatenate.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/concatenate/concatenate.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type CellString,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type ErrorEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { FunctionNode } from \"src/parser/ast\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * CONCATENATE function - Joins several text strings into one text string\n *\n * Usage: CONCATENATE(text1, text2, ...)\n *\n * text1, text2, ...: Text strings to be joined together.\n *\n * Example: CONCATENATE(\"Hello\", \" \", \"World\") returns \"Hello World\"\n *\n * Note:\n * - Takes 1 or more arguments\n * - Supports type coercion: strings, numbers, and booleans are converted to strings\n * - Numbers: converted to string representation (123 -> \"123\", Infinity -> \"INFINITY\")\n * - Booleans: TRUE -> \"TRUE\", FALSE -> \"FALSE\"\n * - Supports dynamic arrays (spilled values) for arguments\n * - If any argument is a spilled value, the result will be spilled\n */\n\n/**\n * Helper function to convert a cell value to string with type coercion\n */\nfunction coerceToString(\n  result: FunctionEvaluationResult,\n  context: EvaluationContext\n): string | ErrorEvaluationResult {\n  if (result.type !== \"value\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Invalid argument type\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  switch (result.result.type) {\n    case \"string\":\n      return result.result.value;\n    case \"number\":\n      // Convert number to string\n      if (result.result.value === Infinity) {\n        return \"INFINITY\";\n      } else if (result.result.value === -Infinity) {\n        return \"-INFINITY\";\n      } else if (isNaN(result.result.value)) {\n        return \"NaN\";\n      } else {\n        return result.result.value.toString();\n      }\n    case \"boolean\":\n      // Convert boolean to string\n      return result.result.value ? \"TRUE\" : \"FALSE\";\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Cannot convert argument to string\",\n        errAddress: context.dependencyNode,\n      };\n  }\n}\n\n/**\n * Helper function to perform CONCATENATE operation on evaluated arguments\n */\nfunction concatenateOperation(\n  textResults: FunctionEvaluationResult[],\n  context: EvaluationContext\n): { type: \"value\"; result: CellString } | ErrorEvaluationResult {\n  let result = \"\";\n  for (const textResult of textResults) {\n    const stringValue = coerceToString(textResult, context);\n    if (typeof stringValue === \"object\" && stringValue.type === \"error\") {\n      return stringValue;\n    }\n    result += stringValue;\n  }\n  return { type: \"value\", result: { type: \"string\", value: result } };\n}\n\n/**\n * Helper for creating spilled-values result for CONCATENATE function\n */\nfunction createConcatenateSpilledResult(\n  this: FormulaEvaluator,\n  {\n    textResults,\n    context,\n  }: {\n    textResults: FunctionEvaluationResult[];\n    context: EvaluationContext;\n  }\n): SpilledValuesEvaluationResult | ErrorEvaluationResult {\n  const spilledResults = textResults.filter(\n    (result) => result.type === \"spilled-values\"\n  );\n\n  if (spilledResults.length === 0) {\n    throw new Error(\n      \"createConcatenateSpilledResult called without spilled values\"\n    );\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress): SpreadsheetRange => {\n      // Calculate spill area (union of all spilled ranges)\n      let spillArea: SpreadsheetRange | undefined;\n\n      for (const result of textResults) {\n        if (result.type === \"spilled-values\") {\n          const currentSpillArea = result.spillArea(origin);\n          if (!spillArea) {\n            spillArea = currentSpillArea;\n          } else {\n            spillArea = this.unionRanges(\n              this.projectRange(spillArea, origin),\n              this.projectRange(currentSpillArea, origin)\n            );\n          }\n        }\n      }\n\n      if (!spillArea) {\n        throw new Error(\"No spilled values found\");\n      }\n      return spillArea;\n    },\n    source: \"CONCATENATE with spilled values\",\n    evaluate: (spilledCell, evalContext): SingleEvaluationResult => {\n      // Evaluate all arguments at this spilled position\n      const spilledTextResults: FunctionEvaluationResult[] = [];\n\n      for (const textResult of textResults) {\n        if (textResult.type === \"spilled-values\") {\n          const spillResult = textResult.evaluate(spilledCell, evalContext);\n          if (spillResult === undefined) {\n            return {\n              type: \"error\",\n              err: FormulaError.REF,\n              message: \"The spilled results have not been evaluated\",\n              errAddress: context.dependencyNode,\n            };\n          }\n          if (spillResult.type === \"error\") {\n            return spillResult;\n          }\n          spilledTextResults.push(spillResult);\n        } else {\n          spilledTextResults.push(textResult);\n        }\n      }\n\n      return concatenateOperation(spilledTextResults, context);\n    },\n    evaluateAllCells: (intersectingRange) => {\n      throw new Error(\n        \"WIP: evaluateAllCells for CONCATENATE is not implemented\"\n      );\n    },\n  };\n}\n\n/**\n * CONCATENATE function implementation\n */\nexport const CONCATENATE: FunctionDefinition = {\n  name: \"CONCATENATE\",\n  evaluate: function (\n    node: FunctionNode,\n    context: EvaluationContext\n  ): FunctionEvaluationResult {\n    if (node.args.length < 1) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"CONCATENATE function requires at least 1 argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate all arguments\n    const textResults: FunctionEvaluationResult[] = [];\n    for (const arg of node.args) {\n      const result = this.evaluateNode(arg, context);\n      if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n        return result;\n      }\n      textResults.push(result);\n    }\n\n    // Check if any arguments are spilled values\n    const hasSpilledValues = textResults.some(\n      (result) => result.type === \"spilled-values\"\n    );\n\n    if (hasSpilledValues) {\n      return createConcatenateSpilledResult.call(this, {\n        textResults,\n        context,\n      });\n    }\n\n    // All arguments are single values - type coercion will be handled in concatenateOperation\n\n    // Perform concatenation\n    return concatenateOperation(textResults, context);\n  },\n  aliases: [\"CONCAT\"],\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "7B1EBEDB06EBEB6364756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/text/exact/exact.cjs

@@ -0,0 +1,171 @@
+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/text/exact/exact.ts
+var exports_exact = {};
+__export(exports_exact, {
+  EXACT: () => EXACT
+});
+module.exports = __toCommonJS(exports_exact);
+var import_types = require("src/core/types");
+function cellValueToString(value) {
+  switch (value.type) {
+    case "string":
+      return value.value;
+    case "number":
+      return value.value.toString();
+    case "boolean":
+      return value.value ? "TRUE" : "FALSE";
+    case "infinity":
+      return value.sign === "positive" ? "INFINITY" : "-INFINITY";
+    default:
+      return "";
+  }
+}
+function createExactSpilledResult({
+  text1Result,
+  text2Result,
+  context
+}) {
+  const hasSpilledText1 = text1Result.type === "spilled-values";
+  const hasSpilledText2 = text2Result.type === "spilled-values";
+  if (!hasSpilledText1 && !hasSpilledText2) {
+    throw new Error("createExactSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      let spillArea;
+      const spilledResults = [
+        hasSpilledText1 ? text1Result : null,
+        hasSpilledText2 ? text2Result : null
+      ].filter(Boolean);
+      for (const result of spilledResults) {
+        const currentSpillArea = result.spillArea(origin);
+        if (!spillArea) {
+          spillArea = currentSpillArea;
+        } else {
+          spillArea = this.unionRanges(this.projectRange(spillArea, origin), this.projectRange(currentSpillArea, origin));
+        }
+      }
+      if (!spillArea) {
+        throw new Error("No spilled values found");
+      }
+      return spillArea;
+    },
+    source: "EXACT with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillText1Result = hasSpilledText1 ? text1Result.evaluate(spilledCell, evalContext) : text1Result;
+      const spillText2Result = hasSpilledText2 ? text2Result.evaluate(spilledCell, evalContext) : text2Result;
+      if (spillText1Result === undefined) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.REF,
+          message: "The spilled text1 argument has not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillText1Result.type === "error" || spillText1Result.type === "awaiting-evaluation") {
+        return spillText1Result;
+      }
+      if (spillText2Result === undefined) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.REF,
+          message: "The spilled text2 argument has not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillText2Result.type === "error" || spillText2Result.type === "awaiting-evaluation") {
+        return spillText2Result;
+      }
+      if (spillText1Result.type !== "value" || spillText2Result.type !== "value") {
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: "Invalid argument types for EXACT function #1",
+          errAddress: context.dependencyNode
+        };
+      }
+      const text1 = cellValueToString(spillText1Result.result);
+      const text2 = cellValueToString(spillText2Result.result);
+      return {
+        type: "value",
+        result: { type: "boolean", value: text1 === text2 }
+      };
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for EXACT is not implemented");
+    }
+  };
+}
+var EXACT = {
+  name: "EXACT",
+  evaluate: function(node, context) {
+    if (node.args.length !== 2) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "EXACT function takes exactly 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const text1Result = this.evaluateNode(node.args[0], context);
+    if (text1Result.type === "error" || text1Result.type === "awaiting-evaluation") {
+      return text1Result;
+    }
+    const text2Result = this.evaluateNode(node.args[1], context);
+    if (text2Result.type === "error" || text2Result.type === "awaiting-evaluation") {
+      return text2Result;
+    }
+    const hasSpilledValues = text1Result.type === "spilled-values" || text2Result.type === "spilled-values";
+    if (hasSpilledValues) {
+      return createExactSpilledResult.call(this, {
+        text1Result,
+        text2Result,
+        context
+      });
+    }
+    if (text1Result.type !== "value" || text2Result.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "Invalid argument types for EXACT function #2",
+        errAddress: context.dependencyNode
+      };
+    }
+    const text1 = cellValueToString(text1Result.result);
+    const text2 = cellValueToString(text2Result.result);
+    return {
+      type: "value",
+      result: { type: "boolean", value: text1 === text2 }
+    };
+  }
+};
+
+//# debugId=F4F9FD1288FD9C7F64756E2164756E21

package/dist/cjs/functions/text/exact/exact.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/text/exact/exact.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 ErrorEvaluationResult,\n} from \"src/core/types\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * EXACT function - Compares two text strings and returns TRUE if they are exactly the same, FALSE otherwise\n * \n * Usage: EXACT(text1, text2)\n * \n * text1: Required. The first text string\n * text2: Required. The second text string\n * \n * Examples:\n *   EXACT(\"Apple\", \"Apple\") - returns TRUE\n *   EXACT(\"Apple\", \"apple\") - returns FALSE (case-sensitive)\n *   EXACT(\"123\", \"123\") - returns TRUE\n *   EXACT(\"\", \"\") - returns TRUE (empty strings are equal)\n * \n * Note:\n * - The comparison is case-sensitive\n * - Non-text values are converted to text before comparison\n * - Supports spilled values (dynamic arrays) for both arguments\n */\n\n/**\n * Convert a cell value to string for text comparison\n */\nfunction cellValueToString(value: CellValue): string {\n  switch (value.type) {\n    case \"string\":\n      return value.value;\n    case \"number\":\n      return value.value.toString();\n    case \"boolean\":\n      return value.value ? \"TRUE\" : \"FALSE\";\n    case \"infinity\":\n      return value.sign === \"positive\" ? \"INFINITY\" : \"-INFINITY\";\n    default:\n      return \"\";\n  }\n}\n\n/**\n * Helper for creating spilled-values result for EXACT function\n */\nfunction createExactSpilledResult(\n  this: FormulaEvaluator,\n  {\n    text1Result,\n    text2Result,\n    context,\n  }: {\n    text1Result: FunctionEvaluationResult;\n    text2Result: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): SpilledValuesEvaluationResult | ErrorEvaluationResult {\n  const hasSpilledText1 = text1Result.type === \"spilled-values\";\n  const hasSpilledText2 = text2Result.type === \"spilled-values\";\n\n  if (!hasSpilledText1 && !hasSpilledText2) {\n    throw new Error(\"createExactSpilledResult called without spilled values\");\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress): SpreadsheetRange => {\n      // Calculate spill area (union of spilled ranges)\n      let spillArea: SpreadsheetRange | undefined;\n\n      const spilledResults = [\n        hasSpilledText1 ? text1Result : null,\n        hasSpilledText2 ? text2Result : null,\n      ].filter(Boolean) as SpilledValuesEvaluationResult[];\n\n      for (const result of spilledResults) {\n        const currentSpillArea = result.spillArea(origin);\n        if (!spillArea) {\n          spillArea = currentSpillArea;\n        } else {\n          spillArea = this.unionRanges(\n            this.projectRange(spillArea, origin),\n            this.projectRange(currentSpillArea, origin)\n          );\n        }\n      }\n\n      if (!spillArea) {\n        throw new Error(\"No spilled values found\");\n      }\n      return spillArea;\n    },\n    source: \"EXACT with spilled values\",\n    evaluate: (spilledCell: any, evalContext: any): SingleEvaluationResult => {\n      // Evaluate both arguments at this spilled position\n      const spillText1Result = hasSpilledText1\n        ? text1Result.evaluate(spilledCell, evalContext)\n        : text1Result;\n      const spillText2Result = hasSpilledText2\n        ? text2Result.evaluate(spilledCell, evalContext)\n        : text2Result;\n\n      // Check for errors\n      if (spillText1Result === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled text1 argument has not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (spillText1Result.type === \"error\" || spillText1Result.type === \"awaiting-evaluation\") {\n        return spillText1Result;\n      }\n\n      if (spillText2Result === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled text2 argument has not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (spillText2Result.type === \"error\" || spillText2Result.type === \"awaiting-evaluation\") {\n        return spillText2Result;\n      }\n\n      // Perform EXACT comparison\n      if (spillText1Result.type !== \"value\" || spillText2Result.type !== \"value\") {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Invalid argument types for EXACT function #1\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      const text1 = cellValueToString(spillText1Result.result);\n      const text2 = cellValueToString(spillText2Result.result);\n\n      return {\n        type: \"value\",\n        result: { type: \"boolean\", value: text1 === text2 },\n      };\n    },\n    evaluateAllCells: (intersectingRange: any) => {\n      throw new Error(\"WIP: evaluateAllCells for EXACT is not implemented\");\n    },\n  };\n}\n\n/**\n * EXACT function implementation\n */\nexport const EXACT: FunctionDefinition = {\n  name: \"EXACT\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length !== 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"EXACT function takes exactly 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate both text arguments\n    const text1Result = this.evaluateNode(node.args[0]!, context);\n    if (text1Result.type === \"error\" || text1Result.type === \"awaiting-evaluation\") {\n      return text1Result;\n    }\n\n    const text2Result = this.evaluateNode(node.args[1]!, context);\n    if (text2Result.type === \"error\" || text2Result.type === \"awaiting-evaluation\") {\n      return text2Result;\n    }\n\n    // Handle spilled values\n    const hasSpilledValues = \n      text1Result.type === \"spilled-values\" ||\n      text2Result.type === \"spilled-values\";\n\n    if (hasSpilledValues) {\n      return createExactSpilledResult.call(this, {\n        text1Result,\n        text2Result,\n        context,\n      });\n    }\n\n    // Both arguments are single values\n    if (text1Result.type !== \"value\" || text2Result.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Invalid argument types for EXACT function #2\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Convert both values to strings and compare\n    const text1 = cellValueToString(text1Result.result);\n    const text2 = cellValueToString(text2Result.result);\n\n    return {\n      type: \"value\",\n      result: { type: \"boolean\", value: text1 === text2 },\n    };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "F4F9FD1288FD9C7F64756E2164756E21",
+  "names": []
+}