@ricsam/formula-engine 0.0.1

package/dist/mjs/functions/logical/and/and.mjs

@@ -0,0 +1,84 @@
+// src/functions/logical/and/and.ts
+import {
+  FormulaError
+} from "src/core/types";
+function isTruthy(value) {
+  switch (value.type) {
+    case "boolean":
+      return value.value;
+    case "number":
+      return value.value !== 0;
+    case "string":
+      return value.value !== "";
+    case "infinity":
+      return true;
+    default:
+      return false;
+  }
+}
+var AND = {
+  name: "AND",
+  evaluate: function(node, context) {
+    if (node.args.length === 0) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "AND function requires at least one argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    for (const arg of node.args) {
+      const argResult = this.evaluateNode(arg, context);
+      if (argResult.type === "error" || argResult.type === "awaiting-evaluation") {
+        return argResult;
+      }
+      if (argResult.type === "value") {
+        if (!isTruthy(argResult.result)) {
+          return {
+            type: "value",
+            result: { type: "boolean", value: false }
+          };
+        }
+      } else if (argResult.type === "spilled-values") {
+        const cellValues = argResult.evaluateAllCells.call(this, {
+          context,
+          origin: context.cellAddress,
+          evaluate: argResult.evaluate,
+          lookupOrder: "col-major"
+        });
+        if (cellValues.type === "error" || cellValues.type === "awaiting-evaluation") {
+          return cellValues;
+        }
+        for (const cellValue of cellValues.values) {
+          if (cellValue.result.type === "error") {
+            return cellValue.result;
+          }
+          if (cellValue.result.type === "value") {
+            if (!isTruthy(cellValue.result.result)) {
+              return {
+                type: "value",
+                result: { type: "boolean", value: false }
+              };
+            }
+          }
+        }
+      } else {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "Invalid argument type for AND function",
+          errAddress: context.dependencyNode
+        };
+      }
+    }
+    return {
+      type: "value",
+      result: { type: "boolean", value: true }
+    };
+  }
+};
+export {
+  AND
+};
+
+//# debugId=83035E28B8777BF964756E2164756E21

