@ricsam/formula-engine 0.0.1

package/dist/mjs/evaluator/comparison/not-equals.mjs

@@ -0,0 +1,23 @@
+// src/evaluator/comparison/not-equals.ts
+import { FormulaError } from "src/core/types";
+import { equals } from "./equals.mjs";
+var notEquals = (left, right, context) => {
+  const equalsResult = equals(left, right, context);
+  if (equalsResult.type === "error" || equalsResult.type === "awaiting-evaluation") {
+    return equalsResult;
+  }
+  if (equalsResult.type === "boolean") {
+    return { type: "boolean", value: !equalsResult.value };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: "Invalid result from equals comparison",
+    errAddress: context.dependencyNode
+  };
+};
+export {
+  notEquals
+};
+
+//# debugId=9A012BC6637AA0F864756E2164756E21

package/dist/mjs/evaluator/comparison/not-equals.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/comparison/not-equals.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\nimport { equals } from \"./equals.mjs\";\n\n/**\n * Not equals operator (<>) - Returns TRUE if values are not equal\n * Uses the equals operator and negates the result\n */\nexport const notEquals: ArethmeticEvaluator = (left, right, context) => {\n  const equalsResult = equals(left, right, context);\n  \n  if (equalsResult.type === \"error\" || equalsResult.type === \"awaiting-evaluation\") {\n    return equalsResult;\n  }\n  \n  if (equalsResult.type === \"boolean\") {\n    return { type: \"boolean\", value: !equalsResult.value };\n  }\n  \n  return {\n    type: \"error\",\n    err: FormulaError.VALUE,\n    message: \"Invalid result from equals comparison\",\n    errAddress: context.dependencyNode,\n  };\n};\n"
+  ],
+  "mappings": ";AACA;AACA;AAMO,IAAM,YAAiC,CAAC,MAAM,OAAO,YAAY;AAAA,EACtE,MAAM,eAAe,OAAO,MAAM,OAAO,OAAO;AAAA,EAEhD,IAAI,aAAa,SAAS,WAAW,aAAa,SAAS,uBAAuB;AAAA,IAChF,OAAO;AAAA,EACT;AAAA,EAEA,IAAI,aAAa,SAAS,WAAW;AAAA,IACnC,OAAO,EAAE,MAAM,WAAW,OAAO,CAAC,aAAa,MAAM;AAAA,EACvD;AAAA,EAEA,OAAO;AAAA,IACL,MAAM;AAAA,IACN,KAAK,aAAa;AAAA,IAClB,SAAS;AAAA,IACT,YAAY,QAAQ;AAAA,EACtB;AAAA;",
+  "debugId": "9A012BC6637AA0F864756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/concatenation/concatenate.mjs

@@ -0,0 +1,42 @@
+// src/evaluator/concatenation/concatenate.ts
+import { FormulaError } from "src/core/types";
+var concatenate = (left, right, context) => {
+  let leftStr;
+  let rightStr;
+  switch (left.type) {
+    case "string":
+      leftStr = left.value;
+      break;
+    case "number":
+      leftStr = left.value.toString();
+      break;
+    default:
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: `Cannot concatenate ${left.type} - only numbers and strings are supported`,
+        errAddress: context.dependencyNode
+      };
+  }
+  switch (right.type) {
+    case "string":
+      rightStr = right.value;
+      break;
+    case "number":
+      rightStr = right.value.toString();
+      break;
+    default:
+      return {
+        type: "error",
+        err: FormulaError.VALUE,
+        message: `Cannot concatenate ${right.type} - only numbers and strings are supported`,
+        errAddress: context.dependencyNode
+      };
+  }
+  return { type: "string", value: leftStr + rightStr };
+};
+export {
+  concatenate
+};
+
+//# debugId=C41F339E88A3533764756E2164756E21

package/dist/mjs/evaluator/concatenation/concatenate.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/concatenation/concatenate.ts"],
+  "sourcesContent": [
+    "import type { ArethmeticEvaluator } from \"src/core/types\";\nimport { FormulaError } from \"src/core/types\";\n\n/**\n * Concatenation operator (&) - Concatenates two values as strings\n * Works with numbers and strings only\n */\nexport const concatenate: ArethmeticEvaluator = (left, right, context) => {\n  // Convert each value to string based on type\n  let leftStr: string;\n  let rightStr: string;\n\n  // Handle left operand\n  switch (left.type) {\n    case \"string\":\n      leftStr = left.value;\n      break;\n    case \"number\":\n      leftStr = left.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${left.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  // Handle right operand\n  switch (right.type) {\n    case \"string\":\n      rightStr = right.value;\n      break;\n    case \"number\":\n      rightStr = right.value.toString();\n      break;\n    default:\n      return {\n        type: \"error\",\n        err: FormulaError.VALUE,\n        message: `Cannot concatenate ${right.type} - only numbers and strings are supported`,\n        errAddress: context.dependencyNode,\n      };\n  }\n\n  return { type: \"string\", value: leftStr + rightStr };\n};\n"
+  ],
+  "mappings": ";AACA;AAMO,IAAM,cAAmC,CAAC,MAAM,OAAO,YAAY;AAAA,EAExE,IAAI;AAAA,EACJ,IAAI;AAAA,EAGJ,QAAQ,KAAK;AAAA,SACN;AAAA,MACH,UAAU,KAAK;AAAA,MACf;AAAA,SACG;AAAA,MACH,UAAU,KAAK,MAAM,SAAS;AAAA,MAC9B;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS,sBAAsB,KAAK;AAAA,QACpC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAIJ,QAAQ,MAAM;AAAA,SACP;AAAA,MACH,WAAW,MAAM;AAAA,MACjB;AAAA,SACG;AAAA,MACH,WAAW,MAAM,MAAM,SAAS;AAAA,MAChC;AAAA;AAAA,MAEA,OAAO;AAAA,QACL,MAAM;AAAA,QACN,KAAK,aAAa;AAAA,QAClB,SAAS,sBAAsB,MAAM;AAAA,QACrC,YAAY,QAAQ;AAAA,MACtB;AAAA;AAAA,EAGJ,OAAO,EAAE,MAAM,UAAU,OAAO,UAAU,SAAS;AAAA;",
+  "debugId": "C41F339E88A3533764756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/dependency-nodes/ast-evaluation-node.mjs

