@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/lookup/xlookup/xlookup.cjs

@@ -0,0 +1,410 @@
+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/lookup/xlookup/xlookup.ts
+var exports_xlookup = {};
+__export(exports_xlookup, {
+  XLOOKUP: () => XLOOKUP
+});
+module.exports = __toCommonJS(exports_xlookup);
+var import_types = require("src/core/types");
+function compareValues(a, b) {
+  if (a.type !== b.type) {
+    const typeOrder = { number: 0, string: 1, boolean: 2, infinity: 0 };
+    return (typeOrder[a.type] || 3) - (typeOrder[b.type] || 3);
+  }
+  if (a.type === "number" && b.type === "number") {
+    return a.value - b.value;
+  }
+  if (a.type === "string" && b.type === "string") {
+    return a.value.localeCompare(b.value);
+  }
+  if (a.type === "boolean" && b.type === "boolean") {
+    return (a.value ? 1 : 0) - (b.value ? 1 : 0);
+  }
+  return 0;
+}
+function valuesMatch(a, b) {
+  if (a.type !== b.type)
+    return false;
+  if (a.type === "number" && b.type === "number") {
+    return a.value === b.value;
+  }
+  if (a.type === "string" && b.type === "string") {
+    return a.value === b.value;
+  }
+  if (a.type === "boolean" && b.type === "boolean") {
+    return a.value === b.value;
+  }
+  return false;
+}
+function wildcardMatch(pattern, text) {
+  let regex = "";
+  let i = 0;
+  while (i < pattern.length) {
+    const char = pattern[i];
+    if (!char)
+      break;
+    if (char === "~" && i + 1 < pattern.length) {
+      const nextChar = pattern[i + 1];
+      if (nextChar) {
+        regex += nextChar.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      }
+      i += 2;
+    } else if (char === "*") {
+      regex += ".*";
+      i++;
+    } else if (char === "?") {
+      regex += ".";
+      i++;
+    } else {
+      regex += char.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      i++;
+    }
+  }
+  try {
+    const re = new RegExp(`^${regex}$`, "i");
+    return re.test(text);
+  } catch {
+    return false;
+  }
+}
+function xlookupOperation(lookupValue, lookupArray, returnArray, ifNotFound, hasIfNotFound, matchMode, searchMode, context) {
+  if (![0, -1, 1, 2].includes(matchMode)) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: `XLOOKUP match_mode must be -1, 0, 1, or 2, got ${matchMode}`
+    };
+  }
+  if (![1, -1, 2, -2].includes(searchMode)) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: `XLOOKUP search_mode must be 1, -1, 2, or -2, got ${searchMode}`
+    };
+  }
+  if (lookupArray.type !== "values") {
+    return lookupArray;
+  }
+  if (returnArray.type !== "values") {
+    return returnArray;
+  }
+  if (lookupArray.values.length !== returnArray.values.length) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: "XLOOKUP lookup_array and return_array must have same dimensions"
+    };
+  }
+  if (lookupArray.values.length === 0) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: "XLOOKUP lookup_array cannot be empty"
+    };
+  }
+  if (searchMode === 2 || searchMode === -2) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: "XLOOKUP binary search mode not yet implemented"
+    };
+  }
+  const searchArray = searchMode === -1 ? [...lookupArray.values].reverse() : lookupArray.values;
+  const searchReturnArray = searchMode === -1 ? [...returnArray.values].reverse() : returnArray.values;
+  let bestMatchIndex = -1;
+  let bestMatchValue = null;
+  for (let i = 0;i < searchArray.length; i++) {
+    const item = searchArray[i];
+    if (!item || item.result.type !== "value")
+      continue;
+    const arrayValue = item.result.result;
+    if (matchMode === 0) {
+      if (valuesMatch(lookupValue, arrayValue)) {
+        const returnItem = searchReturnArray[i];
+        if (!returnItem)
+          continue;
+        if (returnItem.result.type === "value") {
+          return {
+            type: "value",
+            result: returnItem.result.result
+          };
+        } else if (returnItem.result.type === "error") {
+          return returnItem.result;
+        }
+      }
+    } else if (matchMode === 2) {
+      if (lookupValue.type === "string" && arrayValue.type === "string") {
+        if (wildcardMatch(lookupValue.value, arrayValue.value)) {
+          const returnItem = searchReturnArray[i];
+          if (!returnItem)
+            continue;
+          if (returnItem.result.type === "value") {
+            return {
+              type: "value",
+              result: returnItem.result.result
+            };
+          } else if (returnItem.result.type === "error") {
+            return returnItem.result;
+          }
+        }
+      }
+    } else if (matchMode === -1) {
+      const cmp = compareValues(arrayValue, lookupValue);
+      if (cmp === 0) {
+        const returnItem = searchReturnArray[i];
+        if (!returnItem)
+          continue;
+        if (returnItem.result.type === "value") {
+          return {
+            type: "value",
+            result: returnItem.result.result
+          };
+        } else if (returnItem.result.type === "error") {
+          return returnItem.result;
+        }
+      } else if (cmp < 0) {
+        if (bestMatchValue === null || compareValues(arrayValue, bestMatchValue) > 0) {
+          bestMatchIndex = i;
+          bestMatchValue = arrayValue;
+        }
+      }
+    } else if (matchMode === 1) {
+      const cmp = compareValues(arrayValue, lookupValue);
+      if (cmp === 0) {
+        const returnItem = searchReturnArray[i];
+        if (!returnItem)
+          continue;
+        if (returnItem.result.type === "value") {
+          return {
+            type: "value",
+            result: returnItem.result.result
+          };
+        } else if (returnItem.result.type === "error") {
+          return returnItem.result;
+        }
+      } else if (cmp > 0) {
+        if (bestMatchValue === null || compareValues(arrayValue, bestMatchValue) < 0) {
+          bestMatchIndex = i;
+          bestMatchValue = arrayValue;
+        }
+      }
+    }
+  }
+  if (bestMatchIndex !== -1) {
+    const returnItem = searchReturnArray[bestMatchIndex];
+    if (returnItem && returnItem.result.type === "value") {
+      return {
+        type: "value",
+        result: returnItem.result.result
+      };
+    } else if (returnItem && returnItem.result.type === "error") {
+      return returnItem.result;
+    }
+  }
+  if (hasIfNotFound && ifNotFound !== null) {
+    return {
+      type: "value",
+      result: ifNotFound
+    };
+  }
+  return {
+    type: "error",
+    err: import_types.FormulaError.NA,
+    errAddress: context.dependencyNode,
+    message: "XLOOKUP: lookup_value not found"
+  };
+}
+var XLOOKUP = {
+  name: "XLOOKUP",
+  evaluate: function(node, context) {
+    if (node.args.length < 3 || node.args.length > 6) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP function takes 3 to 6 arguments"
+      };
+    }
+    const lookupValueResult = this.evaluateNode(node.args[0], context);
+    if (lookupValueResult.type === "error") {
+      return lookupValueResult;
+    }
+    const lookupArrayResult = this.evaluateNode(node.args[1], context);
+    if (lookupArrayResult.type === "error") {
+      return lookupArrayResult;
+    }
+    const returnArrayResult = this.evaluateNode(node.args[2], context);
+    if (returnArrayResult.type === "error") {
+      return returnArrayResult;
+    }
+    let ifNotFoundResult = null;
+    if (node.args[3]) {
+      ifNotFoundResult = this.evaluateNode(node.args[3], context);
+      if (ifNotFoundResult.type === "error") {
+        return ifNotFoundResult;
+      }
+    }
+    let matchModeResult = {
+      type: "value",
+      result: { type: "number", value: 0 }
+    };
+    if (node.args[4]) {
+      matchModeResult = this.evaluateNode(node.args[4], context);
+      if (matchModeResult.type === "error") {
+        return matchModeResult;
+      }
+    }
+    let searchModeResult = {
+      type: "value",
+      result: { type: "number", value: 1 }
+    };
+    if (node.args[5]) {
+      searchModeResult = this.evaluateNode(node.args[5], context);
+      if (searchModeResult.type === "error") {
+        return searchModeResult;
+      }
+    }
+    if (lookupValueResult.type === "spilled-values" || ifNotFoundResult && ifNotFoundResult.type === "spilled-values" || matchModeResult.type === "spilled-values" || searchModeResult.type === "spilled-values") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Spilled array arguments not yet supported"
+      };
+    }
+    if (lookupValueResult.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid lookup_value result type"
+      };
+    }
+    if (matchModeResult.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid match_mode result type"
+      };
+    }
+    if (searchModeResult.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid search_mode result type"
+      };
+    }
+    if (matchModeResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: `XLOOKUP match_mode must be number, got ${matchModeResult.result.type}`
+      };
+    }
+    if (searchModeResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: `XLOOKUP search_mode must be number, got ${searchModeResult.result.type}`
+      };
+    }
+    let ifNotFound = null;
+    const hasIfNotFound = !!ifNotFoundResult;
+    if (ifNotFoundResult && ifNotFoundResult.type === "value") {
+      ifNotFound = ifNotFoundResult.result;
+    }
+    const matchMode = Math.floor(matchModeResult.result.value);
+    const searchMode = Math.floor(searchModeResult.result.value);
+    let lookupArray = {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: "XLOOKUP: Invalid lookup_array type"
+    };
+    if (lookupArrayResult.type === "value") {
+      lookupArray = {
+        type: "values",
+        values: [{ result: lookupArrayResult, relativePos: { x: 0, y: 0 } }]
+      };
+    } else if (lookupArrayResult.type === "spilled-values") {
+      lookupArray = lookupArrayResult.evaluateAllCells.call(this, {
+        context,
+        evaluate: lookupArrayResult.evaluate,
+        origin: context.cellAddress,
+        lookupOrder: "col-major"
+      });
+    } else {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid lookup_array type"
+      };
+    }
+    let returnArray = {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: "XLOOKUP: Invalid return_array type"
+    };
+    if (returnArrayResult.type === "value") {
+      returnArray = {
+        type: "values",
+        values: [{ result: returnArrayResult, relativePos: { x: 0, y: 0 } }]
+      };
+    } else if (returnArrayResult.type === "spilled-values") {
+      returnArray = returnArrayResult.evaluateAllCells.call(this, {
+        context,
+        evaluate: returnArrayResult.evaluate,
+        origin: context.cellAddress,
+        lookupOrder: "col-major"
+      });
+    } else {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid return_array type"
+      };
+    }
+    return xlookupOperation.call(this, lookupValueResult.result, lookupArray, returnArray, ifNotFound, hasIfNotFound, matchMode, searchMode, context);
+  }
+};
+
+//# debugId=1478594EA3498F9864756E2164756E21

