@ricsam/formula-engine 0.0.1

package/dist/cjs/functions/criteria-utils.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/criteria-utils.ts"],
+  "sourcesContent": [
+    "import {\n  FormulaError,\n  type FunctionDefinition,\n  type FunctionEvaluationResult,\n  type SingleEvaluationResult,\n  type CellInfinity,\n  type ValueEvaluationResult,\n  type ErrorEvaluationResult,\n} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { FunctionNode, ASTNode } from \"src/parser/ast\";\nimport {\n  parseCriteria,\n  matchesParsedCriteria,\n  type ParsedCriteria,\n} from \"./criteria-parser.cjs\";\nimport { flags } from \"src/debug/flags\";\nimport { getRelativeRange } from \"src/core/utils\";\nimport type { LookupOrder } from \"src/core/managers\";\nimport {\n  AwaitingEvaluationError,\n  EvaluationError,\n} from \"src/evaluator/evaluation-error\";\n\n/**\n * Criteria pair for criteria-based functions\n */\nexport interface CriteriaPair {\n  rangeResult: FunctionEvaluationResult;\n  parsedCriteria: ParsedCriteria;\n}\n\n/**\n * Parse criteria pairs from function arguments\n * @param node - The function node\n * @param context - Evaluation context\n * @param evaluateNode - Node evaluation function\n * @param startIndex - Index to start parsing criteria pairs from (1 for IFS functions, 0 for COUNTIFS)\n * @returns Array of criteria pairs or error\n */\nexport function parseCriteriaPairs(\n  this: FormulaEvaluator,\n  node: FunctionNode,\n  context: EvaluationContext,\n  evaluateNode: (\n    node: ASTNode,\n    context: EvaluationContext\n  ) => FunctionEvaluationResult,\n  startIndex: number = 1\n): CriteriaPair[] | ErrorEvaluationResult {\n  const criteriaPairs: CriteriaPair[] = [];\n\n  for (let i = startIndex; i < node.args.length; i += 2) {\n    const criteriaRangeResult = evaluateNode.call(this, node.args[i]!, context);\n    if (\n      criteriaRangeResult.type === \"error\" ||\n      criteriaRangeResult.type === \"awaiting-evaluation\"\n    ) {\n      return criteriaRangeResult;\n    }\n\n    const criteriaResult = evaluateNode.call(this, node.args[i + 1]!, context);\n    if (\n      criteriaResult.type === \"error\" ||\n      criteriaResult.type === \"awaiting-evaluation\"\n    ) {\n      return criteriaResult;\n    }\n\n    let result: ValueEvaluationResult;\n\n    if (criteriaResult.type === \"spilled-values\") {\n      // just take the first spilled value\n      const firstSpilledValue = criteriaResult.evaluate(\n        { x: 0, y: 0 },\n        context\n      );\n      if (\n        firstSpilledValue.type === \"error\" ||\n        firstSpilledValue.type === \"awaiting-evaluation\"\n      ) {\n        return firstSpilledValue;\n      } else {\n        result = firstSpilledValue;\n      }\n    } else {\n      result = criteriaResult;\n    }\n\n    const parsedCriteria = parseCriteria(result.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    criteriaPairs.push({\n      rangeResult: criteriaRangeResult,\n      parsedCriteria,\n    });\n  }\n\n  return criteriaPairs;\n}\n\n/**\n * Check if any criteria involves empty/non-empty cell matching\n */\nexport function hasEmptyCriteria(criteriaPairs: CriteriaPair[]): boolean {\n  return criteriaPairs.some(\n    ({ parsedCriteria }) =>\n      parsedCriteria.type === \"exact\" &&\n      parsedCriteria.value.type === \"string\" &&\n      parsedCriteria.value.value === \"\"\n  );\n}\n\n/**\n * Returns matching values from ranges based on criteria\n * @param evaluator - The function evaluator context\n * @param valueRangeResult - The range of values to process\n * @param criteriaPairs - Array of criteria pairs to match against\n * @param context - Evaluation context\n * @returns Array of SingleEvaluationResult for each matching cell - includes both values and errors\n * Consuming functions decide whether to skip errors or propagate them\n */\nexport function processMultiCriteriaValues(\n  evaluator: FormulaEvaluator,\n  valueRangeResult: FunctionEvaluationResult,\n  criteriaPairs: CriteriaPair[],\n  context: EvaluationContext,\n  lookupOrder: LookupOrder\n):\n  | { type: \"values\"; values: SingleEvaluationResult[] }\n  | ErrorEvaluationResult {\n  const results: SingleEvaluationResult[] = [];\n\n  const criteriaPairWithError = criteriaPairs\n    .map((pair) => pair.rangeResult)\n    .find(\n      (result) =>\n        result.type === \"error\" || result.type === \"awaiting-evaluation\"\n    );\n  if (criteriaPairWithError) {\n    return criteriaPairWithError;\n  }\n\n  // Check if this is an empty criteria case\n  if (\n    hasEmptyCriteria(criteriaPairs) &&\n    valueRangeResult.type === \"spilled-values\"\n  ) {\n    return handleEmptyCriteriaSpilledValues(\n      valueRangeResult,\n      criteriaPairs,\n      context\n    );\n  }\n\n  // Handle different value range types\n  if (valueRangeResult.type === \"value\") {\n    // Single value case - check if all criteria match\n    let allMatch = true;\n    for (const { rangeResult, parsedCriteria } of criteriaPairs) {\n      if (rangeResult.type === \"value\") {\n        if (!matchesParsedCriteria(rangeResult.result, parsedCriteria)) {\n          allMatch = false;\n          break;\n        }\n      } else {\n        // Single value but range criteria - doesn't make sense\n        allMatch = false;\n        break;\n      }\n    }\n\n    if (allMatch) {\n      results.push(valueRangeResult); // Add the entire result (ValueEvaluationResult)\n    }\n  } else if (valueRangeResult.type === \"spilled-values\") {\n    // Range case - first validate dimensions using spillArea for efficiency\n    const valueSpillArea = valueRangeResult.spillArea(context.cellAddress);\n\n    // Check that all criteria ranges have compatible dimensions\n    for (const { rangeResult } of criteriaPairs) {\n      if (rangeResult.type === \"spilled-values\") {\n        const criteriaSpillArea = rangeResult.spillArea(context.cellAddress);\n\n        // Compare dimensions using relative ranges to get width/height\n        const valueRelRange = getRelativeRange(\n          valueSpillArea,\n          context.cellAddress\n        );\n        const criteriaRelRange = getRelativeRange(\n          criteriaSpillArea,\n          context.cellAddress\n        );\n\n        // Check if dimensions are compatible\n        const widthsMatch =\n          (valueRelRange.width.type === \"infinity\" &&\n            criteriaRelRange.width.type === \"infinity\") ||\n          (valueRelRange.width.type === \"number\" &&\n            criteriaRelRange.width.type === \"number\" &&\n            valueRelRange.width.value === criteriaRelRange.width.value);\n\n        const heightsMatch =\n          (valueRelRange.height.type === \"infinity\" &&\n            criteriaRelRange.height.type === \"infinity\") ||\n          (valueRelRange.height.type === \"number\" &&\n            criteriaRelRange.height.type === \"number\" &&\n            valueRelRange.height.value === criteriaRelRange.height.value);\n\n        if (!widthsMatch || !heightsMatch) {\n          // Return #VALUE! error for dimension mismatch\n          throw new EvaluationError(\n            FormulaError.VALUE,\n            \"Criteria range dimensions do not match value range dimensions\"\n          );\n        }\n      }\n      // Single values (type === \"value\") are compatible with any range size\n    }\n\n    // Get all cells to simplify position-based pairing\n    const valueResults = valueRangeResult.evaluateAllCells.call(evaluator, {\n      context,\n      evaluate: valueRangeResult.evaluate,\n      origin: context.cellAddress,\n      lookupOrder,\n    });\n\n    // Get criteria ranges (or track if single value)\n    const criteriaResultsArrays = criteriaPairs.map(({ rangeResult }) => {\n      if (rangeResult.type === \"spilled-values\") {\n        const criteriaResults = rangeResult.evaluateAllCells.call(evaluator, {\n          context,\n          evaluate: rangeResult.evaluate,\n          origin: context.cellAddress,\n          lookupOrder,\n        });\n        return { type: \"array\" as const, results: criteriaResults };\n      } else {\n        // Single value - we'll use it for all positions\n        return { type: \"single\" as const, value: rangeResult };\n      }\n    });\n\n    // Create maps from position to value for each criteria range\n    const criteriaMaps = criteriaResultsArrays.map((criteriaData) => {\n      if (criteriaData.type === \"single\") {\n        return null; // Single values don't need a map\n      }\n      if (criteriaData.results.type !== \"values\") {\n        return null;\n      }\n      const map = new Map<string, SingleEvaluationResult>();\n      for (const { result, relativePos } of criteriaData.results.values) {\n        const key = `${relativePos.x},${relativePos.y}`;\n        map.set(key, result);\n      }\n      return map;\n    });\n\n    if (valueResults.type !== \"values\") {\n      return valueResults;\n    }\n\n    // Iterate through each value position\n    for (const valueCell of valueResults.values) {\n      if (!valueCell) {\n        continue;\n      }\n\n      const posKey = `${valueCell.relativePos.x},${valueCell.relativePos.y}`;\n\n      // Check if all criteria match for this position\n      let allMatch = true;\n      for (let j = 0; j < criteriaPairs.length; j++) {\n        let criteriaCell: SingleEvaluationResult | undefined;\n\n        if (criteriaResultsArrays[j]!.type === \"single\") {\n          // Single value - use it for all positions\n          criteriaCell = criteriaResultsArrays[j]!.value;\n        } else {\n          // Array - look up by position, treat missing as empty\n          criteriaCell = criteriaMaps[j]?.get(posKey);\n        }\n\n        // If criteriaCell is undefined, treat it as an empty cell\n        if (!criteriaCell) {\n          // Check if the criteria matches empty cells\n          const parsedCriteria = criteriaPairs[j]!.parsedCriteria;\n          const emptyValue = { type: \"string\" as const, value: \"\" };\n          if (!matchesParsedCriteria(emptyValue, parsedCriteria)) {\n            allMatch = false;\n            break;\n          }\n        } else if (criteriaCell.type === \"error\") {\n          allMatch = false;\n          break;\n        } else if (criteriaCell.type === \"value\") {\n          if (\n            !matchesParsedCriteria(\n              criteriaCell.result,\n              criteriaPairs[j]!.parsedCriteria\n            )\n          ) {\n            allMatch = false;\n            break;\n          }\n        } else if (criteriaCell.type === \"awaiting-evaluation\") {\n          return criteriaCell;\n        } else {\n          allMatch = false;\n          break;\n        }\n      }\n\n      if (allMatch) {\n        results.push(valueCell.result); // Add the entire SingleEvaluationResult (includes errors and values)\n      }\n    }\n  }\n\n  return { type: \"values\", values: results };\n}\n\n/**\n * Validate multi-criteria function arguments (odd number, min 3)\n */\nexport function validateMultiCriteriaArgs(\n  functionName: string,\n  argCount: number,\n  context: EvaluationContext\n): ErrorEvaluationResult | null {\n  if (argCount < 3 || (argCount - 1) % 2 !== 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `${functionName} function requires an odd number of arguments (min 3): value_range, criteria_range1, criteria1, [criteria_range2, criteria2], ...`,\n      errAddress: context.dependencyNode,\n    };\n  }\n  return null;\n}\n\n/**\n * Validate COUNTIFS function arguments (even number, min 2)\n */\nexport function validateCountifsArgs(\n  argCount: number,\n  context: EvaluationContext\n): ErrorEvaluationResult | null {\n  if (argCount < 2 || argCount % 2 !== 0) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message:\n        \"COUNTIFS function requires an even number of arguments (min 2): criteria_range1, criteria1, [criteria_range2, criteria2], ...\",\n      errAddress: context.dependencyNode,\n    };\n  }\n  return null;\n}\n\n/**\n * Validate single criteria function arguments (2 or 3)\n */\nexport function validateSingleCriteriaArgs(\n  functionName: string,\n  argCount: number,\n  context: EvaluationContext\n): ErrorEvaluationResult | null {\n  if (argCount < 2 || argCount > 3) {\n    return {\n      type: \"error\",\n      err: FormulaError.VALUE,\n      message: `${functionName} function takes 2 or 3 arguments`,\n      errAddress: context.dependencyNode,\n    };\n  }\n  return null;\n}\n\n/**\n * Result type for processInfinity - either return infinity immediately or continue with updated state\n */\nexport type ProcessInfinityResult<T> =\n  | { type: \"infinity\"; infinity: CellInfinity }\n  | { type: \"state\"; state: T };\n\n/**\n * Handle empty cell criteria for spilled values - returns matching values for empty criteria cases\n * This is needed when criteria like \"=\" (empty) or \"<>\" (non-empty) are used with ranges\n *\n * @param valueRangeResult - The range of values to process\n * @param criteriaPairs - Array of criteria pairs\n * @param context - Evaluation context\n * @returns Array of matching values\n */\nfunction handleEmptyCriteriaSpilledValues(\n  valueRangeResult: FunctionEvaluationResult,\n  criteriaPairs: CriteriaPair[],\n  context: EvaluationContext\n):\n  | { type: \"values\"; values: SingleEvaluationResult[] }\n  | ErrorEvaluationResult {\n  if (\n    !hasEmptyCriteria(criteriaPairs) ||\n    valueRangeResult.type !== \"spilled-values\"\n  ) {\n    throw new Error(\"Not an empty criteria case\");\n  }\n  const results: SingleEvaluationResult[] = [];\n  const valueSpillArea = valueRangeResult.spillArea(context.cellAddress);\n\n  // Check if this is an infinite range and we are counting empty cells - throw error\n  if (\n    valueSpillArea.end.col.type === \"infinity\" ||\n    valueSpillArea.end.row.type === \"infinity\"\n  ) {\n    throw new EvaluationError(\n      FormulaError.VALUE,\n      \"Can not process infinite ranges with empty cell criteria\"\n    );\n  }\n\n  // Finite range - iterate over all cells in spill areas\n  if (\n    valueSpillArea.end.col.type === \"number\" &&\n    valueSpillArea.end.row.type === \"number\"\n  ) {\n    for (\n      let row = valueSpillArea.start.row;\n      row <= valueSpillArea.end.row.value;\n      row++\n    ) {\n      for (\n        let col = valueSpillArea.start.col;\n        col <= valueSpillArea.end.col.value;\n        col++\n      ) {\n        const valueCell = valueRangeResult.evaluate(\n          {\n            x: col - valueSpillArea.start.col,\n            y: row - valueSpillArea.start.row,\n          },\n          context\n        );\n\n        // Check all criteria for this position\n        let allMatch = true;\n        for (const { rangeResult, parsedCriteria } of criteriaPairs) {\n          let criteriaCell: SingleEvaluationResult | undefined;\n\n          if (rangeResult.type === \"spilled-values\") {\n            const criteriaSpillArea = rangeResult.spillArea(\n              context.cellAddress\n            );\n            const criteriaRow =\n              row - valueSpillArea.start.row + criteriaSpillArea.start.row;\n            const criteriaCol =\n              col - valueSpillArea.start.col + criteriaSpillArea.start.col;\n\n            if (\n              criteriaRow <=\n                (criteriaSpillArea.end.row.type === \"number\"\n                  ? criteriaSpillArea.end.row.value\n                  : Infinity) &&\n              criteriaCol <=\n                (criteriaSpillArea.end.col.type === \"number\"\n                  ? criteriaSpillArea.end.col.value\n                  : Infinity)\n            ) {\n              criteriaCell = rangeResult.evaluate(\n                {\n                  x: criteriaCol - criteriaSpillArea.start.col,\n                  y: criteriaRow - criteriaSpillArea.start.row,\n                },\n                context\n              );\n            }\n          } else if (rangeResult.type === \"value\") {\n            criteriaCell = rangeResult;\n          }\n\n          // Check if criteria matches (including empty cell logic)\n          const isEmptyCriteria =\n            (parsedCriteria.type === \"exact\" &&\n              parsedCriteria.value.type === \"string\" &&\n              parsedCriteria.value.value === \"\") ||\n            (parsedCriteria.type === \"comparison\" &&\n              parsedCriteria.operator === \"<>\" &&\n              parsedCriteria.value.type === \"string\" &&\n              parsedCriteria.value.value === \"\");\n\n          if (isEmptyCriteria) {\n            // Check if criteria cell matches empty condition\n            const isEmpty =\n              !criteriaCell ||\n              (criteriaCell.type === \"value\" &&\n                criteriaCell.result.type === \"string\" &&\n                criteriaCell.result.value === \"\");\n\n            const shouldMatch =\n              parsedCriteria.type === \"exact\" ? isEmpty : !isEmpty;\n            if (!shouldMatch) {\n              allMatch = false;\n              break;\n            }\n          } else {\n            // Regular criteria matching\n            if (\n              !criteriaCell ||\n              criteriaCell.type !== \"value\" ||\n              !matchesParsedCriteria(criteriaCell.result, parsedCriteria)\n            ) {\n              allMatch = false;\n              break;\n            }\n          }\n        }\n\n        if (allMatch && valueCell) {\n          results.push(valueCell); // Add the matching cell result\n        }\n      }\n    }\n  }\n\n  return { type: \"values\", values: results };\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "5ACCD9DEBF70FD2764756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/function-utils.cjs

@@ -0,0 +1,63 @@
+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/function-utils.ts
+var exports_function_utils = {};
+__export(exports_function_utils, {
+  createArgumentIterator: () => createArgumentIterator
+});
+module.exports = __toCommonJS(exports_function_utils);
+function createArgumentIterator(evaluator, node, context, lookupOrder) {
+  const results = [];
+  for (const arg of node.args) {
+    const result = evaluator.evaluateNode(arg, context);
+    if (result.type === "spilled-values") {
+      const cellValues = result.evaluateAllCells.call(evaluator, {
+        context,
+        evaluate: result.evaluate,
+        origin: context.cellAddress,
+        lookupOrder
+      });
+      if (cellValues.type === "awaiting-evaluation") {
+        return cellValues;
+      }
+      if (cellValues.type === "error") {
+        results.push(cellValues);
+      } else {
+        for (const cellValue of cellValues.values) {
+          results.push(cellValue.result);
+        }
+      }
+    } else {
+      results.push(result);
+    }
+  }
+  return { type: "values", values: results };
+}
+
+//# debugId=ACA075060E20030D64756E2164756E21

package/dist/cjs/functions/function-utils.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/function-utils.ts"],
+  "sourcesContent": [
+    "import type { LookupOrder } from \"src/core/managers\";\nimport {\n  type ErrorEvaluationResult,\n  type SingleEvaluationResult,\n} from \"src/core/types\";\nimport { getCellReference } from \"src/core/utils\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport { AwaitingEvaluationError } from \"src/evaluator/evaluation-error\";\nimport type { FormulaEvaluator } from \"src/evaluator/formula-evaluator\";\nimport type { FunctionNode } from \"src/parser/ast\";\n\n/**\n * Creates an array of all values from arguments of a function node\n * Returns SingleEvaluationResult for each value found in the arguments\n *\n * This is a shared utility used by all basic aggregation functions (SUM, MIN, MAX, AVERAGE)\n * to iterate over their arguments in a consistent way.\n *\n * @param evaluator - The formula evaluator instance\n * @param node - The function node containing arguments\n * @param context - The evaluation context\n * @returns Array of SingleEvaluationResult for each value in the arguments\n */\nexport function createArgumentIterator(\n  evaluator: FormulaEvaluator,\n  node: FunctionNode,\n  context: EvaluationContext,\n  lookupOrder: LookupOrder\n): { type: \"values\"; values: SingleEvaluationResult[] } | ErrorEvaluationResult {\n  const results: SingleEvaluationResult[] = [];\n\n  for (const arg of node.args) {\n    const result = evaluator.evaluateNode(arg, context);\n\n    if (result.type === \"spilled-values\") {\n      // Get all cells in the spilled range\n      const cellValues = result.evaluateAllCells.call(evaluator, {\n        context,\n        evaluate: result.evaluate,\n        origin: context.cellAddress,\n        lookupOrder,\n      });\n\n      if (cellValues.type === \"awaiting-evaluation\") {\n        return cellValues;\n      }\n\n      if (cellValues.type === \"error\") {\n        results.push(cellValues);\n      } else {\n        for (const cellValue of cellValues.values) {\n          results.push(cellValue.result);\n        }\n      }\n    } else {\n      results.push(result);\n    }\n  }\n\n  return { type: \"values\", values: results };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuBO,SAAS,sBAAsB,CACpC,WACA,MACA,SACA,aAC8E;AAAA,EAC9E,MAAM,UAAoC,CAAC;AAAA,EAE3C,WAAW,OAAO,KAAK,MAAM;AAAA,IAC3B,MAAM,SAAS,UAAU,aAAa,KAAK,OAAO;AAAA,IAElD,IAAI,OAAO,SAAS,kBAAkB;AAAA,MAEpC,MAAM,aAAa,OAAO,iBAAiB,KAAK,WAAW;AAAA,QACzD;AAAA,QACA,UAAU,OAAO;AAAA,QACjB,QAAQ,QAAQ;AAAA,QAChB;AAAA,MACF,CAAC;AAAA,MAED,IAAI,WAAW,SAAS,uBAAuB;AAAA,QAC7C,OAAO;AAAA,MACT;AAAA,MAEA,IAAI,WAAW,SAAS,SAAS;AAAA,QAC/B,QAAQ,KAAK,UAAU;AAAA,MACzB,EAAO;AAAA,QACL,WAAW,aAAa,WAAW,QAAQ;AAAA,UACzC,QAAQ,KAAK,UAAU,MAAM;AAAA,QAC/B;AAAA;AAAA,IAEJ,EAAO;AAAA,MACL,QAAQ,KAAK,MAAM;AAAA;AAAA,EAEvB;AAAA,EAEA,OAAO,EAAE,MAAM,UAAU,QAAQ,QAAQ;AAAA;",
+  "debugId": "ACA075060E20030D64756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/index.cjs

@@ -0,0 +1,125 @@
+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/index.ts
+var exports_functions = {};
+__export(exports_functions, {
+  functions: () => functions
+});
+module.exports = __toCommonJS(exports_functions);
+var import_sequence = require("./array/sequence/sequence.cjs");
+var import_index_lookup = require("./lookup/index-lookup/index-lookup.cjs");
+var import_match = require("./lookup/match/match.cjs");
+var import_count = require("./lookup/count/count.cjs");
+var import_countif = require("./lookup/count/countif.cjs");
+var import_average = require("./math/average/average.cjs");
+var import_averageif = require("./math/average/averageif.cjs");
+var import_averageifs = require("./math/average/averageifs.cjs");
+var import_max = require("./math/max/max.cjs");
+var import_maxifs = require("./math/max/maxifs.cjs");
+var import_min = require("./math/min/min.cjs");
+var import_minifs = require("./math/min/minifs.cjs");
+var import_sum = require("./math/sum/sum.cjs");
+var import_sumif = require("./math/sum/sumif.cjs");
+var import_sumifs = require("./math/sum/sumifs.cjs");
+var import_countifs = require("./lookup/count/countifs.cjs");
+var import_maxif = require("./math/max/maxif.cjs");
+var import_minif = require("./math/min/minif.cjs");
+var import_ceiling = require("./math/ceiling/ceiling.cjs");
+var import_exact = require("./text/exact/exact.cjs");
+var import_find = require("./text/find/find.cjs");
+var import_left = require("./text/left/left.cjs");
+var import_mid = require("./text/mid/mid.cjs");
+var import_len = require("./text/len/len.cjs");
+var import_right = require("./text/right/right.cjs");
+var import_concatenate = require("./text/concatenate/concatenate.cjs");
+var import_and = require("./logical/and/and.cjs");
+var import_if = require("./logical/if/if.cjs");
+var import_iferror = require("./logical/iferror/iferror.cjs");
+var import_xlookup = require("./lookup/xlookup/xlookup.cjs");
+var import_or = require("./logical/or/or.cjs");
+var import_textjoin = require("./text/textjoin/textjoin.cjs");
+var import_row = require("./information/row/row.cjs");
+var import_column = require("./information/column/column.cjs");
+var import_cell = require("./information/cell/cell.cjs");
+var import_address = require("./reference/address/address.cjs");
+var import_indirect = require("./reference/indirect/indirect.cjs");
+var import_offset = require("./reference/offset/offset.cjs");
+var buildFunctionIndex = (functions) => {
+  return Object.fromEntries(Object.entries(functions).flatMap(([name, func]) => {
+    const base = [[name, func]];
+    if (func.aliases) {
+      func.aliases.forEach((alias) => {
+        base.push([alias, func]);
+      });
+    }
+    return base;
+  }));
+};
+var functions = buildFunctionIndex({
+  ADDRESS: import_address.ADDRESS,
+  AND: import_and.AND,
+  AVERAGE: import_average.AVERAGE,
+  AVERAGEIF: import_averageif.AVERAGEIF,
+  AVERAGEIFS: import_averageifs.AVERAGEIFS,
+  CEILING: import_ceiling.CEILING,
+  CELL: import_cell.CELL,
+  COLUMN: import_column.COLUMN,
+  CONCATENATE: import_concatenate.CONCATENATE,
+  COUNT: import_count.COUNT,
+  COUNTIF: import_countif.COUNTIF,
+  COUNTIFS: import_countifs.COUNTIFS,
+  EXACT: import_exact.EXACT,
+  FIND: import_find.FIND,
+  IF: import_if.IF,
+  IFERROR: import_iferror.IFERROR,
+  INDEX: import_index_lookup.INDEX,
+  INDIRECT: import_indirect.INDIRECT,
+  LEFT: import_left.LEFT,
+  LEN: import_len.LEN,
+  MATCH: import_match.MATCH,
+  MAX: import_max.MAX,
+  MAXIF: import_maxif.MAXIF,
+  MAXIFS: import_maxifs.MAXIFS,
+  MID: import_mid.MID,
+  MIN: import_min.MIN,
+  MINIF: import_minif.MINIF,
+  MINIFS: import_minifs.MINIFS,
+  OFFSET: import_offset.OFFSET,
+  OR: import_or.OR,
+  RIGHT: import_right.RIGHT,
+  ROW: import_row.ROW,
+  SEQUENCE: import_sequence.SEQUENCE,
+  SUM: import_sum.SUM,
+  SUMIF: import_sumif.SUMIF,
+  SUMIFS: import_sumifs.SUMIFS,
+  TEXTJOIN: import_textjoin.TEXTJOIN,
+  XLOOKUP: import_xlookup.XLOOKUP
+});
+
+//# debugId=DFDC71312AB793C064756E2164756E21

package/dist/cjs/functions/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../src/functions/index.ts"],
+  "sourcesContent": [
+    "import type { FunctionDefinition } from \"src/core/types\";\n// import { arrayFunctions } from \"./array/array-functions.cjs\";\n// import { infoFunctions } from \"./info/info-functions.cjs\";\n// import { logicalComparisonFunctions } from \"./logical/comparisons.cjs\";\n// import { logicalConditionFunctions } from \"./logical/conditions.cjs\";\n// import { lookupFunctions } from \"./lookup/lookup-functions.cjs\";\n// import { advancedMathFunctions } from \"./math/advanced.cjs\";\n// import { basicMathFunctions } from \"./math/basic.cjs\";\n// import { textFunctions } from \"./text/string-functions.cjs\";\nimport { SEQUENCE } from \"./array/sequence/sequence.cjs\";\nimport { INDEX } from \"./lookup/index-lookup/index-lookup.cjs\"; // Fixed import path\nimport { MATCH } from \"./lookup/match/match.cjs\";\nimport { COUNT } from \"./lookup/count/count.cjs\";\nimport { COUNTIF } from \"./lookup/count/countif.cjs\";\nimport { AVERAGE } from \"./math/average/average.cjs\";\nimport { AVERAGEIF } from \"./math/average/averageif.cjs\";\nimport { AVERAGEIFS } from \"./math/average/averageifs.cjs\";\nimport { MAX } from \"./math/max/max.cjs\";\nimport { MAXIFS } from \"./math/max/maxifs.cjs\";\nimport { MIN } from \"./math/min/min.cjs\";\nimport { MINIFS } from \"./math/min/minifs.cjs\";\nimport { SUM } from \"./math/sum/sum.cjs\";\nimport { SUMIF } from \"./math/sum/sumif.cjs\";\nimport { SUMIFS } from \"./math/sum/sumifs.cjs\";\nimport { COUNTIFS } from \"./lookup/count/countifs.cjs\";\nimport { MAXIF } from \"./math/max/maxif.cjs\";\nimport { MINIF } from \"./math/min/minif.cjs\";\nimport { CEILING } from \"./math/ceiling/ceiling.cjs\";\nimport { EXACT } from \"./text/exact/exact.cjs\";\nimport { FIND } from \"./text/find/find.cjs\";\nimport { LEFT } from \"./text/left/left.cjs\";\nimport { MID } from \"./text/mid/mid.cjs\";\nimport { LEN } from \"./text/len/len.cjs\";\nimport { RIGHT } from \"./text/right/right.cjs\";\nimport { CONCATENATE } from \"./text/concatenate/concatenate.cjs\";\nimport { AND } from \"./logical/and/and.cjs\";\nimport { IF } from \"./logical/if/if.cjs\";\nimport { IFERROR } from \"./logical/iferror/iferror.cjs\";\nimport { XLOOKUP } from \"./lookup/xlookup/xlookup.cjs\";\nimport { OR } from \"./logical/or/or.cjs\";\nimport { TEXTJOIN } from \"./text/textjoin/textjoin.cjs\";\nimport { ROW } from \"./information/row/row.cjs\";\nimport { COLUMN } from \"./information/column/column.cjs\";\nimport { CELL } from \"./information/cell/cell.cjs\";\nimport { ADDRESS } from \"./reference/address/address.cjs\";\nimport { INDIRECT } from \"./reference/indirect/indirect.cjs\";\nimport { OFFSET } from \"./reference/offset/offset.cjs\";\n\nconst buildFunctionIndex = (functions: Record<string, FunctionDefinition>) => {\n  return Object.fromEntries(\n    Object.entries(functions).flatMap(([name, func]) => {\n      const base: [string, FunctionDefinition][] = [[name, func]];\n      if (func.aliases) {\n        func.aliases.forEach((alias) => {\n          base.push([alias, func]);\n        });\n      }\n      return base;\n    })\n  );\n};\n\nexport const functions: Record<string, FunctionDefinition> = buildFunctionIndex(\n  {\n    ADDRESS,\n    AND,\n    AVERAGE,\n    AVERAGEIF,\n    AVERAGEIFS,\n    CEILING,\n    CELL,\n    COLUMN,\n    CONCATENATE,\n    COUNT,\n    COUNTIF,\n    COUNTIFS,\n    EXACT,\n    FIND,\n    IF,\n    IFERROR,\n    INDEX,\n    INDIRECT,\n    LEFT,\n    LEN,\n    MATCH,\n    MAX,\n    MAXIF,\n    MAXIFS,\n    MID,\n    MIN,\n    MINIF,\n    MINIFS,\n    OFFSET,\n    OR,\n    RIGHT,\n    ROW,\n    SEQUENCE,\n    SUM,\n    SUMIF,\n    SUMIFS,\n    TEXTJOIN,\n    XLOOKUP,\n  }\n);\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASyB,IAAzB;AACsB,IAAtB;AACsB,IAAtB;AACsB,IAAtB;AACwB,IAAxB;AACwB,IAAxB;AAC0B,IAA1B;AAC2B,IAA3B;AACoB,IAApB;AACuB,IAAvB;AACoB,IAApB;AACuB,IAAvB;AACoB,IAApB;AACsB,IAAtB;AACuB,IAAvB;AACyB,IAAzB;AACsB,IAAtB;AACsB,IAAtB;AACwB,IAAxB;AACsB,IAAtB;AACqB,IAArB;AACqB,IAArB;AACoB,IAApB;AACoB,IAApB;AACsB,IAAtB;AAC4B,IAA5B;AACoB,IAApB;AACmB,IAAnB;AACwB,IAAxB;AACwB,IAAxB;AACmB,IAAnB;AACyB,IAAzB;AACoB,IAApB;AACuB,IAAvB;AACqB,IAArB;AACwB,IAAxB;AACyB,IAAzB;AACuB,IAAvB;AAEA,IAAM,qBAAqB,CAAC,cAAkD;AAAA,EAC5E,OAAO,OAAO,YACZ,OAAO,QAAQ,SAAS,EAAE,QAAQ,EAAE,MAAM,UAAU;AAAA,IAClD,MAAM,OAAuC,CAAC,CAAC,MAAM,IAAI,CAAC;AAAA,IAC1D,IAAI,KAAK,SAAS;AAAA,MAChB,KAAK,QAAQ,QAAQ,CAAC,UAAU;AAAA,QAC9B,KAAK,KAAK,CAAC,OAAO,IAAI,CAAC;AAAA,OACxB;AAAA,IACH;AAAA,IACA,OAAO;AAAA,GACR,CACH;AAAA;AAGK,IAAM,YAAgD,mBAC3D;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CACF;",
+  "debugId": "DFDC71312AB793C064756E2164756E21",
+  "names": []
+}

package/dist/cjs/functions/information/cell/cell.cjs

@@ -0,0 +1,196 @@
+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/information/cell/cell.ts
+var exports_cell = {};
+__export(exports_cell, {
+  CELL: () => CELL
+});
+module.exports = __toCommonJS(exports_cell);
+var import_types = require("src/core/types");
+var import_utils = require("src/core/utils");
+var CELL = {
+  name: "CELL",
+  evaluate: function(node, context) {
+    if (node.args.length === 0 || node.args.length > 2) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "CELL function requires 1 or 2 arguments",
+        errAddress: context.dependencyNode
+      };
+    }
+    const infoTypeResult = this.evaluateNode(node.args[0], context);
+    if (infoTypeResult.type === "error" || infoTypeResult.type === "awaiting-evaluation") {
+      return infoTypeResult;
+    }
+    if (infoTypeResult.type !== "value" || infoTypeResult.result.type !== "string") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: "CELL function info_type must be a string",
+        errAddress: context.dependencyNode
+      };
+    }
+    const infoType = infoTypeResult.result.value.toLowerCase();
+    let referenceCell = context.cellAddress;
+    let referenceValue = null;
+    if (node.args.length === 2) {
+      const refArg = node.args[1];
+      const refResult = this.evaluateNode(refArg, context);
+      if (refResult.type === "error" || refResult.type === "awaiting-evaluation") {
+        return refResult;
+      }
+      const cellOrRange = refResult.type === "spilled-values" ? refResult.sourceCell ?? refResult.sourceRange : refResult.sourceCell;
+      if (!cellOrRange) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: "CELL function requires a cell or range reference",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (import_utils.isCellAddress(cellOrRange)) {
+        referenceCell = cellOrRange;
+      } else if (import_utils.isRangeAddress(cellOrRange)) {
+        referenceCell = {
+          sheetName: cellOrRange.sheetName,
+          workbookName: cellOrRange.workbookName,
+          colIndex: cellOrRange.range.start.col,
+          rowIndex: cellOrRange.range.start.row
+        };
+      } else {
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: "CELL function requires a cell or range reference",
+          errAddress: context.dependencyNode
+        };
+      }
+      if (infoType === "contents" || infoType === "type") {
+        if (refResult.type === "value") {
+          referenceValue = refResult.result;
+        } else if (refResult.type === "spilled-values") {
+          const cellResult = refResult.evaluate({ x: 0, y: 0 }, context);
+          if (cellResult && cellResult.type === "value") {
+            referenceValue = cellResult.result;
+          }
+        }
+      }
+    }
+    switch (infoType) {
+      case "row":
+        return {
+          type: "value",
+          result: { type: "number", value: referenceCell.rowIndex + 1 }
+        };
+      case "col":
+        return {
+          type: "value",
+          result: { type: "number", value: referenceCell.colIndex + 1 }
+        };
+      case "address": {
+        const col = columnNumberToLetter(referenceCell.colIndex + 1);
+        const row = referenceCell.rowIndex + 1;
+        let address = `$${col}$${row}`;
+        if (referenceCell.sheetName !== context.cellAddress.sheetName) {
+          address = `${referenceCell.sheetName}!${address}`;
+        }
+        return {
+          type: "value",
+          result: { type: "string", value: address }
+        };
+      }
+      case "contents":
+        if (referenceValue !== null) {
+          if (referenceValue.type === "string" && referenceValue.value === "") {
+            return {
+              type: "value",
+              result: { type: "number", value: 0 }
+            };
+          }
+          return {
+            type: "value",
+            result: referenceValue
+          };
+        }
+        return {
+          type: "value",
+          result: { type: "number", value: 0 }
+        };
+      case "type": {
+        if (referenceValue === null) {
+          return {
+            type: "value",
+            result: { type: "string", value: "b" }
+          };
+        }
+        if (referenceValue.type === "string" && referenceValue.value === "") {
+          return {
+            type: "value",
+            result: { type: "string", value: "b" }
+          };
+        }
+        if (referenceValue.type === "string") {
+          return {
+            type: "value",
+            result: { type: "string", value: "l" }
+          };
+        }
+        if (referenceValue.type === "number") {
+          return {
+            type: "value",
+            result: { type: "string", value: "v" }
+          };
+        }
+        return {
+          type: "value",
+          result: { type: "string", value: "v" }
+        };
+      }
+      default:
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: `CELL function unknown info_type: "${infoType}"`,
+          errAddress: context.dependencyNode
+        };
+    }
+  }
+};
+function columnNumberToLetter(num) {
+  let letter = "";
+  while (num > 0) {
+    const remainder = (num - 1) % 26;
+    letter = String.fromCharCode(65 + remainder) + letter;
+    num = Math.floor((num - 1) / 26);
+  }
+  return letter;
+}
+
+//# debugId=C3C09EC006226F5764756E2164756E21

