@ricsam/formula-engine 0.0.1

package/dist/mjs/functions/lookup/xlookup/xlookup.mjs

@@ -0,0 +1,382 @@
+// src/functions/lookup/xlookup/xlookup.ts
+import {
+  FormulaError
+} from "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: 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: 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: 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: FormulaError.VALUE,
+      errAddress: context.dependencyNode,
+      message: "XLOOKUP lookup_array cannot be empty"
+    };
+  }
+  if (searchMode === 2 || searchMode === -2) {
+    return {
+      type: "error",
+      err: 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: 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: 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: FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Spilled array arguments not yet supported"
+      };
+    }
+    if (lookupValueResult.type !== "value") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid lookup_value result type"
+      };
+    }
+    if (matchModeResult.type !== "value") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid match_mode result type"
+      };
+    }
+    if (searchModeResult.type !== "value") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid search_mode result type"
+      };
+    }
+    if (matchModeResult.result.type !== "number") {
+      return {
+        type: "error",
+        err: 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: 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: 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: FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid lookup_array type"
+      };
+    }
+    let returnArray = {
+      type: "error",
+      err: 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: FormulaError.VALUE,
+        errAddress: context.dependencyNode,
+        message: "XLOOKUP: Invalid return_array type"
+      };
+    }
+    return xlookupOperation.call(this, lookupValueResult.result, lookupArray, returnArray, ifNotFound, hasIfNotFound, matchMode, searchMode, context);
+  }
+};
+export {
+  XLOOKUP
+};
+
+//# debugId=F246D0507C9ABA1B64756E2164756E21

package/dist/mjs/functions/lookup/xlookup/xlookup.mjs.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": "F246D0507C9ABA1B64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,44 @@
+// src/functions/math/average/average-utils.ts
+import {
+  FormulaError
+} from "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: FormulaError.DIV0,
+      message: "Cannot calculate average of empty range",
+      errAddress: context.dependencyNode
+    };
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: sum / count }
+  };
+}
+export {
+  performAverage
+};
+
+//# debugId=A2F15D16FE74F8C164756E2164756E21

package/dist/mjs/functions/math/average/average-utils.mjs.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": ";AAAA;AAAA;AAAA;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,aAAa;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": "A2F15D16FE74F8C164756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/average/average.mjs

@@ -0,0 +1,18 @@
+// src/functions/math/average/average.ts
+import { performAverage } from "./average-utils.mjs";
+import { createArgumentIterator } from "src/functions/function-utils";
+var AVERAGE = {
+  name: "AVERAGE",
+  evaluate: function(node, context) {
+    const argumentValues = createArgumentIterator(this, node, context, "col-major");
+    if (argumentValues.type !== "values") {
+      return argumentValues;
+    }
+    return performAverage(argumentValues.values, context);
+  }
+};
+export {
+  AVERAGE
+};
+
+//# debugId=C029FB3B43F4C5E164756E2164756E21

package/dist/mjs/functions/math/average/average.mjs.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.mjs\";\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": ";AAIA;AACA;AAkBO,IAAM,UAA8B;AAAA,EACzC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,iBAAiB,uBACrB,MACA,MACA,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AAAA,IACT;AAAA,IAGA,OAAO,eAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "C029FB3B43F4C5E164756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/average/averageif.mjs

@@ -0,0 +1,58 @@
+// src/functions/math/average/averageif.ts
+import {
+  FormulaError
+} from "src/core/types";
+import {
+  processMultiCriteriaValues,
+  validateSingleCriteriaArgs
+} from "../../criteria-utils.mjs";
+import { parseCriteria } from "../../criteria-parser.mjs";
+import { performAverage } from "./average-utils.mjs";
+var AVERAGEIF = {
+  name: "AVERAGEIF",
+  evaluate: function(node, context) {
+    const argError = validateSingleCriteriaArgs("AVERAGEIF", node.args.length, context);
+    if (argError) {
+      return argError;
+    }
+    const criteriaRangeResult = this.evaluateNode(node.args[0], context);
+    if (criteriaRangeResult.type === "error") {
+      return criteriaRangeResult;
+    }
+    const criteriaResult = this.evaluateNode(node.args[1], context);
+    if (criteriaResult.type === "error") {
+      return criteriaResult;
+    }
+    if (criteriaResult.type !== "value") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "AVERAGEIF criteria must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    const parsedCriteria = parseCriteria(criteriaResult.result);
+    if (parsedCriteria.type === "error") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: parsedCriteria.message,
+        errAddress: context.dependencyNode
+      };
+    }
+    const averageRangeResult = node.args.length === 3 ? this.evaluateNode(node.args[2], context) : criteriaRangeResult;
+    if (averageRangeResult.type === "error") {
+      return averageRangeResult;
+    }
+    const matchingValues = processMultiCriteriaValues(this, averageRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return performAverage(matchingValues.values, context);
+  }
+};
+export {
+  AVERAGEIF
+};
+
+//# debugId=ECB1C9E28720AEEC64756E2164756E21