package/dist/cjs/functions/lookup/xlookup/xlookup.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/lookup/xlookup/xlookup.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  type EvaluateAllCellsResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\n\n/**\n * XLOOKUP function - Searches for a value and returns a corresponding value from another array\n * XLOOKUP(lookup_value, lookup_array, return_array, [if_not_found], [match_mode], [search_mode])\n *\n * Parameters:\n * - lookup_value: The value to search for (any type)\n * - lookup_array: The array or range to search\n * - return_array: The array or range to return values from\n * - if_not_found: Optional value to return when no match is found (default: #N/A)\n * - match_mode: Optional integer specifying match type (default: 0)\n *   - 0: Exact match; if none, return #N/A\n *   - -1: Exact match; if none, return next smaller item\n *   - 1: Exact match; if none, return next larger item\n *   - 2: Wildcard match (*, ?, ~)\n * - search_mode: Optional integer specifying search direction (default: 1)\n *   - 1: Search from first item (forward)\n *   - -1: Search from last item (reverse)\n *   - 2: Binary search (ascending order required)\n *   - -2: Binary search (descending order required)\n */\n\n// Helper to compare values for XLOOKUP\nfunction compareValues(a: CellValue, b: CellValue): number {\n  // Handle different type comparisons\n  if (a.type !== b.type) {\n    // Numbers < Strings < Booleans in Excel comparison order\n    const typeOrder = { number: 0, string: 1, boolean: 2, infinity: 0 };\n    return (typeOrder[a.type] || 3) - (typeOrder[b.type] || 3);\n  }\n\n  // Same type comparison\n  if (a.type === \"number\" && b.type === \"number\") {\n    return a.value - b.value;\n  }\n  if (a.type === \"string\" && b.type === \"string\") {\n    return a.value.localeCompare(b.value);\n  }\n  if (a.type === \"boolean\" && b.type === \"boolean\") {\n    return (a.value ? 1 : 0) - (b.value ? 1 : 0);\n  }\n\n  return 0;\n}\n\n// Helper to check if values match (exact match)\nfunction valuesMatch(a: CellValue, b: CellValue): boolean {\n  if (a.type !== b.type) return false;\n  if (a.type === \"number\" && b.type === \"number\") {\n    return a.value === b.value;\n  }\n  if (a.type === \"string\" && b.type === \"string\") {\n    return a.value === b.value;\n  }\n  if (a.type === \"boolean\" && b.type === \"boolean\") {\n    return a.value === b.value;\n  }\n  return false;\n}\n\n// Helper to check wildcard match\nfunction wildcardMatch(pattern: string, text: string): boolean {\n  // Convert wildcard pattern to regex\n  // ~ is escape character, * matches any sequence, ? matches single char\n  let regex = \"\";\n  let i = 0;\n  while (i < pattern.length) {\n    const char = pattern[i];\n    if (!char) break;\n\n    if (char === \"~\" && i + 1 < pattern.length) {\n      // Escape next character\n      const nextChar = pattern[i + 1];\n      if (nextChar) {\n        regex += nextChar.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n      }\n      i += 2;\n    } else if (char === \"*\") {\n      regex += \".*\";\n      i++;\n    } else if (char === \"?\") {\n      regex += \".\";\n      i++;\n    } else {\n      regex += char.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n      i++;\n    }\n  }\n\n  try {\n    const re = new RegExp(`^${regex}$`, \"i\"); // Case-insensitive\n    return re.test(text);\n  } catch {\n    return false;\n  }\n}\n\n// Helper function to perform XLOOKUP operation\nfunction xlookupOperation(\n  this: FormulaEvaluator,\n  lookupValue: CellValue,\n  lookupArray: EvaluateAllCellsResult,\n  returnArray: EvaluateAllCellsResult,\n  ifNotFound: CellValue | null,\n  hasIfNotFound: boolean,\n  matchMode: number,\n  searchMode: number,\n  context: EvaluationContext\n): FunctionEvaluationResult {\n  // Validate match_mode\n  if (![0, -1, 1, 2].includes(matchMode)) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      errAddress: context.dependencyNode,\n      message: `XLOOKUP match_mode must be -1, 0, 1, or 2, got ${matchMode}`,\n    };\n  }\n\n  // Validate search_mode\n  if (![1, -1, 2, -2].includes(searchMode)) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      errAddress: context.dependencyNode,\n      message: `XLOOKUP search_mode must be 1, -1, 2, or -2, got ${searchMode}`,\n    };\n  }\n\n  if (lookupArray.type !== \"values\") {\n    return lookupArray;\n  }\n  if (returnArray.type !== \"values\") {\n    return returnArray;\n  }\n\n  // Check arrays have same length\n  if (lookupArray.values.length !== returnArray.values.length) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      errAddress: context.dependencyNode,\n      message:\n        \"XLOOKUP lookup_array and return_array must have same dimensions\",\n    };\n  }\n\n  if (lookupArray.values.length === 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      errAddress: context.dependencyNode,\n      message: \"XLOOKUP lookup_array cannot be empty\",\n    };\n  }\n\n  // Binary search modes (not yet implemented)\n  if (searchMode === 2 || searchMode === -2) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      errAddress: context.dependencyNode,\n      message: \"XLOOKUP binary search mode not yet implemented\",\n    };\n  }\n\n  // Determine search order\n  const searchArray =\n    searchMode === -1 ? [...lookupArray.values].reverse() : lookupArray.values;\n  const searchReturnArray =\n    searchMode === -1 ? [...returnArray.values].reverse() : returnArray.values;\n\n  let bestMatchIndex = -1;\n  let bestMatchValue: CellValue | null = null;\n\n  // Search through the array\n  for (let i = 0; i < searchArray.length; i++) {\n    const item = searchArray[i];\n    if (!item || item.result.type !== \"value\") continue;\n\n    const arrayValue = item.result.result;\n\n    // Match mode 0: Exact match\n    if (matchMode === 0) {\n      if (valuesMatch(lookupValue, arrayValue)) {\n        const returnItem = searchReturnArray[i];\n        if (!returnItem) continue;\n\n        if (returnItem.result.type === \"value\") {\n          return {\n            type: \"value\",\n            result: returnItem.result.result,\n          };\n        } else if (returnItem.result.type === \"error\") {\n          return returnItem.result;\n        }\n      }\n    }\n    // Match mode 2: Wildcard match\n    else if (matchMode === 2) {\n      if (lookupValue.type === \"string\" && arrayValue.type === \"string\") {\n        if (wildcardMatch(lookupValue.value, arrayValue.value)) {\n          const returnItem = searchReturnArray[i];\n          if (!returnItem) continue;\n\n          if (returnItem.result.type === \"value\") {\n            return {\n              type: \"value\",\n              result: returnItem.result.result,\n            };\n          } else if (returnItem.result.type === \"error\") {\n            return returnItem.result;\n          }\n        }\n      }\n    }\n    // Match mode -1: Exact or next smaller\n    else if (matchMode === -1) {\n      const cmp = compareValues(arrayValue, lookupValue);\n      if (cmp === 0) {\n        // Exact match found\n        const returnItem = searchReturnArray[i];\n        if (!returnItem) continue;\n\n        if (returnItem.result.type === \"value\") {\n          return {\n            type: \"value\",\n            result: returnItem.result.result,\n          };\n        } else if (returnItem.result.type === \"error\") {\n          return returnItem.result;\n        }\n      } else if (cmp < 0) {\n        // arrayValue < lookupValue\n        if (\n          bestMatchValue === null ||\n          compareValues(arrayValue, bestMatchValue) > 0\n        ) {\n          bestMatchIndex = i;\n          bestMatchValue = arrayValue;\n        }\n      }\n    }\n    // Match mode 1: Exact or next larger\n    else if (matchMode === 1) {\n      const cmp = compareValues(arrayValue, lookupValue);\n      if (cmp === 0) {\n        // Exact match found\n        const returnItem = searchReturnArray[i];\n        if (!returnItem) continue;\n\n        if (returnItem.result.type === \"value\") {\n          return {\n            type: \"value\",\n            result: returnItem.result.result,\n          };\n        } else if (returnItem.result.type === \"error\") {\n          return returnItem.result;\n        }\n      } else if (cmp > 0) {\n        // arrayValue > lookupValue\n        if (\n          bestMatchValue === null ||\n          compareValues(arrayValue, bestMatchValue) < 0\n        ) {\n          bestMatchIndex = i;\n          bestMatchValue = arrayValue;\n        }\n      }\n    }\n  }\n\n  // Check if we found an approximate match\n  if (bestMatchIndex !== -1) {\n    const returnItem = searchReturnArray[bestMatchIndex];\n    if (returnItem && returnItem.result.type === \"value\") {\n      return {\n        type: \"value\",\n        result: returnItem.result.result,\n      };\n    } else if (returnItem && returnItem.result.type === \"error\") {\n      return returnItem.result;\n    }\n  }\n\n  // No match found - return if_not_found or #N/A\n  if (hasIfNotFound && ifNotFound !== null) {\n    return {\n      type: \"value\",\n      result: ifNotFound,\n    };\n  }\n\n  return {\n    type: \"error\",\n    err: FormulaError.NA,\n    errAddress: context.dependencyNode,\n    message: \"XLOOKUP: lookup_value not found\",\n  };\n}\n\nexport const XLOOKUP: FunctionDefinition = {\n  name: \"XLOOKUP\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 3 || node.args.length > 6) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: \"XLOOKUP function takes 3 to 6 arguments\",\n      };\n    }\n\n    // Evaluate lookup_value\n    const lookupValueResult = this.evaluateNode(node.args[0]!, context);\n    if (lookupValueResult.type === \"error\") {\n      return lookupValueResult;\n    }\n\n    // Evaluate lookup_array\n    const lookupArrayResult = this.evaluateNode(node.args[1]!, context);\n    if (lookupArrayResult.type === \"error\") {\n      return lookupArrayResult;\n    }\n\n    // Evaluate return_array\n    const returnArrayResult = this.evaluateNode(node.args[2]!, context);\n    if (returnArrayResult.type === \"error\") {\n      return returnArrayResult;\n    }\n\n    // Evaluate if_not_found (optional)\n    let ifNotFoundResult: FunctionEvaluationResult | null = null;\n    if (node.args[3]) {\n      ifNotFoundResult = this.evaluateNode(node.args[3], context);\n      if (ifNotFoundResult.type === \"error\") {\n        return ifNotFoundResult;\n      }\n    }\n\n    // Evaluate match_mode (optional, defaults to 0)\n    let matchModeResult: FunctionEvaluationResult = {\n      type: \"value\",\n      result: { type: \"number\", value: 0 },\n    };\n    if (node.args[4]) {\n      matchModeResult = this.evaluateNode(node.args[4], context);\n      if (matchModeResult.type === \"error\") {\n        return matchModeResult;\n      }\n    }\n\n    // Evaluate search_mode (optional, defaults to 1)\n    let searchModeResult: FunctionEvaluationResult = {\n      type: \"value\",\n      result: { type: \"number\", value: 1 },\n    };\n    if (node.args[5]) {\n      searchModeResult = this.evaluateNode(node.args[5], context);\n      if (searchModeResult.type === \"error\") {\n        return searchModeResult;\n      }\n    }\n\n    // Handle spilled arrays for simple arguments\n    if (\n      lookupValueResult.type === \"spilled-values\" ||\n      (ifNotFoundResult && ifNotFoundResult.type === \"spilled-values\") ||\n      matchModeResult.type === \"spilled-values\" ||\n      searchModeResult.type === \"spilled-values\"\n    ) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: \"XLOOKUP: Spilled array arguments not yet supported\",\n      };\n    }\n\n    // Validate result types\n    if (lookupValueResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: \"XLOOKUP: Invalid lookup_value result type\",\n      };\n    }\n\n    if (matchModeResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: \"XLOOKUP: Invalid match_mode result type\",\n      };\n    }\n\n    if (searchModeResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: \"XLOOKUP: Invalid search_mode result type\",\n      };\n    }\n\n    // Type check match_mode\n    if (matchModeResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: `XLOOKUP match_mode must be number, got ${matchModeResult.result.type}`,\n      };\n    }\n\n    // Type check search_mode\n    if (searchModeResult.result.type !== \"number\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: `XLOOKUP search_mode must be number, got ${searchModeResult.result.type}`,\n      };\n    }\n\n    // Extract if_not_found value\n    let ifNotFound: CellValue | null = null;\n    const hasIfNotFound = !!ifNotFoundResult;\n    if (ifNotFoundResult && ifNotFoundResult.type === \"value\") {\n      ifNotFound = ifNotFoundResult.result;\n    }\n\n    // Extract match_mode and search_mode as integers\n    const matchMode = Math.floor(matchModeResult.result.value);\n    const searchMode = Math.floor(searchModeResult.result.value);\n\n    // Extract lookup_array values\n    let lookupArray: EvaluateAllCellsResult = {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      errAddress: context.dependencyNode,\n      message: \"XLOOKUP: Invalid lookup_array type\",\n    };\n    if (lookupArrayResult.type === \"value\") {\n      lookupArray = {\n        type: \"values\",\n        values: [{ result: lookupArrayResult, relativePos: { x: 0, y: 0 } }],\n      };\n    } else if (lookupArrayResult.type === \"spilled-values\") {\n      lookupArray = lookupArrayResult.evaluateAllCells.call(this, {\n        context,\n        evaluate: lookupArrayResult.evaluate,\n        origin: context.cellAddress,\n        lookupOrder: \"col-major\",\n      });\n    } else {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: \"XLOOKUP: Invalid lookup_array type\",\n      };\n    }\n\n    // Extract return_array values\n    let returnArray: EvaluateAllCellsResult = {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      errAddress: context.dependencyNode,\n      message: \"XLOOKUP: Invalid return_array type\",\n    };\n    if (returnArrayResult.type === \"value\") {\n      returnArray = {\n        type: \"values\",\n        values: [{ result: returnArrayResult, relativePos: { x: 0, y: 0 } }],\n      };\n    } else if (returnArrayResult.type === \"spilled-values\") {\n      returnArray = returnArrayResult.evaluateAllCells.call(this, {\n        context,\n        evaluate: returnArrayResult.evaluate,\n        origin: context.cellAddress,\n        lookupOrder: \"col-major\",\n      });\n    } else {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        errAddress: context.dependencyNode,\n        message: \"XLOOKUP: Invalid return_array type\",\n      };\n    }\n\n    // Perform XLOOKUP operation\n    return xlookupOperation.call(\n      this,\n      lookupValueResult.result,\n      lookupArray,\n      returnArray,\n      ifNotFound,\n      hasIfNotFound,\n      matchMode,\n      searchMode,\n      context\n    );\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "1478594EA3498F9864756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/average/average-utils.cjs

