@ricsam/formula-engine 0.0.1

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/average/averageifs.ts"],
+  "sourcesContent": [
+    "import {\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport {\n  parseCriteriaPairs,\n  processMultiCriteriaValues,\n  validateMultiCriteriaArgs,\n} from \"../../criteria-utils.mjs\";\nimport { performAverage } from \"./average-utils.mjs\";\n\n/**\n * AVERAGEIFS function - Calculates the average of cells in a range that meet multiple criteria\n *\n * Usage: AVERAGEIFS(average_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)\n *\n * average_range: The range of cells to average\n * criteria_range1: The first range to evaluate against criteria1\n * criteria1: The first criteria to match against\n * criteria_range2, criteria2: Optional additional criteria pairs\n *\n * Examples:\n *   AVERAGEIFS(B1:B10, A1:A10, \"Apple\") - averages B1:B10 where A1:A10 = \"Apple\"\n *   AVERAGEIFS(C1:C10, A1:A10, \"Apple\", B1:B10, \">10\") - averages C1:C10 where A1:A10 = \"Apple\" AND B1:B10 > 10\n *\n * Note:\n * - All criteria must be satisfied for a value to be included\n * - Only numeric values are included in the average calculation\n * - Returns error if no values match all criteria\n */\nexport const AVERAGEIFS: FunctionDefinition = {\n  name: \"AVERAGEIFS\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments using utility\n    const argError = validateMultiCriteriaArgs(\"AVERAGEIFS\", node.args.length, context);\n    if (argError) {\n      return argError;\n    }\n\n    // Evaluate average range\n    const averageRangeResult = this.evaluateNode(node.args[0]!, context);\n    if (averageRangeResult.type === \"error\") {\n      return averageRangeResult;\n    }\n\n    // Parse criteria pairs using utility\n    const criteriaPairsResult = parseCriteriaPairs.call(\n      this,\n      node,\n      context,\n      this.evaluateNode,\n      1\n    );\n    if (\"type\" in criteriaPairsResult) {\n      return criteriaPairsResult;\n    }\n    const criteriaPairs = criteriaPairsResult;\n\n    // Use shared average utility for standard cases\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      averageRangeResult,\n      criteriaPairs,\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": ";AAKA;AAAA;AAAA;AAAA;AAAA;AAKA;AAqBO,IAAM,aAAiC;AAAA,EAC5C,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,0BAA0B,cAAc,KAAK,KAAK,QAAQ,OAAO;AAAA,IAClF,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,qBAAqB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IACnE,IAAI,mBAAmB,SAAS,SAAS;AAAA,MACvC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,mBAAmB,KAC7C,MACA,MACA,SACA,KAAK,cACL,CACF;AAAA,IACA,IAAI,UAAU,qBAAqB;AAAA,MACjC,OAAO;AAAA,IACT;AAAA,IACA,MAAM,gBAAgB;AAAA,IAGtB,MAAM,iBAAiB,2BACrB,MACA,oBACA,eACA,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": "81C16C1A4A35CECF64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/ceiling/ceiling.mjs

@@ -0,0 +1,191 @@
+// src/functions/math/ceiling/ceiling.ts
+import {
+  FormulaError
+} from "src/core/types";
+function ceilingOperation(numberValue, significanceValue, context) {
+  if (numberValue.type === "infinity") {
+    return numberValue;
+  }
+  if (significanceValue.type === "infinity") {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "Cannot use infinity as significance",
+      errAddress: context.dependencyNode
+    };
+  }
+  const num = numberValue.value;
+  const sig = significanceValue.value;
+  if (sig === 0) {
+    return {
+      type: "error",
+      err: FormulaError.DIV0,
+      message: "Significance cannot be zero",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (num > 0 && sig < 0) {
+    return {
+      type: "error",
+      err: FormulaError.NUM,
+      message: "Positive number cannot be used with negative significance",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (num < 0 && sig > 0) {
+    return {
+      type: "error",
+      err: FormulaError.NUM,
+      message: "Negative number cannot be used with positive significance",
+      errAddress: context.dependencyNode
+    };
+  }
+  let result;
+  if (sig > 0) {
+    result = Math.ceil(num / sig) * sig;
+  } else {
+    result = Math.ceil(num / sig) * sig;
+  }
+  return { type: "number", value: result };
+}
+function createCeilingSpilledResult({
+  numberResult,
+  significanceResult,
+  context
+}) {
+  const hasSpilledNumber = numberResult.type === "spilled-values";
+  const hasSpilledSignificance = significanceResult.type === "spilled-values";
+  if (!hasSpilledNumber && !hasSpilledSignificance) {
+    throw new Error("createCeilingSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      if (hasSpilledNumber && numberResult.type === "spilled-values") {
+        const spillArea = numberResult.spillArea(origin);
+        if (hasSpilledSignificance && significanceResult.type === "spilled-values") {
+          return this.unionRanges(this.projectRange(spillArea, origin), this.projectRange(significanceResult.spillArea(origin), origin));
+        }
+        return spillArea;
+      } else if (hasSpilledSignificance && significanceResult.type === "spilled-values") {
+        return significanceResult.spillArea(origin);
+      } else {
+        throw new Error("No spilled values found");
+      }
+    },
+    source: "CEILING with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillNumberResult = hasSpilledNumber ? numberResult.evaluate(spilledCell, evalContext) : numberResult;
+      const spillSigResult = hasSpilledSignificance ? significanceResult.evaluate(spilledCell, evalContext) : significanceResult;
+      if (spillNumberResult === undefined || spillSigResult === undefined) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: "The spilled results have not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillNumberResult.type === "error") {
+        return spillNumberResult;
+      }
+      if (spillSigResult.type === "error") {
+        return spillSigResult;
+      }
+      if (spillNumberResult.type !== "value" || spillSigResult.type !== "value") {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "Invalid spilled result for CEILING",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillNumberResult.result.type !== "number" && spillNumberResult.result.type !== "infinity") {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "Number argument must be a number",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillSigResult.result.type !== "number" && spillSigResult.result.type !== "infinity") {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "Significance argument must be a number",
+          errAddress: context.dependencyNode
+        };
+      }
+      const result = ceilingOperation(spillNumberResult.result, spillSigResult.result, context);
+      if (result.type === "error" || result.type === "awaiting-evaluation") {
+        return result;
+      }
+      return { type: "value", result };
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for CEILING is not implemented");
+    }
+  };
+}
+var CEILING = {
+  name: "CEILING",
+  evaluate: function(node, context) {
+    if (node.args.length !== 2) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "CEILING function takes exactly 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const numberResult = this.evaluateNode(node.args[0], context);
+    if (numberResult.type === "error" || numberResult.type === "awaiting-evaluation") {
+      return numberResult;
+    }
+    const significanceResult = this.evaluateNode(node.args[1], context);
+    if (significanceResult.type === "error" || significanceResult.type === "awaiting-evaluation") {
+      return significanceResult;
+    }
+    const hasSpilledValues = numberResult.type === "spilled-values" || significanceResult.type === "spilled-values";
+    if (hasSpilledValues) {
+      return createCeilingSpilledResult.call(this, {
+        numberResult,
+        significanceResult,
+        context
+      });
+    }
+    if (numberResult.type !== "value" || significanceResult.type !== "value") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "Invalid argument type",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (numberResult.result.type !== "number" && numberResult.result.type !== "infinity") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "Number argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (significanceResult.result.type !== "number" && significanceResult.result.type !== "infinity") {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "Significance argument must be a number",
+        errAddress: context.dependencyNode
+      };
+    }
+    const result = ceilingOperation(numberResult.result, significanceResult.result, context);
+    if (result.type === "error" || result.type === "awaiting-evaluation") {
+      return result;
+    }
+    return { type: "value", result };
+  }
+};
+export {
+  CEILING
+};
+
+//# debugId=3507AD64BBC0A37164756E2164756E21