package/dist/cjs/functions/information/cell/cell.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/functions/information/cell/cell.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} from \"src/core/types\";\nimport type { EvaluationContext } from \"src/evaluator/evaluation-context\";\nimport type { ReferenceNode } from \"src/parser/ast\";\nimport { isCellAddress, isRangeAddress } from \"src/core/utils\";\n\n/**\n * CELL function - Returns information about the formatting, location, or contents of a cell\n * \n * Usage: CELL(info_type, [reference])\n * \n * info_type: Text value that specifies what type of cell information you want\n * reference: The cell or range to get information about (defaults to current cell if omitted)\n * \n * Supported info_types:\n * - \"address\" - Returns the reference of the first cell in reference, as text\n * - \"col\" - Returns the column number of the cell\n * - \"row\" - Returns the row number of the cell\n * - \"contents\" - Returns the value of the upper-left cell\n * - \"type\" - Returns \"b\" for blank, \"l\" for label (text), \"v\" for value (number)\n * - \"width\" - Returns the column width\n * - \"filename\" - Returns the filename (including full path) of the file\n * \n * Examples:\n * - CELL(\"address\", A1) returns \"$A$1\"\n * - CELL(\"row\", B5) returns 5\n * - CELL(\"col\", C3) returns 3\n */\nexport const CELL: FunctionDefinition = {\n  name: \"CELL\",\n  evaluate: function (node, context): FunctionEvaluationResult {\n    if (node.args.length === 0 || node.args.length > 2) {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"CELL function requires 1 or 2 arguments\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    // Evaluate the info_type argument\n    const infoTypeResult = this.evaluateNode(node.args[0]!, context);\n    if (\n      infoTypeResult.type === \"error\" ||\n      infoTypeResult.type === \"awaiting-evaluation\"\n    ) {\n      return infoTypeResult;\n    }\n\n    if (infoTypeResult.type !== \"value\" || infoTypeResult.result.type !== \"string\") {\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: \"CELL function info_type must be a string\",\n        errAddress: context.dependencyNode,\n      };\n    }\n\n    const infoType = infoTypeResult.result.value.toLowerCase();\n\n    // Determine the reference cell\n    let referenceCell: CellAddress = context.cellAddress;\n    let referenceValue: CellValue | null = null;\n    \n    if (node.args.length === 2) {\n      const refArg = node.args[1]!;\n      \n      // Evaluate the reference argument\n      const refResult = this.evaluateNode(refArg, context);\n      if (\n        refResult.type === \"error\" ||\n        refResult.type === \"awaiting-evaluation\"\n      ) {\n        return refResult;\n      }\n      \n      // Check if we have a cell or range reference\n      const cellOrRange =\n        refResult.type === \"spilled-values\"\n          ? (refResult.sourceCell ?? refResult.sourceRange)\n          : refResult.sourceCell;\n      \n      if (!cellOrRange) {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"CELL function requires a cell or range reference\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      \n      // Extract the cell address\n      if (isCellAddress(cellOrRange)) {\n        // It's a CellAddress\n        referenceCell = cellOrRange;\n      } else if (isRangeAddress(cellOrRange)) {\n        // It's a RangeAddress - use the upper-left cell\n        referenceCell = {\n          sheetName: cellOrRange.sheetName,\n          workbookName: cellOrRange.workbookName,\n          colIndex: cellOrRange.range.start.col,\n          rowIndex: cellOrRange.range.start.row,\n        };\n      } else {\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: \"CELL function requires a cell or range reference\",\n          errAddress: context.dependencyNode,\n        };\n      }\n      \n      // For \"contents\" and \"type\", we need to get the cell value\n      if (infoType === \"contents\" || infoType === \"type\") {\n        if (refResult.type === \"value\") {\n          referenceValue = refResult.result;\n        } else if (refResult.type === \"spilled-values\") {\n          const cellResult = refResult.evaluate({ x: 0, y: 0 }, context);\n          if (cellResult && cellResult.type === \"value\") {\n            referenceValue = cellResult.result;\n          }\n        }\n      }\n    }\n\n    // Handle different info types (return 1-based row/column numbers)\n    switch (infoType) {\n      case \"row\":\n        return {\n          type: \"value\",\n          result: { type: \"number\", value: referenceCell.rowIndex + 1 },\n        };\n      \n      case \"col\":\n        return {\n          type: \"value\",\n          result: { type: \"number\", value: referenceCell.colIndex + 1 },\n        };\n      \n      case \"address\": {\n        // Return the cell address as text in A1 format\n        const col = columnNumberToLetter(referenceCell.colIndex + 1);\n        const row = referenceCell.rowIndex + 1;\n        let address = `$${col}$${row}`;\n        \n        // Include sheet name if it's different from current sheet\n        if (referenceCell.sheetName !== context.cellAddress.sheetName) {\n          address = `${referenceCell.sheetName}!${address}`;\n        }\n        \n        return {\n          type: \"value\",\n          result: { type: \"string\", value: address },\n        };\n      }\n      \n      case \"contents\":\n        // Return the value of the cell\n        if (referenceValue !== null) {\n          // Empty string counts as empty cell in Excel\n          if (referenceValue.type === \"string\" && referenceValue.value === \"\") {\n            return {\n              type: \"value\",\n              result: { type: \"number\", value: 0 },\n            };\n          }\n          return {\n            type: \"value\",\n            result: referenceValue,\n          };\n        }\n        // If we couldn't get the value, return 0 (empty cell)\n        return {\n          type: \"value\",\n          result: { type: \"number\", value: 0 },\n        };\n      \n      case \"type\": {\n        // Return \"b\" for blank, \"l\" for label (text), \"v\" for value (number)\n        if (referenceValue === null) {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"b\" },\n          };\n        }\n        // Empty string counts as blank cell in Excel\n        if (referenceValue.type === \"string\" && referenceValue.value === \"\") {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"b\" },\n          };\n        }\n        if (referenceValue.type === \"string\") {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"l\" },\n          };\n        }\n        if (referenceValue.type === \"number\") {\n          return {\n            type: \"value\",\n            result: { type: \"string\", value: \"v\" },\n          };\n        }\n        // Boolean or other types default to \"v\"\n        return {\n          type: \"value\",\n          result: { type: \"string\", value: \"v\" },\n        };\n      }\n      \n      default:\n        return {\n          type: \"error\",\n          err: FormulaError.VALUE,\n          message: `CELL function unknown info_type: \"${infoType}\"`,\n          errAddress: context.dependencyNode,\n        };\n    }\n  },\n};\n\n/**\n * Helper function to convert column number (1-based) to letter(s)\n */\nfunction columnNumberToLetter(num: number): string {\n  let letter = \"\";\n  while (num > 0) {\n    const remainder = (num - 1) % 26;\n    letter = String.fromCharCode(65 + remainder) + letter;\n    num = Math.floor((num - 1) / 26);\n  }\n  return letter;\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAWO,IAXP;AAc8C,IAA9C;AAwBO,IAAM,OAA2B;AAAA,EACtC,MAAM;AAAA,EACN,UAAU,QAAS,CAAC,MAAM,SAAmC;AAAA,IAC3D,IAAI,KAAK,KAAK,WAAW,KAAK,KAAK,KAAK,SAAS,GAAG;AAAA,MAClD,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAGA,MAAM,iBAAiB,KAAK,aAAa,KAAK,KAAK,IAAK,OAAO;AAAA,IAC/D,IACE,eAAe,SAAS,WACxB,eAAe,SAAS,uBACxB;AAAA,MACA,OAAO;AAAA,IACT;AAAA,IAEA,IAAI,eAAe,SAAS,WAAW,eAAe,OAAO,SAAS,UAAU;AAAA,MAC9E,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,0BAAa;AAAA,QAClB,SAAS;AAAA,QACT,YAAY,QAAQ;AAAA,MACtB;AAAA,IACF;AAAA,IAEA,MAAM,WAAW,eAAe,OAAO,MAAM,YAAY;AAAA,IAGzD,IAAI,gBAA6B,QAAQ;AAAA,IACzC,IAAI,iBAAmC;AAAA,IAEvC,IAAI,KAAK,KAAK,WAAW,GAAG;AAAA,MAC1B,MAAM,SAAS,KAAK,KAAK;AAAA,MAGzB,MAAM,YAAY,KAAK,aAAa,QAAQ,OAAO;AAAA,MACnD,IACE,UAAU,SAAS,WACnB,UAAU,SAAS,uBACnB;AAAA,QACA,OAAO;AAAA,MACT;AAAA,MAGA,MAAM,cACJ,UAAU,SAAS,mBACd,UAAU,cAAc,UAAU,cACnC,UAAU;AAAA,MAEhB,IAAI,CAAC,aAAa;AAAA,QAChB,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA,MACF;AAAA,MAGA,IAAI,2BAAc,WAAW,GAAG;AAAA,QAE9B,gBAAgB;AAAA,MAClB,EAAO,SAAI,4BAAe,WAAW,GAAG;AAAA,QAEtC,gBAAgB;AAAA,UACd,WAAW,YAAY;AAAA,UACvB,cAAc,YAAY;AAAA,UAC1B,UAAU,YAAY,MAAM,MAAM;AAAA,UAClC,UAAU,YAAY,MAAM,MAAM;AAAA,QACpC;AAAA,MACF,EAAO;AAAA,QACL,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS;AAAA,UACT,YAAY,QAAQ;AAAA,QACtB;AAAA;AAAA,MAIF,IAAI,aAAa,cAAc,aAAa,QAAQ;AAAA,QAClD,IAAI,UAAU,SAAS,SAAS;AAAA,UAC9B,iBAAiB,UAAU;AAAA,QAC7B,EAAO,SAAI,UAAU,SAAS,kBAAkB;AAAA,UAC9C,MAAM,aAAa,UAAU,SAAS,EAAE,GAAG,GAAG,GAAG,EAAE,GAAG,OAAO;AAAA,UAC7D,IAAI,cAAc,WAAW,SAAS,SAAS;AAAA,YAC7C,iBAAiB,WAAW;AAAA,UAC9B;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IAGA,QAAQ;AAAA,WACD;AAAA,QACH,OAAO;AAAA,UACL,MAAM;AAAA,UACN,QAAQ,EAAE,MAAM,UAAU,OAAO,cAAc,WAAW,EAAE;AAAA,QAC9D;AAAA,WAEG;AAAA,QACH,OAAO;AAAA,UACL,MAAM;AAAA,UACN,QAAQ,EAAE,MAAM,UAAU,OAAO,cAAc,WAAW,EAAE;AAAA,QAC9D;AAAA,WAEG,WAAW;AAAA,QAEd,MAAM,MAAM,qBAAqB,cAAc,WAAW,CAAC;AAAA,QAC3D,MAAM,MAAM,cAAc,WAAW;AAAA,QACrC,IAAI,UAAU,IAAI,OAAO;AAAA,QAGzB,IAAI,cAAc,cAAc,QAAQ,YAAY,WAAW;AAAA,UAC7D,UAAU,GAAG,cAAc,aAAa;AAAA,QAC1C;AAAA,QAEA,OAAO;AAAA,UACL,MAAM;AAAA,UACN,QAAQ,EAAE,MAAM,UAAU,OAAO,QAAQ;AAAA,QAC3C;AAAA,MACF;AAAA,WAEK;AAAA,QAEH,IAAI,mBAAmB,MAAM;AAAA,UAE3B,IAAI,eAAe,SAAS,YAAY,eAAe,UAAU,IAAI;AAAA,YACnE,OAAO;AAAA,cACL,MAAM;AAAA,cACN,QAAQ,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,YACrC;AAAA,UACF;AAAA,UACA,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ;AAAA,UACV;AAAA,QACF;AAAA,QAEA,OAAO;AAAA,UACL,MAAM;AAAA,UACN,QAAQ,EAAE,MAAM,UAAU,OAAO,EAAE;AAAA,QACrC;AAAA,WAEG,QAAQ;AAAA,QAEX,IAAI,mBAAmB,MAAM;AAAA,UAC3B,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,EAAE,MAAM,UAAU,OAAO,IAAI;AAAA,UACvC;AAAA,QACF;AAAA,QAEA,IAAI,eAAe,SAAS,YAAY,eAAe,UAAU,IAAI;AAAA,UACnE,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,EAAE,MAAM,UAAU,OAAO,IAAI;AAAA,UACvC;AAAA,QACF;AAAA,QACA,IAAI,eAAe,SAAS,UAAU;AAAA,UACpC,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,EAAE,MAAM,UAAU,OAAO,IAAI;AAAA,UACvC;AAAA,QACF;AAAA,QACA,IAAI,eAAe,SAAS,UAAU;AAAA,UACpC,OAAO;AAAA,YACL,MAAM;AAAA,YACN,QAAQ,EAAE,MAAM,UAAU,OAAO,IAAI;AAAA,UACvC;AAAA,QACF;AAAA,QAEA,OAAO;AAAA,UACL,MAAM;AAAA,UACN,QAAQ,EAAE,MAAM,UAAU,OAAO,IAAI;AAAA,QACvC;AAAA,MACF;AAAA;AAAA,QAGE,OAAO;AAAA,UACL,MAAM;AAAA,UACN,KAAK,0BAAa;AAAA,UAClB,SAAS,qCAAqC;AAAA,UAC9C,YAAY,QAAQ;AAAA,QACtB;AAAA;AAAA;AAGR;AAKA,SAAS,oBAAoB,CAAC,KAAqB;AAAA,EACjD,IAAI,SAAS;AAAA,EACb,OAAO,MAAM,GAAG;AAAA,IACd,MAAM,aAAa,MAAM,KAAK;AAAA,IAC9B,SAAS,OAAO,aAAa,KAAK,SAAS,IAAI;AAAA,IAC/C,MAAM,KAAK,OAAO,MAAM,KAAK,EAAE;AAAA,EACjC;AAAA,EACA,OAAO;AAAA;",
+  "debugId": "C3C09EC006226F5764756E2164756E21",
+  "names": []
+}