@@ -0,0 +1,28 @@
+// src/evaluator/dependency-nodes/ast-evaluation-node.ts
+import { astToString } from "src/parser/formatter";
+import { BaseEvalNode } from "./base-eval-node.mjs";
+
+class AstEvaluationNode extends BaseEvalNode {
+  ast;
+  _contextDependency;
+  constructor(ast, contextDependency) {
+    const key = `ast:${astToString(ast)}`;
+    super(key);
+    this.ast = ast;
+    this._contextDependency = contextDependency;
+  }
+  toString() {
+    return this.key;
+  }
+  getContextDependency() {
+    return this._contextDependency;
+  }
+  setContextDependency(contextDependency) {
+    this._contextDependency = contextDependency;
+  }
+}
+export {
+  AstEvaluationNode
+};
+
+//# debugId=72758B35AE24D18964756E2164756E21

package/dist/mjs/evaluator/dependency-nodes/ast-evaluation-node.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/dependency-nodes/ast-evaluation-node.ts"],
+  "sourcesContent": [
+    "import type { FunctionEvaluationResult } from \"src/core/types\";\nimport type { ASTNode } from \"src/parser/ast\";\nimport { astToString } from \"src/parser/formatter\";\nimport type { ContextDependency } from \"../evaluation-context.mjs\";\nimport { BaseEvalNode } from \"./base-eval-node.mjs\";\n\nexport class AstEvaluationNode extends BaseEvalNode<FunctionEvaluationResult> {\n  private _contextDependency: ContextDependency;\n  constructor(\n    public ast: ASTNode,\n    contextDependency: ContextDependency\n  ) {\n    const key = `ast:${astToString(ast)}`;\n    super(key);\n    this._contextDependency = contextDependency;\n  }\n\n  public override toString(): string {\n    return this.key;\n  }\n\n  getContextDependency() {\n    return this._contextDependency;\n  }\n\n  setContextDependency(contextDependency: ContextDependency) {\n    this._contextDependency = contextDependency;\n  }\n}\n"
+  ],
+  "mappings": ";AAEA;AAEA;AAAA;AAEO,MAAM,0BAA0B,aAAuC;AAAA,EAGnE;AAAA,EAFD;AAAA,EACR,WAAW,CACF,KACP,mBACA;AAAA,IACA,MAAM,MAAM,OAAO,YAAY,GAAG;AAAA,IAClC,MAAM,GAAG;AAAA,IAJF;AAAA,IAKP,KAAK,qBAAqB;AAAA;AAAA,EAGZ,QAAQ,GAAW;AAAA,IACjC,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,GAAG;AAAA,IACrB,OAAO,KAAK;AAAA;AAAA,EAGd,oBAAoB,CAAC,mBAAsC;AAAA,IACzD,KAAK,qBAAqB;AAAA;AAE9B;",
+  "debugId": "72758B35AE24D18964756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/dependency-nodes/base-eval-node.mjs

