@ricsam/formula-engine 0.0.1

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

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/max/maxif.ts
+var exports_maxif = {};
+__export(exports_maxif, {
+  MAXIF: () => MAXIF
+});
+module.exports = __toCommonJS(exports_maxif);
+var import_types = require("src/core/types");
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_criteria_parser = require("../../criteria-parser.cjs");
+var import_max_utils = require("./max-utils.cjs");
+var MAXIF = {
+  name: "MAXIF",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.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: import_types.FormulaError.VALUE,
+        message: "MAXIF criteria must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    const parsedCriteria = import_criteria_parser.parseCriteria(criteriaResult.result);
+    if (parsedCriteria.type === "error") {
+      return {
+        type: "error",
+        err: import_types.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 = import_criteria_utils.processMultiCriteriaValues(this, maxRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_max_utils.performMaximum(matchingValues.values, context);
+  }
+};
+
+//# debugId=77CABD257E7CFC7564756E2164756E21

package/dist/cjs/functions/math/max/maxif.cjs.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.cjs\";\nimport { parseCriteria, matchesParsedCriteria } from \"../../criteria-parser.cjs\";\nimport { performMaximum } from \"./max-utils.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AASO,IAHP;AAIqD,IAArD;AAC+B,IAA/B;AAuBO,IAAM,QAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,iDAA2B,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,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,iBAAiB,qCAAc,eAAe,MAAM;AAAA,IAC1D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;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,iDACrB,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,gCAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "77CABD257E7CFC7564756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/max/maxifs.ts
+var exports_maxifs = {};
+__export(exports_maxifs, {
+  MAXIFS: () => MAXIFS
+});
+module.exports = __toCommonJS(exports_maxifs);
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_max_utils = require("./max-utils.cjs");
+var MAXIFS = {
+  name: "MAXIFS",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.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 = import_criteria_utils.parseCriteriaPairs.call(this, node, context, this.evaluateNode, 1);
+    if ("type" in criteriaPairsResult) {
+      return criteriaPairsResult;
+    }
+    const criteriaPairs = criteriaPairsResult;
+    const matchingValues = import_criteria_utils.processMultiCriteriaValues(this, maxRangeResult, criteriaPairs, context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_max_utils.performMaximum(matchingValues.values, context);
+  }
+};
+
+//# debugId=6761528404368E3864756E2164756E21

package/dist/cjs/functions/math/max/maxifs.cjs.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.cjs\";\nimport { performMaximum } from \"./max-utils.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUO,IAJP;AAK+B,IAA/B;AAqBO,IAAM,SAA6B;AAAA,EACxC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,gDAA0B,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,yCAAmB,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,iDACrB,MACA,gBACA,eACA,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,gCAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "6761528404368E3864756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,71 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/min/min-utils.ts
+var exports_min_utils = {};
+__export(exports_min_utils, {
+  performMinimum: () => performMinimum
+});
+module.exports = __toCommonJS(exports_min_utils);
+var import_types = require("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: import_types.FormulaError.VALUE,
+      message: "No numeric values found",
+      errAddress: context.dependencyNode
+    };
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: minValue }
+  };
+}
+
+//# debugId=E76E20B587C68AD364756E2164756E21

package/dist/cjs/functions/math/min/min-utils.cjs.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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKO,IALP;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,0BAAa;AAAA,MAClB,SAAS;AAAA,MACT,YAAY,QAAQ;AAAA,IACtB;AAAA,EACF;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,EAAE,MAAM,UAAU,OAAO,SAAS;AAAA,EAC5C;AAAA;",
+  "debugId": "E76E20B587C68AD364756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/min/min.cjs

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