package/dist/mjs/functions/math/average/averageif.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/average/averageif.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport { \n  processMultiCriteriaValues, \n  validateSingleCriteriaArgs,\n} from \"../../criteria-utils.mjs\";\nimport { parseCriteria, matchesParsedCriteria } from \"../../criteria-parser.mjs\";\nimport { performAverage } from \"./average-utils.mjs\";\n\n/**\n * AVERAGEIF function - Calculates the average of cells in a range that meet a criteria\n * \n * Usage: AVERAGEIF(range, criteria, [average_range])\n * \n * range: The range of cells to evaluate against the criteria\n * criteria: The criteria to match against. Can be:\n *   - Exact value: \"Apple\", 42\n *   - Comparison: \">10\", \"<=5\", \"<>0\"\n *   - Wildcards: \"App*\", \"?ruit\"\n * average_range: Optional. The range to average. If omitted, uses the range parameter\n * \n * Examples:\n *   AVERAGEIF(A1:A10, \"Apple\") - averages cells in A1:A10 that contain \"Apple\"\n *   AVERAGEIF(B1:B10, \">10\") - averages cells in B1:B10 with values greater than 10\n *   AVERAGEIF(A1:A10, \"Apple\", B1:B10) - averages B1:B10 where A1:A10 contains \"Apple\"\n * \n * Note:\n * - Only numeric values are included in the average calculation\n * - Returns error if no values match the criteria\n */\nexport const AVERAGEIF: FunctionDefinition = {\n  name: \"AVERAGEIF\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments\n    const argError = validateSingleCriteriaArgs(\"AVERAGEIF\", node.args.length, context);\n    if (argError) {\n      return argError;\n    }\n\n    // Evaluate criteria range (first argument)\n    const criteriaRangeResult = this.evaluateNode(node.args[0]!, context);\n    if (criteriaRangeResult.type === \"error\") {\n      return criteriaRangeResult;\n    }\n\n    // Evaluate criteria (second argument)\n    const criteriaResult = this.evaluateNode(node.args[1]!, context);\n    if (criteriaResult.type === \"error\") {\n      return criteriaResult;\n    }\n\n    if (criteriaResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"AVERAGEIF criteria must be a single value\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Parse criteria\n    const parsedCriteria = parseCriteria(criteriaResult.result);\n    if (parsedCriteria.type === \"error\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: parsedCriteria.message,\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Determine average range (third argument if present, otherwise same as criteria range)\n    const averageRangeResult = node.args.length === 3 \n      ? this.evaluateNode(node.args[2]!, context)\n      : criteriaRangeResult;\n    \n    if (averageRangeResult.type === \"error\") {\n      return averageRangeResult;\n    }\n\n    // Use shared average utility for standard cases\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      averageRangeResult,\n      [{ rangeResult: criteriaRangeResult, parsedCriteria }],\n      context,\n      \"col-major\"\n    );\n\n    if (matchingValues.type === \"error\" || matchingValues.type === \"awaiting-evaluation\") {\n      return matchingValues;\n    }\n\n    return performAverage(matchingValues.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAMA;AAAA;AAAA;AAAA;AAIA;AACA;AAuBO,IAAM,YAAgC;AAAA,EAC3C,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,2BAA2B,aAAa,KAAK,KAAK,QAAQ,OAAO;AAAA,IAClF,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IACpE,IAAI,oBAAoB,SAAS,SAAS;AAAA,MACxC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,iBAAiB,cAAc,eAAe,MAAM;AAAA,IAC1D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS,eAAe;AAAA,QACxB,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,qBAAqB,KAAK,KAAK,WAAW,IAC5C,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO,IACxC;AAAA,IAEJ,IAAI,mBAAmB,SAAS,SAAS;AAAA,MACvC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,2BACrB,MACA,oBACA,CAAC,EAAE,aAAa,qBAAqB,eAAe,CAAC,GACrD,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,eAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "ECB1C9E28720AEEC64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/average/averageifs.mjs

@@ -0,0 +1,35 @@
+// src/functions/math/average/averageifs.ts
+import {
+  parseCriteriaPairs,
+  processMultiCriteriaValues,
+  validateMultiCriteriaArgs
+} from "../../criteria-utils.mjs";
+import { performAverage } from "./average-utils.mjs";
+var AVERAGEIFS = {
+  name: "AVERAGEIFS",
+  evaluate: function(node, context) {
+    const argError = validateMultiCriteriaArgs("AVERAGEIFS", node.args.length, context);
+    if (argError) {
+      return argError;
+    }
+    const averageRangeResult = this.evaluateNode(node.args[0], context);
+    if (averageRangeResult.type === "error") {
+      return averageRangeResult;
+    }
+    const criteriaPairsResult = parseCriteriaPairs.call(this, node, context, this.evaluateNode, 1);
+    if ("type" in criteriaPairsResult) {
+      return criteriaPairsResult;
+    }
+    const criteriaPairs = criteriaPairsResult;
+    const matchingValues = processMultiCriteriaValues(this, averageRangeResult, criteriaPairs, context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return performAverage(matchingValues.values, context);
+  }
+};
+export {
+  AVERAGEIFS
+};
+
+//# debugId=81C16C1A4A35CECF64756E2164756E21