@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/math/average/averageif.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/average/averageif.ts
+var exports_averageif = {};
+__export(exports_averageif, {
+  AVERAGEIF: () => AVERAGEIF
+});
+module.exports = __toCommonJS(exports_averageif);
+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_average_utils = require("./average-utils.cjs");
+var AVERAGEIF = {
+  name: "AVERAGEIF",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.validateSingleCriteriaArgs("AVERAGEIF", node.args.length, context);
+    if (argError) {
+      return argError;
+    }
+    const criteriaRangeResult = this.evaluateNode(node.args[0], context);
+    if (criteriaRangeResult.type === "error") {
+      return criteriaRangeResult;
+    }
+    const criteriaResult = this.evaluateNode(node.args[1], context);
+    if (criteriaResult.type === "error") {
+      return criteriaResult;
+    }
+    if (criteriaResult.type !== "value") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "AVERAGEIF 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 averageRangeResult = node.args.length === 3 ? this.evaluateNode(node.args[2], context) : criteriaRangeResult;
+    if (averageRangeResult.type === "error") {
+      return averageRangeResult;
+    }
+    const matchingValues = import_criteria_utils.processMultiCriteriaValues(this, averageRangeResult, [{ rangeResult: criteriaRangeResult, parsedCriteria }], context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_average_utils.performAverage(matchingValues.values, context);
+  }
+};
+
+//# debugId=2C57561504078A1F64756E2164756E21

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

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

package/dist/cjs/functions/math/average/averageifs.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/average/averageifs.ts
+var exports_averageifs = {};
+__export(exports_averageifs, {
+  AVERAGEIFS: () => AVERAGEIFS
+});
+module.exports = __toCommonJS(exports_averageifs);
+var import_criteria_utils = require("../../criteria-utils.cjs");
+var import_average_utils = require("./average-utils.cjs");
+var AVERAGEIFS = {
+  name: "AVERAGEIFS",
+  evaluate: function(node, context) {
+    const argError = import_criteria_utils.validateMultiCriteriaArgs("AVERAGEIFS", node.args.length, context);
+    if (argError) {
+      return argError;
+    }
+    const averageRangeResult = this.evaluateNode(node.args[0], context);
+    if (averageRangeResult.type === "error") {
+      return averageRangeResult;
+    }
+    const criteriaPairsResult = 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, averageRangeResult, criteriaPairs, context, "col-major");
+    if (matchingValues.type === "error" || matchingValues.type === "awaiting-evaluation") {
+      return matchingValues;
+    }
+    return import_average_utils.performAverage(matchingValues.values, context);
+  }
+};
+
+//# debugId=6D93A8D7357B520E64756E2164756E21

package/dist/cjs/functions/math/average/averageifs.cjs.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.cjs\";\nimport { performAverage } from \"./average-utils.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASO,IAJP;AAK+B,IAA/B;AAqBO,IAAM,aAAiC;AAAA,EAC5C,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,WAAW,gDAA0B,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,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,oBACA,eACA,SACA,WACF;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,SAAS,uBAAuB;AAAA,MACpF,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,oCAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "6D93A8D7357B520E64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/ceiling/ceiling.cjs

@@ -0,0 +1,219 @@
+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/ceiling/ceiling.ts
+var exports_ceiling = {};
+__export(exports_ceiling, {
+  CEILING: () => CEILING
+});
+module.exports = __toCommonJS(exports_ceiling);
+var import_types = require("src/core/types");
+function ceilingOperation(numberValue, significanceValue, context) {
+  if (numberValue.type === "infinity") {
+    return numberValue;
+  }
+  if (significanceValue.type === "infinity") {
+    return {
+      type: "error",
+      err: import_types.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: import_types.FormulaError.DIV0,
+      message: "Significance cannot be zero",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (num > 0 && sig < 0) {
+    return {
+      type: "error",
+      err: import_types.FormulaError.NUM,
+      message: "Positive number cannot be used with negative significance",
+      errAddress: context.dependencyNode
+    };
+  }
+  if (num < 0 && sig > 0) {
+    return {
+      type: "error",
+      err: import_types.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: import_types.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: import_types.FormulaError.VALUE,
+          message: "Invalid spilled result for CEILING",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillNumberResult.result.type !== "number" && spillNumberResult.result.type !== "infinity") {
+        return {
+          type: "error",
+          err: import_types.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: import_types.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: import_types.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: import_types.FormulaError.VALUE,
+        message: "Invalid argument type",
+        errAddress: context.dependencyNode
+      };
+    }
+    if (numberResult.result.type !== "number" && numberResult.result.type !== "infinity") {
+      return {
+        type: "error",
+        err: import_types.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: import_types.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 };
+  }
+};
+
+//# debugId=094A5BA492E34C3364756E2164756E21

package/dist/cjs/functions/math/ceiling/ceiling.cjs.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": "094A5BA492E34C3364756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/max/max-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/max/max-utils.ts
+var exports_max_utils = {};
+__export(exports_max_utils, {
+  performMaximum: () => performMaximum
+});
+module.exports = __toCommonJS(exports_max_utils);
+var import_types = require("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: import_types.FormulaError.VALUE,
+      message: "No numeric values found",
+      errAddress: context.dependencyNode
+    };
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: maxValue }
+  };
+}
+
+//# debugId=E317844019E8356164756E2164756E21

package/dist/cjs/functions/math/max/max-utils.cjs.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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKO,IALP;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,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": "E317844019E8356164756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/math/max/max.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/max/max.ts
+var exports_max = {};
+__export(exports_max, {
+  MAX: () => MAX
+});
+module.exports = __toCommonJS(exports_max);
+var import_max_utils = require("./max-utils.cjs");
+var import_function_utils = require("src/functions/function-utils");
+var MAX = {
+  name: "MAX",
+  evaluate: function(node, context) {
+    const argumentValues = import_function_utils.createArgumentIterator(this, node, context, "col-major");
+    if (argumentValues.type !== "values") {
+      return argumentValues;
+    }
+    return import_max_utils.performMaximum(argumentValues.values, context);
+  }
+};
+
+//# debugId=36355D055954E28164756E2164756E21

package/dist/cjs/functions/math/max/max.cjs.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.cjs\";\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI+B,IAA/B;AACuC,IAAvC;AAkBO,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,iBAAiB,6CAAuB,MAAM,MAAM,SAAS,WAAW;AAAA,IAC9E,IAAI,eAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,gCAAe,eAAe,QAAQ,OAAO;AAAA;AAExD;",
+  "debugId": "36355D055954E28164756E2164756E21",
+  "names": []
+}