@@ -0,0 +1,81 @@
+// src/evaluator/dependency-nodes/base-eval-node.ts
+class BaseEvalNode {
+  key;
+  _dependencies = new Set;
+  _lastDependencies = new Set;
+  _evaluationResult;
+  _resolved = false;
+  constructor(key) {
+    this.key = key;
+    this._evaluationResult = {
+      type: "awaiting-evaluation",
+      waitingFor: this,
+      errAddress: this
+    };
+  }
+  addDependency(dep) {
+    if (this._dependencies.has(dep)) {
+      return;
+    }
+    this._dependencies.add(dep);
+  }
+  get directDepsUpdated() {
+    return !this._lastDependencies.isSubsetOf(this._dependencies) || this._dependencies.size !== this._lastDependencies.size;
+  }
+  resolve() {
+    if (this.canResolve()) {
+      this._resolved = true;
+    }
+  }
+  canResolve() {
+    return this.evaluationResult.type !== "awaiting-evaluation" && !this.directDepsUpdated;
+  }
+  get resolved() {
+    return this._resolved;
+  }
+  get evaluationResult() {
+    return this._evaluationResult;
+  }
+  setEvaluationResult(result) {
+    this._evaluationResult = result;
+  }
+  resetDirectDepsUpdated() {
+    if (this._resolved) {
+      return;
+    }
+    this._lastDependencies = new Set(this._dependencies);
+    this._dependencies = new Set;
+  }
+  getDependencies() {
+    return this._dependencies;
+  }
+  getAllDependencies() {
+    return this.getDependencies();
+  }
+  getFrontierDependencies() {
+    return new Set;
+  }
+  toJSON(visitor = new Set) {
+    const hasVisited = visitor?.has(this.key);
+    if (hasVisited) {
+      return {
+        key: this.key,
+        resolved: this.resolved,
+        cycle: true,
+        dependencies: []
+      };
+    }
+    visitor?.add(this.key);
+    return {
+      key: this.key,
+      resolved: this.resolved,
+      evaluationResult: this.evaluationResult,
+      dependencies: Array.from(this.getDependencies()).map((node) => node.toJSON(visitor))
+    };
+  }
+}
+export {
+  BaseEvalNode
+};
+
+//# debugId=7D7A4F1893384B5164756E2164756E21

package/dist/mjs/evaluator/dependency-nodes/base-eval-node.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/dependency-nodes/base-eval-node.ts"],
+  "sourcesContent": [
+    "import { type DependencyNode } from \"src/core/managers/dependency-node\";\nimport type {\n  DoesNotSpillResult,\n  FunctionEvaluationResult,\n  SpilledValuesEvaluationResult,\n} from \"src/core/types\";\nimport type { SpillMetaNode } from \"./spill-meta-node.mjs\";\n\nexport class BaseEvalNode<T> {\n  public key: string;\n  private _dependencies: Set<DependencyNode> = new Set();\n  private _lastDependencies: Set<DependencyNode> = new Set();\n  public _evaluationResult: T;\n  private _resolved: boolean = false;\n\n  constructor(key: string) {\n    this.key = key;\n    this._evaluationResult = {\n      type: \"awaiting-evaluation\",\n      waitingFor: this,\n      errAddress: this,\n    } as any;\n  }\n\n  public addDependency(dep: DependencyNode) {\n    if (this._dependencies.has(dep)) {\n      return;\n    }\n    this._dependencies.add(dep);\n  }\n\n  public get directDepsUpdated() {\n    return (\n      !this._lastDependencies.isSubsetOf(this._dependencies) ||\n      this._dependencies.size !== this._lastDependencies.size\n    );\n  }\n\n  public resolve() {\n    if (this.canResolve()) {\n      this._resolved = true;\n    }\n  }\n\n  public canResolve() {\n    return (\n      (this.evaluationResult as any).type !== \"awaiting-evaluation\" &&\n      !this.directDepsUpdated\n    );\n  }\n\n  public get resolved() {\n    return this._resolved;\n  }\n\n  public get evaluationResult(): T {\n    return this._evaluationResult;\n  }\n\n  public setEvaluationResult(result: T) {\n    this._evaluationResult = result;\n  }\n\n  public resetDirectDepsUpdated() {\n    if (this._resolved) {\n      return;\n    }\n    this._lastDependencies = new Set(this._dependencies);\n    this._dependencies = new Set();\n  }\n\n  /**\n   * Get the direct dependencies of the node, either RangeEvaluationNode or DependencyNode\n   */\n  public getDependencies() {\n    return this._dependencies;\n  }\n\n  /**\n   * Just to mirror the method in RangeEvaluationNode\n   */\n  public getAllDependencies() {\n    return this.getDependencies();\n  }\n\n  /**\n   * Just to mirror the method in RangeEvaluationNode\n   */\n  public getFrontierDependencies(): Set<SpillMetaNode> {\n    return new Set();\n  }\n\n  toJSON(visitor: Set<string> = new Set()): any {\n    const hasVisited = visitor?.has(this.key);\n    if (hasVisited) {\n      return {\n        key: this.key,\n        resolved: this.resolved,\n        cycle: true,\n        dependencies: [],\n      };\n    }\n    visitor?.add(this.key);\n    return {\n      key: this.key,\n      resolved: this.resolved,\n      evaluationResult: this.evaluationResult,\n      dependencies: Array.from(this.getDependencies()).map((node) =>\n        node.toJSON(visitor)\n      ),\n    };\n  }\n}\n"
+  ],
+  "mappings": ";AAQO,MAAM,aAAgB;AAAA,EACpB;AAAA,EACC,gBAAqC,IAAI;AAAA,EACzC,oBAAyC,IAAI;AAAA,EAC9C;AAAA,EACC,YAAqB;AAAA,EAE7B,WAAW,CAAC,KAAa;AAAA,IACvB,KAAK,MAAM;AAAA,IACX,KAAK,oBAAoB;AAAA,MACvB,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA;AAAA,EAGK,aAAa,CAAC,KAAqB;AAAA,IACxC,IAAI,KAAK,cAAc,IAAI,GAAG,GAAG;AAAA,MAC/B;AAAA,IACF;AAAA,IACA,KAAK,cAAc,IAAI,GAAG;AAAA;AAAA,MAGjB,iBAAiB,GAAG;AAAA,IAC7B,OACE,CAAC,KAAK,kBAAkB,WAAW,KAAK,aAAa,KACrD,KAAK,cAAc,SAAS,KAAK,kBAAkB;AAAA;AAAA,EAIhD,OAAO,GAAG;AAAA,IACf,IAAI,KAAK,WAAW,GAAG;AAAA,MACrB,KAAK,YAAY;AAAA,IACnB;AAAA;AAAA,EAGK,UAAU,GAAG;AAAA,IAClB,OACG,KAAK,iBAAyB,SAAS,yBACxC,CAAC,KAAK;AAAA;AAAA,MAIC,QAAQ,GAAG;AAAA,IACpB,OAAO,KAAK;AAAA;AAAA,MAGH,gBAAgB,GAAM;AAAA,IAC/B,OAAO,KAAK;AAAA;AAAA,EAGP,mBAAmB,CAAC,QAAW;AAAA,IACpC,KAAK,oBAAoB;AAAA;AAAA,EAGpB,sBAAsB,GAAG;AAAA,IAC9B,IAAI,KAAK,WAAW;AAAA,MAClB;AAAA,IACF;AAAA,IACA,KAAK,oBAAoB,IAAI,IAAI,KAAK,aAAa;AAAA,IACnD,KAAK,gBAAgB,IAAI;AAAA;AAAA,EAMpB,eAAe,GAAG;AAAA,IACvB,OAAO,KAAK;AAAA;AAAA,EAMP,kBAAkB,GAAG;AAAA,IAC1B,OAAO,KAAK,gBAAgB;AAAA;AAAA,EAMvB,uBAAuB,GAAuB;AAAA,IACnD,OAAO,IAAI;AAAA;AAAA,EAGb,MAAM,CAAC,UAAuB,IAAI,KAAY;AAAA,IAC5C,MAAM,aAAa,SAAS,IAAI,KAAK,GAAG;AAAA,IACxC,IAAI,YAAY;AAAA,MACd,OAAO;AAAA,QACL,KAAK,KAAK;AAAA,QACV,UAAU,KAAK;AAAA,QACf,OAAO;AAAA,QACP,cAAc,CAAC;AAAA,MACjB;AAAA,IACF;AAAA,IACA,SAAS,IAAI,KAAK,GAAG;AAAA,IACrB,OAAO;AAAA,MACL,KAAK,KAAK;AAAA,MACV,UAAU,KAAK;AAAA,MACf,kBAAkB,KAAK;AAAA,MACvB,cAAc,MAAM,KAAK,KAAK,gBAAgB,CAAC,EAAE,IAAI,CAAC,SACpD,KAAK,OAAO,OAAO,CACrB;AAAA,IACF;AAAA;AAEJ;",
+  "debugId": "7D7A4F1893384B5164756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/dependency-nodes/cell-value-node.mjs