@@ -0,0 +1,72 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/average/average-utils.ts
+var exports_average_utils = {};
+__export(exports_average_utils, {
+  performAverage: () => performAverage
+});
+module.exports = __toCommonJS(exports_average_utils);
+var import_types = require("src/core/types");
+function performAverage(results, context) {
+  let sum = 0;
+  let count = 0;
+  for (const result of results) {
+    if (result.type === "error") {
+      return result;
+    }
+    if (result.type === "awaiting-evaluation") {
+      return result;
+    }
+    if (result.type === "value") {
+      if (result.result.type === "number") {
+        sum += result.result.value;
+        count++;
+      } else if (result.result.type === "infinity") {
+        return {
+          type: "value",
+          result: result.result
+        };
+      }
+    }
+  }
+  if (count === 0) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.DIV0,
+      message: "Cannot calculate average of empty range",
+      errAddress: context.dependencyNode
+    };
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: sum / count }
+  };
+}
+
+//# debugId=C183EA81D21EE8D764756E2164756E21

package/dist/cjs/functions/math/average/average-utils.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/average/average-utils.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * Performs averaging of an iterable of SingleEvaluationResult values\n * Handles numbers, infinities, and errors according to Excel's AVERAGE behavior\n *\n * @param results - Iterable of SingleEvaluationResult to average\n * @returns FunctionEvaluationResult with the average or appropriate error\n */\nexport function performAverage(\n  results: SingleEvaluationResult[],\n  context: EvaluationContext\n): FunctionEvaluationResult {\n  let sum = 0;\n  let count = 0;\n\n  for (const result of results) {\n    if (result.type === \"error\") {\n      // Propagate errors immediately\n      return result;\n    }\n    if (result.type === \"awaiting-evaluation\") {\n      return result;\n    }\n\n    if (result.type === \"value\") {\n      if (result.result.type === \"number\") {\n        sum += result.result.value;\n        count++;\n      } else if (result.result.type === \"infinity\") {\n        // Infinity dominates - return immediately\n        return {\n          type: \"value\",\n          result: result.result,\n        };\n      }\n      // Non-numeric values (strings, booleans) are ignored\n    }\n  }\n\n  if (count === 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.DIV0,\n      message: \"Cannot calculate average of empty range\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  return {\n    type: \"value\",\n    result: { type: \"number\", value: sum / count },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AAcO,SAAS,cAAc,CAC5B,SACA,SAC0B;AAAA,EAC1B,IAAI,MAAM;AAAA,EACV,IAAI,QAAQ;AAAA,EAEZ,WAAW,UAAU,SAAS;AAAA,IAC5B,IAAI,OAAO,SAAS,SAAS;AAAA,MAE3B,OAAO;AAAA,IACT;AAAA,IACA,IAAI,OAAO,SAAS,uBAAuB;AAAA,MACzC,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,OAAO,SAAS,SAAS;AAAA,MAC3B,IAAI,OAAO,OAAO,SAAS,UAAU;AAAA,QACnC,OAAO,OAAO,OAAO;AAAA,QACrB;AAAA,MACF,EAAO,SAAI,OAAO,OAAO,SAAS,YAAY;AAAA,QAE5C,OAAO;AAAA,UACL,MAAM;AAAA,UACN,QAAQ,OAAO;AAAA,QACjB;AAAA,MACF;AAAA,IAEF;AAAA,EACF;AAAA,EAEA,IAAI,UAAU,GAAG;AAAA,IACf,OAAO;AAAA,MACL,MAAM;AAAA,MACN,KAAK,0BAAa;AAAA,MAClB,SAAS;AAAA,MACT,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,EAAE,MAAM,UAAU,OAAO,MAAM,MAAM;AAAA,EAC/C;AAAA;",
+  "debugId": "C183EA81D21EE8D764756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/average/average.cjs