package/dist/mjs/functions/logical/and/and.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/logical/and/and.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type 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 * AND function - Returns TRUE if all arguments are TRUE, FALSE otherwise\n *\n * Usage: AND(logical1, [logical2], ...)\n *\n * logical1, logical2, ...: Logical values or expressions to evaluate\n *\n * Examples:\n *   AND(TRUE, TRUE) - returns TRUE\n *   AND(TRUE, FALSE) - returns FALSE\n *   AND(A1>10, B1<20) - returns TRUE if both conditions are met\n *   AND(A1:A3) - returns TRUE if all values in A1:A3 are truthy\n *\n * Note:\n * - Supports spilled values (dynamic arrays) for arguments\n * - Logical evaluation: 0 and empty string are FALSE, everything else is TRUE\n * - If any argument is spilled, returns spilled results\n * - Short-circuit evaluation: stops at first FALSE value\n */\n\n/**\n * Convert a cell value to boolean for logical evaluation\n */\nfunction isTruthy(value: CellValue): boolean {\n  switch (value.type) {\n    case \"boolean\":\n      return value.value;\n    case \"number\":\n      return value.value !== 0;\n    case \"string\":\n      return value.value !== \"\";\n    case \"infinity\":\n      return true; // Infinity is truthy\n    default:\n      return false;\n  }\n}\n\n// AND function does not create spilled results - it processes all values in ranges\n// as individual logical tests and returns a single boolean result\n\n/**\n * AND function implementation\n */\nexport const AND: FunctionDefinition = {\n  name: \"AND\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length === 0) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"AND function requires at least one argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Process arguments one by one (like SUM function)\n    for (const arg of node.args) {\n      const argResult = this.evaluateNode(arg, context);\n\n      if (argResult.type === \"error\" || argResult.type === \"awaiting-evaluation\") {\n        return argResult;\n      }\n\n      if (argResult.type === \"value\") {\n        // Single value - check if truthy\n        if (!isTruthy(argResult.result)) {\n          return {\n            type: \"value\",\n            result: { type: \"boolean\", value: false },\n          };\n        }\n      } else if (argResult.type === \"spilled-values\") {\n        // Range - check all values in the range\n        const cellValues = argResult.evaluateAllCells.call(this, {\n          context,\n          origin: context.cellAddress,\n          evaluate: argResult.evaluate,\n          lookupOrder: \"col-major\",\n        });\n\n        if (cellValues.type === \"error\" || cellValues.type === \"awaiting-evaluation\") {\n          return cellValues;\n        }\n\n        for (const cellValue of cellValues.values) {\n          if (cellValue.result.type === \"error\") {\n            return cellValue.result;\n          }\n          if (cellValue.result.type === \"value\") {\n            if (!isTruthy(cellValue.result.result)) {\n              return {\n                type: \"value\",\n                result: { type: \"boolean\", value: false },\n              };\n            }\n          }\n        }\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Invalid argument type for AND function\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // All arguments are truthy\n    return {\n      type: \"value\",\n      result: { type: \"boolean\", value: true },\n    };\n  },\n};\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAuCA,SAAS,QAAQ,CAAC,OAA2B;AAAA,EAC3C,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,OAAO,MAAM;AAAA,SACV;AAAA,MACH,OAAO,MAAM,UAAU;AAAA,SACpB;AAAA,MACH,OAAO,MAAM,UAAU;AAAA,SACpB;AAAA,MACH,OAAO;AAAA;AAAA,MAEP,OAAO;AAAA;AAAA;AAUN,IAAM,MAA0B;AAAA,EACrC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,WAAW,OAAO,KAAK,MAAM;AAAA,MAC3B,MAAM,YAAY,KAAK,aAAa,KAAK,OAAO;AAAA,MAEhD,IAAI,UAAU,SAAS,WAAW,UAAU,SAAS,uBAAuB;AAAA,QAC1E,OAAO;AAAA,MACT;AAAA,MAEA,IAAI,UAAU,SAAS,SAAS;AAAA,QAE9B,IAAI,CAAC,SAAS,UAAU,MAAM,GAAG;AAAA,UAC/B,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,UAC1C;AAAA,QACF;AAAA,MACF,EAAO,SAAI,UAAU,SAAS,kBAAkB;AAAA,QAE9C,MAAM,aAAa,UAAU,iBAAiB,KAAK,MAAM;AAAA,UACvD;AAAA,UACA,QAAQ,QAAQ;AAAA,UAChB,UAAU,UAAU;AAAA,UACpB,aAAa;AAAA,QACf,CAAC;AAAA,QAED,IAAI,WAAW,SAAS,WAAW,WAAW,SAAS,uBAAuB;AAAA,UAC5E,OAAO;AAAA,QACT;AAAA,QAEA,WAAW,aAAa,WAAW,QAAQ;AAAA,UACzC,IAAI,UAAU,OAAO,SAAS,SAAS;AAAA,YACrC,OAAO,UAAU;AAAA,UACnB;AAAA,UACA,IAAI,UAAU,OAAO,SAAS,SAAS;AAAA,YACrC,IAAI,CAAC,SAAS,UAAU,OAAO,MAAM,GAAG;AAAA,cACtC,OAAO;AAAA,gBACL,MAAM;AAAA,gBACN,QAAQ,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,cAC1C;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF,EAAO;AAAA,QACL,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,aAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA;AAAA,IAEJ;AAAA,IAGA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,IACzC;AAAA;AAEJ;",
+  "debugId": "83035E28B8777BF964756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/logical/if/if.mjs

@@ -0,0 +1,167 @@
+// src/functions/logical/if/if.ts
+import {
+  FormulaError
+} from "src/core/types";
+function isTruthy(value) {
+  switch (value.type) {
+    case "boolean":
+      return value.value;
+    case "number":
+      return value.value !== 0;
+    case "string":
+      return value.value !== "";
+    case "infinity":
+      return true;
+    default:
+      return false;
+  }
+}
+function createIfSpilledResult({
+  logicalTestResult,
+  valueIfTrueResult,
+  valueIfFalseResult,
+  context
+}) {
+  const hasSpilledTest = logicalTestResult.type === "spilled-values";
+  const hasSpilledTrue = valueIfTrueResult.type === "spilled-values";
+  const hasSpilledFalse = valueIfFalseResult.type === "spilled-values";
+  if (!hasSpilledTest && !hasSpilledTrue && !hasSpilledFalse) {
+    throw new Error("createIfSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      let spillArea;
+      const spilledResults = [
+        hasSpilledTest ? logicalTestResult : null,
+        hasSpilledTrue ? valueIfTrueResult : null,
+        hasSpilledFalse ? valueIfFalseResult : null
+      ].filter(Boolean);
+      for (const result of spilledResults) {
+        const currentSpillArea = result.spillArea(origin);
+        if (!spillArea) {
+          spillArea = currentSpillArea;
+        } else {
+          spillArea = this.unionRanges(this.projectRange(spillArea, origin), this.projectRange(currentSpillArea, origin));
+        }
+      }
+      if (!spillArea) {
+        throw new Error("No spilled values found");
+      }
+      return spillArea;
+    },
+    source: "IF with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillLogicalResult = hasSpilledTest ? logicalTestResult.evaluate(spilledCell, evalContext) : logicalTestResult;
+      const spillTrueResult = hasSpilledTrue ? valueIfTrueResult.evaluate(spilledCell, evalContext) : valueIfTrueResult;
+      const spillFalseResult = hasSpilledFalse ? valueIfFalseResult.evaluate(spilledCell, evalContext) : valueIfFalseResult;
+      if (spillLogicalResult === undefined) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: "The spilled logical test has not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillLogicalResult.type === "error" || spillLogicalResult.type === "awaiting-evaluation") {
+        return spillLogicalResult;
+      }
+      if (spillTrueResult === undefined) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: "The spilled true value has not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillTrueResult.type === "error" || spillTrueResult.type === "awaiting-evaluation") {
+        return spillTrueResult;
+      }
+      if (spillFalseResult === undefined) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: "The spilled false value has not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillFalseResult.type === "error" || spillFalseResult.type === "awaiting-evaluation") {
+        return spillFalseResult;
+      }
+      if (spillLogicalResult.type !== "value") {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "Invalid logical test result",
+          errAddress: context.dependencyNode
+        };
+      }
+      const isTrue = isTruthy(spillLogicalResult.result);
+      return isTrue ? spillTrueResult : spillFalseResult;
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for IF is not implemented");
+    }
+  };
+}
+var IF = {
+  name: "IF",
+  evaluate: function(node, context) {
+    if (node.args.length < 2 || node.args.length > 3) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "IF function takes 2 or 3 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const logicalTestResult = this.evaluateNode(node.args[0], context);
+    if (logicalTestResult.type === "awaiting-evaluation" || logicalTestResult.type === "error") {
+      return logicalTestResult;
+    }
+    if (logicalTestResult.type === "spilled-values") {
+      const valueIfTrueResult = this.evaluateNode(node.args[1], context);
+      if (valueIfTrueResult.type === "error" || valueIfTrueResult.type === "awaiting-evaluation") {
+        return valueIfTrueResult;
+      }
+      let valueIfFalseResult;
+      if (node.args.length > 2) {
+        valueIfFalseResult = this.evaluateNode(node.args[2], context);
+        if (valueIfFalseResult.type === "error" || valueIfFalseResult.type === "awaiting-evaluation") {
+          return valueIfFalseResult;
+        }
+      } else {
+        valueIfFalseResult = {
+          type: "value",
+          result: { type: "boolean", value: false }
+        };
+      }
+      return createIfSpilledResult.call(this, {
+        logicalTestResult,
+        valueIfTrueResult,
+        valueIfFalseResult,
+        context
+      });
+    }
+    const isTrue = isTruthy(logicalTestResult.result);
+    if (isTrue) {
+      const valueIfTrueResult = this.evaluateNode(node.args[1], context);
+      return valueIfTrueResult;
+    } else {
+      if (node.args.length > 2) {
+        const valueIfFalseResult = this.evaluateNode(node.args[2], context);
+        return valueIfFalseResult;
+      } else {
+        return {
+          type: "value",
+          result: { type: "boolean", value: false }
+        };
+      }
+    }
+  }
+};
+export {
+  IF
+};
+
+//# debugId=B7DDA16B3C6C29FD64756E2164756E21