@@ -0,0 +1,24 @@
+// src/evaluator/dependency-nodes/cell-value-node.ts
+import { getCellReference, keyToCellAddress } from "src/core/utils";
+import { BaseEvalNode } from "./base-eval-node.mjs";
+
+class CellValueNode extends BaseEvalNode {
+  cellAddress;
+  constructor(key) {
+    const cellAddress = keyToCellAddress(key);
+    super(key);
+    this.cellAddress = cellAddress;
+  }
+  toString() {
+    return getCellReference(this.cellAddress);
+  }
+  spillMeta;
+  setSpillMetaNode(node) {
+    this.spillMeta = node;
+  }
+}
+export {
+  CellValueNode
+};
+
+//# debugId=D70C954EBA7519EF64756E2164756E21

package/dist/mjs/evaluator/dependency-nodes/cell-value-node.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/dependency-nodes/cell-value-node.ts"],
+  "sourcesContent": [
+    "import type {\n  AwaitingEvaluationResult,\n  CellAddress,\n  ErrorEvaluationResult,\n  SingleEvaluationResult,\n  SpilledValuesEvaluationResult,\n} from \"src/core/types\";\nimport { getCellReference, keyToCellAddress } from \"src/core/utils\";\nimport { BaseEvalNode } from \"./base-eval-node.mjs\";\nimport type { SpillMetaNode } from \"./spill-meta-node.mjs\";\n\nexport class CellValueNode extends BaseEvalNode<SingleEvaluationResult> {\n  public readonly cellAddress: CellAddress;\n\n  constructor(key: string) {\n    const cellAddress = keyToCellAddress(key);\n    super(key);\n\n    this.cellAddress = cellAddress;\n  }\n\n  public override toString(): string {\n    return getCellReference(this.cellAddress);\n  }\n\n  spillMeta: SpillMetaNode | undefined;\n\n  setSpillMetaNode(node: SpillMetaNode) {\n    this.spillMeta = node;\n  }\n}\n"
+  ],
+  "mappings": ";AAOA;AACA;AAAA;AAGO,MAAM,sBAAsB,aAAqC;AAAA,EACtD;AAAA,EAEhB,WAAW,CAAC,KAAa;AAAA,IACvB,MAAM,cAAc,iBAAiB,GAAG;AAAA,IACxC,MAAM,GAAG;AAAA,IAET,KAAK,cAAc;AAAA;AAAA,EAGL,QAAQ,GAAW;AAAA,IACjC,OAAO,iBAAiB,KAAK,WAAW;AAAA;AAAA,EAG1C;AAAA,EAEA,gBAAgB,CAAC,MAAqB;AAAA,IACpC,KAAK,YAAY;AAAA;AAErB;",
+  "debugId": "D70C954EBA7519EF64756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/dependency-nodes/empty-cell-evaluation-node.mjs