@@ -0,0 +1,48 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/average/average.ts
+var exports_average = {};
+__export(exports_average, {
+  AVERAGE: () => AVERAGE
+});
+module.exports = __toCommonJS(exports_average);
+var import_average_utils = require("./average-utils.cjs");
+var import_function_utils = require("src/functions/function-utils");
+var AVERAGE = {
+  name: "AVERAGE",
+  evaluate: function(node, context) {
+    const argumentValues = import_function_utils.createArgumentIterator(this, node, context, "col-major");
+    if (argumentValues.type !== "values") {
+      return argumentValues;
+    }
+    return import_average_utils.performAverage(argumentValues.values, context);
+  }
+};
+
+//# debugId=42E5FEF82516EAA264756E2164756E21

package/dist/cjs/functions/math/average/average.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/average/average.ts"],
+  "sourcesContent": [
+    "import {\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport { performAverage } from \"./average-utils.cjs\";\nimport { createArgumentIterator } from \"src/functions/function-utils\";\n\n/**\n * AVERAGE function - Calculates the arithmetic mean of all numbers in the arguments\n *\n * Usage: AVERAGE(value1, [value2], ...)\n *\n * Examples:\n *   AVERAGE(1, 2, 3) - returns 2\n *   AVERAGE(A1:A10) - averages all numbers in the range A1:A10\n *   AVERAGE(A1:A5, B1:B5) - averages all numbers in both ranges\n *\n * Note:\n * - Only numeric values are included in the calculation\n * - Text, logical values, and empty cells are ignored in ranges\n * - Direct text/logical arguments cause errors\n * - Returns #DIV/0! if no numeric values are found\n */\nexport const AVERAGE: FunctionDefinition = {\n  name: \"AVERAGE\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Create iterator over all argument values\n    const argumentValues = createArgumentIterator(\n      this,\n      node,\n      context,\n      \"col-major\"\n    );\n\n    if (argumentValues.type !== \"values\") {\n      return argumentValues;\n    }\n\n    // Use shared averaging utility (now with unified error propagation)\n    return performAverage(argumentValues.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI+B,IAA/B;AACuC,IAAvC;AAkBO,IAAM,UAA8B;AAAA,EACzC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,iBAAiB,6CACrB,MACA,MACA,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AAAA,IACT;AAAA,IAGA,OAAO,oCAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "42E5FEF82516EAA264756E2164756E21",
+  "names": []
+}