@ricsam/formula-engine 0.0.1

package/dist/cjs/evaluator/formula-evaluator.cjs

@@ -0,0 +1,797 @@
+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/evaluator/formula-evaluator.ts
+var exports_formula_evaluator = {};
+__export(exports_formula_evaluator, {
+  FormulaEvaluator: () => FormulaEvaluator
+});
+module.exports = __toCommonJS(exports_formula_evaluator);
+var import_parser = require("src/parser/parser");
+var import_types = require("../core/types.cjs");
+var import_evaluate_scalar_operator = require("src/evaluator/evaluate-scalar-operator");
+var import_functions = require("src/functions");
+var import_utils = require("../core/utils.cjs");
+var import_add = require("./arithmetic/add/add.cjs");
+var import_divide = require("./arithmetic/divide/divide.cjs");
+var import_multiply = require("./arithmetic/multiply/multiply.cjs");
+var import_power = require("./arithmetic/power/power.cjs");
+var import_subtract = require("./arithmetic/subtract/subtract.cjs");
+var import_equals = require("./comparison/equals.cjs");
+var import_greater_than = require("./comparison/greater-than.cjs");
+var import_greater_than_or_equal = require("./comparison/greater-than-or-equal.cjs");
+var import_less_than = require("./comparison/less-than.cjs");
+var import_less_than_or_equal = require("./comparison/less-than-or-equal.cjs");
+var import_not_equals = require("./comparison/not-equals.cjs");
+var import_concatenate = require("./concatenation/concatenate.cjs");
+var import_evaluation_context = require("./evaluation-context.cjs");
+var import_cell_value_node = require("./dependency-nodes/cell-value-node.cjs");
+
+class FormulaEvaluator {
+  tableManager;
+  dependencyManager;
+  namedExpressionManager;
+  constructor(tableManager, dependencyManager, namedExpressionManager) {
+    this.tableManager = tableManager;
+    this.dependencyManager = dependencyManager;
+    this.namedExpressionManager = namedExpressionManager;
+  }
+  evaluateFormula(formula, context) {
+    const ast = import_parser.parseFormula(formula);
+    return import_utils.captureEvaluationErrors(context.dependencyNode, () => {
+      const result = this.evaluateNode(ast, context);
+      return result;
+    });
+  }
+  evaluateNode(node, context) {
+    const currentContext = {
+      ...context.cellAddress,
+      tableName: context.tableName
+    };
+    const astNode = this.dependencyManager.getAstNode(node, currentContext);
+    context.dependencyNode.addDependency(astNode);
+    if (astNode.resolved) {
+      const astContextDependency2 = astNode.getContextDependency();
+      context.appendContextDependency(astContextDependency2);
+      return astNode.evaluationResult;
+    }
+    astNode.resetDirectDepsUpdated();
+    function runEvaluation(context2) {
+      switch (node.type) {
+        case "value":
+          return {
+            type: "value",
+            result: this.evaluateValue(node)
+          };
+        case "infinity":
+          return {
+            type: "value",
+            result: {
+              type: "infinity",
+              sign: "positive"
+            }
+          };
+        case "binary-op":
+          return this.evaluateBinaryOp(node, context2);
+        case "reference":
+          return this.evaluateReference(node, context2);
+        case "named-expression":
+          return this.evaluateNamedExpression(node, context2);
+        case "structured-reference":
+          return this.evaluateStructuredReference(node, context2);
+        case "function":
+          return this.evaluateFunction(node, context2);
+        case "range":
+          return this.evaluateRange(node, context2);
+        case "unary-op":
+          return this.evaluateUnaryOp(node, context2);
+        case "3d-range":
+          return this.evaluate3DRange(node, context2);
+        case "array":
+          return this.evaluateArray(node, context2);
+        default:
+          return {
+            type: "error",
+            err: import_types.FormulaError.ERROR,
+            message: "WIP: unimplemented support for " + node.type,
+            errAddress: context2.dependencyNode
+          };
+      }
+    }
+    const newContext = new import_evaluation_context.EvaluationContext(this.tableManager, astNode, context.cellAddress);
+    const result = import_utils.captureEvaluationErrors(astNode, () => runEvaluation.call(this, newContext));
+    astNode.setEvaluationResult(result);
+    const astContextDependency = newContext.getContextDependency();
+    astNode.setContextDependency(astContextDependency);
+    context.appendContextDependency(astContextDependency);
+    return result;
+  }
+  evaluateStructuredReference(node, context) {
+    let table;
+    if (node.tableName && node.workbookName) {
+      table = this.tableManager.getTables(node.workbookName).get(node.tableName);
+    } else if (node.tableName) {
+      context.addContextDependency("workbook");
+      table = this.tableManager.getTables(context.cellAddress.workbookName).get(node.tableName);
+    } else {
+      context.addContextDependency("workbook", "table");
+      table = this.tableManager.isCellInTable(context.cellAddress);
+    }
+    if (node.isCurrentRow) {
+      context.addContextDependency("row");
+    }
+    if (!table) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.REF,
+        message: `Table ${node.tableName} not found`,
+        errAddress: context.dependencyNode
+      };
+    }
+    const rowIndex = context.cellAddress.rowIndex;
+    const tableStart = table.start;
+    if (node.selector) {
+      let startRow;
+      let endRow;
+      switch (node.selector) {
+        case "#Headers":
+          startRow = table.start.rowIndex;
+          endRow = { type: "number", value: table.start.rowIndex };
+          break;
+        case "#Data":
+          startRow = table.start.rowIndex + 1;
+          endRow = table.endRow;
+          break;
+        case "#All":
+          startRow = table.start.rowIndex;
+          endRow = table.endRow;
+          break;
+        default:
+          return {
+            type: "error",
+            err: import_types.FormulaError.REF,
+            message: `Unknown table selector: ${node.selector}`,
+            errAddress: context.dependencyNode
+          };
+      }
+      if (node.cols) {
+        const startCol = table.headers.get(node.cols.startCol);
+        const endCol = table.headers.get(node.cols.endCol);
+        if (!startCol || !endCol) {
+          return {
+            type: "error",
+            err: import_types.FormulaError.REF,
+            message: `Column ${node.cols.startCol} or ${node.cols.endCol} not found in table ${table.name}`,
+            errAddress: context.dependencyNode
+          };
+        }
+        const startColIndex = tableStart.colIndex + startCol.index;
+        const endColIndex = tableStart.colIndex + endCol.index;
+        const range = {
+          start: {
+            row: startRow,
+            col: startColIndex
+          },
+          end: {
+            row: endRow,
+            col: { type: "number", value: endColIndex }
+          }
+        };
+        return this.evaluateRange({
+          type: "range",
+          range,
+          isAbsolute: {
+            start: {
+              col: true,
+              row: true
+            },
+            end: {
+              col: true,
+              row: true
+            }
+          },
+          sheetName: table.sheetName
+        }, context);
+      } else {
+        const range = {
+          start: {
+            row: startRow,
+            col: tableStart.colIndex
+          },
+          end: {
+            row: endRow,
+            col: {
+              type: "number",
+              value: tableStart.colIndex + table.headers.size - 1
+            }
+          }
+        };
+        return this.evaluateRange({
+          type: "range",
+          range,
+          isAbsolute: {
+            start: {
+              col: true,
+              row: true
+            },
+            end: {
+              col: true,
+              row: true
+            }
+          },
+          sheetName: table.sheetName
+        }, context);
+      }
+    }
+    if (node.cols) {
+      const startCol = table.headers.get(node.cols.startCol);
+      const endCol = table.headers.get(node.cols.endCol);
+      if (!startCol || !endCol) {
+        return {
+          type: "error",
+          err: import_types.FormulaError.REF,
+          message: `Column ${node.cols.startCol} or ${node.cols.endCol} not found in table ${table.name}`,
+          errAddress: context.dependencyNode
+        };
+      }
+      const startColIndex = tableStart.colIndex + startCol.index;
+      const endColIndex = tableStart.colIndex + endCol.index;
+      const range = {
+        start: {
+          row: node.isCurrentRow ? rowIndex : table.start.rowIndex + 1,
+          col: startColIndex
+        },
+        end: {
+          row: node.isCurrentRow ? { type: "number", value: rowIndex } : table.endRow,
+          col: { type: "number", value: endColIndex }
+        }
+      };
+      return this.evaluateRange({
+        type: "range",
+        range,
+        isAbsolute: {
+          start: {
+            col: true,
+            row: true
+          },
+          end: {
+            col: true,
+            row: true
+          }
+        },
+        sheetName: table.sheetName
+      }, context);
+    }
+    return {
+      type: "error",
+      err: import_types.FormulaError.REF,
+      message: "Structured reference must specify either a selector or columns",
+      errAddress: context.dependencyNode
+    };
+  }
+  evaluateValue(node) {
+    return node.value;
+  }
+  evaluate3DRange(node, context) {
+    throw new Error("WIP: 3d range is not implemented");
+  }
+  evaluateRange(node, context) {
+    if (import_utils.isRangeOneCell(node.range)) {
+      return this.evaluateReference({
+        type: "reference",
+        address: {
+          colIndex: node.range.start.col,
+          rowIndex: node.range.start.row
+        },
+        isAbsolute: {
+          col: node.isAbsolute.start.col || node.isAbsolute.end.col,
+          row: node.isAbsolute.start.row || node.isAbsolute.end.row
+        },
+        sheetName: node.sheetName
+      }, context);
+    }
+    const debugRange = import_utils.getRangeKey(node.range);
+    const rangeAddress = {
+      sheetName: node.sheetName ?? context.cellAddress.sheetName,
+      workbookName: node.workbookName ?? context.cellAddress.workbookName,
+      range: node.range
+    };
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => this.projectRange(node.range, origin),
+      source: `range ${debugRange}`,
+      sourceRange: rangeAddress,
+      evaluate: (spillOffset, context2) => {
+        if (!node.sheetName && !node.workbookName) {
+          context2.addContextDependency("workbook", "sheet");
+        } else if (!node.sheetName) {
+          context2.addContextDependency("sheet");
+        } else if (!node.workbookName) {
+          context2.addContextDependency("workbook");
+        } else {}
+        const originSheetName = node.sheetName ?? context2.cellAddress.sheetName;
+        const originWorkbookName = node.workbookName ?? context2.cellAddress.workbookName;
+        const colIndex = node.range.start.col + spillOffset.x;
+        const rowIndex = node.range.start.row + spillOffset.y;
+        const cellAddress = {
+          colIndex,
+          rowIndex,
+          sheetName: originSheetName,
+          workbookName: originWorkbookName
+        };
+        const evalNode = this.dependencyManager.getCellValueOrEmptyCellNode(import_utils.cellAddressToKey(cellAddress));
+        context2.dependencyNode.addDependency(evalNode);
+        const result = evalNode.evaluationResult;
+        return result;
+      },
+      evaluateAllCells: function({
+        evaluate,
+        intersection,
+        context: context2,
+        origin,
+        lookupOrder
+      }) {
+        let range = node.range;
+        if (intersection) {
+          const relativeRange = import_utils.getRelativeRange(intersection, origin);
+          const start = {
+            colIndex: node.range.start.col,
+            rowIndex: node.range.start.row
+          };
+          const projectedIntersection = import_utils.getAbsoluteRange(relativeRange, start);
+          const calculateIntersection = import_utils.getRangeIntersection(node.range, projectedIntersection);
+          if (calculateIntersection) {
+            range = calculateIntersection;
+          }
+        }
+        const address = {
+          range,
+          sheetName: node.sheetName ?? context2.cellAddress.sheetName,
+          workbookName: node.workbookName ?? context2.cellAddress.workbookName
+        };
+        const rangeNode = this.dependencyManager.getRangeNode(import_utils.rangeAddressToKey(address));
+        context2.dependencyNode.addDependency(rangeNode);
+        return this.dependencyManager.getRangeNode(import_utils.rangeAddressToKey(address)).result;
+      }
+    };
+  }
+  evaluateArray(node, context) {
+    const firstRow = node.elements[0];
+    if (!firstRow) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.REF,
+        message: "Array is empty",
+        errAddress: context.dependencyNode
+      };
+    }
+    const firstCell = firstRow[0];
+    if (!firstCell) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.REF,
+        message: "Array is empty",
+        errAddress: context.dependencyNode
+      };
+    }
+    const originResult = this.evaluateNode(firstCell, context);
+    if (originResult.type === "error" || originResult.type === "awaiting-evaluation") {
+      return originResult;
+    }
+    return {
+      type: "spilled-values",
+      spillArea: (origin) => ({
+        start: {
+          col: origin.colIndex,
+          row: origin.rowIndex
+        },
+        end: {
+          col: {
+            type: "number",
+            value: origin.colIndex + firstRow.length - 1
+          },
+          row: {
+            type: "number",
+            value: origin.rowIndex + node.elements.length - 1
+          }
+        }
+      }),
+      source: `array`,
+      evaluate: (spillOffset, context2) => {
+        const row = node.elements[spillOffset.y];
+        if (!row) {
+          return {
+            type: "error",
+            err: import_types.FormulaError.REF,
+            message: "Array is empty",
+            errAddress: context2.dependencyNode
+          };
+        }
+        const cell = row[spillOffset.x];
+        if (!cell) {
+          return {
+            type: "error",
+            err: import_types.FormulaError.REF,
+            message: "Array is empty",
+            errAddress: context2.dependencyNode
+          };
+        }
+        const result = this.evaluateNode(cell, context2);
+        if (result.type === "spilled-values") {
+          return {
+            type: "error",
+            err: import_types.FormulaError.VALUE,
+            message: "Arrays cannot contain spilled values",
+            errAddress: context2.dependencyNode
+          };
+        }
+        return result;
+      },
+      evaluateAllCells: (intersectingRange) => {
+        throw new Error("WIP: evaluateAllCells for array is not implemented");
+      }
+    };
+  }
+  evaluateUnaryOp(node, context) {
+    const operandResult = this.evaluateNode(node.operand, context);
+    if (operandResult.type === "error" || operandResult.type === "awaiting-evaluation") {
+      return operandResult;
+    }
+    if (operandResult.type === "spilled-values") {
+      return {
+        type: "spilled-values",
+        spillArea: (origin) => operandResult.spillArea(origin),
+        source: `unary ${node.operator} operation`,
+        evaluate: (spilledCell, context2) => {
+          const spillResult = operandResult.evaluate(spilledCell, context2);
+          if (!spillResult || spillResult.type === "error" || spillResult.type === "awaiting-evaluation") {
+            return spillResult;
+          }
+          if (spillResult.type !== "value") {
+            return {
+              type: "error",
+              err: import_types.FormulaError.VALUE,
+              message: "Invalid spilled result for unary operation",
+              errAddress: context2.dependencyNode
+            };
+          }
+          return this.evaluateUnaryScalar(node.operator, spillResult.result, context2);
+        },
+        evaluateAllCells: function(options) {
+          const cellValues = operandResult.evaluateAllCells.call(this, options);
+          if (cellValues.type !== "values") {
+            return cellValues;
+          }
+          return {
+            type: "values",
+            values: cellValues.values.map((cellValue) => {
+              if (cellValue.result.type === "error" || cellValue.result.type === "awaiting-evaluation") {
+                return cellValue;
+              } else {
+                return {
+                  result: this.evaluateUnaryScalar(node.operator, cellValue.result.result, context),
+                  relativePos: cellValue.relativePos
+                };
+              }
+            })
+          };
+        }
+      };
+    }
+    if (operandResult.type === "value") {
+      return this.evaluateUnaryScalar(node.operator, operandResult.result, context);
+    }
+    return {
+      type: "error",
+      err: import_types.FormulaError.VALUE,
+      message: "Invalid operand for unary operation",
+      errAddress: context.dependencyNode
+    };
+  }
+  evaluateUnaryScalar(operator, operand, context) {
+    if (operand.type !== "number" && operand.type !== "infinity") {
+      return {
+        type: "error",
+        err: import_types.FormulaError.VALUE,
+        message: `Cannot apply unary ${operator} to non-number`,
+        errAddress: context.dependencyNode
+      };
+    }
+    if (operand.type === "infinity") {
+      if (operator === "%") {
+        return {
+          type: "error",
+          err: import_types.FormulaError.NUM,
+          message: "Cannot apply % to infinity",
+          errAddress: context.dependencyNode
+        };
+      }
+      return {
+        type: "value",
+        result: {
+          type: "infinity",
+          sign: operator === "+" ? "positive" : "negative"
+        }
+      };
+    }
+    switch (operator) {
+      case "+":
+        return { type: "value", result: operand };
+      case "-":
+        return {
+          type: "value",
+          result: {
+            type: "number",
+            value: -operand.value
+          }
+        };
+      case "%":
+        return {
+          type: "value",
+          result: { type: "number", value: operand.value / 100 }
+        };
+      default:
+        return {
+          type: "error",
+          err: import_types.FormulaError.VALUE,
+          message: `Unknown unary operator: ${operator}`,
+          errAddress: context.dependencyNode
+        };
+    }
+  }
+  evaluateBinaryOp(node, context) {
+    const left = this.evaluateNode(node.left, context);
+    const right = this.evaluateNode(node.right, context);
+    if (left.type === "error" || left.type === "awaiting-evaluation") {
+      return left;
+    }
+    if (right.type === "error" || right.type === "awaiting-evaluation") {
+      return right;
+    }
+    return this.evaluateBinaryScalar(node.operator, left, right, context);
+  }
+  evaluateReference(node, context) {
+    const cellAddress = {
+      ...node.address,
+      sheetName: node.sheetName ?? context.cellAddress.sheetName,
+      workbookName: node.workbookName ?? context.cellAddress.workbookName
+    };
+    const key = import_utils.cellAddressToKey(cellAddress);
+    const evalNode = this.dependencyManager.getCellValueOrEmptyCellNode(key);
+    context.dependencyNode.addDependency(evalNode);
+    if (!node.sheetName && !node.workbookName) {
+      context.addContextDependency("workbook", "sheet");
+    } else if (!node.sheetName) {
+      context.addContextDependency("sheet");
+    } else if (!node.workbookName) {
+      context.addContextDependency("workbook");
+    } else {}
+    if (evalNode instanceof import_cell_value_node.CellValueNode && evalNode.spillMeta) {
+      if (evalNode.spillMeta.evaluationResult.type === "spilled-values") {
+        return {
+          ...evalNode.spillMeta.evaluationResult,
+          sourceCell: cellAddress,
+          sourceRange: undefined
+        };
+      }
+    }
+    return { ...evalNode.evaluationResult, sourceCell: cellAddress };
+  }
+  evaluateNamedExpression(node, context) {
+    const expression = this.namedExpressionManager.resolveNamedExpression(node, context);
+    if (!expression) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.NAME,
+        message: `Named expression ${node.name} not found`,
+        errAddress: context.dependencyNode
+      };
+    }
+    return this.evaluateFormula(expression, context);
+  }
+  evaluateBinaryScalar(operator, left, right, context) {
+    switch (operator) {
+      case "+":
+        return this.add(left, right, context);
+      case "-":
+        return this.subtract(left, right, context);
+      case "*":
+        return this.multiply(left, right, context);
+      case "/":
+        return this.divide(left, right, context);
+      case "^":
+        return this.power(left, right, context);
+      case "&":
+        return this.concatenateOp(left, right, context);
+      case "=":
+        return this.equalsOp(left, right, context);
+      case "<>":
+        return this.notEqualsOp(left, right, context);
+      case "<":
+        return this.lessThanOp(left, right, context);
+      case "<=":
+        return this.lessThanOrEqualOp(left, right, context);
+      case ">":
+        return this.greaterThanOp(left, right, context);
+      case ">=":
+        return this.greaterThanOrEqualOp(left, right, context);
+      default:
+        return {
+          type: "error",
+          err: import_types.FormulaError.ERROR,
+          message: `Unknown binary operator: ${operator}`,
+          errAddress: context.dependencyNode
+        };
+    }
+  }
+  evaluateFunction(node, context) {
+    const func = import_functions.functions[node.name];
+    if (!func) {
+      return {
+        type: "error",
+        err: import_types.FormulaError.NAME,
+        message: `Function ${node.name} not found`,
+        errAddress: context.dependencyNode
+      };
+    }
+    return func.evaluate.call(this, node, context);
+  }
+  add(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_add.add,
+      context,
+      name: "add"
+    });
+  }
+  multiply(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_multiply.multiply,
+      context,
+      name: "multiply"
+    });
+  }
+  divide(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_divide.divide,
+      context,
+      name: "divide"
+    });
+  }
+  evaluateScalarOperator(left, right, options) {
+    return import_evaluate_scalar_operator.evaluateScalarOperator.call(this, left, right, options);
+  }
+  subtract(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_subtract.subtract,
+      context,
+      name: "subtract"
+    });
+  }
+  power(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_power.power,
+      context,
+      name: "power"
+    });
+  }
+  equalsOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_equals.equals,
+      context,
+      name: "equals"
+    });
+  }
+  notEqualsOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_not_equals.notEquals,
+      context,
+      name: "notEquals"
+    });
+  }
+  lessThanOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_less_than.lessThan,
+      context,
+      name: "lessThan"
+    });
+  }
+  lessThanOrEqualOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_less_than_or_equal.lessThanOrEqual,
+      context,
+      name: "lessThanOrEqual"
+    });
+  }
+  greaterThanOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_greater_than.greaterThan,
+      context,
+      name: "greaterThan"
+    });
+  }
+  greaterThanOrEqualOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_greater_than_or_equal.greaterThanOrEqual,
+      context,
+      name: "greaterThanOrEqual"
+    });
+  }
+  concatenateOp(left, right, context) {
+    return this.evaluateScalarOperator(left, right, {
+      evaluateScalar: import_concatenate.concatenate,
+      context,
+      name: "concatenate"
+    });
+  }
+  projectRange(range, originCellAddress) {
+    const offsetLeft = originCellAddress.colIndex - range.start.col;
+    const offsetTop = originCellAddress.rowIndex - range.start.row;
+    return {
+      start: {
+        col: range.start.col + offsetLeft,
+        row: range.start.row + offsetTop
+      },
+      end: {
+        col: range.end.col.type === "number" ? { type: "number", value: range.end.col.value + offsetLeft } : range.end.col,
+        row: range.end.row.type === "number" ? { type: "number", value: range.end.row.value + offsetTop } : range.end.row
+      }
+    };
+  }
+  unionRanges(range1, range2) {
+    const endCol = (() => {
+      if (range1.end.col.type === "infinity" || range2.end.col.type === "infinity") {
+        return { type: "infinity", sign: "positive" };
+      }
+      return {
+        type: "number",
+        value: Math.max(range1.end.col.value, range2.end.col.value)
+      };
+    })();
+    const endRow = (() => {
+      if (range1.end.row.type === "infinity" || range2.end.row.type === "infinity") {
+        return { type: "infinity", sign: "positive" };
+      }
+      return {
+        type: "number",
+        value: Math.max(range1.end.row.value, range2.end.row.value)
+      };
+    })();
+    return {
+      start: {
+        col: Math.min(range1.start.col, range2.start.col),
+        row: Math.min(range1.start.row, range2.start.row)
+      },
+      end: {
+        col: endCol,
+        row: endRow
+      }
+    };
+  }
+}
+
+//# debugId=933F15F432C0CF0A64756E2164756E21