@@ -0,0 +1,78 @@
+// src/evaluator/dependency-nodes/empty-cell-evaluation-node.ts
+import { FrontierDependencyManager } from "src/core/managers/frontier-dependency-manager";
+import { getCellReference, keyToCellAddress } from "src/core/utils";
+
+class EmptyCellEvaluationNode extends FrontierDependencyManager {
+  emptyCellKey;
+  key;
+  cellAddress;
+  _evaluationResult;
+  constructor(emptyCellKey, evaluationManager, workbookManager) {
+    const cellAddress = keyToCellAddress(emptyCellKey);
+    const emptyCellRange = {
+      range: {
+        start: {
+          col: cellAddress.colIndex,
+          row: cellAddress.rowIndex
+        },
+        end: {
+          col: { type: "number", value: cellAddress.colIndex },
+          row: { type: "number", value: cellAddress.rowIndex }
+        }
+      },
+      sheetName: cellAddress.sheetName,
+      workbookName: cellAddress.workbookName
+    };
+    super(emptyCellRange, workbookManager, evaluationManager);
+    this.emptyCellKey = emptyCellKey;
+    this.cellAddress = cellAddress;
+    this.key = emptyCellKey.replace(/^cell:/, "empty:");
+    this._evaluationResult = {
+      type: "awaiting-evaluation",
+      waitingFor: this,
+      errAddress: this
+    };
+  }
+  setEvaluationResult(result) {
+    this._evaluationResult = result;
+  }
+  get evaluationResult() {
+    return this._evaluationResult;
+  }
+  resolve() {
+    if (this.canResolve()) {
+      super.resolve();
+    }
+  }
+  canResolve() {
+    return super.canResolve() && this.evaluationResult.type !== "awaiting-evaluation";
+  }
+  toJSON(visitor = new Set) {
+    const hasVisited = visitor?.has(this.key);
+    if (hasVisited) {
+      return {
+        key: this.key,
+        resolved: this.resolved,
+        cycle: true,
+        dependencies: [],
+        frontierDependencies: []
+      };
+    }
+    visitor?.add(this.key);
+    return {
+      key: this.key,
+      resolved: this.resolved,
+      evaluationResult: this.evaluationResult,
+      dependencies: Array.from(this.getDependencies()).map((node) => node.toJSON(visitor)),
+      frontierDependencies: Array.from(this.getFrontierDependencies()).map((node) => node.toJSON(visitor))
+    };
+  }
+  toString() {
+    return getCellReference(this.cellAddress);
+  }
+}
+export {
+  EmptyCellEvaluationNode
+};
+
+//# debugId=E999CDF7A08C7F3A64756E2164756E21