package/dist/mjs/functions/math/ceiling/ceiling.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/ceiling/ceiling.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type CellInfinity,\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 * CEILING function - Rounds a number up to the nearest multiple of significance\n *\n * Usage: CEILING(number, significance)\n *\n * number: The number to round up (required)\n * significance: The multiple to round up to (required)\n *\n * Examples:\n *   CEILING(4.3) returns 5 (rounds up to nearest integer)\n *   CEILING(4.3, 0.5) returns 4.5 (rounds up to nearest 0.5)\n *   CEILING(-2.1, -1) returns -3 (rounds away from zero)\n *\n * Note:\n * - Both arguments are required and must be numbers (no type coercion)\n * - Positive number with negative significance returns #NUM! error\n * - Supports spilled values (dynamic arrays)\n * - Handles infinity values appropriately\n */\n\n/**\n * Helper function to perform CEILING operation\n */\nfunction ceilingOperation(\n  numberValue: CellNumber | CellInfinity,\n  significanceValue: CellNumber | CellInfinity,\n  context: EvaluationContext\n): CellNumber | CellInfinity | ErrorEvaluationResult {\n  // Handle infinity cases\n  if (numberValue.type === \"infinity\") {\n    return numberValue; // Infinity remains infinity\n  }\n\n  if (significanceValue.type === \"infinity\") {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"Cannot use infinity as significance\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Both are numbers\n  const num = numberValue.value;\n  const sig = significanceValue.value;\n\n  // Significance cannot be zero\n  if (sig === 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.DIV0,\n      message: \"Significance cannot be zero\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Excel CEILING behavior based on testing:\n  // - Always rounds away from zero\n  // - Positive number with negative significance gives #NUM! error\n\n  if (num > 0 && sig < 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.NUM,\n      message: \"Positive number cannot be used with negative significance\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  if (num < 0 && sig > 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.NUM,\n      message: \"Negative number cannot be used with positive significance\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  // Calculate result - always rounds away from zero\n  let result: number;\n\n  if (sig > 0) {\n    // Positive significance with positive/zero number\n    result = Math.ceil(num / sig) * sig;\n  } else {\n    // Negative significance with negative/zero number\n    // Round away from zero: -2.1/-1 = 2.1, ceil(2.1) = 3, 3*-1 = -3\n    result = Math.ceil(num / sig) * sig;\n  }\n\n  return { type: \"number\", value: result };\n}\n\n/**\n * Helper for creating spilled-values result for CEILING function\n */\nfunction createCeilingSpilledResult(\n  this: FormulaEvaluator,\n  {\n    numberResult,\n    significanceResult,\n    context,\n  }: {\n    numberResult: FunctionEvaluationResult;\n    significanceResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): SpilledValuesEvaluationResult | ErrorEvaluationResult {\n  const hasSpilledNumber = numberResult.type === \"spilled-values\";\n  const hasSpilledSignificance = significanceResult.type === \"spilled-values\";\n\n  if (!hasSpilledNumber && !hasSpilledSignificance) {\n    throw new Error(\"createCeilingSpilledResult 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      if (hasSpilledNumber && numberResult.type === \"spilled-values\") {\n        const spillArea = numberResult.spillArea(origin);\n        if (\n          hasSpilledSignificance &&\n          significanceResult.type === \"spilled-values\"\n        ) {\n          return this.unionRanges(\n            this.projectRange(spillArea, origin),\n            this.projectRange(significanceResult.spillArea(origin), origin)\n          );\n        }\n        return spillArea;\n      } else if (\n        hasSpilledSignificance &&\n        significanceResult.type === \"spilled-values\"\n      ) {\n        return significanceResult.spillArea(origin);\n      } else {\n        throw new Error(\"No spilled values found\");\n      }\n    },\n    source: \"CEILING with spilled values\",\n    evaluate: (spilledCell: any, evalContext: any): SingleEvaluationResult => {\n      // Evaluate arguments at this spilled position\n      const spillNumberResult = hasSpilledNumber\n        ? numberResult.evaluate(spilledCell, evalContext)\n        : numberResult;\n      const spillSigResult = hasSpilledSignificance\n        ? significanceResult.evaluate(spilledCell, evalContext)\n        : significanceResult;\n\n      if (spillNumberResult === undefined || spillSigResult === 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\n      if (spillNumberResult.type === \"error\") {\n        return spillNumberResult;\n      }\n      if (spillSigResult.type === \"error\") {\n        return spillSigResult;\n      }\n\n      if (\n        spillNumberResult.type !== \"value\" ||\n        spillSigResult.type !== \"value\"\n      ) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Invalid spilled result for CEILING\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      // Type checking\n      if (\n        spillNumberResult.result.type !== \"number\" &&\n        spillNumberResult.result.type !== \"infinity\"\n      ) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Number argument must be a number\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (\n        spillSigResult.result.type !== \"number\" &&\n        spillSigResult.result.type !== \"infinity\"\n      ) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Significance argument must be a number\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      const result = ceilingOperation(\n        spillNumberResult.result,\n        spillSigResult.result,\n        context\n      );\n      if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n        return result;\n      }\n      return { type: \"value\", result };\n    },\n    evaluateAllCells: (intersectingRange: any) => {\n      throw new Error(\"WIP: evaluateAllCells for CEILING is not implemented\");\n    },\n  };\n}\n\n/**\n * CEILING function implementation\n */\nexport const CEILING: FunctionDefinition = {\n  name: \"CEILING\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length !== 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"CEILING function takes exactly 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate number argument\n    const numberResult = this.evaluateNode(node.args[0]!, context);\n    if (numberResult.type === \"error\" || numberResult.type === \"awaiting-evaluation\") {\n      return numberResult;\n    }\n\n    // Evaluate significance argument (required)\n    const significanceResult = this.evaluateNode(node.args[1]!, context);\n    if (significanceResult.type === \"error\" || significanceResult.type === \"awaiting-evaluation\") {\n      return significanceResult;\n    }\n\n    // Handle spilled values\n    const hasSpilledValues =\n      numberResult.type === \"spilled-values\" ||\n      significanceResult.type === \"spilled-values\";\n\n    if (hasSpilledValues) {\n      return createCeilingSpilledResult.call(this, {\n        numberResult,\n        significanceResult,\n        context,\n      });\n    }\n\n    // Both arguments are single values\n    if (numberResult.type !== \"value\" || significanceResult.type !== \"value\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Invalid argument type\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Type checking - only numbers and infinity allowed\n    if (\n      numberResult.result.type !== \"number\" &&\n      numberResult.result.type !== \"infinity\"\n    ) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Number argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    if (\n      significanceResult.result.type !== \"number\" &&\n      significanceResult.result.type !== \"infinity\"\n    ) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"Significance argument must be a number\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Perform CEILING operation\n    const result = ceilingOperation(\n      numberResult.result,\n      significanceResult.result,\n      context\n    );\n    if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n      return result;\n    }\n    return { type: \"value\", result };\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "3507AD64BBC0A37164756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,43 @@
+// src/functions/math/max/max-utils.ts
+import {
+  FormulaError
+} from "src/core/types";
+function performMaximum(results, context) {
+  let maxValue = -Infinity;
+  let hasValues = false;
+  for (const result of results) {
+    if (result.type === "error") {
+      return result;
+    }
+    if (result.type === "value") {
+      if (result.result.type === "number") {
+        maxValue = Math.max(maxValue, result.result.value);
+        hasValues = true;
+      } else if (result.result.type === "infinity") {
+        if (result.result.sign === "positive") {
+          return {
+            type: "value",
+            result: result.result
+          };
+        }
+      }
+    }
+  }
+  if (!hasValues) {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "No numeric values found",
+      errAddress: context.dependencyNode
+    };
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: maxValue }
+  };
+}
+export {
+  performMaximum
+};
+
+//# debugId=B42D64F3DF6AD2FE64756E2164756E21