package/dist/mjs/functions/logical/if/if.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/logical/if/if.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type ErrorEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\n\n/**\n * IF function - Returns one value if a condition is true and another value if it's false\n *\n * Usage: IF(logical_test, value_if_true, [value_if_false])\n *\n * logical_test: The condition to evaluate (required)\n * value_if_true: The value to return if the condition is true (required)\n * value_if_false: The value to return if the condition is false (optional, defaults to FALSE)\n *\n * Examples:\n *   IF(A1>10, \"High\", \"Low\") - returns \"High\" if A1>10, otherwise \"Low\"\n *   IF(B1=\"\", \"Empty\", B1) - returns \"Empty\" if B1 is empty, otherwise B1's value\n *   IF(C1<0, \"Negative\") - returns \"Negative\" if C1<0, otherwise FALSE\n *\n * Note:\n * - Supports spilled values (dynamic arrays) for all arguments\n * - Logical test evaluation: 0 and empty string are FALSE, everything else is TRUE\n * - If logical_test is spilled, returns spilled results\n */\n\n/**\n * Convert a cell value to boolean for logical evaluation\n */\nfunction isTruthy(value: CellValue): boolean {\n  switch (value.type) {\n    case \"boolean\":\n      return value.value;\n    case \"number\":\n      return value.value !== 0;\n    case \"string\":\n      return value.value !== \"\";\n    case \"infinity\":\n      return true; // Infinity is truthy\n    default:\n      return false;\n  }\n}\n\n/**\n * Helper for creating spilled-values result for IF function\n */\nfunction createIfSpilledResult(\n  this: FormulaEvaluator,\n  {\n    logicalTestResult,\n    valueIfTrueResult,\n    valueIfFalseResult,\n    context,\n  }: {\n    logicalTestResult: FunctionEvaluationResult;\n    valueIfTrueResult: FunctionEvaluationResult;\n    valueIfFalseResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): SpilledValuesEvaluationResult | ErrorEvaluationResult {\n  const hasSpilledTest = logicalTestResult.type === \"spilled-values\";\n  const hasSpilledTrue = valueIfTrueResult.type === \"spilled-values\";\n  const hasSpilledFalse = valueIfFalseResult.type === \"spilled-values\";\n\n  if (!hasSpilledTest && !hasSpilledTrue && !hasSpilledFalse) {\n    throw new Error(\"createIfSpilledResult called without spilled values\");\n  }\n\n  return {\n    type: \"spilled-values\",\n    spillArea: (origin: CellAddress): SpreadsheetRange => {\n      // Calculate spill area (union of all spilled ranges)\n      let spillArea: SpreadsheetRange | undefined;\n\n      const spilledResults = [\n        hasSpilledTest ? logicalTestResult : null,\n        hasSpilledTrue ? valueIfTrueResult : null,\n        hasSpilledFalse ? valueIfFalseResult : null,\n      ].filter(Boolean) as SpilledValuesEvaluationResult[];\n\n      for (const result of spilledResults) {\n        const currentSpillArea = result.spillArea(origin);\n        if (!spillArea) {\n          spillArea = currentSpillArea;\n        } else {\n          spillArea = this.unionRanges(\n            this.projectRange(spillArea, origin),\n            this.projectRange(currentSpillArea, origin)\n          );\n        }\n      }\n\n      if (!spillArea) {\n        throw new Error(\"No spilled values found\");\n      }\n      return spillArea;\n    },\n    source: \"IF with spilled values\",\n    evaluate: (spilledCell: any, evalContext: any): SingleEvaluationResult => {\n      // Evaluate all arguments at this spilled position\n      const spillLogicalResult = hasSpilledTest\n        ? logicalTestResult.evaluate(spilledCell, evalContext)\n        : logicalTestResult;\n      const spillTrueResult = hasSpilledTrue\n        ? valueIfTrueResult.evaluate(spilledCell, evalContext)\n        : valueIfTrueResult;\n      const spillFalseResult = hasSpilledFalse\n        ? valueIfFalseResult.evaluate(spilledCell, evalContext)\n        : valueIfFalseResult;\n\n      // Check for errors\n      if (spillLogicalResult === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled logical test has not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (spillLogicalResult.type === \"error\" || spillLogicalResult.type === \"awaiting-evaluation\") {\n        return spillLogicalResult;\n      }\n\n      if (spillTrueResult === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled true value has not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (spillTrueResult.type === \"error\" || spillTrueResult.type === \"awaiting-evaluation\") {\n        return spillTrueResult;\n      }\n\n      if (spillFalseResult === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled false value has not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      if (spillFalseResult.type === \"error\" || spillFalseResult.type === \"awaiting-evaluation\") {\n        return spillFalseResult;\n      }\n\n      // Perform IF logic\n      if (spillLogicalResult.type !== \"value\") {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Invalid logical test result\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      const isTrue = isTruthy(spillLogicalResult.result);\n      return isTrue ? spillTrueResult : spillFalseResult;\n    },\n    evaluateAllCells: (intersectingRange: any) => {\n      throw new Error(\"WIP: evaluateAllCells for IF is not implemented\");\n    },\n  };\n}\n\n/**\n * IF function implementation\n */\nexport const IF: FunctionDefinition = {\n  name: \"IF\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length < 2 || node.args.length > 3) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"IF function takes 2 or 3 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate logical test\n    const logicalTestResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      logicalTestResult.type === \"awaiting-evaluation\" ||\n      logicalTestResult.type === \"error\"\n    ) {\n      return logicalTestResult;\n    }\n\n    // Handle spilled values - we need to evaluate both branches\n    // because different cells might take different paths\n    if (logicalTestResult.type === \"spilled-values\") {\n      // Evaluate value_if_true\n      const valueIfTrueResult = this.evaluateNode(node.args[1]!, context);\n      if (valueIfTrueResult.type === \"error\" || valueIfTrueResult.type === \"awaiting-evaluation\") {\n        return valueIfTrueResult;\n      }\n\n      // Evaluate value_if_false (optional, defaults to FALSE)\n      let valueIfFalseResult: FunctionEvaluationResult;\n      if (node.args.length > 2) {\n        valueIfFalseResult = this.evaluateNode(node.args[2]!, context);\n        if (valueIfFalseResult.type === \"error\" || valueIfFalseResult.type === \"awaiting-evaluation\") {\n          return valueIfFalseResult;\n        }\n      } else {\n        valueIfFalseResult = {\n          type: \"value\",\n          result: { type: \"boolean\", value: false },\n        };\n      }\n\n      return createIfSpilledResult.call(this, {\n        logicalTestResult,\n        valueIfTrueResult,\n        valueIfFalseResult,\n        context,\n      });\n    }\n\n    // Evaluate the logical test\n    const isTrue = isTruthy(logicalTestResult.result);\n\n    // LAZY EVALUATION: Only evaluate the branch we need\n    if (isTrue) {\n      // Evaluate value_if_true\n      const valueIfTrueResult = this.evaluateNode(node.args[1]!, context);\n      return valueIfTrueResult;\n    } else {\n      // Evaluate value_if_false (optional, defaults to FALSE)\n      if (node.args.length > 2) {\n        const valueIfFalseResult = this.evaluateNode(node.args[2]!, context);\n        return valueIfFalseResult;\n      } else {\n        return {\n          type: \"value\",\n          result: { type: \"boolean\", value: false },\n        };\n      }\n    }\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "B7DDA16B3C6C29FD64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/logical/iferror/iferror.mjs

@@ -0,0 +1,98 @@
+// src/functions/logical/iferror/iferror.ts
+import {
+  FormulaError
+} from "src/core/types";
+import { captureEvaluationErrors } from "src/core/utils";
+function createIfErrorSpilledResult({
+  valueResult,
+  valueIfErrorResult,
+  context
+}) {
+  const hasSpilledValue = valueResult.type === "spilled-values";
+  const hasSpilledError = valueIfErrorResult.type === "spilled-values";
+  if (!hasSpilledValue && !hasSpilledError) {
+    throw new Error("createIfErrorSpilledResult called without spilled values");
+  }
+  return {
+    type: "spilled-values",
+    spillArea: (origin) => {
+      if (hasSpilledValue && valueResult.type === "spilled-values") {
+        const spillArea = valueResult.spillArea(origin);
+        if (hasSpilledError && valueIfErrorResult.type === "spilled-values") {
+          return this.unionRanges(this.projectRange(spillArea, origin), this.projectRange(valueIfErrorResult.spillArea(origin), origin));
+        }
+        return spillArea;
+      } else if (hasSpilledError && valueIfErrorResult.type === "spilled-values") {
+        return valueIfErrorResult.spillArea(origin);
+      } else {
+        throw new Error("No spilled values found");
+      }
+    },
+    source: "IFERROR with spilled values",
+    evaluate: (spilledCell, evalContext) => {
+      const spillValueResult = hasSpilledValue ? valueResult.evaluate(spilledCell, evalContext) : valueResult;
+      const spillErrorResult = hasSpilledError ? valueIfErrorResult.evaluate(spilledCell, evalContext) : valueIfErrorResult;
+      if (spillValueResult === undefined) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: "The spilled value has not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillErrorResult === undefined) {
+        return {
+          type: "error",
+          err: FormulaError.REF,
+          message: "The spilled error value has not been evaluated",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (spillValueResult.type === "error" || spillValueResult.type === "awaiting-evaluation") {
+        return spillErrorResult;
+      }
+      return spillValueResult;
+    },
+    evaluateAllCells: (intersectingRange) => {
+      throw new Error("WIP: evaluateAllCells for IFERROR is not implemented");
+    }
+  };
+}
+var IFERROR = {
+  name: "IFERROR",
+  evaluate: function(node, context) {
+    if (node.args.length !== 2) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "IFERROR function takes exactly 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const valueResult = captureEvaluationErrors(context.dependencyNode, () => this.evaluateNode(node.args[0], context));
+    if (valueResult.type === "awaiting-evaluation") {
+      return valueResult;
+    }
+    if (valueResult.type === "spilled-values") {
+      const valueIfErrorResult = this.evaluateNode(node.args[1], context);
+      if (valueIfErrorResult.type === "error" || valueIfErrorResult.type === "awaiting-evaluation") {
+        return valueIfErrorResult;
+      }
+      return createIfErrorSpilledResult.call(this, {
+        valueResult,
+        valueIfErrorResult,
+        context
+      });
+    }
+    if (valueResult.type === "error") {
+      const valueIfErrorResult = this.evaluateNode(node.args[1], context);
+      return valueIfErrorResult;
+    }
+    return valueResult;
+  }
+};
+export {
+  IFERROR
+};
+
+//# debugId=CC626D59CFEBD9BB64756E2164756E21

package/dist/mjs/functions/logical/iferror/iferror.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/logical/iferror/iferror.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type ErrorEvaluationResult,\n} from \"src/core/types\";\nimport { captureEvaluationErrors } from \"src/core/utils\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\n\n/**\n * IFERROR function - Returns a value you specify if a formula evaluates to an error\n *\n * Usage: IFERROR(value, value_if_error)\n *\n * value: The expression to check for errors (required)\n * value_if_error: The value to return if the expression is an error (required)\n *\n * Examples:\n *   IFERROR(A1/B1, \"Division error\") - returns \"Division error\" if B1 is 0\n *   IFERROR(VLOOKUP(A1, table, 2), \"Not found\") - returns \"Not found\" if lookup fails\n *   IFERROR(1/0, 0) - returns 0 instead of #DIV/0! error\n *\n * Note:\n * - If value is not an error, returns the value unchanged\n * - If value is an error, returns value_if_error\n * - Supports spilled values (dynamic arrays) for both arguments\n * - Any error type (#VALUE!, #DIV/0!, #N/A, etc.) triggers the error handling\n */\n\n/**\n * Helper for creating spilled-values result for IFERROR function\n */\nfunction createIfErrorSpilledResult(\n  this: FormulaEvaluator,\n  {\n    valueResult,\n    valueIfErrorResult,\n    context,\n  }: {\n    valueResult: FunctionEvaluationResult;\n    valueIfErrorResult: FunctionEvaluationResult;\n    context: EvaluationContext;\n  }\n): SpilledValuesEvaluationResult | ErrorEvaluationResult {\n  const hasSpilledValue = valueResult.type === \"spilled-values\";\n  const hasSpilledError = valueIfErrorResult.type === \"spilled-values\";\n\n  if (!hasSpilledValue && !hasSpilledError) {\n    throw new Error(\"createIfErrorSpilledResult 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 (hasSpilledValue && valueResult.type === \"spilled-values\") {\n        const spillArea = valueResult.spillArea(origin);\n        if (hasSpilledError && valueIfErrorResult.type === \"spilled-values\") {\n          return this.unionRanges(\n            this.projectRange(spillArea, origin),\n            this.projectRange(valueIfErrorResult.spillArea(origin), origin)\n          );\n        }\n        return spillArea;\n      } else if (\n        hasSpilledError &&\n        valueIfErrorResult.type === \"spilled-values\"\n      ) {\n        return valueIfErrorResult.spillArea(origin);\n      } else {\n        throw new Error(\"No spilled values found\");\n      }\n    },\n    source: \"IFERROR with spilled values\",\n    evaluate: (spilledCell: any, evalContext: any): SingleEvaluationResult => {\n      // Evaluate arguments at this spilled position\n      const spillValueResult = hasSpilledValue\n        ? valueResult.evaluate(spilledCell, evalContext)\n        : valueResult;\n      const spillErrorResult = hasSpilledError\n        ? valueIfErrorResult.evaluate(spilledCell, evalContext)\n        : valueIfErrorResult;\n\n      if (spillValueResult === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled value has not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      if (spillErrorResult === undefined) {\n        return {\n          type: \"error\",\n          err: FormulaError.REF,\n          message: \"The spilled error value has not been evaluated\",\n          errAddress: context.dependencyNode,\n        };\n      }\n\n      // IFERROR logic: if first argument is error, return second argument\n      if (\n        spillValueResult.type === \"error\" ||\n        spillValueResult.type === \"awaiting-evaluation\"\n      ) {\n        return spillErrorResult;\n      }\n\n      // If first argument is not an error, return it\n      return spillValueResult;\n    },\n    evaluateAllCells: (intersectingRange: any) => {\n      throw new Error(\"WIP: evaluateAllCells for IFERROR is not implemented\");\n    },\n  };\n}\n\n/**\n * IFERROR function implementation\n */\nexport const IFERROR: FunctionDefinition = {\n  name: \"IFERROR\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length !== 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"IFERROR function takes exactly 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the value argument (the expression to check for errors)\n    const valueResult = captureEvaluationErrors(\n      context.dependencyNode,\n      () => this.evaluateNode(node.args[0]!, context)\n    );\n\n    if (valueResult.type === \"awaiting-evaluation\") {\n      return valueResult;\n    }\n\n    // Handle spilled values - we need to evaluate both branches\n    // because different cells might have errors or not\n    if (valueResult.type === \"spilled-values\") {\n      // Evaluate the value_if_error argument\n      const valueIfErrorResult = this.evaluateNode(node.args[1]!, context);\n      if (\n        valueIfErrorResult.type === \"error\" ||\n        valueIfErrorResult.type === \"awaiting-evaluation\"\n      ) {\n        return valueIfErrorResult; // Error in the error handler itself\n      }\n\n      return createIfErrorSpilledResult.call(this, {\n        valueResult,\n        valueIfErrorResult,\n        context,\n      });\n    }\n\n    // LAZY EVALUATION: Only evaluate error handler if we have an error\n    // IFERROR logic: if first argument is error, return second argument\n    if (valueResult.type === \"error\") {\n      const valueIfErrorResult = this.evaluateNode(node.args[1]!, context);\n      return valueIfErrorResult;\n    }\n\n    // If first argument is not an error, return it unchanged\n    // WITHOUT evaluating the error handler\n    return valueResult;\n  },\n};\n"
+  ],
+  "mappings": "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",
+  "debugId": "CC626D59CFEBD9BB64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/logical/or/or.mjs

@@ -0,0 +1,84 @@
+// src/functions/logical/or/or.ts
+import {
+  FormulaError
+} from "src/core/types";
+function isTruthy(value) {
+  switch (value.type) {
+    case "boolean":
+      return value.value;
+    case "number":
+      return value.value !== 0;
+    case "string":
+      return value.value !== "";
+    case "infinity":
+      return true;
+    default:
+      return false;
+  }
+}
+var OR = {
+  name: "OR",
+  evaluate: function(node, context) {
+    if (node.args.length === 0) {
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: "OR function requires at least one argument",
+        errAddress: context.dependencyNode
+      };
+    }
+    for (const arg of node.args) {
+      const argResult = this.evaluateNode(arg, context);
+      if (argResult.type === "error" || argResult.type === "awaiting-evaluation") {
+        return argResult;
+      }
+      if (argResult.type === "value") {
+        if (isTruthy(argResult.result)) {
+          return {
+            type: "value",
+            result: { type: "boolean", value: true }
+          };
+        }
+      } else if (argResult.type === "spilled-values") {
+        const cellValues = argResult.evaluateAllCells.call(this, {
+          context,
+          origin: context.cellAddress,
+          evaluate: argResult.evaluate,
+          lookupOrder: "col-major"
+        });
+        if (cellValues.type === "error" || cellValues.type === "awaiting-evaluation") {
+          return cellValues;
+        }
+        for (const cellValue of cellValues.values) {
+          if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+            return cellValue.result;
+          }
+          if (cellValue.result.type === "value") {
+            if (isTruthy(cellValue.result.result)) {
+              return {
+                type: "value",
+                result: { type: "boolean", value: true }
+              };
+            }
+          }
+        }
+      } else {
+        return {
+          type: "error",
+          err: FormulaError.VALUE,
+          message: "Invalid argument type for OR function",
+          errAddress: context.dependencyNode
+        };
+      }
+    }
+    return {
+      type: "value",
+      result: { type: "boolean", value: false }
+    };
+  }
+};
+export {
+  OR
+};
+
+//# debugId=1823CFBC008C71DB64756E2164756E21