package/dist/mjs/evaluator/dependency-nodes/empty-cell-evaluation-node.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/dependency-nodes/empty-cell-evaluation-node.ts"],
+  "sourcesContent": [
+    "import type { DependencyManager } from \"src/core/managers/dependency-manager\";\nimport { FrontierDependencyManager } from \"src/core/managers/frontier-dependency-manager\";\nimport type { WorkbookManager } from \"src/core/managers/workbook-manager\";\nimport type {\n  CellAddress,\n  RangeAddress,\n  SingleEvaluationResult,\n} from \"src/core/types\";\nimport { getCellReference, keyToCellAddress } from \"src/core/utils\";\n\nexport class EmptyCellEvaluationNode extends FrontierDependencyManager {\n  public key: string;\n  public cellAddress: CellAddress;\n  private _evaluationResult: SingleEvaluationResult;\n\n  constructor(\n    public emptyCellKey: string,\n    evaluationManager: DependencyManager,\n    workbookManager: WorkbookManager\n  ) {\n    const cellAddress = keyToCellAddress(emptyCellKey);\n    const emptyCellRange: RangeAddress = {\n      range: {\n        start: {\n          col: cellAddress.colIndex,\n          row: cellAddress.rowIndex,\n        },\n        end: {\n          col: { type: \"number\", value: cellAddress.colIndex },\n          row: { type: \"number\", value: cellAddress.rowIndex },\n        },\n      },\n      sheetName: cellAddress.sheetName,\n      workbookName: cellAddress.workbookName,\n    };\n\n    super(emptyCellRange, workbookManager, evaluationManager);\n\n    this.cellAddress = cellAddress;\n    this.key = emptyCellKey.replace(/^cell:/, \"empty:\");\n    this._evaluationResult = {\n      type: \"awaiting-evaluation\",\n      waitingFor: this,\n      errAddress: this,\n    };\n  }\n\n  public setEvaluationResult(result: SingleEvaluationResult) {\n    this._evaluationResult = result;\n  }\n\n  public get evaluationResult(): SingleEvaluationResult {\n    return this._evaluationResult;\n  }\n\n  public override resolve() {\n    if (this.canResolve()) {\n      super.resolve();\n    }\n  }\n\n  public override canResolve() {\n    return (\n      super.canResolve() && this.evaluationResult.type !== \"awaiting-evaluation\"\n    );\n  }\n\n  toJSON(visitor: Set<string> = new Set()): any {\n    const hasVisited = visitor?.has(this.key);\n    if (hasVisited) {\n      return {\n        key: this.key,\n        resolved: this.resolved,\n        cycle: true,\n        dependencies: [],\n        frontierDependencies: [],\n      };\n    }\n    visitor?.add(this.key);\n    return {\n      key: this.key,\n      resolved: this.resolved,\n      evaluationResult: this.evaluationResult,\n      dependencies: Array.from(this.getDependencies()).map((node) =>\n        node.toJSON(visitor)\n      ),\n      frontierDependencies: Array.from(this.getFrontierDependencies()).map(\n        (node) => node.toJSON(visitor)\n      ),\n    };\n  }\n\n  public override toString(): string {\n    return getCellReference(this.cellAddress);\n  }\n}\n"
+  ],
+  "mappings": ";AACA;AAOA;AAAA;AAEO,MAAM,gCAAgC,0BAA0B;AAAA,EAM5D;AAAA,EALF;AAAA,EACA;AAAA,EACC;AAAA,EAER,WAAW,CACF,cACP,mBACA,iBACA;AAAA,IACA,MAAM,cAAc,iBAAiB,YAAY;AAAA,IACjD,MAAM,iBAA+B;AAAA,MACnC,OAAO;AAAA,QACL,OAAO;AAAA,UACL,KAAK,YAAY;AAAA,UACjB,KAAK,YAAY;AAAA,QACnB;AAAA,QACA,KAAK;AAAA,UACH,KAAK,EAAE,MAAM,UAAU,OAAO,YAAY,SAAS;AAAA,UACnD,KAAK,EAAE,MAAM,UAAU,OAAO,YAAY,SAAS;AAAA,QACrD;AAAA,MACF;AAAA,MACA,WAAW,YAAY;AAAA,MACvB,cAAc,YAAY;AAAA,IAC5B;AAAA,IAEA,MAAM,gBAAgB,iBAAiB,iBAAiB;AAAA,IApBjD;AAAA,IAsBP,KAAK,cAAc;AAAA,IACnB,KAAK,MAAM,aAAa,QAAQ,UAAU,QAAQ;AAAA,IAClD,KAAK,oBAAoB;AAAA,MACvB,MAAM;AAAA,MACN,YAAY;AAAA,MACZ,YAAY;AAAA,IACd;AAAA;AAAA,EAGK,mBAAmB,CAAC,QAAgC;AAAA,IACzD,KAAK,oBAAoB;AAAA;AAAA,MAGhB,gBAAgB,GAA2B;AAAA,IACpD,OAAO,KAAK;AAAA;AAAA,EAGE,OAAO,GAAG;AAAA,IACxB,IAAI,KAAK,WAAW,GAAG;AAAA,MACrB,MAAM,QAAQ;AAAA,IAChB;AAAA;AAAA,EAGc,UAAU,GAAG;AAAA,IAC3B,OACE,MAAM,WAAW,KAAK,KAAK,iBAAiB,SAAS;AAAA;AAAA,EAIzD,MAAM,CAAC,UAAuB,IAAI,KAAY;AAAA,IAC5C,MAAM,aAAa,SAAS,IAAI,KAAK,GAAG;AAAA,IACxC,IAAI,YAAY;AAAA,MACd,OAAO;AAAA,QACL,KAAK,KAAK;AAAA,QACV,UAAU,KAAK;AAAA,QACf,OAAO;AAAA,QACP,cAAc,CAAC;AAAA,QACf,sBAAsB,CAAC;AAAA,MACzB;AAAA,IACF;AAAA,IACA,SAAS,IAAI,KAAK,GAAG;AAAA,IACrB,OAAO;AAAA,MACL,KAAK,KAAK;AAAA,MACV,UAAU,KAAK;AAAA,MACf,kBAAkB,KAAK;AAAA,MACvB,cAAc,MAAM,KAAK,KAAK,gBAAgB,CAAC,EAAE,IAAI,CAAC,SACpD,KAAK,OAAO,OAAO,CACrB;AAAA,MACA,sBAAsB,MAAM,KAAK,KAAK,wBAAwB,CAAC,EAAE,IAC/D,CAAC,SAAS,KAAK,OAAO,OAAO,CAC/B;AAAA,IACF;AAAA;AAAA,EAGc,QAAQ,GAAW;AAAA,IACjC,OAAO,iBAAiB,KAAK,WAAW;AAAA;AAE5C;",
+  "debugId": "E999CDF7A08C7F3A64756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/dependency-nodes/spill-meta-node.mjs