package/dist/mjs/functions/math/max/max-utils.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/max/max-utils.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionEvaluationResult,\n  type SingleEvaluationResult,\n  type CellInfinity,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\n\n/**\n * Result type for processInfinity in max functions\n */\nexport type ProcessInfinityResult<T> =\n  | { type: \"infinity\"; infinity: CellInfinity }\n  | { type: \"state\"; state: T };\n\n/**\n * Perform maximum calculation over an iterator of SingleEvaluationResults\n * Handles the common logic shared by MAX, MAXIF, MAXIFS functions\n *\n * @param results - Iterator of SingleEvaluationResults to find maximum from\n * @returns FunctionEvaluationResult with the maximum, infinity, or error\n */\nexport function performMaximum(\n  results: Iterable<SingleEvaluationResult>,\n  context: EvaluationContext\n): FunctionEvaluationResult {\n  let maxValue = -Infinity;\n  let hasValues = false;\n\n  for (const result of results) {\n    if (result.type === \"error\") {\n      // Propagate errors immediately\n      return result;\n    }\n\n    if (result.type === \"value\") {\n      if (result.result.type === \"number\") {\n        maxValue = Math.max(maxValue, result.result.value);\n        hasValues = true;\n      } else if (result.result.type === \"infinity\") {\n        if (result.result.sign === \"positive\") {\n          // Positive infinity is always the maximum - return immediately\n          return {\n            type: \"value\",\n            result: result.result,\n          };\n        }\n        // Negative infinity doesn't change the maximum\n      }\n      // Non-numeric values (strings, booleans) are ignored in maximum calculation\n    }\n  }\n\n  if (!hasValues) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"No numeric values found\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  return {\n    type: \"value\",\n    result: { type: \"number\", value: maxValue },\n  };\n}\n\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAsBO,SAAS,cAAc,CAC5B,SACA,SAC0B;AAAA,EAC1B,IAAI,WAAW;AAAA,EACf,IAAI,YAAY;AAAA,EAEhB,WAAW,UAAU,SAAS;AAAA,IAC5B,IAAI,OAAO,SAAS,SAAS;AAAA,MAE3B,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,OAAO,SAAS,SAAS;AAAA,MAC3B,IAAI,OAAO,OAAO,SAAS,UAAU;AAAA,QACnC,WAAW,KAAK,IAAI,UAAU,OAAO,OAAO,KAAK;AAAA,QACjD,YAAY;AAAA,MACd,EAAO,SAAI,OAAO,OAAO,SAAS,YAAY;AAAA,QAC5C,IAAI,OAAO,OAAO,SAAS,YAAY;AAAA,UAErC,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,OAAO;AAAA,UACjB;AAAA,QACF;AAAA,MAEF;AAAA,IAEF;AAAA,EACF;AAAA,EAEA,IAAI,CAAC,WAAW;AAAA,IACd,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,SAAS;AAAA,EAC5C;AAAA;",
+  "debugId": "B42D64F3DF6AD2FE64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/max/max.mjs

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

package/dist/mjs/functions/math/max/max.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/max/max.ts"],
+  "sourcesContent": [
+    "import {\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport { performMaximum } from \"./max-utils.mjs\";\nimport { createArgumentIterator } from \"src/functions/function-utils\";\n\n/**\n * MAX function - Returns the largest number in the arguments\n *\n * Usage: MAX(value1, [value2], ...)\n *\n * Examples:\n *   MAX(1, 2, 3) - returns 3\n *   MAX(A1:A10) - finds maximum in the range A1:A10\n *   MAX(A1:A5, B1:B5) - finds maximum across both ranges\n *\n * Note:\n * - Only numeric values are considered\n * - Text, logical values, and empty cells are ignored in ranges\n * - Direct text/logical arguments cause errors\n * - Returns error if no numeric values are found\n */\nexport const MAX: FunctionDefinition = {\n  name: \"MAX\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Create iterator over all argument values\n    const argumentValues = createArgumentIterator(this, node, context, \"col-major\");\n    if (argumentValues.type !== \"values\") {\n      return argumentValues;\n    }\n    // Use shared maximum utility (now with unified error propagation)\n    return performMaximum(argumentValues.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";AAIA;AACA;AAkBO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,iBAAiB,uBAAuB,MAAM,MAAM,SAAS,WAAW;AAAA,IAC9E,IAAI,eAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,eAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "9D5A2733BE9346AF64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/max/maxif.mjs

@@ -0,0 +1,58 @@
+// src/functions/math/max/maxif.ts
+import {
+  FormulaError
+} from "src/core/types";
+import {
+  processMultiCriteriaValues,
+  validateSingleCriteriaArgs
+} from "../../criteria-utils.mjs";
+import { parseCriteria } from "../../criteria-parser.mjs";
+import { performMaximum } from "./max-utils.mjs";
+var MAXIF = {
+  name: "MAXIF",
+  evaluate: function(node, context) {
+    const argError = validateSingleCriteriaArgs("MAXIF", 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: "MAXIF 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 maxRangeResult = node.args.length === 3 ? this.evaluateNode(node.args[2], context) : criteriaRangeResult;
+    if (maxRangeResult.type === "error") {
+      return maxRangeResult;
+    }
+    const matchingValues = processMultiCriteriaValues(this, maxRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return performMaximum(matchingValues.values, context);
+  }
+};
+export {
+  MAXIF
+};
+
+//# debugId=5350E4759DCAFED564756E2164756E21

package/dist/mjs/functions/math/max/maxif.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/max/maxif.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 { performMaximum } from \"./max-utils.mjs\";\n\n/**\n * MAXIF function - Returns the maximum value among cells specified by a criteria\n *\n * Usage: MAXIF(range, criteria, [max_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 * max_range: Optional. The range to find maximum from. If omitted, uses the range parameter\n *\n * Examples:\n *   MAXIF(A1:A10, \"Apple\") - max of cells in A1:A10 that contain \"Apple\"\n *   MAXIF(B1:B10, \">10\") - max of cells in B1:B10 with values greater than 10\n *   MAXIF(A1:A10, \"Apple\", B1:B10) - max of B1:B10 where A1:A10 contains \"Apple\"\n *\n * Note:\n * - Only numeric values are considered for the maximum\n * - Returns error if no values match the criteria\n */\nexport const MAXIF: FunctionDefinition = {\n  name: \"MAXIF\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments\n    const argError = validateSingleCriteriaArgs(\"MAXIF\", 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: \"MAXIF 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 max range (third argument if present, otherwise same as criteria range)\n    const maxRangeResult =\n      node.args.length === 3\n        ? this.evaluateNode(node.args[2]!, context)\n        : criteriaRangeResult;\n\n    if (maxRangeResult.type === \"error\") {\n      return maxRangeResult;\n    }\n\n    // Use shared maximum utility\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      maxRangeResult,\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 performMaximum(matchingValues.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAMA;AAAA;AAAA;AAAA;AAIA;AACA;AAuBO,IAAM,QAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,2BAA2B,SAAS,KAAK,KAAK,QAAQ,OAAO;AAAA,IAC9E,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IACpE,IAAI,oBAAoB,SAAS,SAAS;AAAA,MACxC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,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,iBACJ,KAAK,KAAK,WAAW,IACjB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO,IACxC;AAAA,IAEN,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,2BACrB,MACA,gBACA,CAAC,EAAE,aAAa,qBAAqB,eAAe,CAAC,GACrD,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,eAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "5350E4759DCAFED564756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/max/maxifs.mjs

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

package/dist/mjs/functions/math/max/maxifs.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/max/maxifs.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport {\n  parseCriteriaPairs,\n  processMultiCriteriaValues,\n  validateMultiCriteriaArgs,\n} from \"../../criteria-utils.mjs\";\nimport { performMaximum } from \"./max-utils.mjs\";\n\n/**\n * MAXIFS function - Returns the maximum value among cells specified by multiple criteria\n *\n * Usage: MAXIFS(max_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)\n *\n * max_range: The range of cells from which you want the maximum\n * criteria_range1: The first range in which to evaluate criteria\n * criteria1: The criteria to apply to criteria_range1\n * criteria_range2, criteria2: Optional additional criteria pairs\n *\n * Examples:\n *   MAXIFS(B1:B10, A1:A10, \"Apple\") - max of B1:B10 where A1:A10 = \"Apple\"\n *   MAXIFS(C1:C10, A1:A10, \"Apple\", B1:B10, \">10\") - max of C1:C10 where A1:A10 = \"Apple\" AND B1:B10 > 10\n *\n * Note:\n * - All criteria must be satisfied for a value to be included\n * - Only numeric values are considered for the maximum\n * - Returns error if no values match all criteria\n */\nexport const MAXIFS: FunctionDefinition = {\n  name: \"MAXIFS\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments using utility\n    const argError = validateMultiCriteriaArgs(\"MAXIFS\", node.args.length, context);\n    if (argError) {\n      return argError;\n    }\n\n    // Evaluate max range\n    const maxRangeResult = this.evaluateNode(node.args[0]!, context);\n    if (maxRangeResult.type === \"error\") {\n      return maxRangeResult;\n    }\n\n    // Parse criteria pairs using utility\n    const criteriaPairsResult = parseCriteriaPairs.call(\n      this,\n      node,\n      context,\n      this.evaluateNode,\n      1\n    );\n    if (\"type\" in criteriaPairsResult) {\n      return criteriaPairsResult;\n    }\n    const criteriaPairs = criteriaPairsResult;\n\n    // Use shared maximum utility for standard cases\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      maxRangeResult,\n      criteriaPairs,\n      context,\n      \"col-major\"\n    );\n\n    if (matchingValues.type === \"error\" || matchingValues.type === \"awaiting-evaluation\") {\n      return matchingValues;\n    }\n\n    return performMaximum(matchingValues.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";AAMA;AAAA;AAAA;AAAA;AAAA;AAKA;AAqBO,IAAM,SAA6B;AAAA,EACxC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,0BAA0B,UAAU,KAAK,KAAK,QAAQ,OAAO;AAAA,IAC9E,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,mBAAmB,KAC7C,MACA,MACA,SACA,KAAK,cACL,CACF;AAAA,IACA,IAAI,UAAU,qBAAqB;AAAA,MACjC,OAAO;AAAA,IACT;AAAA,IACA,MAAM,gBAAgB;AAAA,IAGtB,MAAM,iBAAiB,2BACrB,MACA,gBACA,eACA,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": "77A345BBA074DE7F64756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,43 @@
+// src/functions/math/min/min-utils.ts
+import {
+  FormulaError
+} from "src/core/types";
+function performMinimum(results, context) {
+  let minValue = Infinity;
+  let hasValues = false;
+  for (const result of results) {
+    if (result.type === "error") {
+      return result;
+    }
+    if (result.type === "value") {
+      if (result.result.type === "number") {
+        minValue = Math.min(minValue, result.result.value);
+        hasValues = true;
+      } else if (result.result.type === "infinity") {
+        if (result.result.sign === "negative") {
+          return {
+            type: "value",
+            result: result.result
+          };
+        }
+      }
+    }
+  }
+  if (!hasValues) {
+    return {
+      type: "error",
+      err: FormulaError.VALUE,
+      message: "No numeric values found",
+      errAddress: context.dependencyNode
+    };
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: minValue }
+  };
+}
+export {
+  performMinimum
+};
+
+//# debugId=B3A2044B021358D264756E2164756E21

package/dist/mjs/functions/math/min/min-utils.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/min/min-utils.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionEvaluationResult,\n  type SingleEvaluationResult,\n  type CellInfinity,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { FunctionNode } from \"src/parser/ast\";\n\n/**\n * Result type for processInfinity in min functions\n */\nexport type ProcessInfinityResult<T> =\n  | { type: \"infinity\"; infinity: CellInfinity }\n  | { type: \"state\"; state: T };\n\n/**\n * Perform minimum calculation over an iterator of SingleEvaluationResults\n * Handles the common logic shared by MIN, MINIF, MINIFS functions\n *\n * @param results - Iterator of SingleEvaluationResults to find minimum from\n * @returns FunctionEvaluationResult with the minimum, infinity, or error\n */\nexport function performMinimum(\n  results: Iterable<SingleEvaluationResult>,\n  context: EvaluationContext\n): FunctionEvaluationResult {\n  let minValue = Infinity;\n  let hasValues = false;\n\n  for (const result of results) {\n    if (result.type === \"error\") {\n      // Propagate errors immediately\n      return result;\n    }\n\n    if (result.type === \"value\") {\n      if (result.result.type === \"number\") {\n        minValue = Math.min(minValue, result.result.value);\n        hasValues = true;\n      } else if (result.result.type === \"infinity\") {\n        if (result.result.sign === \"negative\") {\n          // Negative infinity is always the minimum - return immediately\n          return {\n            type: \"value\",\n            result: result.result,\n          };\n        }\n        // Positive infinity doesn't change the minimum\n      }\n      // Non-numeric values (strings, booleans) are ignored in minimum calculation\n    }\n  }\n\n  if (!hasValues) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: \"No numeric values found\",\n      errAddress: context.dependencyNode,\n    };\n  }\n\n  return {\n    type: \"value\",\n    result: { type: \"number\", value: minValue },\n  };\n}\n\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAwBO,SAAS,cAAc,CAC5B,SACA,SAC0B;AAAA,EAC1B,IAAI,WAAW;AAAA,EACf,IAAI,YAAY;AAAA,EAEhB,WAAW,UAAU,SAAS;AAAA,IAC5B,IAAI,OAAO,SAAS,SAAS;AAAA,MAE3B,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,OAAO,SAAS,SAAS;AAAA,MAC3B,IAAI,OAAO,OAAO,SAAS,UAAU;AAAA,QACnC,WAAW,KAAK,IAAI,UAAU,OAAO,OAAO,KAAK;AAAA,QACjD,YAAY;AAAA,MACd,EAAO,SAAI,OAAO,OAAO,SAAS,YAAY;AAAA,QAC5C,IAAI,OAAO,OAAO,SAAS,YAAY;AAAA,UAErC,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,OAAO;AAAA,UACjB;AAAA,QACF;AAAA,MAEF;AAAA,IAEF;AAAA,EACF;AAAA,EAEA,IAAI,CAAC,WAAW;AAAA,IACd,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,SAAS;AAAA,EAC5C;AAAA;",
+  "debugId": "B3A2044B021358D264756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/min/min.mjs

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

package/dist/mjs/functions/math/min/min.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/min/min.ts"],
+  "sourcesContent": [
+    "import { type FunctionDefinition } from \"src/core/types\";\nimport { performMinimum } from \"./min-utils.mjs\";\nimport { createArgumentIterator } from \"src/functions/function-utils\";\n\n/**\n * MIN function - Returns the smallest number in the arguments\n */\nexport const MIN: FunctionDefinition = {\n  name: \"MIN\",\n  evaluate: function (node, context) {\n    // Create iterator from all arguments\n    const argumentIterator = createArgumentIterator(\n      this,\n      node,\n      context,\n      \"col-major\"\n    );\n\n    if (argumentIterator.type !== \"values\") {\n      return argumentIterator;\n    }\n\n    // Perform minimum calculation (now with unified error propagation)\n    return performMinimum(argumentIterator.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";AACA;AACA;AAKO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAS;AAAA,IAEjC,MAAM,mBAAmB,uBACvB,MACA,MACA,SACA,WACF;AAAA,IAEA,IAAI,iBAAiB,SAAS,UAAU;AAAA,MACtC,OAAO;AAAA,IACT;AAAA,IAGA,OAAO,eAAe,iBAAiB,QAAQ,OAAO;AAAA;AAE1D;",
+  "debugId": "A87E46630521EB2264756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/math/min/minif.mjs

@@ -0,0 +1,58 @@
+// src/functions/math/min/minif.ts
+import {
+  FormulaError
+} from "src/core/types";
+import {
+  processMultiCriteriaValues,
+  validateSingleCriteriaArgs
+} from "../../criteria-utils.mjs";
+import { parseCriteria } from "../../criteria-parser.mjs";
+import { performMinimum } from "./min-utils.mjs";
+var MINIF = {
+  name: "MINIF",
+  evaluate: function(node, context) {
+    const argError = validateSingleCriteriaArgs("MINIF", 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: "MINIF 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 minRangeResult = node.args.length === 3 ? this.evaluateNode(node.args[2], context) : criteriaRangeResult;
+    if (minRangeResult.type === "error") {
+      return minRangeResult;
+    }
+    const matchingValues = processMultiCriteriaValues(this, minRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return performMinimum(matchingValues.values, context);
+  }
+};
+export {
+  MINIF
+};
+
+//# debugId=4ABA08F6CF9EBBD864756E2164756E21

package/dist/mjs/functions/math/min/minif.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/min/minif.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 { performMinimum } from \"./min-utils.mjs\";\n\n/**\n * MINIF function - Returns the minimum value among cells specified by a criteria\n *\n * Usage: MINIF(range, criteria, [min_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 * min_range: Optional. The range to find minimum from. If omitted, uses the range parameter\n *\n * Examples:\n *   MINIF(A1:A10, \"Apple\") - min of cells in A1:A10 that contain \"Apple\"\n *   MINIF(B1:B10, \">10\") - min of cells in B1:B10 with values greater than 10\n *   MINIF(A1:A10, \"Apple\", B1:B10) - min of B1:B10 where A1:A10 contains \"Apple\"\n *\n * Note:\n * - Only numeric values are considered for the minimum\n * - Returns error if no values match the criteria\n */\nexport const MINIF: FunctionDefinition = {\n  name: \"MINIF\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments\n    const argError = validateSingleCriteriaArgs(\"MINIF\", 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: \"MINIF 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 min range (third argument if present, otherwise same as criteria range)\n    const minRangeResult =\n      node.args.length === 3\n        ? this.evaluateNode(node.args[2]!, context)\n        : criteriaRangeResult;\n\n    if (minRangeResult.type === \"error\") {\n      return minRangeResult;\n    }\n\n    // Use shared minimum utility for standard cases\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      minRangeResult,\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 performMinimum(matchingValues.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAMA;AAAA;AAAA;AAAA;AAIA;AACA;AAuBO,IAAM,QAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,2BAA2B,SAAS,KAAK,KAAK,QAAQ,OAAO;AAAA,IAC9E,IAAI,UAAU;AAAA,MACZ,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,sBAAsB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IACpE,IAAI,oBAAoB,SAAS,SAAS;AAAA,MACxC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,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,iBACJ,KAAK,KAAK,WAAW,IACjB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO,IACxC;AAAA,IAEN,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,IACT;AAAA,IAGA,MAAM,iBAAiB,2BACrB,MACA,gBACA,CAAC,EAAE,aAAa,qBAAqB,eAAe,CAAC,GACrD,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,eAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "4ABA08F6CF9EBBD864756E2164756E21",
+  "names": []
+}