@ricsam/formula-engine 0.0.1

package/dist/cjs/parser/parser.cjs

@@ -0,0 +1,1700 @@
+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/parser/parser.ts
+var exports_parser = {};
+__export(exports_parser, {
+  parseFormula: () => parseFormula,
+  Parser: () => Parser,
+  ParseError: () => ParseError
+});
+module.exports = __toCommonJS(exports_parser);
+var import_utils = require("../core/utils.cjs");
+var import_types = require("../core/types.cjs");
+var import_ast = require("./ast.cjs");
+var import_grammar = require("./grammar.cjs");
+var import_lexer = require("./lexer.cjs");
+
+class ParseError extends Error {
+  position;
+  constructor(message, position) {
+    super(message);
+    this.position = position;
+    this.name = "ParseError";
+  }
+}
+
+class Parser {
+  tokens;
+  input;
+  constructor(tokens, input) {
+    this.tokens = new import_lexer.TokenStream(tokens);
+    this.input = input || "";
+  }
+  lookAheadForWorkbookReference() {
+    let pos = 1;
+    while (pos < 10) {
+      const token = this.tokens.peekAhead(pos);
+      if (!token || token.type === "EOF") {
+        return { isWorkbookReference: false };
+      }
+      if (token.type === "RBRACKET") {
+        const nextToken = this.tokens.peekAhead(pos + 1);
+        if (nextToken && nextToken.type === "IDENTIFIER") {
+          let lookPos = pos + 2;
+          while (lookPos < pos + 10) {
+            const lookToken = this.tokens.peekAhead(lookPos);
+            if (!lookToken || lookToken.type === "EOF") {
+              return { isWorkbookReference: true };
+            }
+            if (lookToken.type === "EXCLAMATION") {
+              return { isWorkbookReference: true };
+            }
+            lookPos++;
+          }
+        }
+        return { isWorkbookReference: false };
+      }
+      if (token.type === "IDENTIFIER" || token.type === "FUNCTION" || token.type === "NUMBER" || token.type === "OPERATOR" && (token.value === "-" || token.value === "=" || token.value === "%") || token.type === "LPAREN" || token.type === "RPAREN") {
+        pos++;
+        continue;
+      }
+      return { isWorkbookReference: false };
+    }
+    return { isWorkbookReference: false };
+  }
+  parseWorkbookReference() {
+    const start = this.tokens.peek().position.start;
+    this.tokens.consume();
+    const workbookStartPos = this.tokens.peek().position.start;
+    let workbookEndPos = workbookStartPos;
+    while (!this.tokens.match("RBRACKET")) {
+      if (this.tokens.isAtEnd()) {
+        throw new ParseError("Expected ] to close workbook reference", this.tokens.peek().position);
+      }
+      const token = this.tokens.peek();
+      if (token.type === "IDENTIFIER" || token.type === "FUNCTION" || token.type === "NUMBER" || token.type === "OPERATOR" && (token.value === "-" || token.value === "=" || token.value === "%") || token.type === "LPAREN" || token.type === "RPAREN") {
+        const consumedToken = this.tokens.consume();
+        workbookEndPos = consumedToken.position.end;
+      } else {
+        throw new ParseError(`Invalid character in workbook name: ${token.value}`, token.position);
+      }
+    }
+    const workbookName = this.input.substring(workbookStartPos, workbookEndPos);
+    this.tokens.consume();
+    if (!this.tokens.match("IDENTIFIER")) {
+      throw new ParseError("Expected sheet name after workbook reference", this.tokens.peek().position);
+    }
+    const sheetToken = this.tokens.consume();
+    let sheetName = sheetToken.value;
+    if (sheetName.startsWith("'") && sheetName.endsWith("'")) {
+      sheetName = sheetName.slice(1, -1).replace(/''/g, "'");
+    }
+    if (this.tokens.match("COLON")) {
+      const nextToken = this.tokens.peekAhead(1);
+      const tokenAfterNext = this.tokens.peekAhead(2);
+      if (nextToken?.type === "IDENTIFIER" && tokenAfterNext?.type === "EXCLAMATION") {
+        this.tokens.consume();
+        const endSheetToken = this.tokens.consume();
+        let endSheetName = endSheetToken.value;
+        if (endSheetName.startsWith("'") && endSheetName.endsWith("'")) {
+          endSheetName = endSheetName.slice(1, -1).replace(/''/g, "'");
+        }
+        this.tokens.consume();
+        const ref = this.parseCellOrRangeAfterSheets();
+        return import_ast.createThreeDRangeNode(sheetName, endSheetName, ref, {
+          start,
+          end: this.tokens.peek().position?.end ?? 0
+        }, workbookName);
+      }
+    }
+    if (this.tokens.match("EXCLAMATION")) {
+      this.tokens.consume();
+      const cellRef = this.parseCellOrRangeWithWorkbookAndSheet(workbookName, sheetName, start);
+      return cellRef;
+    } else {
+      const range = {
+        start: {
+          col: 0,
+          row: 0
+        },
+        end: {
+          col: {
+            type: "infinity",
+            sign: "positive"
+          },
+          row: {
+            type: "infinity",
+            sign: "positive"
+          }
+        }
+      };
+      return import_ast.createRangeNode({
+        workbookName,
+        sheetName,
+        range,
+        isAbsolute: {
+          start: { col: false, row: false },
+          end: { col: false, row: false }
+        },
+        position: {
+          start,
+          end: this.tokens.peek().position?.start ?? 0
+        }
+      });
+    }
+  }
+  parseBareColumnReference() {
+    const startPos = this.tokens.peek().position.start;
+    this.tokens.consume();
+    let selector;
+    let cols;
+    let isCurrentRow = false;
+    if (this.tokens.match("HASH")) {
+      this.tokens.consume();
+      if (!this.tokens.match("IDENTIFIER")) {
+        throw new ParseError("Expected selector name after #", this.tokens.peek().position);
+      }
+      const selectorName = this.tokens.consume().value;
+      selector = `#${selectorName}`;
+    } else if (this.tokens.match("IDENTIFIER")) {
+      const colStart = this.parseColumnName();
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const colEnd = this.parseColumnName();
+        cols = {
+          startCol: colStart,
+          endCol: colEnd
+        };
+      } else {
+        cols = {
+          startCol: colStart,
+          endCol: colStart
+        };
+      }
+    } else {
+      throw new ParseError("Expected column name or selector in bare column reference", this.tokens.peek().position);
+    }
+    if (!this.tokens.match("RBRACKET")) {
+      throw new ParseError("Expected ] to close column reference", this.tokens.peek().position);
+    }
+    this.tokens.consume();
+    return import_ast.createStructuredReferenceNode({
+      tableName: undefined,
+      cols,
+      selector,
+      isCurrentRow,
+      position: {
+        start: startPos,
+        end: this.tokens.peek().position?.end ?? 0
+      }
+    });
+  }
+  parseColumnName() {
+    if (!this.tokens.match("IDENTIFIER") && !this.tokens.match("FUNCTION") && !this.tokens.match("NUMBER") && !this.tokens.match("OPERATOR")) {
+      throw new ParseError("Expected column name", this.tokens.peek().position);
+    }
+    const startToken = this.tokens.peek();
+    const startPos = startToken.position.start;
+    this.tokens.consume();
+    const endTokens = new Set([
+      "RBRACKET",
+      "COMMA",
+      "EOF"
+    ]);
+    while (!endTokens.has(this.tokens.peek().type)) {
+      if (this.tokens.match("OPERATOR")) {
+        this.tokens.consume();
+      } else {
+        this.tokens.consume();
+      }
+    }
+    const currentPos = this.tokens.getPosition();
+    let endPos = currentPos > 0 ? this.tokens.getTokens()[currentPos - 1]?.position?.end || startPos : startPos;
+    if (this.tokens.match("RBRACKET")) {
+      const nextTokenPos = this.tokens.peek().position.start;
+      endPos = nextTokenPos;
+    }
+    const columnName = this.input.substring(startPos, endPos);
+    return columnName;
+  }
+  static parse(formula) {
+    const lexer = new import_lexer.Lexer(formula);
+    const tokens = lexer.tokenize();
+    const parser = new Parser(tokens, formula);
+    return parser.parseFormula();
+  }
+  parseFormula() {
+    if (this.tokens.isAtEnd()) {
+      return import_ast.createEmptyNode();
+    }
+    if (this.tokens.peek().type === "EOF") {
+      return import_ast.createErrorNode(import_types.FormulaError.ERROR, "Empty formula");
+    }
+    try {
+      const expr = this.parseExpression();
+      if (!this.tokens.isAtEnd()) {
+        throw new ParseError(`Unexpected token: ${this.tokens.peek().value}`, this.tokens.peek().position);
+      }
+      return expr;
+    } catch (error) {
+      if (error instanceof ParseError) {
+        throw error;
+      }
+      throw new ParseError(String(error));
+    }
+  }
+  parseExpression() {
+    return this.parseBinaryExpression(0);
+  }
+  parseBinaryExpression(minPrecedence) {
+    let left = this.parseUnaryExpression();
+    while (true) {
+      const token = this.tokens.peek();
+      if (token.type !== "OPERATOR" || !import_grammar.isBinaryOperator(token.value)) {
+        break;
+      }
+      const precedence = import_grammar.getOperatorPrecedence(token.value);
+      if (precedence < minPrecedence) {
+        break;
+      }
+      const operator = token.value;
+      const associativity = import_grammar.getOperatorAssociativity(operator);
+      const start = token.position.start;
+      this.tokens.consume();
+      const nextMinPrecedence = associativity === "right" ? precedence : precedence + 1;
+      const right = this.parseBinaryExpression(nextMinPrecedence);
+      left = import_ast.createBinaryOpNode(operator, left, right, right.position?.end ? {
+        start,
+        end: right.position.end
+      } : undefined);
+    }
+    return left;
+  }
+  parseUnaryExpression() {
+    const token = this.tokens.peek();
+    if (token.type === "OPERATOR" && (token.value === "+" || token.value === "-")) {
+      const start = token.position.start;
+      const operator = token.value;
+      this.tokens.consume();
+      const operand = this.parseUnaryExpression();
+      return import_ast.createUnaryOpNode(operator, operand, operand.position ? {
+        start,
+        end: operand.position.end
+      } : undefined);
+    }
+    return this.parsePostfixExpression();
+  }
+  parsePostfixExpression() {
+    let expr = this.parsePrimaryExpression();
+    if (this.tokens.match("OPERATOR") && this.tokens.peek().value === "%") {
+      const token = this.tokens.consume();
+      expr = import_ast.createUnaryOpNode("%", expr, expr.position ? {
+        start: expr.position.start,
+        end: token.position.end
+      } : undefined);
+    }
+    return expr;
+  }
+  parsePrimaryExpression() {
+    const token = this.tokens.peek();
+    const start = token.position.start;
+    switch (token.type) {
+      case "NUMBER":
+        return this.parseNumber();
+      case "STRING":
+        return this.parseString();
+      case "BOOLEAN":
+        return this.parseBoolean();
+      case "ERROR":
+        return this.parseError();
+      case "FUNCTION":
+        return this.parseFunctionCall();
+      case "IDENTIFIER":
+        return this.parseIdentifier();
+      case "INFINITY":
+        const infinityToken = this.tokens.consume();
+        return import_ast.createInfinityNode(infinityToken.position);
+      case "AT":
+        return this.parseCurrentRowReference();
+      case "HASH":
+        return this.parseTableSelector();
+      case "DOLLAR":
+        return this.parseAbsoluteReference();
+      case "LPAREN":
+        return this.parseParenthesizedExpression();
+      case "LBRACE":
+        return this.parseArrayLiteral();
+      case "LBRACKET":
+        if (this.tokens.peekAhead(1)?.type === "AT") {
+          return this.parseCurrentRowReference();
+        } else if (this.tokens.peekAhead(1)?.type === "IDENTIFIER" || this.tokens.peekAhead(1)?.type === "FUNCTION" || this.tokens.peekAhead(1)?.type === "NUMBER" || this.tokens.peekAhead(1)?.type === "HASH") {
+          const lookahead = this.lookAheadForWorkbookReference();
+          if (lookahead.isWorkbookReference) {
+            return this.parseWorkbookReference();
+          }
+          return this.parseBareColumnReference();
+        }
+        throw new ParseError(`Unexpected bracket: ${token.value}`, token.position);
+      default:
+        throw new ParseError(`Unexpected token: ${token.value}`, token.position);
+    }
+  }
+  parseAbsoluteReference() {
+    const start = this.tokens.peek().position.start;
+    let ref = "";
+    ref += this.tokens.consume().value;
+    if (this.tokens.match("IDENTIFIER")) {
+      const identifier = this.tokens.consume().value;
+      const match = identifier.match(/^([A-Z]+)(\d+)$/i);
+      if (match) {
+        ref += identifier;
+      } else if (/^[A-Z]+$/i.test(identifier)) {
+        ref += identifier;
+        if (this.tokens.match("DOLLAR")) {
+          ref += this.tokens.consume().value;
+        }
+        if (this.tokens.match("NUMBER")) {
+          ref += this.tokens.consume().value;
+        } else if (!this.tokens.match("COLON")) {
+          throw new ParseError("Expected row number", this.tokens.peek().position);
+        }
+      } else {
+        throw new ParseError("Invalid cell reference format", this.tokens.peek().position);
+      }
+    } else if (this.tokens.match("NUMBER")) {
+      const number = this.tokens.consume().value;
+      ref += number;
+    } else {
+      throw new ParseError("Expected column letter or row number after $", this.tokens.peek().position);
+    }
+    if (this.tokens.match("COLON")) {
+      this.tokens.consume();
+      const endRef = this.parseRangeEnd();
+      return this.parseRange(ref, endRef, start, this.tokens.peek().position.start);
+    }
+    const cellRef = this.parseCellReferenceString(ref);
+    if (cellRef) {
+      return cellRef;
+    }
+    throw new ParseError(`Invalid cell reference: ${ref}`, {
+      start,
+      end: this.tokens.peek().position.start
+    });
+  }
+  parseNumber() {
+    const token = this.tokens.peek();
+    const start = token.position.start;
+    if (this.tokens.peekNext() && this.tokens.peekNext().type === "COLON") {
+      const startRow = this.tokens.consume().value;
+      this.tokens.consume();
+      let endRow = "";
+      if (this.tokens.match("DOLLAR")) {
+        endRow += this.tokens.consume().value;
+      }
+      if (this.tokens.match("NUMBER")) {
+        endRow += this.tokens.consume().value;
+      } else {
+        throw new ParseError("Expected row number after :", this.tokens.peek().position);
+      }
+      return this.parseRange(startRow, endRow, start, this.tokens.peek().position.start);
+    }
+    this.tokens.consume();
+    const value = parseFloat(token.value);
+    if (isNaN(value)) {
+      throw new ParseError(`Invalid number: ${token.value}`, token.position);
+    }
+    return import_ast.createValueNode({
+      type: "number",
+      value
+    }, {
+      start: token.position.start,
+      end: token.position.end
+    });
+  }
+  parseString() {
+    const token = this.tokens.consume();
+    return import_ast.createValueNode({
+      type: "string",
+      value: token.value
+    }, {
+      start: token.position.start,
+      end: token.position.end
+    });
+  }
+  parseBoolean() {
+    const token = this.tokens.consume();
+    const value = token.value.toUpperCase() === "TRUE";
+    return import_ast.createValueNode({
+      type: "boolean",
+      value
+    }, {
+      start: token.position.start,
+      end: token.position.end
+    });
+  }
+  parseError() {
+    const token = this.tokens.consume();
+    const error = token.value;
+    return import_ast.createErrorNode(error, `Error literal: ${error}`, {
+      start: token.position.start,
+      end: token.position.end
+    });
+  }
+  parseFunctionCall() {
+    const nameToken = this.tokens.consume();
+    const functionName = nameToken.value;
+    const start = nameToken.position.start;
+    if (import_grammar.SPECIAL_FUNCTIONS.has(functionName.toUpperCase()) && !this.tokens.match("LPAREN")) {
+      return import_ast.createFunctionNode(functionName, [], {
+        start,
+        end: nameToken.position.end
+      });
+    }
+    if (!this.tokens.match("LPAREN")) {
+      throw new ParseError(`Expected '(' after function name ${functionName}`, this.tokens.peek().position);
+    }
+    this.tokens.consume();
+    const args = [];
+    if (this.tokens.match("RPAREN")) {
+      const rparenToken = this.tokens.consume();
+      const endPos = rparenToken.position.end;
+      const node = import_ast.createFunctionNode(functionName, args, {
+        start,
+        end: endPos
+      });
+      return node;
+    }
+    while (true) {
+      args.push(this.parseExpression());
+      if (this.tokens.match("COMMA")) {
+        this.tokens.consume();
+      } else if (this.tokens.match("RPAREN")) {
+        const rparenToken = this.tokens.consume();
+        const end = rparenToken.position.end;
+        const node = import_ast.createFunctionNode(functionName, args, {
+          start,
+          end
+        });
+        return node;
+      } else {
+        throw new ParseError(`Expected ',' or ')' in function arguments`, this.tokens.peek().position);
+      }
+    }
+    throw new ParseError("Unexpected end of function argument parsing", this.tokens.peek().position);
+  }
+  parseIdentifier() {
+    const start = this.tokens.peek().position.start;
+    const token = this.tokens.consume();
+    let value = token.value;
+    if (this.tokens.match("COLON")) {
+      const colonPos = this.tokens.getPosition();
+      const nextToken = this.tokens.peekAhead(1);
+      const tokenAfterNext = this.tokens.peekAhead(2);
+      if (nextToken?.type === "IDENTIFIER" && tokenAfterNext?.type === "EXCLAMATION") {
+        this.tokens.consume();
+        const endSheetToken = this.tokens.consume();
+        const endSheet = endSheetToken.value;
+        this.tokens.consume();
+        let startSheet = value;
+        if (startSheet.startsWith("'") && startSheet.endsWith("'")) {
+          startSheet = startSheet.slice(1, -1).replace(/''/g, "'");
+        }
+        let endSheetName = endSheet;
+        if (endSheetName.startsWith("'") && endSheetName.endsWith("'")) {
+          endSheetName = endSheetName.slice(1, -1).replace(/''/g, "'");
+        }
+        const ref = this.parseCellOrRangeAfterSheets();
+        return import_ast.createThreeDRangeNode(startSheet, endSheetName, ref, {
+          start,
+          end: this.tokens.peek().position?.end ?? 0
+        });
+      }
+    }
+    if (this.tokens.match("EXCLAMATION")) {
+      this.tokens.consume();
+      let sheetName = value;
+      if (sheetName.startsWith("'") && sheetName.endsWith("'")) {
+        sheetName = sheetName.slice(1, -1).replace(/''/g, "'");
+      }
+      const cellRef = this.parseCellOrRangeWithSheet(sheetName, start);
+      return cellRef;
+    }
+    if (this.tokens.match("LBRACKET")) {
+      return this.parseTableReference(value, start);
+    }
+    if (this.tokens.match("DOLLAR") && this.isColumnIdentifier(value)) {
+      value += this.tokens.consume().value;
+      if (this.tokens.match("NUMBER")) {
+        value += this.tokens.consume().value;
+      } else {
+        throw new ParseError("Expected row number after $", this.tokens.peek().position);
+      }
+    } else if (this.tokens.match("NUMBER") && this.isColumnIdentifier(value)) {
+      value += this.tokens.consume().value;
+    }
+    if (this.tokens.match("COLON")) {
+      this.tokens.consume();
+      const endStart = this.tokens.peek().position.start;
+      const endRef = this.parseRangeEnd();
+      const endPos = this.tokens.peek().position.start;
+      return this.parseRange(value, endRef, start, endPos);
+    }
+    const parsedCellRef = this.parseCellReferenceString(value);
+    if (parsedCellRef) {
+      return parsedCellRef;
+    }
+    return import_ast.createNamedExpressionNode(value, {
+      start,
+      end: token.position.end
+    });
+  }
+  isColumnIdentifier(str) {
+    return /^[A-Z]+$/i.test(str);
+  }
+  parseRangeEnd() {
+    let result = "";
+    if (this.tokens.match("INFINITY")) {
+      result += this.tokens.consume().value;
+      return result;
+    }
+    if (this.tokens.match("DOLLAR")) {
+      result += this.tokens.consume().value;
+    }
+    if (this.tokens.match("IDENTIFIER")) {
+      result += this.tokens.consume().value;
+      if (this.tokens.match("DOLLAR")) {
+        result += this.tokens.consume().value;
+      }
+      if (this.tokens.match("NUMBER")) {
+        result += this.tokens.consume().value;
+      }
+    } else if (this.tokens.match("NUMBER")) {
+      result += this.tokens.consume().value;
+    } else {
+      throw new ParseError("Expected cell reference, column, row, or INFINITY after :", this.tokens.peek().position);
+    }
+    return result;
+  }
+  parseParenthesizedExpression() {
+    const start = this.tokens.peek().position.start;
+    this.tokens.consume();
+    const expr = this.parseExpression();
+    if (!this.tokens.match("RPAREN")) {
+      throw new ParseError(`Expected ')'`, this.tokens.peek().position);
+    }
+    const end = this.tokens.peek().position.end;
+    this.tokens.consume();
+    if (expr.position) {
+      expr.position.start = start;
+      expr.position.end = end;
+    }
+    return expr;
+  }
+  parseArrayLiteral() {
+    const start = this.tokens.peek().position.start;
+    this.tokens.consume();
+    const rows = [];
+    let currentRow = [];
+    if (this.tokens.match("RBRACE")) {
+      this.tokens.consume();
+      return import_ast.createArrayNode([[import_ast.createEmptyNode()]], {
+        start,
+        end: this.tokens.peek().position.start
+      });
+    }
+    while (true) {
+      currentRow.push(this.parseExpression());
+      if (this.tokens.match("COMMA")) {
+        this.tokens.consume();
+      } else if (this.tokens.match("SEMICOLON")) {
+        this.tokens.consume();
+        rows.push(currentRow);
+        currentRow = [];
+      } else if (this.tokens.match("RBRACE")) {
+        this.tokens.consume();
+        rows.push(currentRow);
+        break;
+      } else {
+        throw new ParseError(`Expected ',', ';', or '}' in array literal`, this.tokens.peek().position);
+      }
+    }
+    if (rows.length > 0 && rows[0]) {
+      const rowLength = rows[0].length;
+      for (let i = 1;i < rows.length; i++) {
+        const row = rows[i];
+        if (row && row.length !== rowLength) {
+          throw new ParseError(`Inconsistent row lengths in array literal`, {
+            start,
+            end: this.tokens.peek().position.start
+          });
+        }
+      }
+    }
+    return import_ast.createArrayNode(rows, {
+      start,
+      end: this.tokens.peek().position.start
+    });
+  }
+  parseCellReferenceString(value) {
+    const parsed = import_grammar.parseCellReference(value);
+    if (!parsed) {
+      return null;
+    }
+    const colNum = import_utils.columnToIndex(parsed.col);
+    const rowNum = parseInt(parsed.row) - 1;
+    if (colNum < 0 || rowNum < 0) {
+      return null;
+    }
+    return import_ast.createReferenceNode({
+      address: {
+        colIndex: colNum,
+        rowIndex: rowNum
+      },
+      isAbsolute: {
+        col: parsed.colAbsolute,
+        row: parsed.rowAbsolute
+      },
+      sheetName: parsed.sheet
+    });
+  }
+  parseTableReference(tableName, startPos) {
+    this.tokens.consume();
+    let selector;
+    let cols;
+    let isCurrentRow = false;
+    if (this.tokens.match("LBRACKET")) {
+      this.tokens.consume();
+      if (this.tokens.match("HASH")) {
+        this.tokens.consume();
+        if (!this.tokens.match("IDENTIFIER")) {
+          throw new ParseError("Expected selector name after #", this.tokens.peek().position);
+        }
+        const selectorName = this.tokens.consume().value;
+        selector = `#${selectorName}`;
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after selector", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+        if (this.tokens.match("COMMA")) {
+          this.tokens.consume();
+          if (!this.tokens.match("LBRACKET")) {
+            throw new ParseError("Expected [ after comma", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          if (!this.tokens.match("IDENTIFIER") && !this.tokens.match("FUNCTION") && !this.tokens.match("NUMBER") && !this.tokens.match("OPERATOR")) {
+            throw new ParseError("Expected column name", this.tokens.peek().position);
+          }
+          const colStart = this.parseColumnName();
+          if (this.tokens.match("COLON") && !this.tokens.peekAhead(1)?.type.match(/RBRACKET/)) {
+            this.tokens.consume();
+            if (!this.tokens.match("IDENTIFIER") && !this.tokens.match("FUNCTION") && !this.tokens.match("NUMBER") && !this.tokens.match("OPERATOR")) {
+              throw new ParseError("Expected end column name after :", this.tokens.peek().position);
+            }
+            const colEnd = this.parseColumnName();
+            cols = {
+              startCol: colStart,
+              endCol: colEnd
+            };
+          } else {
+            cols = {
+              startCol: colStart,
+              endCol: colStart
+            };
+          }
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after column specification", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          if (this.tokens.match("COLON")) {
+            this.tokens.consume();
+            if (!this.tokens.match("LBRACKET")) {
+              throw new ParseError("Expected [ after : in column range", this.tokens.peek().position);
+            }
+            this.tokens.consume();
+            if (!this.tokens.match("IDENTIFIER") && !this.tokens.match("FUNCTION") && !this.tokens.match("NUMBER") && !this.tokens.match("OPERATOR")) {
+              throw new ParseError("Expected end column name", this.tokens.peek().position);
+            }
+            const colEnd = this.parseColumnName();
+            if (!this.tokens.match("RBRACKET")) {
+              throw new ParseError("Expected ] after end column name", this.tokens.peek().position);
+            }
+            this.tokens.consume();
+            cols = {
+              startCol: colStart,
+              endCol: colEnd
+            };
+          }
+        }
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+      } else if (this.tokens.match("IDENTIFIER") || this.tokens.match("FUNCTION") || this.tokens.match("NUMBER") || this.tokens.match("OPERATOR")) {
+        const colStart = this.parseColumnName();
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after column name", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          if (!this.tokens.match("LBRACKET")) {
+            throw new ParseError("Expected [ before second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          const colEnd = this.parseColumnName();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          cols = {
+            startCol: colStart,
+            endCol: colEnd
+          };
+        } else {
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          cols = {
+            startCol: colStart,
+            endCol: colStart
+          };
+        }
+      }
+    } else if (this.tokens.match("AT")) {
+      this.tokens.consume();
+      isCurrentRow = true;
+      if (this.tokens.match("LBRACKET")) {
+        this.tokens.consume();
+        const colStart = this.parseColumnName();
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after column name", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          if (!this.tokens.match("LBRACKET")) {
+            throw new ParseError("Expected [ before second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          const colEnd = this.parseColumnName();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          cols = {
+            startCol: colStart,
+            endCol: colEnd
+          };
+        } else {
+          cols = {
+            startCol: colStart,
+            endCol: colStart
+          };
+        }
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+      } else {
+        const colStart = this.parseColumnName();
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          const colEnd = this.parseColumnName();
+          cols = {
+            startCol: colStart,
+            endCol: colEnd
+          };
+        } else {
+          cols = {
+            startCol: colStart,
+            endCol: colStart
+          };
+        }
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after column reference", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+      }
+    } else if (this.tokens.match("IDENTIFIER") || this.tokens.match("FUNCTION") || this.tokens.match("NUMBER") || this.tokens.match("OPERATOR")) {
+      const colStart = this.parseColumnName();
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const colEnd = this.parseColumnName();
+        cols = {
+          startCol: colStart,
+          endCol: colEnd
+        };
+      } else {
+        cols = {
+          startCol: colStart,
+          endCol: colStart
+        };
+      }
+      if (!this.tokens.match("RBRACKET")) {
+        throw new ParseError("Expected ] after column name", this.tokens.peek().position);
+      }
+      this.tokens.consume();
+    } else if (this.tokens.match("HASH")) {
+      this.tokens.consume();
+      if (!this.tokens.match("IDENTIFIER")) {
+        throw new ParseError("Expected selector name after #", this.tokens.peek().position);
+      }
+      const selectorName = this.tokens.consume().value;
+      selector = `#${selectorName}`;
+      if (!this.tokens.match("RBRACKET")) {
+        throw new ParseError("Expected ] after selector", this.tokens.peek().position);
+      }
+      this.tokens.consume();
+    } else {
+      throw new ParseError("Expected column name or selector in table reference", this.tokens.peek().position);
+    }
+    return import_ast.createStructuredReferenceNode({
+      tableName,
+      cols,
+      selector,
+      isCurrentRow,
+      position: {
+        start: startPos,
+        end: this.tokens.peek().position?.end ?? 0
+      }
+    });
+  }
+  parseTableReferenceWithSheet(tableName, sheetName, startPos) {
+    this.tokens.consume();
+    let selector;
+    let cols;
+    let isCurrentRow = false;
+    if (this.tokens.match("LBRACKET")) {
+      this.tokens.consume();
+      if (this.tokens.match("HASH")) {
+        this.tokens.consume();
+        if (!this.tokens.match("IDENTIFIER")) {
+          throw new ParseError("Expected selector name after #", this.tokens.peek().position);
+        }
+        const selectorName = this.tokens.consume().value;
+        selector = `#${selectorName}`;
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after selector", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+        if (this.tokens.match("COMMA")) {
+          this.tokens.consume();
+          if (!this.tokens.match("LBRACKET")) {
+            throw new ParseError("Expected [ after comma", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          if (!this.tokens.match("IDENTIFIER") && !this.tokens.match("FUNCTION") && !this.tokens.match("NUMBER") && !this.tokens.match("OPERATOR")) {
+            throw new ParseError("Expected column name", this.tokens.peek().position);
+          }
+          const colStart = this.parseColumnName();
+          if (this.tokens.match("COLON") && !this.tokens.peekAhead(1)?.type.match(/RBRACKET/)) {
+            this.tokens.consume();
+            if (!this.tokens.match("IDENTIFIER") && !this.tokens.match("FUNCTION") && !this.tokens.match("NUMBER") && !this.tokens.match("OPERATOR")) {
+              throw new ParseError("Expected end column name after :", this.tokens.peek().position);
+            }
+            const colEnd = this.parseColumnName();
+            cols = {
+              startCol: colStart,
+              endCol: colEnd
+            };
+          } else {
+            cols = {
+              startCol: colStart,
+              endCol: colStart
+            };
+          }
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after column specification", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          if (this.tokens.match("COLON")) {
+            this.tokens.consume();
+            if (!this.tokens.match("LBRACKET")) {
+              throw new ParseError("Expected [ after : in column range", this.tokens.peek().position);
+            }
+            this.tokens.consume();
+            if (!this.tokens.match("IDENTIFIER") && !this.tokens.match("FUNCTION") && !this.tokens.match("NUMBER") && !this.tokens.match("OPERATOR")) {
+              throw new ParseError("Expected end column name", this.tokens.peek().position);
+            }
+            const colEnd = this.parseColumnName();
+            if (!this.tokens.match("RBRACKET")) {
+              throw new ParseError("Expected ] after end column name", this.tokens.peek().position);
+            }
+            this.tokens.consume();
+            cols = {
+              startCol: colStart,
+              endCol: colEnd
+            };
+          }
+        }
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+      } else if (this.tokens.match("IDENTIFIER") || this.tokens.match("FUNCTION") || this.tokens.match("NUMBER") || this.tokens.match("OPERATOR")) {
+        const colStart = this.parseColumnName();
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after column name", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          if (!this.tokens.match("LBRACKET")) {
+            throw new ParseError("Expected [ before second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          const colEnd = this.parseColumnName();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          cols = {
+            startCol: colStart,
+            endCol: colEnd
+          };
+        } else {
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          cols = {
+            startCol: colStart,
+            endCol: colStart
+          };
+        }
+      }
+    } else if (this.tokens.match("AT")) {
+      this.tokens.consume();
+      isCurrentRow = true;
+      if (this.tokens.match("LBRACKET")) {
+        this.tokens.consume();
+        const colStart = this.parseColumnName();
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after column name", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          if (!this.tokens.match("LBRACKET")) {
+            throw new ParseError("Expected [ before second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          const colEnd = this.parseColumnName();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          cols = {
+            startCol: colStart,
+            endCol: colEnd
+          };
+        } else {
+          cols = {
+            startCol: colStart,
+            endCol: colStart
+          };
+        }
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] to close table reference", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+      } else {
+        const colStart = this.parseColumnName();
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          const colEnd = this.parseColumnName();
+          cols = {
+            startCol: colStart,
+            endCol: colEnd
+          };
+        } else {
+          cols = {
+            startCol: colStart,
+            endCol: colStart
+          };
+        }
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] after column reference", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+      }
+    } else if (this.tokens.match("IDENTIFIER") || this.tokens.match("FUNCTION") || this.tokens.match("NUMBER") || this.tokens.match("OPERATOR")) {
+      const colStart = this.parseColumnName();
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const colEnd = this.parseColumnName();
+        cols = {
+          startCol: colStart,
+          endCol: colEnd
+        };
+      } else {
+        cols = {
+          startCol: colStart,
+          endCol: colStart
+        };
+      }
+      if (!this.tokens.match("RBRACKET")) {
+        throw new ParseError("Expected ] after column name", this.tokens.peek().position);
+      }
+      this.tokens.consume();
+    } else if (this.tokens.match("HASH")) {
+      this.tokens.consume();
+      if (!this.tokens.match("IDENTIFIER")) {
+        throw new ParseError("Expected selector name after #", this.tokens.peek().position);
+      }
+      const selectorName = this.tokens.consume().value;
+      selector = `#${selectorName}`;
+      if (!this.tokens.match("RBRACKET")) {
+        throw new ParseError("Expected ] after selector", this.tokens.peek().position);
+      }
+      this.tokens.consume();
+    } else {
+      throw new ParseError("Expected column name or selector in table reference", this.tokens.peek().position);
+    }
+    return import_ast.createStructuredReferenceNode({
+      tableName,
+      sheetName,
+      cols,
+      selector,
+      isCurrentRow,
+      position: {
+        start: startPos,
+        end: this.tokens.peek().position?.end ?? 0
+      }
+    });
+  }
+  parseCellOrRangeAfterSheets() {
+    const start = this.tokens.peek().position?.start ?? 0;
+    if (this.tokens.match("IDENTIFIER")) {
+      const firstIdent = this.tokens.consume().value;
+      const cellRef = this.parseCellReferenceString(firstIdent);
+      if (cellRef) {
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          const endRef = this.parseRangeEnd();
+          const endPos = this.tokens.peek().position?.end ?? 0;
+          const parsed = this.parseRange(firstIdent, endRef, start, endPos);
+          if (parsed.type === "range") {
+            parsed.sheetName = undefined;
+          }
+          return parsed;
+        }
+        if (cellRef.type === "reference") {
+          cellRef.sheetName = undefined;
+        }
+        return cellRef;
+      }
+    }
+    if (this.tokens.match("DOLLAR")) {
+      const dollarStart = this.tokens.getPosition();
+      this.tokens.consume();
+      let ref = "$";
+      if (this.tokens.match("IDENTIFIER")) {
+        const col = this.tokens.consume().value;
+        if (this.isColumnIdentifier(col)) {
+          ref += col;
+        }
+      }
+      if (this.tokens.match("DOLLAR")) {
+        ref += this.tokens.consume().value;
+      }
+      if (this.tokens.match("NUMBER")) {
+        ref += this.tokens.consume().value;
+      }
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const endRef = this.parseRangeEnd();
+        const endPos = this.tokens.peek().position?.end ?? 0;
+        const parsed = this.parseRange(ref, endRef, start, endPos);
+        if (parsed.type === "range") {
+          parsed.sheetName = undefined;
+        }
+        return parsed;
+      }
+      const cellRef = this.parseCellReferenceString(ref);
+      if (!cellRef) {
+        throw new ParseError(`Invalid cell reference: ${ref}`, this.tokens.peek().position);
+      }
+      if (cellRef.type === "reference") {
+        cellRef.sheetName = undefined;
+      }
+      return cellRef;
+    }
+    throw new ParseError("Expected cell or range reference after sheet range", this.tokens.peek().position);
+  }
+  parseCurrentRowReference() {
+    const start = this.tokens.getPosition();
+    if (this.tokens.match("LBRACKET")) {
+      this.tokens.consume();
+      if (!this.tokens.match("AT")) {
+        throw new ParseError("Expected @ after [", this.tokens.peek().position);
+      }
+      this.tokens.consume();
+      let columnName2;
+      if (this.tokens.match("LBRACKET")) {
+        this.tokens.consume();
+        const colStart = this.parseColumnName();
+        if (!this.tokens.match("RBRACKET")) {
+          throw new ParseError("Expected ] to close column name", this.tokens.peek().position);
+        }
+        this.tokens.consume();
+        if (this.tokens.match("COLON")) {
+          this.tokens.consume();
+          if (!this.tokens.match("LBRACKET")) {
+            throw new ParseError("Expected [ before second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          const colEnd = this.parseColumnName();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after second column name", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] to close column range", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          return import_ast.createStructuredReferenceNode({
+            tableName: undefined,
+            cols: {
+              startCol: colStart,
+              endCol: colEnd
+            },
+            isCurrentRow: true,
+            position: {
+              start: this.tokens.getTokens()[start]?.position?.start ?? 0,
+              end: this.tokens.peek().position?.end ?? 0
+            }
+          });
+        } else {
+          if (!this.tokens.match("RBRACKET")) {
+            throw new ParseError("Expected ] after column reference", this.tokens.peek().position);
+          }
+          this.tokens.consume();
+          return import_ast.createStructuredReferenceNode({
+            tableName: undefined,
+            cols: {
+              startCol: colStart,
+              endCol: colStart
+            },
+            isCurrentRow: true,
+            position: {
+              start: this.tokens.getTokens()[start]?.position?.start ?? 0,
+              end: this.tokens.peek().position?.end ?? 0
+            }
+          });
+        }
+      } else {
+        columnName2 = this.parseColumnName();
+      }
+      if (!this.tokens.match("RBRACKET")) {
+        throw new ParseError("Expected ] after column reference", this.tokens.peek().position);
+      }
+      this.tokens.consume();
+      return import_ast.createStructuredReferenceNode({
+        tableName: undefined,
+        cols: {
+          startCol: columnName2,
+          endCol: columnName2
+        },
+        isCurrentRow: true,
+        position: {
+          start: this.tokens.getTokens()[start]?.position?.start ?? 0,
+          end: this.tokens.peek().position?.end ?? 0
+        }
+      });
+    }
+    this.tokens.consume();
+    const columnName = this.parseColumnName();
+    return import_ast.createStructuredReferenceNode({
+      tableName: undefined,
+      cols: {
+        startCol: columnName,
+        endCol: columnName
+      },
+      isCurrentRow: true,
+      position: {
+        start: this.tokens.getTokens()[start]?.position?.start ?? 0,
+        end: this.tokens.peek().position?.end ?? 0
+      }
+    });
+  }
+  parseTableSelector() {
+    const hashToken = this.tokens.consume();
+    if (!this.tokens.match("IDENTIFIER")) {
+      throw new ParseError("Expected selector name after #", this.tokens.peek().position);
+    }
+    const selectorName = this.tokens.consume().value;
+    const selector = `#${selectorName}`;
+    if (!["#All", "#Data", "#Headers"].includes(selector.toUpperCase())) {
+      throw new ParseError(`Invalid table selector: ${selector}`, hashToken.position);
+    }
+    throw new ParseError("Table selector must be part of a table reference", hashToken.position);
+  }
+  parseRangeWithWorkbook(startRef, endRef, workbookName, startPos, endPos) {
+    const rangeNode = this.parseRange(startRef, endRef, startPos, endPos);
+    rangeNode.workbookName = workbookName;
+    return rangeNode;
+  }
+  parseTableReferenceWithWorkbookAndSheet(tableName, workbookName, sheetName, startPos) {
+    const tableRef = this.parseTableReferenceWithSheet(tableName, sheetName, startPos);
+    if (tableRef.type === "structured-reference") {
+      tableRef.workbookName = workbookName;
+    }
+    return tableRef;
+  }
+  parseRange(startRef, endRef, startPos, endPos) {
+    let fullRange = `${startRef}:${endRef}`;
+    let sheetName;
+    const sheetMatch = startRef.match(/^(?:([A-Za-z_][A-Za-z0-9_]*)|'([^']+)')!/);
+    if (sheetMatch) {
+      sheetName = sheetMatch[1] || sheetMatch[2];
+      const infiniteTest = import_grammar.parseInfiniteRange(fullRange);
+      const openEndedTest = import_grammar.parseOpenEndedRange(fullRange);
+      if (infiniteTest || openEndedTest) {} else {
+        const endSheetMatch = endRef.match(/^(?:([A-Za-z_][A-Za-z0-9_]*)|'([^']+)')!/);
+        if (!endSheetMatch && sheetName) {
+          const quotedSheetName = sheetName.includes(" ") ? `'${sheetName}'` : sheetName;
+          endRef = `${quotedSheetName}!${endRef}`;
+          fullRange = `${startRef}:${endRef}`;
+        }
+      }
+    }
+    const infiniteParsed = import_grammar.parseInfiniteRange(fullRange);
+    if (infiniteParsed) {
+      sheetName = sheetName ?? infiniteParsed.sheet;
+      if (infiniteParsed.type === "column") {
+        const startCol2 = import_utils.columnToIndex(infiniteParsed.start);
+        const endCol2 = import_utils.columnToIndex(infiniteParsed.end);
+        if (startCol2 < 0 || endCol2 < 0) {
+          throw new ParseError(`Invalid column range: ${startRef}:${endRef}`, {
+            start: startPos,
+            end: endPos
+          });
+        }
+        const range2 = {
+          start: {
+            col: Math.min(startCol2, endCol2),
+            row: 0
+          },
+          end: {
+            col: {
+              type: "number",
+              value: Math.max(startCol2, endCol2)
+            },
+            row: {
+              type: "infinity",
+              sign: "positive"
+            }
+          }
+        };
+        return import_ast.createRangeNode({
+          sheetName,
+          range: range2,
+          isAbsolute: {
+            start: {
+              col: infiniteParsed.startAbsolute,
+              row: false
+            },
+            end: {
+              col: infiniteParsed.endAbsolute,
+              row: false
+            }
+          },
+          position: {
+            start: startPos,
+            end: endPos
+          }
+        });
+      } else {
+        const startRow2 = parseInt(infiniteParsed.start) - 1;
+        const endRow2 = parseInt(infiniteParsed.end) - 1;
+        if (startRow2 < 0 || endRow2 < 0) {
+          throw new ParseError(`Invalid row range: ${startRef}:${endRef}`, {
+            start: startPos,
+            end: endPos
+          });
+        }
+        const range2 = {
+          start: {
+            col: 0,
+            row: Math.min(startRow2, endRow2)
+          },
+          end: {
+            col: {
+              type: "infinity",
+              sign: "positive"
+            },
+            row: {
+              type: "number",
+              value: Math.max(startRow2, endRow2)
+            }
+          }
+        };
+        return import_ast.createRangeNode({
+          sheetName,
+          range: range2,
+          isAbsolute: {
+            start: {
+              col: false,
+              row: infiniteParsed.startAbsolute
+            },
+            end: {
+              col: false,
+              row: infiniteParsed.endAbsolute
+            }
+          },
+          position: {
+            start: startPos,
+            end: endPos
+          }
+        });
+      }
+    }
+    const openEndedParsed = import_grammar.parseOpenEndedRange(fullRange);
+    if (openEndedParsed) {
+      sheetName = sheetName ?? openEndedParsed.sheet;
+      const startCol2 = import_utils.columnToIndex(openEndedParsed.startCol);
+      const startRow2 = parseInt(openEndedParsed.startRow) - 1;
+      if (startCol2 < 0 || startRow2 < 0) {
+        throw new ParseError(`Invalid range reference: ${startRef}:${endRef}`, {
+          start: startPos,
+          end: endPos
+        });
+      }
+      if (openEndedParsed.type === "infinity") {
+        const range2 = {
+          start: {
+            col: startCol2,
+            row: startRow2
+          },
+          end: {
+            col: {
+              type: "infinity",
+              sign: "positive"
+            },
+            row: {
+              type: "infinity",
+              sign: "positive"
+            }
+          }
+        };
+        return import_ast.createRangeNode({
+          sheetName,
+          range: range2,
+          isAbsolute: {
+            start: {
+              col: openEndedParsed.startColAbsolute,
+              row: openEndedParsed.startRowAbsolute
+            },
+            end: {
+              col: false,
+              row: false
+            }
+          },
+          position: {
+            start: startPos,
+            end: endPos
+          }
+        });
+      } else if (openEndedParsed.type === "column-bounded") {
+        const endCol2 = import_utils.columnToIndex(openEndedParsed.endCol);
+        if (endCol2 < 0) {
+          throw new ParseError(`Invalid column range: ${startRef}:${endRef}`, {
+            start: startPos,
+            end: endPos
+          });
+        }
+        const range2 = {
+          start: {
+            col: Math.min(startCol2, endCol2),
+            row: startRow2
+          },
+          end: {
+            col: {
+              type: "number",
+              value: Math.max(startCol2, endCol2)
+            },
+            row: {
+              type: "infinity",
+              sign: "positive"
+            }
+          }
+        };
+        return import_ast.createRangeNode({
+          sheetName,
+          range: range2,
+          isAbsolute: {
+            start: {
+              col: openEndedParsed.startColAbsolute,
+              row: openEndedParsed.startRowAbsolute
+            },
+            end: {
+              col: openEndedParsed.endColAbsolute,
+              row: false
+            }
+          },
+          position: {
+            start: startPos,
+            end: endPos
+          }
+        });
+      } else if (openEndedParsed.type === "row-bounded") {
+        const endRow2 = parseInt(openEndedParsed.endRow) - 1;
+        if (endRow2 < 0) {
+          throw new ParseError(`Invalid row range: ${startRef}:${endRef}`, {
+            start: startPos,
+            end: endPos
+          });
+        }
+        const range2 = {
+          start: {
+            col: startCol2,
+            row: Math.min(startRow2, endRow2)
+          },
+          end: {
+            col: {
+              type: "infinity",
+              sign: "positive"
+            },
+            row: {
+              type: "number",
+              value: Math.max(startRow2, endRow2)
+            }
+          }
+        };
+        return import_ast.createRangeNode({
+          sheetName,
+          range: range2,
+          isAbsolute: {
+            start: {
+              col: openEndedParsed.startColAbsolute,
+              row: openEndedParsed.startRowAbsolute
+            },
+            end: {
+              col: false,
+              row: openEndedParsed.endRowAbsolute
+            }
+          },
+          position: {
+            start: startPos,
+            end: endPos
+          }
+        });
+      }
+    }
+    const startParsed = import_grammar.parseCellReference(startRef);
+    const endParsed = import_grammar.parseCellReference(endRef);
+    if (!startParsed || !endParsed) {
+      throw new ParseError(`Invalid range reference: ${startRef}:${endRef}`, {
+        start: startPos,
+        end: endPos
+      });
+    }
+    const startSheet = startParsed.sheet;
+    const endSheet = endParsed.sheet;
+    if (startSheet !== endSheet) {
+      throw new ParseError(`Range references must be on the same sheet`, {
+        start: startPos,
+        end: endPos
+      });
+    }
+    sheetName = sheetName ?? startSheet;
+    const startCol = import_utils.columnToIndex(startParsed.col);
+    const startRow = parseInt(startParsed.row) - 1;
+    const endCol = import_utils.columnToIndex(endParsed.col);
+    const endRow = parseInt(endParsed.row) - 1;
+    if (startCol < 0 || startRow < 0 || endCol < 0 || endRow < 0) {
+      throw new ParseError(`Invalid range reference: ${startRef}:${endRef}`, {
+        start: startPos,
+        end: endPos
+      });
+    }
+    const range = {
+      start: {
+        col: Math.min(startCol, endCol),
+        row: Math.min(startRow, endRow)
+      },
+      end: {
+        col: {
+          type: "number",
+          value: Math.max(startCol, endCol)
+        },
+        row: {
+          type: "number",
+          value: Math.max(startRow, endRow)
+        }
+      }
+    };
+    return import_ast.createRangeNode({
+      sheetName,
+      range,
+      isAbsolute: {
+        start: {
+          col: startParsed.colAbsolute,
+          row: startParsed.rowAbsolute
+        },
+        end: {
+          col: endParsed.colAbsolute,
+          row: endParsed.rowAbsolute
+        }
+      },
+      position: {
+        start: startPos,
+        end: endPos
+      }
+    });
+  }
+  parseCellOrRangeWithWorkbookAndSheet(workbookName, sheetName, startPos) {
+    let ref = sheetName.includes(" ") ? `'${sheetName}'!` : sheetName + "!";
+    if (this.tokens.match("DOLLAR")) {
+      ref += this.tokens.consume().value;
+    }
+    if (this.tokens.match("IDENTIFIER")) {
+      const identifier2 = this.tokens.consume();
+      ref += identifier2.value;
+      if (this.tokens.match("LBRACKET")) {
+        return this.parseTableReferenceWithWorkbookAndSheet(identifier2.value, workbookName, sheetName, startPos);
+      }
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const endRef = this.parseRangeEnd();
+        return this.parseRangeWithWorkbook(ref, endRef, workbookName, startPos, this.tokens.peek().position.start);
+      }
+      if (this.tokens.match("DOLLAR")) {
+        ref += this.tokens.consume().value;
+      }
+      if (this.tokens.match("NUMBER")) {
+        ref += this.tokens.consume().value;
+      }
+    } else if (this.tokens.match("NUMBER")) {
+      const number = this.tokens.consume();
+      ref += number.value;
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const endRef = this.parseRangeEnd();
+        return this.parseRangeWithWorkbook(ref, endRef, workbookName, startPos, this.tokens.peek().position.start);
+      }
+    } else {
+      throw new ParseError(`Expected cell reference after [${workbookName}]${sheetName}!`, this.tokens.peek().position);
+    }
+    if (this.tokens.match("COLON")) {
+      this.tokens.consume();
+      const endRef = this.parseRangeEnd();
+      return this.parseRangeWithWorkbook(ref, endRef, workbookName, startPos, this.tokens.peek().position.start);
+    }
+    const cellRef = this.parseCellReferenceString(ref);
+    if (cellRef) {
+      cellRef.workbookName = workbookName;
+      return cellRef;
+    }
+    const sheetPrefix = sheetName.includes(" ") ? `'${sheetName}'!` : `${sheetName}!`;
+    const identifier = ref.substring(sheetPrefix.length);
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+      return import_ast.createNamedExpressionNode(identifier, {
+        start: startPos,
+        end: this.tokens.peek().position.start
+      }, sheetName, workbookName);
+    }
+    throw new ParseError(`Invalid cell reference: ${ref}`, {
+      start: startPos,
+      end: this.tokens.peek().position.start
+    });
+  }
+  parseCellOrRangeWithSheet(sheetName, startPos) {
+    let ref = sheetName.includes(" ") ? `'${sheetName}'!` : sheetName + "!";
+    if (this.tokens.match("DOLLAR")) {
+      ref += this.tokens.consume().value;
+    }
+    if (this.tokens.match("IDENTIFIER")) {
+      const identifier = this.tokens.consume();
+      ref += identifier.value;
+      if (this.tokens.match("LBRACKET")) {
+        return this.parseTableReferenceWithSheet(identifier.value, sheetName, startPos);
+      }
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const endRef = this.parseRangeEnd();
+        return this.parseRange(ref, endRef, startPos, this.tokens.peek().position.start);
+      }
+      if (this.tokens.match("DOLLAR")) {
+        ref += this.tokens.consume().value;
+      }
+      if (this.tokens.match("NUMBER")) {
+        ref += this.tokens.consume().value;
+      }
+    } else if (this.tokens.match("NUMBER")) {
+      const number = this.tokens.consume();
+      ref += number.value;
+      if (this.tokens.match("COLON")) {
+        this.tokens.consume();
+        const endRef = this.parseRangeEnd();
+        return this.parseRange(ref, endRef, startPos, this.tokens.peek().position.start);
+      }
+    } else {
+      throw new ParseError(`Expected cell reference after ${sheetName}!`, this.tokens.peek().position);
+    }
+    if (this.tokens.match("COLON")) {
+      this.tokens.consume();
+      const endRef = this.parseRangeEnd();
+      return this.parseRange(ref, endRef, startPos, this.tokens.peek().position.start);
+    }
+    const cellRef = this.parseCellReferenceString(ref);
+    if (cellRef) {
+      return cellRef;
+    }
+    if (this.tokens.isAtEnd() || !this.tokens.match("IDENTIFIER")) {
+      const sheetPrefix = sheetName.includes(" ") ? `'${sheetName}'!` : `${sheetName}!`;
+      const identifier = ref.substring(sheetPrefix.length);
+      if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
+        return import_ast.createNamedExpressionNode(identifier, {
+          start: startPos,
+          end: this.tokens.peek().position.start
+        }, sheetName);
+      }
+    }
+    throw new ParseError(`Invalid cell reference: ${ref}`, {
+      start: startPos,
+      end: this.tokens.peek().position.start
+    });
+  }
+}
+function parseFormula(formula) {
+  return Parser.parse(formula);
+}
+
+//# debugId=1BD93F3357F24C4664756E2164756E21