package/dist/cjs/functions/math/min/min.cjs.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.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC+B,IAA/B;AACuC,IAAvC;AAKO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAS;AAAA,IAEjC,MAAM,mBAAmB,6CACvB,MACA,MACA,SACA,WACF;AAAA,IAEA,IAAI,iBAAiB,SAAS,UAAU;AAAA,MACtC,OAAO;AAAA,IACT;AAAA,IAGA,OAAO,gCAAe,iBAAiB,QAAQ,OAAO;AAAA;AAE1D;",
+  "debugId": "EBE7826A02CF9CD264756E2164756E21",
+  "names": []
+}

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

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/min/minif.ts
+var exports_minif = {};
+__export(exports_minif, {
+  MINIF: () => MINIF
+});
+module.exports = __toCommonJS(exports_minif);
+var import_types = require("src/core/types");
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_criteria_parser = require("../../criteria-parser.cjs");
+var import_min_utils = require("./min-utils.cjs");
+var MINIF = {
+  name: "MINIF",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.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: import_types.FormulaError.VALUE,
+        message: "MINIF criteria must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    const parsedCriteria = import_criteria_parser.parseCriteria(criteriaResult.result);
+    if (parsedCriteria.type === "error") {
+      return {
+        type: "error",
+        err: import_types.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 = import_criteria_utils.processMultiCriteriaValues(this, minRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_min_utils.performMinimum(matchingValues.values, context);
+  }
+};
+
+//# debugId=A92C94AABB5109F464756E2164756E21

package/dist/cjs/functions/math/min/minif.cjs.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.cjs\";\nimport { parseCriteria, matchesParsedCriteria } from \"../../criteria-parser.cjs\";\nimport { performMinimum } from \"./min-utils.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIO,IAJP;AASO,IAHP;AAIqD,IAArD;AAC+B,IAA/B;AAuBO,IAAM,QAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,iDAA2B,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,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,iBAAiB,qCAAc,eAAe,MAAM;AAAA,IAC1D,IAAI,eAAe,SAAS,SAAS;AAAA,MACnC,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;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,iDACrB,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,gCAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "A92C94AABB5109F464756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/min/minifs.cjs

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/min/minifs.ts
+var exports_minifs = {};
+__export(exports_minifs, {
+  MINIFS: () => MINIFS
+});
+module.exports = __toCommonJS(exports_minifs);
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_min_utils = require("./min-utils.cjs");
+var MINIFS = {
+  name: "MINIFS",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.validateMultiCriteriaArgs("MINIFS", node.args.length, context);
+    if (argError) {
+      return argError;
+    }
+    const minRangeResult = this.evaluateNode(node.args[0], context);
+    if (minRangeResult.type === "error") {
+      return minRangeResult;
+    }
+    const criteriaPairsResult = import_criteria_utils.parseCriteriaPairs.call(this, node, context, this.evaluateNode, 1);
+    if ("type" in criteriaPairsResult) {
+      return criteriaPairsResult;
+    }
+    const criteriaPairs = criteriaPairsResult;
+    const matchingValues = import_criteria_utils.processMultiCriteriaValues(this, minRangeResult, criteriaPairs, context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_min_utils.performMinimum(matchingValues.values, context);
+  }
+};
+
+//# debugId=C590C84DF95D2F8D64756E2164756E21

package/dist/cjs/functions/math/min/minifs.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/min/minifs.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.cjs\";\nimport { performMinimum } from \"./min-utils.cjs\";\nimport { parseCriteria, matchesParsedCriteria } from \"../../criteria-parser.cjs\";\n\n/**\n * MINIFS function - Returns the minimum value among cells specified by multiple criteria\n *\n * Usage: MINIFS(min_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...)\n *\n * min_range: The range of cells from which you want the minimum\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 *   MINIFS(B1:B10, A1:A10, \"Apple\") - min of B1:B10 where A1:A10 = \"Apple\"\n *   MINIFS(C1:C10, A1:A10, \"Apple\", B1:B10, \">10\") - min 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 minimum\n * - Returns error if no values match all criteria\n */\nexport const MINIFS: FunctionDefinition = {\n  name: \"MINIFS\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Validate arguments using utility\n    const argError = validateMultiCriteriaArgs(\"MINIFS\", node.args.length, context);\n    if (argError) {\n      return argError;\n    }\n\n    // Evaluate min range\n    const minRangeResult = this.evaluateNode(node.args[0]!, context);\n    if (minRangeResult.type === \"error\") {\n      return minRangeResult;\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 minimum utility for standard cases\n    const matchingValues = processMultiCriteriaValues(\n      this,\n      minRangeResult,\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 performMinimum(matchingValues.values, context);\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAUO,IAJP;AAK+B,IAA/B;AAsBO,IAAM,SAA6B;AAAA,EACxC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,gDAA0B,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,yCAAmB,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,iDACrB,MACA,gBACA,eACA,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,gCAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "C590C84DF95D2F8D64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/sum/sum.cjs

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

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/math/sum/sum.ts"],
+  "sourcesContent": [
+    "import { type FunctionDefinition } from \"src/core/types\";\nimport { performSummation } from \"./summation-utils.cjs\";\nimport { createArgumentIterator } from \"src/functions/function-utils\";\n\n/**\n * SUM function - Adds all numbers in the arguments\n */\nexport const SUM: FunctionDefinition = {\n  name: \"SUM\",\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 summation with error propagation (SUM propagates errors from direct arguments)\n    return performSummation(argumentIterator.values);\n  },\n};\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACiC,IAAjC;AACuC,IAAvC;AAKO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAS;AAAA,IAEjC,MAAM,mBAAmB,6CACvB,MACA,MACA,SACA,WACF;AAAA,IAEA,IAAI,iBAAiB,SAAS,UAAU;AAAA,MACtC,OAAO;AAAA,IACT;AAAA,IAGA,OAAO,wCAAiB,iBAAiB,MAAM;AAAA;AAEnD;",
+  "debugId": "02880DD013A6504164756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/sum/sumif.cjs

@@ -0,0 +1,83 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/functions/math/sum/sumif.ts
+var exports_sumif = {};
+__export(exports_sumif, {
+  SUMIF: () => SUMIF
+});
+module.exports = __toCommonJS(exports_sumif);
+var import_types = require("src/core/types");
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_criteria_parser = require("../../criteria-parser.cjs");
+var import_summation_utils = require("./summation-utils.cjs");
+var SUMIF = {
+  name: "SUMIF",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.validateSingleCriteriaArgs("SUMIF", 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: import_types.FormulaError.VALUE,
+        message: "SUMIF criteria must be a single value",
+        errAddress: context.dependencyNode
+      };
+    }
+    const parsedCriteria = import_criteria_parser.parseCriteria(criteriaResult.result);
+    if (parsedCriteria.type === "error") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: parsedCriteria.message,
+        errAddress: context.dependencyNode
+      };
+    }
+    const sumRangeResult = node.args.length === 3 ? this.evaluateNode(node.args[2], context) : criteriaRangeResult;
+    if (sumRangeResult.type === "error") {
+      return sumRangeResult;
+    }
+    const matchingValues = import_criteria_utils.processMultiCriteriaValues(this, sumRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_summation_utils.performSummation(matchingValues.values);
+  }
+};
+
+//# debugId=69F1440DE6A72EA864756E2164756E21