package/dist/mjs/functions/logical/or/or.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/logical/or/or.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type CellValue,\n  type CellNumber,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type ValueEvaluationResult,\n  type CellAddress,\n  type SpreadsheetRange,\n  type SpilledValuesEvaluationResult,\n  type SingleEvaluationResult,\n  type 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 * OR function - Returns TRUE if any argument is TRUE, FALSE otherwise\n *\n * Usage: OR(logical1, [logical2], ...)\n *\n * logical1, logical2, ...: Logical values or expressions to evaluate\n *\n * Examples:\n *   OR(TRUE, FALSE) - returns TRUE\n *   OR(FALSE, FALSE) - returns FALSE\n *   OR(A1>10, B1<20) - returns TRUE if either condition is met\n *   OR(A1:A3) - returns TRUE if any value in A1:A3 is truthy\n *\n * Note:\n * - Supports spilled values (dynamic arrays) for arguments\n * - Logical evaluation: 0 and empty string are FALSE, everything else is TRUE\n * - If any argument is spilled, processes all values in the range\n * - Short-circuit evaluation: stops at first TRUE value\n */\n\n/**\n * Convert a cell value to boolean for logical evaluation\n */\nfunction isTruthy(value: CellValue): boolean {\n  switch (value.type) {\n    case \"boolean\":\n      return value.value;\n    case \"number\":\n      return value.value !== 0;\n    case \"string\":\n      return value.value !== \"\";\n    case \"infinity\":\n      return true; // Infinity is truthy\n    default:\n      return false;\n  }\n}\n\n// OR function does not create spilled results - it processes all values in ranges\n// as individual logical tests and returns a single boolean result\n\n/**\n * OR function implementation\n */\nexport const OR: FunctionDefinition = {\n  name: \"OR\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length === 0) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"OR function requires at least one argument\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Process arguments one by one (like AND function)\n    for (const arg of node.args) {\n      const argResult = this.evaluateNode(arg, context);\n\n      if (argResult.type === \"error\" || argResult.type === \"awaiting-evaluation\") {\n        return argResult;\n      }\n\n      if (argResult.type === \"value\") {\n        // Single value - check if truthy\n        if (isTruthy(argResult.result)) {\n          // Short-circuit: return TRUE on first truthy value\n          return {\n            type: \"value\",\n            result: { type: \"boolean\", value: true },\n          };\n        }\n      } else if (argResult.type === \"spilled-values\") {\n        // Range - check all values in the range\n        const cellValues = argResult.evaluateAllCells.call(this, {\n          context,\n          origin: context.cellAddress,\n          evaluate: argResult.evaluate,\n          lookupOrder: \"col-major\",\n        });\n        if (cellValues.type === \"error\" || cellValues.type === \"awaiting-evaluation\") {\n          return cellValues;\n        }\n        for (const cellValue of cellValues.values) {\n          if (cellValue.result.type === \"error\" || cellValue.result.type === \"awaiting-evaluation\") {\n            return cellValue.result;\n          }\n          if (cellValue.result.type === \"value\") {\n            if (isTruthy(cellValue.result.result)) {\n              // Short-circuit: return TRUE on first truthy value\n              return {\n                type: \"value\",\n                result: { type: \"boolean\", value: true },\n              };\n            }\n          }\n        }\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"Invalid argument type for OR function\",\n          errAddress: context.dependencyNode,\n        };\n      }\n    }\n\n    // All arguments are falsy\n    return {\n      type: \"value\",\n      result: { type: \"boolean\", value: false },\n    };\n  },\n};\n"
+  ],
+  "mappings": ";AAAA;AAAA;AAAA;AAuCA,SAAS,QAAQ,CAAC,OAA2B;AAAA,EAC3C,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,OAAO,MAAM;AAAA,SACV;AAAA,MACH,OAAO,MAAM,UAAU;AAAA,SACpB;AAAA,MACH,OAAO,MAAM,UAAU;AAAA,SACpB;AAAA,MACH,OAAO;AAAA;AAAA,MAEP,OAAO;AAAA;AAAA;AAUN,IAAM,KAAyB;AAAA,EACpC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,WAAW,OAAO,KAAK,MAAM;AAAA,MAC3B,MAAM,YAAY,KAAK,aAAa,KAAK,OAAO;AAAA,MAEhD,IAAI,UAAU,SAAS,WAAW,UAAU,SAAS,uBAAuB;AAAA,QAC1E,OAAO;AAAA,MACT;AAAA,MAEA,IAAI,UAAU,SAAS,SAAS;AAAA,QAE9B,IAAI,SAAS,UAAU,MAAM,GAAG;AAAA,UAE9B,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,UACzC;AAAA,QACF;AAAA,MACF,EAAO,SAAI,UAAU,SAAS,kBAAkB;AAAA,QAE9C,MAAM,aAAa,UAAU,iBAAiB,KAAK,MAAM;AAAA,UACvD;AAAA,UACA,QAAQ,QAAQ;AAAA,UAChB,UAAU,UAAU;AAAA,UACpB,aAAa;AAAA,QACf,CAAC;AAAA,QACD,IAAI,WAAW,SAAS,WAAW,WAAW,SAAS,uBAAuB;AAAA,UAC5E,OAAO;AAAA,QACT;AAAA,QACA,WAAW,aAAa,WAAW,QAAQ;AAAA,UACzC,IAAI,UAAU,OAAO,SAAS,WAAW,UAAU,OAAO,SAAS,uBAAuB;AAAA,YACxF,OAAO,UAAU;AAAA,UACnB;AAAA,UACA,IAAI,UAAU,OAAO,SAAS,SAAS;AAAA,YACrC,IAAI,SAAS,UAAU,OAAO,MAAM,GAAG;AAAA,cAErC,OAAO;AAAA,gBACL,MAAM;AAAA,gBACN,QAAQ,EAAE,MAAM,WAAW,OAAO,KAAK;AAAA,cACzC;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF,EAAO;AAAA,QACL,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,aAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA;AAAA,IAEJ;AAAA,IAGA,OAAO;AAAA,MACL,MAAM;AAAA,MACN,QAAQ,EAAE,MAAM,WAAW,OAAO,MAAM;AAAA,IAC1C;AAAA;AAEJ;",
+  "debugId": "1823CFBC008C71DB64756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/lookup/count/count-utils.mjs

@@ -0,0 +1,35 @@
+// src/functions/lookup/count/count-utils.ts
+function performCount(results) {
+  let count = 0;
+  for (const result of results) {
+    if (result.type === "error" || result.type === "awaiting-evaluation") {
+      return result;
+    }
+    if (result.type === "value") {
+      if (result.result.type === "number" || result.result.type === "infinity") {
+        count++;
+      }
+    }
+  }
+  return {
+    type: "value",
+    result: { type: "number", value: count }
+  };
+}
+function countEmptyCells(criteriaRangeResult, parsedCriteria, currentCell) {
+  if (criteriaRangeResult.type === "spilled-values" && parsedCriteria.type === "exact" && parsedCriteria.value.type === "string" && parsedCriteria.value.value === "") {
+    const spillArea = criteriaRangeResult.spillArea(currentCell);
+    if (spillArea.end.col.type === "infinity" || spillArea.end.row.type === "infinity") {
+      return {
+        type: "value",
+        result: { type: "infinity", sign: "positive" }
+      };
+    }
+  }
+}
+export {
+  performCount,
+  countEmptyCells
+};
+
+//# debugId=27BAB068756EB60864756E2164756E21

package/dist/mjs/functions/lookup/count/count-utils.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/lookup/count/count-utils.ts"],
+  "sourcesContent": [
+    "import {\n  type CellAddress,\n  type FunctionEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport type { ParsedCriteria } from \"src/functions/criteria-parser\";\n\n/**\n * Performs counting of numeric values from an iterable of SingleEvaluationResult values\n * Handles numbers and infinities according to Excel's COUNT behavior\n * - Propagates errors immediately\n * - Only counts numeric values (numbers and infinities)\n * - Ignores non-numeric values (strings, booleans, empty cells)\n *\n * @param results - Iterable of SingleEvaluationResult to count\n * @returns FunctionEvaluationResult with the count\n */\nexport function performCount(\n  results: Iterable<SingleEvaluationResult>\n): FunctionEvaluationResult {\n  let count = 0;\n\n  for (const result of results) {\n    if (result.type === \"error\" || result.type === \"awaiting-evaluation\") {\n      // Propagate errors immediately\n      return result;\n    }\n\n    if (result.type === \"value\") {\n      if (\n        result.result.type === \"number\" ||\n        result.result.type === \"infinity\"\n      ) {\n        count++;\n      }\n      // Non-numeric values (strings, booleans) are ignored\n    }\n  }\n\n  return {\n    type: \"value\",\n    result: { type: \"number\", value: count },\n  };\n}\n\nexport function countEmptyCells(\n  criteriaRangeResult: FunctionEvaluationResult,\n  parsedCriteria: ParsedCriteria,\n  currentCell: CellAddress\n): FunctionEvaluationResult | undefined {\n  // Special case: counting empty cells over infinite ranges\n  if (\n    criteriaRangeResult.type === \"spilled-values\" &&\n    parsedCriteria.type === \"exact\" &&\n    parsedCriteria.value.type === \"string\" &&\n    parsedCriteria.value.value === \"\"\n  ) {\n    const spillArea = criteriaRangeResult.spillArea(currentCell);\n\n    // Check if this is an infinite range\n    if (\n      spillArea.end.col.type === \"infinity\" ||\n      spillArea.end.row.type === \"infinity\"\n    ) {\n      // Return infinity for infinite empty cell count\n      return {\n        type: \"value\",\n        result: { type: \"infinity\", sign: \"positive\" },\n      };\n    }\n  }\n}\n"
+  ],
+  "mappings": ";AAiBO,SAAS,YAAY,CAC1B,SAC0B;AAAA,EAC1B,IAAI,QAAQ;AAAA,EAEZ,WAAW,UAAU,SAAS;AAAA,IAC5B,IAAI,OAAO,SAAS,WAAW,OAAO,SAAS,uBAAuB;AAAA,MAEpE,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,OAAO,SAAS,SAAS;AAAA,MAC3B,IACE,OAAO,OAAO,SAAS,YACvB,OAAO,OAAO,SAAS,YACvB;AAAA,QACA;AAAA,MACF;AAAA,IAEF;AAAA,EACF;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,QAAQ,EAAE,MAAM,UAAU,OAAO,MAAM;AAAA,EACzC;AAAA;AAGK,SAAS,eAAe,CAC7B,qBACA,gBACA,aACsC;AAAA,EAEtC,IACE,oBAAoB,SAAS,oBAC7B,eAAe,SAAS,WACxB,eAAe,MAAM,SAAS,YAC9B,eAAe,MAAM,UAAU,IAC/B;AAAA,IACA,MAAM,YAAY,oBAAoB,UAAU,WAAW;AAAA,IAG3D,IACE,UAAU,IAAI,IAAI,SAAS,cAC3B,UAAU,IAAI,IAAI,SAAS,YAC3B;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,QAAQ,EAAE,MAAM,YAAY,MAAM,WAAW;AAAA,MAC/C;AAAA,IACF;AAAA,EACF;AAAA;",
+  "debugId": "27BAB068756EB60864756E2164756E21",
+  "names": []
+}

package/dist/mjs/functions/lookup/count/count.mjs

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

package/dist/mjs/functions/lookup/count/count.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/lookup/count/count.ts"],
+  "sourcesContent": [
+    "import {\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n} from \"src/core/types\";\nimport { createArgumentIterator } from \"src/functions/function-utils\";\nimport { performCount } from \"./count-utils.mjs\";\n\n/**\n * COUNT function - Counts the number of cells that contain numbers\n * \n * Usage: COUNT(value1, [value2], ...)\n * \n * Examples:\n *   COUNT(1, 2, 3) - returns 3\n *   COUNT(A1:A10) - counts numeric values in the range A1:A10\n *   COUNT(A1:A5, B1:B5) - counts numeric values in both ranges\n * \n * Note:\n * - Only numeric values are counted (numbers and infinities)\n * - Text, logical values, and empty cells are ignored\n * - Errors propagate immediately\n * \n * From Excel documentation:\n * \"The COUNT function counts the number of cells that contain numbers, \n * and counts numbers within the list of arguments.\"\n */\nexport const COUNT: FunctionDefinition = {\n  name: \"COUNT\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    // Create iterator over all argument values\n    const argumentValues = createArgumentIterator(this, node, context, \"col-major\");\n\n    if (argumentValues.type !== \"values\") {\n      return argumentValues;\n    }\n    // Use shared counting utility\n    return performCount(argumentValues.values);\n  },\n};\n"
+  ],
+  "mappings": ";AAIA;AACA;AAqBO,IAAM,QAA4B;AAAA,EACvC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAE3D,MAAM,iBAAiB,uBAAuB,MAAM,MAAM,SAAS,WAAW;AAAA,IAE9E,IAAI,eAAe,SAAS,UAAU;AAAA,MACpC,OAAO;AAAA,IACT;AAAA,IAEA,OAAO,aAAa,eAAe,MAAM;AAAA;AAE7C;",
+  "debugId": "06386725A95B4B8F64756E2164756E21",
+  "names": []
+}