@@ -0,0 +1,20 @@
+// src/evaluator/dependency-nodes/spill-meta-node.ts
+import { getCellReference, keyToCellAddress } from "src/core/utils";
+import { BaseEvalNode } from "./base-eval-node.mjs";
+
+class SpillMetaNode extends BaseEvalNode {
+  cellAddress;
+  constructor(key) {
+    const cellAddress = keyToCellAddress(key);
+    super(key);
+    this.cellAddress = cellAddress;
+  }
+  toString() {
+    return getCellReference(this.cellAddress);
+  }
+}
+export {
+  SpillMetaNode
+};
+
+//# debugId=574697BC842974D864756E2164756E21

package/dist/mjs/evaluator/dependency-nodes/spill-meta-node.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/evaluator/dependency-nodes/spill-meta-node.ts"],
+  "sourcesContent": [
+    "import type {\n  CellAddress,\n  DoesNotSpillResult,\n  ErrorEvaluationResult,\n  SpilledValuesEvaluationResult,\n} from \"src/core/types\";\nimport { getCellReference, keyToCellAddress } from \"src/core/utils\";\nimport { BaseEvalNode } from \"./base-eval-node.mjs\";\n\nexport class SpillMetaNode extends BaseEvalNode<\n  SpilledValuesEvaluationResult | ErrorEvaluationResult | DoesNotSpillResult\n> {\n  public readonly cellAddress: CellAddress;\n\n  constructor(key: string) {\n    const cellAddress = keyToCellAddress(key);\n    super(key);\n    this.cellAddress = cellAddress;\n  }\n\n  public override toString(): string {\n    return getCellReference(this.cellAddress);\n  }\n}\n"
+  ],
+  "mappings": ";AAMA;AACA;AAAA;AAEO,MAAM,sBAAsB,aAEjC;AAAA,EACgB;AAAA,EAEhB,WAAW,CAAC,KAAa;AAAA,IACvB,MAAM,cAAc,iBAAiB,GAAG;AAAA,IACxC,MAAM,GAAG;AAAA,IACT,KAAK,cAAc;AAAA;AAAA,EAGL,QAAQ,GAAW;AAAA,IACjC,OAAO,iBAAiB,KAAK,WAAW;AAAA;AAE5C;",
+  "debugId": "574697BC842974D864756E2164756E21",
+  "names": []
+}

package/dist/mjs/evaluator/evaluate-scalar-operator.mjs

@@ -0,0 +1,226 @@
+// src/evaluator/evaluate-scalar-operator.ts
+import {
+  FormulaError
+} from "../core/types.mjs";
+function evaluateSingleScalarOperator(leftValue, rightValue, evaluateScalar, context) {
+  const result = evaluateScalar(leftValue, rightValue, context);
+  if (result.type === "error" || result.type === "awaiting-evaluation") {
+    return result;
+  }
+  return { type: "value", result };
+}
+function evaluateScalarOperator(left, right, options) {
+  const { evaluateScalar, context, name } = options;
+  if (left.type === "error" || left.type === "awaiting-evaluation") {
+    return left;
+  }
+  if (right.type === "error" || right.type === "awaiting-evaluation") {
+    return right;
+  }
+  if (left.type === "value" && right.type === "value") {
+    const leftValue = left.result;
+    const rightValue = right.result;
+    const result = evaluateScalar(leftValue, rightValue, options.context);
+    if (result.type === "error" || result.type === "awaiting-evaluation") {
+      return result;
+    }
+    if (result) {
+      return { type: "value", result };
+    }
+  }
+  if (left.type === "spilled-values" && right.type === "value") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => left.spillArea(origin),
+      source: `evaulate left spilled range onto right value in scalar operator ${name}`,
+      evaluate: (spilled, context2) => {
+        const evaledLeft = left.evaluate(spilled, context2);
+        if (evaledLeft.type === "error" || evaledLeft.type === "awaiting-evaluation") {
+          return evaledLeft;
+        }
+        return evaluateSingleScalarOperator(evaledLeft.result, right.result, evaluateScalar, options.context);
+      },
+      evaluateAllCells: function(options2) {
+        const leftResults = left.evaluateAllCells.call(this, options2);
+        if (leftResults.type === "error" || leftResults.type === "awaiting-evaluation") {
+          return leftResults;
+        }
+        const results = leftResults.values.map((cellValue) => {
+          if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+            return cellValue;
+          } else {
+            return {
+              result: evaluateSingleScalarOperator(cellValue.result.result, right.result, evaluateScalar, options2.context),
+              relativePos: cellValue.relativePos
+            };
+          }
+        });
+        return {
+          type: "values",
+          values: results
+        };
+      }
+    };
+  }
+  if (right.type === "spilled-values" && left.type === "value") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => right.spillArea(origin),
+      source: `evaluate right spilled range onto left value in scalar operator ${name}`,
+      evaluate: (spilled, context2) => {
+        const evaledRight = right.evaluate(spilled, context2);
+        if (evaledRight.type === "error" || evaledRight.type === "awaiting-evaluation") {
+          return evaledRight;
+        }
+        return evaluateSingleScalarOperator(left.result, evaledRight.result, evaluateScalar, options.context);
+      },
+      evaluateAllCells: function(options2) {
+        const rightResults = right.evaluateAllCells.call(this, options2);
+        if (rightResults.type === "error" || rightResults.type === "awaiting-evaluation") {
+          return rightResults;
+        }
+        const results = rightResults.values.map((cellValue) => {
+          if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+            return cellValue;
+          } else {
+            const result = evaluateSingleScalarOperator(left.result, cellValue.result.result, evaluateScalar, options2.context);
+            return {
+              result,
+              relativePos: cellValue.relativePos
+            };
+          }
+        });
+        return {
+          type: "values",
+          values: results
+        };
+      }
+    };
+  }
+  if (left.type === "spilled-values" && right.type === "spilled-values") {
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => this.unionRanges(left.spillArea(origin), right.spillArea(origin)),
+      source: `evaluate spilled ranges in scalar operator ${name}`,
+      evaluate: (spilled, context2) => {
+        const evaledLeft = left.evaluate(spilled, context2);
+        if (evaledLeft.type === "error" || evaledLeft.type === "awaiting-evaluation") {
+          return evaledLeft;
+        }
+        const evaledRight = right.evaluate(spilled, context2);
+        if (evaledRight.type === "error" || evaledRight.type === "awaiting-evaluation") {
+          return evaledRight;
+        }
+        const isLeftEmpty = evaledLeft.type === "value" && evaledLeft.result.type === "string" && evaledLeft.result.value === "";
+        const isRightEmpty = evaledRight.type === "value" && evaledRight.result.type === "string" && evaledRight.result.value === "";
+        if (isLeftEmpty || isRightEmpty) {
+          return {
+            type: "error",
+            err: FormulaError.NA,
+            message: "Empty cell in scalar operation",
+            errAddress: options.context.dependencyNode
+          };
+        }
+        return evaluateSingleScalarOperator(evaledLeft.result, evaledRight.result, evaluateScalar, options.context);
+      },
+      evaluateAllCells: function(options2) {
+        const leftResults = left.evaluateAllCells.call(this, options2);
+        if (leftResults.type === "error" || leftResults.type === "awaiting-evaluation") {
+          return leftResults;
+        }
+        const rightResults = right.evaluateAllCells.call(this, options2);
+        if (rightResults.type === "error" || rightResults.type === "awaiting-evaluation") {
+          return rightResults;
+        }
+        const leftMap = new Map;
+        const rightMap = new Map;
+        const allPositions = new Set;
+        for (const result of leftResults.values) {
+          const key = `${result.relativePos.x},${result.relativePos.y}`;
+          leftMap.set(key, result);
+          allPositions.add(key);
+        }
+        for (const result of rightResults.values) {
+          const key = `${result.relativePos.x},${result.relativePos.y}`;
+          rightMap.set(key, result);
+          allPositions.add(key);
+        }
+        const results = [];
+        for (const posKey of allPositions) {
+          const leftResult = leftMap.get(posKey);
+          const rightResult = rightMap.get(posKey);
+          const [x, y] = posKey.split(",").map(Number);
+          const relativePos = { x, y };
+          if (!leftResult && !rightResult) {
+            continue;
+          } else if (!leftResult && rightResult) {
+            if (rightResult.result.type === "error" || rightResult.result.type === "awaiting-evaluation") {
+              results.push(rightResult);
+            } else if (rightResult.result.type === "value") {
+              results.push({
+                result: {
+                  type: "error",
+                  err: FormulaError.NA,
+                  message: "Left operand is empty",
+                  errAddress: context.dependencyNode
+                },
+                relativePos
+              });
+            } else {
+              results.push(rightResult);
+            }
+          } else if (!rightResult && leftResult) {
+            if (leftResult.result.type === "error" || leftResult.result.type === "awaiting-evaluation") {
+              results.push(leftResult);
+            } else if (leftResult.result.type === "value") {
+              results.push({
+                result: {
+                  type: "error",
+                  err: FormulaError.NA,
+                  message: "Right operand is empty",
+                  errAddress: context.dependencyNode
+                },
+                relativePos
+              });
+            } else {
+              results.push(leftResult);
+            }
+          } else if (leftResult && rightResult) {
+            if (leftResult.result.type === "error" || leftResult.result.type === "awaiting-evaluation") {
+              results.push(leftResult);
+            } else if (rightResult.result.type === "error" || rightResult.result.type === "awaiting-evaluation") {
+              results.push(rightResult);
+            } else if (leftResult.result.type === "value" && rightResult.result.type === "value") {
+              results.push({
+                result: evaluateSingleScalarOperator(leftResult.result.result, rightResult.result.result, evaluateScalar, options2.context),
+                relativePos: leftResult.relativePos
+              });
+            } else {
+              results.push({
+                result: {
+                  type: "error",
+                  err: FormulaError.VALUE,
+                  message: "Cannot evaluate scalar operator on non-value results",
+                  errAddress: context.dependencyNode
+                },
+                relativePos
+              });
+            }
+          }
+        }
+        return { type: "values", values: results };
+      }
+    };
+  }
+  return {
+    type: "error",
+    err: FormulaError.VALUE,
+    message: `Can't evaluate (${left.type}, ${right.type}) in scalar operator ${name}`,
+    errAddress: options.context.dependencyNode
+  };
+}
+export {
+  evaluateScalarOperator
+};
+
+//# debugId=05B49E306BDF335264756E2164756E21