vba-runner 0.1.0-alpha.0

package/dist/bin/vba-parse-check.cjs

@@ -0,0 +1,2499 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../src/engine/lexer.ts
+var LexError = class extends Error {
+  constructor(message, line, column) {
+    super(`${message} (line ${line})`);
+    this.line = line;
+    this.column = column;
+    this.name = "LexError";
+  }
+};
+var Lexer = class _Lexer {
+  input = "";
+  pos = 0;
+  line = 1;
+  column = 1;
+  diagnostics = [];
+  // MS-VBAL §3.3.5: name-start-character = Unicode-Letter (Lu,Ll,Lt,Lm,Lo,Nl) | "_"
+  static reUnicodeNameStart = /^[\p{L}\p{Nl}]$/u;
+  // name-continue-character adds Unicode-Combining-Character (Mn,Mc), Digit (Nd), Connector-Punct (Pc)
+  static reUnicodeNameContinue = /^[\p{Mn}\p{Mc}\p{Nd}\p{Pc}]$/u;
+  constructor(input) {
+    this.input = input;
+  }
+  peek() {
+    if (this.pos >= this.input.length) return "\0";
+    return this.input[this.pos];
+  }
+  advance() {
+    if (this.pos >= this.input.length) return "\0";
+    const char = this.input[this.pos++];
+    if (char === "\n") {
+      this.line++;
+      this.column = 1;
+    } else {
+      this.column++;
+    }
+    return char;
+  }
+  isWhitespace(char) {
+    return char === " " || char === "	" || char === "\r";
+  }
+  isAlpha(char) {
+    if (char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_") return true;
+    const code = char.codePointAt(0) ?? 0;
+    return code > 127 && _Lexer.reUnicodeNameStart.test(char);
+  }
+  isAlphaNumeric(char) {
+    if (char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_") return true;
+    if (char >= "0" && char <= "9") return true;
+    const code = char.codePointAt(0) ?? 0;
+    return code > 127 && (_Lexer.reUnicodeNameStart.test(char) || _Lexer.reUnicodeNameContinue.test(char));
+  }
+  isDigit(char) {
+    return char >= "0" && char <= "9";
+  }
+  skipWhitespace() {
+    while (this.isWhitespace(this.peek())) {
+      this.advance();
+    }
+  }
+  getNextToken() {
+    while (true) {
+      this.skipWhitespace();
+      const startLine = this.line;
+      const startColumn = this.column;
+      if (this.pos >= this.input.length) {
+        return { type: 136 /* EOF */, value: "", line: startLine, column: startColumn };
+      }
+      const char = this.peek();
+      if (char === "#") {
+        let foundClosingHash = false;
+        for (let j = this.pos + 1; j < this.input.length; j++) {
+          if (this.input[j] === "#") {
+            foundClosingHash = true;
+            break;
+          }
+          if (this.input[j] === "\n") break;
+        }
+        if (foundClosingHash) {
+          let potentialDate = "";
+          let k = this.pos + 1;
+          while (k < this.input.length && this.input[k] !== "#" && this.input[k] !== "\n") {
+            potentialDate += this.input[k];
+            k++;
+          }
+          const dateRegex = /^[0-9\/\-\s:apm,]+$/i;
+          const monthsRegex = /jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/i;
+          if (dateRegex.test(potentialDate) || monthsRegex.test(potentialDate)) {
+            this.advance();
+            let dateValue = "";
+            while (this.peek() !== "#" && this.peek() !== "\n" && this.peek() !== "\0") {
+              dateValue += this.advance();
+            }
+            if (this.peek() === "#") {
+              this.advance();
+              return { type: 134 /* Date */, value: dateValue, line: startLine, column: startColumn };
+            }
+          }
+        }
+        this.advance();
+        return { type: 111 /* OperatorHash */, value: "#", line: startLine, column: startColumn };
+      }
+      if (char === "_") {
+        const next = this.pos + 1 < this.input.length ? this.input[this.pos + 1] : "\0";
+        const afterCr = next === "\r" && this.pos + 2 < this.input.length ? this.input[this.pos + 2] : "\0";
+        if (next === "\n" || next === "\r" && afterCr === "\n") {
+          this.advance();
+          if (this.peek() === "\r") this.advance();
+          if (this.peek() === "\n") this.advance();
+          continue;
+        }
+        let lookahead = this.pos + 1;
+        while (lookahead < this.input.length && this.input[lookahead] === " ") lookahead++;
+        const afterSpaces = lookahead < this.input.length ? this.input[lookahead] : "\0";
+        if (afterSpaces === "\n" || afterSpaces === "\r" || afterSpaces === "'") {
+          const msg = afterSpaces === "'" ? "\u884C\u7D99\u7D9A\u6587\u5B57 '_' \u306E\u5F8C\u306B\u30B3\u30E1\u30F3\u30C8\u306F\u8A18\u8FF0\u3067\u304D\u307E\u305B\u3093" : "\u884C\u7D99\u7D9A\u6587\u5B57 '_' \u306E\u76F4\u5F8C\u306B\u7A7A\u767D\u3092\u7F6E\u304F\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093";
+          this.advance();
+          while (this.peek() !== "\n" && this.peek() !== "\0") this.advance();
+          if (this.peek() === "\n") this.advance();
+          throw new LexError(msg, startLine, startColumn);
+        }
+      }
+      if (char === "'") {
+        let commentText = "";
+        while (this.peek() !== "\n" && this.peek() !== "\0") {
+          commentText += this.advance();
+        }
+        if (/[ \t]*_[ \t]*$/.test(commentText)) {
+          this.diagnostics.push({
+            message: "\u30B3\u30E1\u30F3\u30C8\u672B\u5C3E\u306E '_' \u306F\u884C\u7D99\u7D9A\u3068\u3057\u3066\u6A5F\u80FD\u3057\u307E\u305B\u3093",
+            line: startLine,
+            column: startColumn + 1 + commentText.lastIndexOf("_")
+          });
+        }
+        continue;
+      }
+      if (char === "\n") {
+        this.advance();
+        return { type: 135 /* Newline */, value: "\n", line: startLine, column: startColumn };
+      }
+      if (char === '"') {
+        this.advance();
+        let strValue = "";
+        while (this.peek() !== "\0") {
+          if (this.peek() === '"') {
+            this.advance();
+            if (this.peek() === '"') {
+              strValue += '"';
+              this.advance();
+            } else {
+              return { type: 2 /* String */, value: strValue, line: startLine, column: startColumn };
+            }
+          } else {
+            strValue += this.advance();
+          }
+        }
+        return { type: 2 /* String */, value: strValue, line: startLine, column: startColumn };
+      }
+      if (char === "=") {
+        this.advance();
+        return { type: 120 /* OperatorEquals */, value: "=", line: startLine, column: startColumn };
+      }
+      if (char === "<") {
+        this.advance();
+        if (this.peek() === ">") {
+          this.advance();
+          return { type: 121 /* OperatorNotEquals */, value: "<>", line: startLine, column: startColumn };
+        }
+        if (this.peek() === "=") {
+          this.advance();
+          return { type: 124 /* OperatorLessThanOrEqual */, value: "<=", line: startLine, column: startColumn };
+        }
+        return { type: 122 /* OperatorLessThan */, value: "<", line: startLine, column: startColumn };
+      }
+      if (char === ">") {
+        this.advance();
+        if (this.peek() === "=") {
+          this.advance();
+          return { type: 125 /* OperatorGreaterThanOrEqual */, value: ">=", line: startLine, column: startColumn };
+        }
+        return { type: 123 /* OperatorGreaterThan */, value: ">", line: startLine, column: startColumn };
+      }
+      if (char === "+") {
+        this.advance();
+        return { type: 112 /* OperatorPlus */, value: "+", line: startLine, column: startColumn };
+      }
+      if (char === "-") {
+        this.advance();
+        return { type: 113 /* OperatorMinus */, value: "-", line: startLine, column: startColumn };
+      }
+      if (char === "!") {
+        this.advance();
+        return { type: 132 /* OperatorExclamation */, value: "!", line: startLine, column: startColumn };
+      }
+      if (char === "&") {
+        this.advance();
+        const next = this.peek().toLowerCase();
+        if (next === "h") {
+          this.advance();
+          let hexStr = "";
+          while (/[0-9a-f]/i.test(this.peek())) {
+            hexStr += this.advance();
+          }
+          return { type: 1 /* Number */, value: "0x" + hexStr, line: startLine, column: startColumn };
+        } else if (next === "o" || this.isDigit(next)) {
+          if (next === "o") this.advance();
+          let octStr = "";
+          while (/[0-7]/.test(this.peek())) {
+            octStr += this.advance();
+          }
+          return { type: 1 /* Number */, value: "0o" + octStr, line: startLine, column: startColumn };
+        }
+        return { type: 117 /* OperatorAmpersand */, value: "&", line: startLine, column: startColumn };
+      }
+      if (char === ",") {
+        this.advance();
+        return { type: 126 /* OperatorComma */, value: ",", line: startLine, column: startColumn };
+      }
+      if (char === "#") {
+        this.advance();
+        return { type: 111 /* OperatorHash */, value: "#", line: startLine, column: startColumn };
+      }
+      if (char === "(") {
+        this.advance();
+        return { type: 127 /* OperatorLParen */, value: "(", line: startLine, column: startColumn };
+      }
+      if (char === ")") {
+        this.advance();
+        return { type: 128 /* OperatorRParen */, value: ")", line: startLine, column: startColumn };
+      }
+      if (char === "[") {
+        this.advance();
+        let foreignStr = "";
+        while (this.peek() !== "]" && this.peek() !== "\n" && this.peek() !== "\r" && this.peek() !== "\0") {
+          foreignStr += this.advance();
+        }
+        if (this.peek() === "]") this.advance();
+        return { type: 138 /* ForeignName */, value: foreignStr, line: startLine, column: startColumn };
+      }
+      if (char === ".") {
+        this.advance();
+        return { type: 129 /* OperatorDot */, value: ".", line: startLine, column: startColumn };
+      }
+      if (char === ":") {
+        this.advance();
+        if (this.peek() === "=") {
+          this.advance();
+          return { type: 131 /* OperatorColonEquals */, value: ":=", line: startLine, column: startColumn };
+        }
+        return { type: 130 /* OperatorColon */, value: ":", line: startLine, column: startColumn };
+      }
+      if (char === ";") {
+        this.advance();
+        return { type: 133 /* OperatorSemicolon */, value: ";", line: startLine, column: startColumn };
+      }
+      if (this.isDigit(char)) {
+        let numStr = "";
+        while (this.isDigit(this.peek())) {
+          numStr += this.advance();
+        }
+        if (this.peek() === ".") {
+          numStr += this.advance();
+          while (this.isDigit(this.peek())) {
+            numStr += this.advance();
+          }
+        }
+        const nextChar = this.peek().toLowerCase();
+        if (nextChar === "e") {
+          numStr += this.advance();
+          if (this.peek() === "+" || this.peek() === "-") {
+            numStr += this.advance();
+          }
+          while (this.isDigit(this.peek())) {
+            numStr += this.advance();
+          }
+        }
+        const peekChar = this.peek();
+        if (["%", "&", "@", "!", "#", "^"].indexOf(peekChar) !== -1) {
+          numStr += this.advance();
+        }
+        return { type: 1 /* Number */, value: numStr, line: startLine, column: startColumn };
+      }
+      if (this.isAlpha(char)) {
+        let idStr = "";
+        while (this.isAlphaNumeric(this.peek())) {
+          idStr += this.advance();
+        }
+        const typeHints = ["$", "%", "&", "#", "@"];
+        if (typeHints.includes(this.peek())) {
+          idStr += this.advance();
+        }
+        const lowerId = idStr.toLowerCase();
+        const lowerBase = lowerId.replace(/[$%&#@]$/, "");
+        if (lowerBase === "rem") {
+          while (this.peek() !== "\n" && this.peek() !== "\0") {
+            this.advance();
+          }
+          continue;
+        }
+        if (lowerBase === "for") return { type: 3 /* KeywordFor */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "to") return { type: 4 /* KeywordTo */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "next") return { type: 5 /* KeywordNext */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "if") return { type: 6 /* KeywordIf */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "then") return { type: 7 /* KeywordThen */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "elseif") return { type: 8 /* KeywordElseIf */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "else") return { type: 9 /* KeywordElse */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "end") return { type: 10 /* KeywordEnd */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "do") return { type: 11 /* KeywordDo */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "while") return { type: 12 /* KeywordWhile */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "wend") return { type: 13 /* KeywordWend */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "loop") return { type: 14 /* KeywordLoop */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "until") return { type: 15 /* KeywordUntil */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "gosub") return { type: 37 /* KeywordGoSub */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "return") return { type: 38 /* KeywordReturn */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "lset") return { type: 39 /* KeywordLSet */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "rset") return { type: 40 /* KeywordRSet */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "stop") return { type: 16 /* KeywordStop */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "sub") return { type: 17 /* KeywordSub */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "function") return { type: 18 /* KeywordFunction */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "property") return { type: 19 /* KeywordProperty */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "get") return { type: 20 /* KeywordGet */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "let") return { type: 21 /* KeywordLet */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "dim") return { type: 22 /* KeywordDim */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "as") return { type: 23 /* KeywordAs */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "new") return { type: 24 /* KeywordNew */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "collection") return { type: 25 /* KeywordCollection */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "like") return { type: 63 /* KeywordLike */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "and") return { type: 26 /* KeywordAnd */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "or") return { type: 27 /* KeywordOr */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "xor") return { type: 64 /* KeywordXor */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "eqv") return { type: 65 /* KeywordEqv */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "imp") return { type: 66 /* KeywordImp */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "not") return { type: 28 /* KeywordNot */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "option") return { type: 29 /* KeywordOption */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "explicit") return { type: 30 /* KeywordExplicit */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "const") return { type: 31 /* KeywordConst */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "set") return { type: 32 /* KeywordSet */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "call") return { type: 33 /* KeywordCall */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "on") return { type: 34 /* KeywordOn */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "error") return { type: 35 /* KeywordError */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "goto") return { type: 36 /* KeywordGoTo */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "erase") return { type: 41 /* KeywordErase */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "redim") return { type: 42 /* KeywordReDim */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "step") return { type: 43 /* KeywordStep */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "empty") return { type: 44 /* KeywordEmpty */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "exit") return { type: 45 /* KeywordExit */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "byref") return { type: 46 /* KeywordByRef */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "byval") return { type: 47 /* KeywordByVal */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "mod") return { type: 118 /* KeywordMod */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "type") return { type: 48 /* KeywordType */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "nothing") return { type: 49 /* KeywordNothing */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "optional") return { type: 50 /* KeywordOptional */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "is") return { type: 51 /* KeywordIs */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "resume") return { type: 52 /* KeywordResume */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "select") return { type: 53 /* KeywordSelect */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "case") return { type: 54 /* KeywordCase */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "each") return { type: 55 /* KeywordEach */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "in") return { type: 56 /* KeywordIn */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "public") return { type: 57 /* KeywordPublic */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "private") return { type: 58 /* KeywordPrivate */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "enum") return { type: 59 /* KeywordEnum */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "typeof") return { type: 62 /* KeywordTypeOf */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "friend") return { type: 60 /* KeywordFriend */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "with") return { type: 61 /* KeywordWith */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "null") return { type: 67 /* KeywordNull */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "static") return { type: 68 /* KeywordStatic */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "class") return { type: 69 /* KeywordClass */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "me") return { type: 70 /* KeywordMe */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "compare") return { type: 71 /* KeywordCompare */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "binary") return { type: 72 /* KeywordBinary */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "text") return { type: 73 /* KeywordText */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "attribute") return { type: 74 /* KeywordAttribute */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "declare") return { type: 75 /* KeywordDeclare */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "lib") return { type: 76 /* KeywordLib */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "alias") return { type: 77 /* KeywordAlias */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "ptrsafe") return { type: 78 /* KeywordPtrSafe */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "open") return { type: 81 /* KeywordOpen */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "close") return { type: 82 /* KeywordClose */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "line") return { type: 83 /* KeywordLine */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "input") return { type: 84 /* KeywordInput */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "print") return { type: 85 /* KeywordPrint */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "put") return { type: 86 /* KeywordPut */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "output") return { type: 87 /* KeywordOutput */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "append") return { type: 88 /* KeywordAppend */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "random") return { type: 89 /* KeywordRandom */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "access") return { type: 90 /* KeywordAccess */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "read") return { type: 91 /* KeywordRead */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "write") return { type: 92 /* KeywordWrite */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "lock") return { type: 93 /* KeywordLock */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "shared") return { type: 94 /* KeywordShared */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "spc") return { type: 95 /* KeywordSpc */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "tab") return { type: 96 /* KeywordTab */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "kill") return { type: 97 /* KeywordKill */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "get") return { type: 20 /* KeywordGet */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "seek") return { type: 98 /* KeywordSeek */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "reset") return { type: 99 /* KeywordReset */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "unlock") return { type: 100 /* KeywordUnlock */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "paramarray") return { type: 101 /* KeywordParamArray */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "module") return { type: 80 /* KeywordModule */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "event") return { type: 102 /* KeywordEvent */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "raiseevent") return { type: 103 /* KeywordRaiseEvent */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "withevents") return { type: 104 /* KeywordWithEvents */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "implements") return { type: 105 /* KeywordImplements */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "appactivate") return { type: 106 /* KeywordAppActivate */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "sendkeys") return { type: 107 /* KeywordSendKeys */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "mid") return { type: 108 /* KeywordMid */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "midb") return { type: 108 /* KeywordMid */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "width") return { type: 109 /* KeywordWidth */, value: idStr, line: startLine, column: startColumn };
+        if (lowerBase === "addressof") return { type: 110 /* KeywordAddressOf */, value: idStr, line: startLine, column: startColumn };
+        return { type: 0 /* Identifier */, value: idStr, line: startLine, column: startColumn };
+      }
+      if (char === "*") {
+        this.advance();
+        return { type: 114 /* OperatorMultiply */, value: "*", line: startLine, column: startColumn };
+      }
+      if (char === "/") {
+        this.advance();
+        return { type: 115 /* OperatorDivide */, value: "/", line: startLine, column: startColumn };
+      }
+      if (char === "\\") {
+        this.advance();
+        return { type: 116 /* OperatorIntDivide */, value: "\\", line: startLine, column: startColumn };
+      }
+      if (char === "^") {
+        this.advance();
+        return { type: 119 /* OperatorPower */, value: "^", line: startLine, column: startColumn };
+      }
+      const unknownChar = this.advance();
+      return { type: 137 /* Unknown */, value: unknownChar, line: startLine, column: startColumn };
+    }
+  }
+  tokenize() {
+    const tokens = [];
+    let token;
+    do {
+      token = this.getNextToken();
+      tokens.push(token);
+    } while (token.type !== 136 /* EOF */);
+    return tokens;
+  }
+};
+
+// ../../src/engine/parser.ts
+var ParseError = class extends Error {
+  constructor(message, line, column) {
+    super(message);
+    this.line = line;
+    this.column = column;
+  }
+};
+var Parser = class _Parser {
+  tokens;
+  pos = 0;
+  parseAsClass;
+  _diagnostics = [];
+  // ---------------------------------------------------------------
+  // §3.3.5.2 contextual keyword Sets
+  //
+  // IDENTIFIER = <any lex-identifier that is not a reserved-identifier>
+  // The following keywords are NOT listed in any <reserved-identifier>
+  // category and are therefore valid IDENTIFIERs outside the specific
+  // syntactic positions where they carry dedicated meaning.
+  // ---------------------------------------------------------------
+  /** file-mode specifiers: Open...For <mode>  (§5.4.5.1 open-stmt) */
+  static CONTEXTUAL_KW_FILE_MODE = /* @__PURE__ */ new Set([
+    87 /* KeywordOutput */,
+    88 /* KeywordAppend */,
+    89 /* KeywordRandom */,
+    72 /* KeywordBinary */
+    // also: Option Compare Binary
+  ]);
+  /** file-access specifiers: Open...Access <access>  (§5.4.5.1 open-stmt) */
+  static CONTEXTUAL_KW_FILE_ACCESS = /* @__PURE__ */ new Set([
+    90 /* KeywordAccess */,
+    91 /* KeywordRead */
+  ]);
+  /** option-statement modifiers: Option Compare/Base/Explicit/Module  (§5.2.2) */
+  static CONTEXTUAL_KW_OPTION = /* @__PURE__ */ new Set([
+    73 /* KeywordText */,
+    // Option Compare Text
+    71 /* KeywordCompare */,
+    // Option Compare ...
+    30 /* KeywordExplicit */,
+    // Option Explicit
+    79 /* KeywordBase */,
+    // Option Base 0|1
+    80 /* KeywordModule */
+    // Option Private Module
+  ]);
+  /** declare-statement modifiers: Declare [PtrSafe]...Lib...Alias  (§5.2.3.1) */
+  static CONTEXTUAL_KW_DECLARE = /* @__PURE__ */ new Set([
+    76 /* KeywordLib */,
+    77 /* KeywordAlias */,
+    78 /* KeywordPtrSafe */
+  ]);
+  /** standalone statements absent from <statement-keyword>  (§3.3.5.2) */
+  static CONTEXTUAL_KW_STMT_ABSENT = /* @__PURE__ */ new Set([
+    43 /* KeywordStep */,
+    // For...Step  (not in <marker-keyword>)
+    108 /* KeywordMid */,
+    // Mid-stmt mode-specifier (§5.4.3.8); also Mid/Mid$/MidB function
+    97 /* KeywordKill */,
+    // Kill <pathname>
+    109 /* KeywordWidth */,
+    // Width #<filenumber>, <width>
+    83 /* KeywordLine */,
+    // Line Input #<filenumber>, <variable>
+    99 /* KeywordReset */,
+    // Reset
+    106 /* KeywordAppActivate */,
+    // AppActivate <title>
+    107 /* KeywordSendKeys */
+    // SendKeys <keys>
+  ]);
+  /** Structural keywords that appear in dedicated lexer token types but are NOT
+   *  listed in any §3.3.5.2 reserved-identifier category.
+   *  They are valid IDENTIFIERs in declaration and expression contexts.
+   *  Note: statement-level dispatch (e.g. Class → parseClassDeclaration) still has
+   *  priority; assignment `Class = x` is disambiguated by a `!= OperatorEquals` guard. */
+  static CONTEXTUAL_KW_STRUCTURAL = /* @__PURE__ */ new Set([
+    69 /* KeywordClass */,
+    // Class declaration keyword (not in spec's statement-keyword list)
+    25 /* KeywordCollection */,
+    // Built-in object type name (not in reserved-identifier list)
+    35 /* KeywordError */,
+    // On Error construct element (not standalone reserved)
+    19 /* KeywordProperty */
+    // Property Get/Set/Let keyword (not in spec's statement-keyword list)
+  ]);
+  /** Union of all contextual keyword groups above.
+   *  Tokens in this Set are valid IDENTIFIERs in Dim declarations,
+   *  expression context, and assignment statements. */
+  static CONTEXTUAL_KW = /* @__PURE__ */ new Set([
+    ..._Parser.CONTEXTUAL_KW_FILE_MODE,
+    ..._Parser.CONTEXTUAL_KW_FILE_ACCESS,
+    ..._Parser.CONTEXTUAL_KW_OPTION,
+    ..._Parser.CONTEXTUAL_KW_DECLARE,
+    ..._Parser.CONTEXTUAL_KW_STMT_ABSENT,
+    ..._Parser.CONTEXTUAL_KW_STRUCTURAL
+  ]);
+  /** <statement-keyword> tokens additionally permitted as IDENTIFIERs in
+   *  expression context (parsePrimary) for practical VBA compatibility —
+   *  e.g. as method names (obj.Print, ws.Get) or file I/O targets.
+   *  These remain <reserved-identifier> per §3.3.5.2. */
+  static COMPAT_KW_EXPR = /* @__PURE__ */ new Set([
+    98 /* KeywordSeek */,
+    // <statement-keyword>
+    84 /* KeywordInput */,
+    // <statement-keyword> / <special-form>
+    85 /* KeywordPrint */,
+    // <statement-keyword>
+    86 /* KeywordPut */,
+    // <statement-keyword>
+    20 /* KeywordGet */,
+    // <statement-keyword>
+    93 /* KeywordLock */,
+    // <statement-keyword>
+    100 /* KeywordUnlock */
+    // <statement-keyword>
+  ]);
+  errorRecovery;
+  /** Returns true if token is a valid IDENTIFIER per §3.3.5.2:
+   *  either a plain lex-identifier or a contextual keyword that is not reserved. */
+  isIdentifier(token) {
+    return token.type === 0 /* Identifier */ || token.type === 138 /* ForeignName */ || _Parser.CONTEXTUAL_KW.has(token.type);
+  }
+  constructor(tokens, options = {}) {
+    this.tokens = tokens;
+    this.parseAsClass = options.parseAsClass;
+    this.errorRecovery = options.errorRecovery ?? false;
+  }
+  // Keywords can appear as property/class names in VBA (e.g. obj.Property, New Collection)
+  isNameToken(token) {
+    return token.type === 0 /* Identifier */ || token.type === 138 /* ForeignName */ || token.type >= 3 /* KeywordFor */ && token.type <= 110 /* KeywordAddressOf */;
+  }
+  recordError(message, token) {
+    const pos = { line: token.line, column: token.column };
+    this._diagnostics.push({ message, loc: { start: pos, end: pos }, severity: "error" });
+  }
+  throwMissingRParen() {
+    const peek = this.peek();
+    if (peek.type === 135 /* Newline */) {
+      const prevToken = this.tokens[Math.max(0, this.pos - 1)];
+      if (prevToken && this.isContinuationEndToken(prevToken.type)) {
+        this.throwError(
+          `\u884C\u7D99\u7D9A\u6587\u5B57 '_' \u304C\u5FC5\u8981\u3067\u3059\uFF08'${prevToken.value}' \u306E\u5F8C\u3067\u6539\u884C\u3055\u308C\u3066\u3044\u307E\u3059\uFF09`,
+          peek
+        );
+      }
+    }
+    this.throwError(`Parse error: Expected ')' at line ${peek.line} `);
+  }
+  isContinuationEndToken(type) {
+    return type === 112 /* OperatorPlus */ || type === 113 /* OperatorMinus */ || type === 114 /* OperatorMultiply */ || type === 115 /* OperatorDivide */ || type === 116 /* OperatorIntDivide */ || type === 119 /* OperatorPower */ || type === 117 /* OperatorAmpersand */ || type === 120 /* OperatorEquals */ || type === 121 /* OperatorNotEquals */ || type === 122 /* OperatorLessThan */ || type === 123 /* OperatorGreaterThan */ || type === 124 /* OperatorLessThanOrEqual */ || type === 125 /* OperatorGreaterThanOrEqual */ || type === 126 /* OperatorComma */ || type === 127 /* OperatorLParen */ || type === 26 /* KeywordAnd */ || type === 27 /* KeywordOr */ || type === 64 /* KeywordXor */ || type === 65 /* KeywordEqv */ || type === 66 /* KeywordImp */ || type === 118 /* KeywordMod */ || type === 63 /* KeywordLike */ || type === 51 /* KeywordIs */ || type === 28 /* KeywordNot */;
+  }
+  tokenDisplay(value) {
+    return value.replace(/\n/g, "<\u6539\u884C>").replace(/\r/g, "<CR>").replace(/\t/g, "<\u30BF\u30D6>");
+  }
+  throwError(message, token) {
+    const peek = this.peek();
+    const t = token ?? (peek.type !== 136 /* EOF */ ? peek : this.tokens[Math.max(0, this.pos - 1)]);
+    throw new ParseError(message, t.line, t.column);
+  }
+  syncToNextTopLevelStatement() {
+    while (this.peek().type !== 136 /* EOF */ && this.peek().type !== 135 /* Newline */) {
+      this.advance();
+    }
+    while (this.isAtEndTerminator()) {
+      this.advance();
+      this.advance();
+      while (this.peek().type !== 136 /* EOF */ && this.peek().type !== 135 /* Newline */) {
+        this.advance();
+      }
+    }
+  }
+  peek(offset = 0) {
+    if (this.pos + offset >= this.tokens.length) {
+      return this.tokens[this.tokens.length - 1];
+    }
+    return this.tokens[this.pos + offset];
+  }
+  advance() {
+    const token = this.peek();
+    this.pos++;
+    return token;
+  }
+  parseOptionCompareStatement() {
+    const modeToken = this.advance();
+    let mode;
+    if (modeToken.type === 72 /* KeywordBinary */) {
+      mode = "Binary";
+    } else if (modeToken.type === 73 /* KeywordText */) {
+      mode = "Text";
+    } else {
+      this.throwError(`Parse error: Expected 'Binary' or 'Text' after 'Option Compare' at line ${modeToken.line}`);
+    }
+    return { type: "OptionCompareStatement", mode };
+  }
+  parseParameter() {
+    let isByVal = false;
+    let isOptional = false;
+    if (this.match(50 /* KeywordOptional */)) {
+      isOptional = true;
+    }
+    let isParamArray = false;
+    if (this.match(101 /* KeywordParamArray */)) {
+      isParamArray = true;
+    }
+    let hasPassingModifier = false;
+    if (this.peek().type === 47 /* KeywordByVal */ || this.peek().type === 46 /* KeywordByRef */) {
+      hasPassingModifier = true;
+      isByVal = this.advance().type === 47 /* KeywordByVal */;
+    }
+    const token = this.peek();
+    if (token.type !== 0 /* Identifier */ && (token.type < 79 /* KeywordBase */ || token.type > 110 /* KeywordAddressOf */)) {
+      this.throwError(`Parse error at line ${token.line}: Expected parameter name (Found ${this.tokenDisplay(token.value)})`);
+    }
+    const nameToken = this.advance();
+    let isArray = false;
+    if (this.match(127 /* OperatorLParen */)) {
+      this.consume(128 /* OperatorRParen */, "Expected ')' after parameter name");
+      isArray = true;
+    }
+    let paramType;
+    if (this.match(23 /* KeywordAs */)) {
+      paramType = this.advance().value;
+      if (this.peek().type === 129 /* OperatorDot */) {
+        this.advance();
+        paramType += "." + this.advance().value;
+      }
+    }
+    let defaultValue;
+    if (this.match(120 /* OperatorEquals */)) {
+      defaultValue = this.parseExpression();
+    }
+    return {
+      type: "Parameter",
+      name: nameToken.value,
+      isByVal,
+      hasPassingModifier,
+      isOptional,
+      isParamArray,
+      isArray,
+      paramType,
+      defaultValue,
+      loc: { start: { line: nameToken.line, column: nameToken.column }, end: { line: nameToken.line, column: nameToken.column + nameToken.value.length } }
+    };
+  }
+  parseAttributeStatement() {
+    this.advance();
+    const name = this.advance().value;
+    this.consume(120 /* OperatorEquals */, "Expected '=' after Attribute name");
+    const value = this.parseExpression();
+    return { type: "AttributeStatement", name, value };
+  }
+  parseOpenStatement() {
+    this.advance();
+    const path2 = this.parseExpression();
+    this.consume(3 /* KeywordFor */, "Expected 'For' in Open statement");
+    let mode = "Random";
+    const modeToken = this.advance();
+    switch (modeToken.type) {
+      case 84 /* KeywordInput */:
+        mode = "Input";
+        break;
+      case 87 /* KeywordOutput */:
+        mode = "Output";
+        break;
+      case 88 /* KeywordAppend */:
+        mode = "Append";
+        break;
+      case 89 /* KeywordRandom */:
+        mode = "Random";
+        break;
+      case 72 /* KeywordBinary */:
+        mode = "Binary";
+        break;
+      default:
+        this.throwError(`Parse error: Invalid Open mode '${modeToken.value}' at line ${modeToken.line}`);
+    }
+    let access = void 0;
+    if (this.match(90 /* KeywordAccess */)) {
+      const first = this.advance();
+      if (first.type === 91 /* KeywordRead */) {
+        if (this.match(92 /* KeywordWrite */)) {
+          access = "Read Write";
+        } else {
+          access = "Read";
+        }
+      } else if (first.type === 92 /* KeywordWrite */) {
+        access = "Write";
+      }
+    }
+    let lock = void 0;
+    if (this.match(93 /* KeywordLock */)) {
+      const first = this.advance();
+      if (first.type === 94 /* KeywordShared */) {
+        lock = "Shared";
+      } else if (first.type === 91 /* KeywordRead */) {
+        if (this.match(92 /* KeywordWrite */)) {
+          lock = "Lock Read Write";
+        } else {
+          lock = "Lock Read";
+        }
+      } else if (first.type === 92 /* KeywordWrite */) {
+        lock = "Lock Write";
+      }
+    }
+    this.consume(23 /* KeywordAs */, "Expected 'As' in Open statement");
+    this.match(111 /* OperatorHash */);
+    const fileNumber = this.parseExpression();
+    return { type: "OpenStatement", path: path2, mode, access, lock, fileNumber };
+  }
+  parseCloseStatement() {
+    this.advance();
+    const fileNumbers = [];
+    while (!this.isAtTerminator()) {
+      this.match(111 /* OperatorHash */);
+      fileNumbers.push(this.parseExpression());
+      if (!this.match(126 /* OperatorComma */)) break;
+    }
+    return { type: "CloseStatement", fileNumbers };
+  }
+  parsePrintStatement() {
+    this.advance();
+    this.consume(111 /* OperatorHash */, "Expected '#' in Print statement");
+    const fileNumber = this.parseExpression();
+    this.consume(126 /* OperatorComma */, "Expected ',' after file number in Print statement");
+    const expressions = [];
+    while (!this.isAtTerminator()) {
+      if (this.match(95 /* KeywordSpc */)) {
+        this.consume(127 /* OperatorLParen */, "Expected '(' after Spc");
+        expressions.push({ type: "Spc", val: this.parseExpression() });
+        this.consume(128 /* OperatorRParen */, "Expected ')' after Spc");
+      } else if (this.match(96 /* KeywordTab */)) {
+        if (this.match(127 /* OperatorLParen */)) {
+          expressions.push({ type: "Tab", val: this.parseExpression() });
+          this.consume(128 /* OperatorRParen */, "Expected ')' after Tab");
+        } else {
+          expressions.push("Tab");
+        }
+      } else if (this.peek().type === 126 /* OperatorComma */) {
+        this.advance();
+        expressions.push("Comma");
+      } else if (this.peek().type === 133 /* OperatorSemicolon */) {
+        this.advance();
+        expressions.push("Semicolon");
+      } else {
+        expressions.push(this.parseExpression());
+      }
+      if (this.isAtTerminator()) break;
+    }
+    return { type: "PrintStatement", fileNumber, expressions };
+  }
+  parseLineInputStatement() {
+    this.advance();
+    this.consume(84 /* KeywordInput */, "Expected 'Input' after 'Line'");
+    this.consume(111 /* OperatorHash */, "Expected '#' in Line Input statement");
+    const fileNumber = this.parseExpression();
+    this.consume(126 /* OperatorComma */, "Expected ',' after file number");
+    const variable = this.parsePrimary();
+    if (variable.type !== "Identifier") {
+      this.throwError(`Parse error: Expected variable name in Line Input at line ${this.peek().line}`);
+    }
+    return { type: "LineInputStatement", fileNumber, variable };
+  }
+  parsePutStatement() {
+    this.advance();
+    this.consume(111 /* OperatorHash */, "Expected '#' in Put statement");
+    const fileNumber = this.parseExpression();
+    this.consume(126 /* OperatorComma */, "Expected ',' after file number");
+    let recordNumber = void 0;
+    if (this.peek().type !== 126 /* OperatorComma */) {
+      recordNumber = this.parseExpression();
+    }
+    this.consume(126 /* OperatorComma */, "Expected second ',' in Put statement");
+    const data = this.parseExpression();
+    return { type: "PutStatement", fileNumber, recordNumber, data };
+  }
+  parseKillStatement() {
+    this.advance();
+    const path2 = this.parseExpression();
+    return { type: "KillStatement", path: path2 };
+  }
+  parseWriteStatement() {
+    this.advance();
+    this.consume(111 /* OperatorHash */, "Expected '#' in Write statement");
+    const fileNumber = this.parseExpression();
+    const items = [];
+    if (this.match(126 /* OperatorComma */)) {
+      while (!this.isAtTerminator()) {
+        items.push(this.parseExpression());
+        if (!this.match(126 /* OperatorComma */)) break;
+      }
+    }
+    return { type: "WriteStatement", fileNumber, items };
+  }
+  parseInputStatement() {
+    this.advance();
+    this.consume(111 /* OperatorHash */, "Expected '#' in Input statement");
+    const fileNumber = this.parseExpression();
+    this.consume(126 /* OperatorComma */, "Expected ',' in Input statement");
+    const variables = [];
+    while (!this.isAtTerminator()) {
+      variables.push(this.parseExpression());
+      if (!this.match(126 /* OperatorComma */)) break;
+    }
+    return { type: "InputStatement", fileNumber, variables };
+  }
+  parseGetStatement() {
+    this.advance();
+    this.consume(111 /* OperatorHash */, "Expected '#' in Get statement");
+    const fileNumber = this.parseExpression();
+    this.consume(126 /* OperatorComma */, "Expected ',' in Get statement");
+    let recordNumber = void 0;
+    if (this.peek().type !== 126 /* OperatorComma */) {
+      recordNumber = this.parseExpression();
+    }
+    this.consume(126 /* OperatorComma */, "Expected ',' in Get statement");
+    const variable = this.parseExpression();
+    return { type: "GetStatement", fileNumber, recordNumber, variable };
+  }
+  parseSeekStatement() {
+    this.advance();
+    this.consume(111 /* OperatorHash */, "Expected '#' in Seek statement");
+    const fileNumber = this.parseExpression();
+    this.consume(126 /* OperatorComma */, "Expected ',' in Seek statement");
+    const position = this.parseExpression();
+    return { type: "SeekStatement", fileNumber, position };
+  }
+  parseResetStatement() {
+    this.advance();
+    return { type: "ResetStatement" };
+  }
+  parseDeclareStatement() {
+    this.advance();
+    let isPtrSafe = false;
+    if (this.peek().type === 78 /* KeywordPtrSafe */) {
+      this.advance();
+      isPtrSafe = true;
+    }
+    let isSub = false;
+    if (this.peek().type === 17 /* KeywordSub */) {
+      this.advance();
+      isSub = true;
+    } else if (this.peek().type === 18 /* KeywordFunction */) {
+      this.advance();
+      isSub = false;
+    } else {
+      this.throwError(`Parser error: Expected Sub or Function after Declare at line ${this.peek().line}`);
+    }
+    const name = this.advance().value;
+    if (this.peek().type !== 76 /* KeywordLib */) {
+      this.throwError(`Parser error: Expected Lib after Declare name at line ${this.peek().line}`);
+    }
+    this.advance();
+    const libName = this.advance().value.replace(/^"|"$/g, "");
+    let aliasName;
+    if (this.peek().type === 77 /* KeywordAlias */) {
+      this.advance();
+      aliasName = this.advance().value.replace(/^"|"$/g, "");
+    }
+    let parameters = [];
+    if (this.peek().type === 127 /* OperatorLParen */) {
+      this.advance();
+      while (this.peek().type !== 128 /* OperatorRParen */ && this.peek().type !== 136 /* EOF */) {
+        parameters.push(this.parseParameter());
+        if (this.peek().type === 126 /* OperatorComma */) {
+          this.advance();
+        }
+      }
+      this.consume(128 /* OperatorRParen */, "Expected ')' after declare parameters");
+    }
+    let returnType;
+    if (!isSub) {
+      if (this.peek().type === 23 /* KeywordAs */) {
+        this.advance();
+        returnType = this.advance().value;
+      }
+    }
+    return {
+      type: "DeclareStatement",
+      isPtrSafe,
+      isSub,
+      name,
+      libName,
+      aliasName,
+      parameters,
+      returnType
+    };
+  }
+  isAtEndTerminator() {
+    const token = this.peek();
+    if (token.type !== 10 /* KeywordEnd */) return false;
+    const next = this.peek(1);
+    return next.type === 17 /* KeywordSub */ || next.type === 18 /* KeywordFunction */ || next.type === 6 /* KeywordIf */ || next.type === 53 /* KeywordSelect */ || next.type === 61 /* KeywordWith */ || next.type === 48 /* KeywordType */ || next.type === 59 /* KeywordEnum */ || next.type === 19 /* KeywordProperty */ || next.type === 69 /* KeywordClass */;
+  }
+  match(expectedType) {
+    if (this.peek().type === expectedType) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+  // Returns true for operators that can ONLY appear in a binary position (never as unary or
+  // argument starters). When one of these follows a greedily-parsed CallExpression in a
+  // statement context, it signals that the `(args)` was actually part of the argument expression.
+  isBinaryOnlyOperator(type) {
+    return type === 114 /* OperatorMultiply */ || type === 115 /* OperatorDivide */ || type === 116 /* OperatorIntDivide */ || type === 119 /* OperatorPower */ || type === 112 /* OperatorPlus */ || type === 113 /* OperatorMinus */ || type === 117 /* OperatorAmpersand */ || type === 121 /* OperatorNotEquals */ || type === 122 /* OperatorLessThan */ || type === 123 /* OperatorGreaterThan */ || type === 124 /* OperatorLessThanOrEqual */ || type === 125 /* OperatorGreaterThanOrEqual */ || type === 118 /* KeywordMod */;
+  }
+  // Returns true if there is whitespace between the previous token and the current token (same line).
+  // Used to distinguish `Foo(arg)` (no space = function-call postfix) from
+  // `Foo (arg)*x` (space = argument expression; `(arg)*x` must be parsed as one expression).
+  hasSpaceBeforeCurrentToken() {
+    if (this.pos <= 0) return false;
+    const cur = this.tokens[this.pos];
+    const prev = this.tokens[this.pos - 1];
+    if (prev.line !== cur.line) return false;
+    return cur.column > prev.column + prev.value.length;
+  }
+  isAtTerminator() {
+    const type = this.peek().type;
+    return type === 135 /* Newline */ || type === 136 /* EOF */ || type === 130 /* OperatorColon */;
+  }
+  consume(expectedType, message) {
+    if (this.peek().type === expectedType) {
+      return this.advance();
+    }
+    this.throwError(`Parse error at line ${this.peek().line}: ${message}`);
+  }
+  skipNewlines() {
+    while (this.match(135 /* Newline */)) {
+    }
+  }
+  // Build a SourceLocation spanning from start token to end token (inclusive).
+  exprLoc(start, end) {
+    return {
+      start: { line: start.line, column: start.column },
+      end: { line: end.line, column: end.column + end.value.length }
+    };
+  }
+  // Returns true if the token can serve as a name (identifier or any keyword).
+  // VBA §5.2.3.3 allows reserved words as UDT/Enum member names (reserved-name-member-dcl).
+  // MS-VBAL §3.3.5: name-start は Unicode-Letter (Lo を含む) も許容するため Unicode フラグを使う。
+  isWordToken(t) {
+    return /^[\p{L}\p{Nl}_][\p{L}\p{Nl}\p{Mn}\p{Mc}\p{Nd}\p{Pc}_]*$/u.test(t.value);
+  }
+  // Create an Identifier node with location from the given token.
+  makeIdentifier(token) {
+    return {
+      type: "Identifier",
+      name: token.value,
+      loc: {
+        start: { line: token.line, column: token.column },
+        end: { line: token.line, column: token.column + token.value.length }
+      }
+    };
+  }
+  parse() {
+    if (this.parseAsClass) {
+      const classDecl = this.parseClassBody(this.parseAsClass, false);
+      return { type: "Program", body: [classDecl], diagnostics: this._diagnostics };
+    }
+    const program = {
+      type: "Program",
+      body: [],
+      diagnostics: this._diagnostics
+    };
+    this.skipNewlines();
+    while (this.peek().type !== 136 /* EOF */) {
+      const startPos = this.pos;
+      const startToken = this.peek();
+      try {
+        const stmt = this.parseStatement();
+        if (stmt) {
+          program.body.push(stmt);
+        }
+      } catch (e) {
+        if (!this.errorRecovery) throw e;
+        const msg = e instanceof Error ? e.message : String(e);
+        if (e instanceof ParseError) {
+          const pos = { line: e.line, column: e.column };
+          this._diagnostics.push({ message: msg, loc: { start: pos, end: pos }, severity: "error" });
+        } else {
+          this.recordError(msg, startToken);
+        }
+        this.syncToNextTopLevelStatement();
+      }
+      if (this.pos === startPos && this.peek().type !== 136 /* EOF */) {
+        if (this.isAtEndTerminator()) {
+          this.advance();
+          this.advance();
+        } else {
+          this.advance();
+        }
+      }
+      this.skipNewlines();
+    }
+    return program;
+  }
+  parseExpressionPublic() {
+    this.skipNewlines();
+    return this.parseExpression();
+  }
+  // §5.4.1: block-statement = statement EOS
+  // checkEOS=false is used only for inline-If bodies where Else/EOF terminate instead of EOS.
+  parseStatement(checkEOS = true) {
+    this.skipNewlines();
+    const startToken = this.peek();
+    const stmt = this.parseStatementInner();
+    if (stmt !== null) {
+      const isLabel = stmt.type === "LabelStatement";
+      if (checkEOS && !isLabel && !this.isAtTerminator()) {
+        this.throwError(`Parse error: unexpected token '${this.peek().value}' after statement at line ${this.peek().line}`);
+      }
+      const endToken = this.tokens[this.pos - 1];
+      if (startToken.line !== void 0) {
+        stmt.line = startToken.line;
+        const startPos = { line: startToken.line, column: startToken.column };
+        const endPos = endToken && endToken.line !== void 0 ? { line: endToken.line, column: endToken.column + endToken.value.length } : startPos;
+        stmt.loc = { start: startPos, end: endPos };
+      }
+    }
+    return stmt;
+  }
+  parseStatementInner() {
+    const token = this.peek();
+    if (token.type === 57 /* KeywordPublic */ || token.type === 58 /* KeywordPrivate */ || token.type === 60 /* KeywordFriend */) {
+      const scope = this.advance().value.toLowerCase();
+      const next = this.peek();
+      if (next.type === 17 /* KeywordSub */ || next.type === 18 /* KeywordFunction */ || next.type === 19 /* KeywordProperty */) {
+        return this.parseProcedureDeclaration(scope, false);
+      }
+      if (next.type === 31 /* KeywordConst */) {
+        const stmt2 = this.parseConstDeclaration();
+        stmt2.scope = scope;
+        return stmt2;
+      }
+      if (next.type === 48 /* KeywordType */) {
+        const stmt2 = this.parseTypeDeclaration();
+        stmt2.scope = scope;
+        return stmt2;
+      }
+      if (next.type === 59 /* KeywordEnum */) {
+        const stmt2 = this.parseEnumDeclaration();
+        stmt2.scope = scope;
+        return stmt2;
+      }
+      if (next.type === 75 /* KeywordDeclare */) {
+        const stmt2 = this.parseDeclareStatement();
+        stmt2.scope = scope;
+        return stmt2;
+      }
+      const stmt = this.parseDimStatement(false, true);
+      if (stmt) {
+        stmt.scope = scope;
+      }
+      return stmt;
+    }
+    if (token.type === 3 /* KeywordFor */) {
+      return this.parseForStatement();
+    } else if (token.type === 6 /* KeywordIf */) {
+      return this.parseIfStatement();
+    } else if (token.type === 11 /* KeywordDo */) {
+      return this.parseDoWhileStatement();
+    } else if (token.type === 12 /* KeywordWhile */) {
+      return this.parseWhileStatement();
+    } else if (token.type === 17 /* KeywordSub */ || token.type === 18 /* KeywordFunction */ || token.type === 19 /* KeywordProperty */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseProcedureDeclaration();
+    } else if (token.type === 68 /* KeywordStatic */) {
+      this.advance();
+      const next = this.peek();
+      if (next.type === 17 /* KeywordSub */ || next.type === 18 /* KeywordFunction */ || next.type === 19 /* KeywordProperty */) {
+        return this.parseProcedureDeclaration(void 0, true);
+      }
+      return this.parseDimStatement(true, true);
+    } else if (token.type === 22 /* KeywordDim */) {
+      return this.parseDimStatement();
+    } else if (token.type === 31 /* KeywordConst */) {
+      return this.parseConstDeclaration();
+    } else if (token.type === 16 /* KeywordStop */) {
+      this.advance();
+      if (!this.isAtTerminator()) {
+        this.throwError(`Parse error: unexpected token after 'Stop'`);
+      }
+      return { type: "StopStatement" };
+    } else if (token.type === 10 /* KeywordEnd */) {
+      if (this.isAtEndTerminator()) {
+        return null;
+      }
+      this.advance();
+      if (!this.isAtTerminator()) {
+        this.throwError(`Parse error: unexpected token after 'End'`);
+      }
+      return { type: "EndStatement" };
+    } else if (token.type === 36 /* KeywordGoTo */) {
+      return this.parseGoToStatement();
+    } else if (token.type === 32 /* KeywordSet */) {
+      return this.parseSetStatement();
+    } else if (token.type === 34 /* KeywordOn */) {
+      const next = this.peek(1);
+      if (next.type === 35 /* KeywordError */) {
+        return this.parseOnErrorStatement();
+      } else {
+        return this.parseOnGoToSubStatement();
+      }
+    } else if (token.type === 35 /* KeywordError */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseErrorStatement();
+    } else if (token.type === 37 /* KeywordGoSub */) {
+      return this.parseGoSubStatement();
+    } else if (token.type === 38 /* KeywordReturn */) {
+      this.advance();
+      return { type: "ReturnStatement" };
+    } else if (token.type === 39 /* KeywordLSet */) {
+      return this.parseLSetStatement();
+    } else if (token.type === 40 /* KeywordRSet */) {
+      return this.parseRSetStatement();
+    } else if (token.type === 45 /* KeywordExit */) {
+      return this.parseExitStatement();
+    } else if (token.type === 41 /* KeywordErase */) {
+      return this.parseEraseStatement();
+    } else if (token.type === 42 /* KeywordReDim */) {
+      return this.parseReDimStatement();
+    } else if (token.type === 52 /* KeywordResume */) {
+      return this.parseResumeStatement();
+    } else if (token.type === 105 /* KeywordImplements */) {
+      return this.parseImplementsDirective();
+    } else if (token.type === 106 /* KeywordAppActivate */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseAppActivateStatement();
+    } else if (token.type === 107 /* KeywordSendKeys */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseSendKeysStatement();
+    } else if (token.type === 29 /* KeywordOption */) {
+      this.advance();
+      if (this.match(71 /* KeywordCompare */)) {
+        return this.parseOptionCompareStatement();
+      }
+      if (this.match(30 /* KeywordExplicit */)) {
+        return { type: "OptionExplicitStatement" };
+      }
+      if (this.peek().type === 0 /* Identifier */ && this.peek().value.toLowerCase() === "base") {
+        this.advance();
+        const baseToken = this.advance();
+        if (baseToken.value === "0" || baseToken.value === "1") {
+          return { type: "OptionBaseStatement", base: parseInt(baseToken.value) };
+        }
+        this.throwError(`Parse error: Option Base must be 0 or 1 at line ${baseToken.line}`);
+      }
+      if (this.match(58 /* KeywordPrivate */)) {
+        this.consume(80 /* KeywordModule */, "Expected 'Module' after 'Option Private'");
+        return { type: "OptionPrivateModuleStatement" };
+      }
+      return null;
+    } else if (token.type === 74 /* KeywordAttribute */) {
+      return this.parseAttributeStatement();
+    } else if (token.type === 75 /* KeywordDeclare */) {
+      return this.parseDeclareStatement();
+    } else if (token.type === 53 /* KeywordSelect */) {
+      return this.parseSelectCaseStatement();
+    } else if (token.type === 61 /* KeywordWith */) {
+      return this.parseWithStatement();
+    } else if (token.type === 48 /* KeywordType */) {
+      return this.parseTypeDeclaration();
+    } else if (token.type === 59 /* KeywordEnum */) {
+      return this.parseEnumDeclaration();
+    } else if (token.type === 81 /* KeywordOpen */) {
+      return this.parseOpenStatement();
+    } else if (token.type === 82 /* KeywordClose */) {
+      return this.parseCloseStatement();
+    } else if (token.type === 83 /* KeywordLine */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseLineInputStatement();
+    } else if (token.type === 85 /* KeywordPrint */) {
+      return this.parsePrintStatement();
+    } else if (token.type === 86 /* KeywordPut */) {
+      return this.parsePutStatement();
+    } else if (token.type === 20 /* KeywordGet */) {
+      return this.parseGetStatement();
+    } else if (token.type === 84 /* KeywordInput */) {
+      return this.parseInputStatement();
+    } else if (token.type === 92 /* KeywordWrite */) {
+      return this.parseWriteStatement();
+    } else if (token.type === 98 /* KeywordSeek */) {
+      return this.parseSeekStatement();
+    } else if (token.type === 99 /* KeywordReset */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseResetStatement();
+    } else if (token.type === 97 /* KeywordKill */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseKillStatement();
+    } else if (token.type === 102 /* KeywordEvent */) {
+      return this.parseEventDeclaration();
+    } else if (token.type === 103 /* KeywordRaiseEvent */) {
+      return this.parseRaiseEventStatement();
+    } else if (token.type === 93 /* KeywordLock */) {
+      return this.parseLockStatement();
+    } else if (token.type === 100 /* KeywordUnlock */) {
+      return this.parseUnlockStatement();
+    } else if (token.type === 109 /* KeywordWidth */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseWidthStatement();
+    } else if (token.type === 69 /* KeywordClass */ && this.peek(1).type !== 120 /* OperatorEquals */) {
+      return this.parseClassDeclaration();
+    } else if (token.type === 33 /* KeywordCall */) {
+      this.advance();
+      const expr = this.parsePrimary();
+      if (expr.type === "CallExpression") {
+        return { type: "CallStatement", expression: expr };
+      } else if (expr.type === "Identifier" || expr.type === "MemberExpression") {
+        return { type: "CallStatement", expression: { type: "CallExpression", callee: expr, args: [] } };
+      }
+      this.throwError(`Parse error: Expected procedure call after 'Call'`);
+    } else if (token.type === 0 /* Identifier */ || token.type === 138 /* ForeignName */ || token.type === 129 /* OperatorDot */ || token.type === 1 /* Number */ || _Parser.CONTEXTUAL_KW.has(token.type)) {
+      if (token.type === 0 /* Identifier */ && this.pos + 1 < this.tokens.length && this.tokens[this.pos + 1].type === 130 /* OperatorColon */) {
+        const labelName = token.value;
+        this.advance();
+        this.advance();
+        return { type: "LabelStatement", label: labelName };
+      } else if (token.type === 1 /* Number */) {
+        const labelName = token.value;
+        this.advance();
+        this.match(130 /* OperatorColon */);
+        return { type: "LabelStatement", label: labelName };
+      }
+      const savedPos = this.pos;
+      const expr = this.parsePrimary();
+      if (this.match(120 /* OperatorEquals */)) {
+        return {
+          type: "AssignmentStatement",
+          left: expr,
+          right: this.parseExpression()
+        };
+      } else {
+        if (expr.type === "CallExpression" && this.isBinaryOnlyOperator(this.peek().type)) {
+          this.pos = savedPos;
+          const callee = this.parsePrimary(
+            /* stopBeforeSpacedLParen= */
+            true
+          );
+          const args3 = [this.parseCallArgument()];
+          while (this.match(126 /* OperatorComma */)) {
+            args3.push(this.parseCallArgument());
+          }
+          return { type: "CallStatement", expression: { type: "CallExpression", callee, args: args3 } };
+        }
+        const args2 = [];
+        if (this.peek().type !== 135 /* Newline */ && this.peek().type !== 136 /* EOF */ && this.peek().type !== 9 /* KeywordElse */ && this.peek().type !== 8 /* KeywordElseIf */ && this.peek().type !== 10 /* KeywordEnd */ && this.peek().type !== 5 /* KeywordNext */ && this.peek().type !== 14 /* KeywordLoop */) {
+          args2.push(this.parseCallArgument());
+          while (this.match(126 /* OperatorComma */)) {
+            args2.push(this.parseCallArgument());
+          }
+        }
+        if (args2.length > 0) {
+          return { type: "CallStatement", expression: { type: "CallExpression", callee: expr, args: args2 } };
+        } else if (expr.type === "CallExpression") {
+          const callExpr = expr;
+          if (callExpr.args.length === 0 && callExpr.callee.type === "Identifier" && !callExpr.callee.foreign) {
+            const line = callExpr.loc?.start.line ?? this.peek().line;
+            this.throwError(`Parse error: syntax error at line ${line}`);
+          }
+          return { type: "CallStatement", expression: callExpr };
+        } else {
+          return { type: "CallStatement", expression: { type: "CallExpression", callee: expr, args: [] } };
+        }
+      }
+    } else if (token.type === 137 /* Unknown */) {
+      this.throwError(`Parse error: Unknown token '${this.tokenDisplay(token.value)}' at line ${token.line}`);
+    } else {
+      this.advance();
+    }
+    return null;
+  }
+  parseProcedureDeclaration(scope, isStatic) {
+    const isFunction = this.peek().type === 18 /* KeywordFunction */;
+    const isProperty = this.peek().type === 19 /* KeywordProperty */;
+    this.advance();
+    let propertyType;
+    if (isProperty) {
+      const typeToken = this.advance();
+      if (typeToken.type === 20 /* KeywordGet */) propertyType = "get";
+      else if (typeToken.type === 21 /* KeywordLet */) propertyType = "let";
+      else if (typeToken.type === 32 /* KeywordSet */) propertyType = "set";
+      else {
+        this.throwError(`Parse error: Expected 'Get', 'Let', or 'Set' after 'Property' at line ${typeToken.line}`);
+      }
+    }
+    const idToken = this.advance();
+    if (!this.isIdentifier(idToken) && (idToken.type < 79 /* KeywordBase */ || idToken.type > 110 /* KeywordAddressOf */)) {
+      this.throwError(`Parse error at line ${idToken.line}: Expected procedure name (Found ${this.tokenDisplay(idToken.value)})`);
+    }
+    const name = this.makeIdentifier(idToken);
+    const parameters = [];
+    let paramsEndColumn;
+    if (this.match(127 /* OperatorLParen */)) {
+      if (this.peek().type !== 128 /* OperatorRParen */) {
+        parameters.push(this.parseParameter());
+        while (this.match(126 /* OperatorComma */)) {
+          parameters.push(this.parseParameter());
+        }
+      }
+      const rParen = this.consume(128 /* OperatorRParen */, "Expected ')' after procedure parameters");
+      paramsEndColumn = rParen.column + 1;
+    }
+    let returnType;
+    if (this.match(23 /* KeywordAs */)) {
+      returnType = this.advance().value;
+      if (this.peek().type === 129 /* OperatorDot */) {
+        this.advance();
+        returnType += "." + this.advance().value;
+      }
+    }
+    if (this.peek().type === 68 /* KeywordStatic */) {
+      this.advance();
+      isStatic = true;
+    }
+    this.skipNewlines();
+    const body = [];
+    const expectedEndStr = isFunction ? "Function" : isProperty ? "Property" : "Sub";
+    while (!this.isAtEndTerminator() && this.peek().type !== 136 /* EOF */) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+      this.skipNewlines();
+    }
+    if (this.peek().type === 10 /* KeywordEnd */) {
+      this.advance();
+      const endToken = this.advance();
+      if (endToken.value.toLowerCase() !== expectedEndStr.toLowerCase()) {
+        this.throwError(`Parse error: Expected '${expectedEndStr}' after 'End' at line ${endToken.line}`);
+      }
+    } else if (this.peek().type === 136 /* EOF */) {
+      this.throwError(`Parse error: Expected 'End ${expectedEndStr}'`);
+    }
+    return { type: "ProcedureDeclaration", isFunction, isProperty, propertyType, name, parameters, returnType, body, scope: scope || "public", isStatic, paramsEndColumn };
+  }
+  parseDimStatement(isStatic = false, keywordConsumed = false) {
+    if (!keywordConsumed && !isStatic) this.advance();
+    const declarations = [];
+    while (true) {
+      let isWithEvents = false;
+      if (this.match(104 /* KeywordWithEvents */)) {
+        isWithEvents = true;
+      }
+      const idToken = this.advance();
+      if (!this.isIdentifier(idToken) && (idToken.type < 79 /* KeywordBase */ || idToken.type > 110 /* KeywordAddressOf */)) {
+        this.throwError(`Parse error at line ${idToken.line}: Expected variable name (Found ${this.tokenDisplay(idToken.value)})`);
+      }
+      const name = this.makeIdentifier(idToken);
+      let isArray = false;
+      let arrayBounds;
+      let isNew = false;
+      let objectType;
+      let arrayEndColumn;
+      if (this.match(127 /* OperatorLParen */)) {
+        isArray = true;
+        if (this.peek().type !== 128 /* OperatorRParen */) {
+          arrayBounds = [];
+          while (true) {
+            let lower;
+            let upper = this.parseExpression();
+            if (this.match(4 /* KeywordTo */)) {
+              lower = upper;
+              upper = this.parseExpression();
+            }
+            arrayBounds.push({ lower, upper });
+            if (!this.match(126 /* OperatorComma */)) {
+              break;
+            }
+          }
+        }
+        const rParenTok = this.peek();
+        if (this.match(128 /* OperatorRParen */)) {
+          arrayEndColumn = rParenTok.column + 1;
+        }
+      }
+      if (this.match(23 /* KeywordAs */)) {
+        if (this.match(24 /* KeywordNew */)) {
+          isNew = true;
+        }
+        const typeToken = this.peek();
+        if (this.isNameToken(typeToken)) {
+          objectType = this.advance().value;
+          if (this.peek().type === 129 /* OperatorDot */) {
+            this.advance();
+            objectType += "." + this.advance().value;
+          }
+        }
+      }
+      declarations.push({ name, isArray, arrayBounds, isNew, isWithEvents, objectType, arrayEndColumn });
+      if (this.match(126 /* OperatorComma */)) {
+        continue;
+      } else {
+        break;
+      }
+    }
+    return { type: "VariableDeclaration", declarations, isStatic };
+  }
+  parseConstDeclaration() {
+    this.advance();
+    const idToken = this.advance();
+    if (!this.isIdentifier(idToken)) this.throwError(`Parse error: Expected identifier after Const at line ${idToken.line}`);
+    const name = this.makeIdentifier(idToken);
+    if (this.match(23 /* KeywordAs */)) {
+      this.advance();
+    }
+    if (!this.match(120 /* OperatorEquals */)) this.throwError(`Parse error: Expected '=' in Const at line ${this.peek().line}`);
+    const value = this.parseExpression();
+    return { type: "ConstDeclaration", name, value };
+  }
+  parseSetStatement() {
+    this.advance();
+    const left = this.parsePrimary();
+    if (!this.match(120 /* OperatorEquals */)) this.throwError(`Parse error: Expected '=' in Set statement at line ${this.peek().line}`);
+    const right = this.parseExpression();
+    return { type: "SetStatement", left, right };
+  }
+  parseOnErrorStatement() {
+    this.advance();
+    if (!this.match(35 /* KeywordError */)) this.throwError(`Parse error: Expected 'Error' after 'On' at line ${this.peek().line}`);
+    let label = "";
+    if (this.match(36 /* KeywordGoTo */)) {
+      const labelToken = this.advance();
+      label = labelToken.value;
+    } else {
+      while (this.peek().type !== 135 /* Newline */ && this.peek().type !== 136 /* EOF */) {
+        label += this.advance().value + " ";
+      }
+      label = label.trim();
+    }
+    return { type: "OnErrorStatement", label };
+  }
+  parseExitStatement() {
+    this.advance();
+    const typeToken = this.advance();
+    let exitType;
+    if (typeToken.type === 3 /* KeywordFor */) {
+      exitType = "For";
+    } else if (typeToken.type === 11 /* KeywordDo */) {
+      exitType = "Do";
+    } else if (typeToken.type === 17 /* KeywordSub */) {
+      exitType = "Sub";
+    } else if (typeToken.type === 18 /* KeywordFunction */) {
+      exitType = "Function";
+    } else if (typeToken.type === 19 /* KeywordProperty */) {
+      exitType = "Property";
+    } else {
+      this.throwError(`Parse error: Expected 'For', 'Do', 'Sub', 'Function', or 'Property' after 'Exit' at line ${typeToken.line}`);
+    }
+    return { type: "ExitStatement", exitType };
+  }
+  parseGoToStatement() {
+    this.advance();
+    const labelToken = this.advance();
+    if (labelToken.type !== 0 /* Identifier */ && labelToken.type !== 1 /* Number */) {
+      this.throwError(`Parse error: Expected identifier or number after 'GoTo' at line ${labelToken.line}`);
+    }
+    return { type: "GoToStatement", label: labelToken.value };
+  }
+  parseResumeStatement() {
+    this.advance();
+    let target = "";
+    while (this.peek().type !== 135 /* Newline */ && this.peek().type !== 136 /* EOF */) {
+      target += this.advance().value;
+    }
+    return { type: "ResumeStatement", target: target.trim() };
+  }
+  parseEraseStatement() {
+    this.advance();
+    const idToken = this.advance();
+    const name = this.makeIdentifier(idToken);
+    return { type: "EraseStatement", name };
+  }
+  parseReDimStatement() {
+    this.advance();
+    let isPreserve = false;
+    if (this.peek().type === 0 /* Identifier */ && this.peek().value.toLowerCase() === "preserve") {
+      isPreserve = true;
+      this.advance();
+    }
+    const idToken = this.advance();
+    const name = this.makeIdentifier(idToken);
+    const bounds = [];
+    if (this.match(127 /* OperatorLParen */)) {
+      if (this.peek().type !== 128 /* OperatorRParen */) {
+        while (true) {
+          let lower;
+          let upper = this.parseExpression();
+          if (this.match(4 /* KeywordTo */)) {
+            lower = upper;
+            upper = this.parseExpression();
+          }
+          bounds.push({ lower, upper });
+          if (!this.match(126 /* OperatorComma */)) {
+            break;
+          }
+        }
+      }
+      this.match(128 /* OperatorRParen */);
+    }
+    let objectType;
+    if (this.match(23 /* KeywordAs */)) {
+      objectType = this.advance().value;
+    }
+    return { type: "ReDimStatement", name, bounds, isPreserve, objectType };
+  }
+  parseTypeDeclaration() {
+    this.advance();
+    const nameToken = this.advance();
+    if (!this.isIdentifier(nameToken)) {
+      this.throwError(`Parse error: Expected identifier after 'Type' at line ${nameToken.line}`);
+    }
+    const typeName = nameToken.value;
+    const members = [];
+    this.skipNewlines();
+    while (this.peek().type !== 10 /* KeywordEnd */ && this.peek().type !== 136 /* EOF */) {
+      const memberNameToken = this.advance();
+      if (!this.isWordToken(memberNameToken)) {
+        this.throwError(`Parse error: Expected member name in Type at line ${memberNameToken.line}`);
+      }
+      if (this.peek().type === 127 /* OperatorLParen */) {
+        this.advance();
+        let depth = 1;
+        while (depth > 0 && this.peek().type !== 136 /* EOF */ && this.peek().type !== 135 /* Newline */) {
+          const t = this.advance();
+          if (t.type === 127 /* OperatorLParen */) depth++;
+          else if (t.type === 128 /* OperatorRParen */) depth--;
+        }
+      }
+      if (!this.match(23 /* KeywordAs */)) {
+        this.throwError(`Parse error: Expected 'As' in Type member declaration at line ${this.peek().line}`);
+      }
+      const memberTypeToken = this.advance();
+      members.push({ name: memberNameToken.value, memberType: memberTypeToken.value });
+      this.skipNewlines();
+    }
+    if (this.peek().type === 10 /* KeywordEnd */) {
+      this.advance();
+      if (!this.match(48 /* KeywordType */)) {
+        this.throwError(`Parse error: Expected 'Type' after 'End' at line ${this.peek().line}`);
+      }
+    }
+    return { type: "TypeDeclaration", name: typeName, members };
+  }
+  parseEnumDeclaration() {
+    this.advance();
+    const nameToken = this.advance();
+    if (!this.isIdentifier(nameToken)) {
+      this.throwError(`Parse error: Expected identifier after 'Enum' at line ${nameToken.line}`);
+    }
+    const name = this.makeIdentifier(nameToken);
+    const members = [];
+    this.skipNewlines();
+    while (this.peek().type !== 10 /* KeywordEnd */ && this.peek().type !== 136 /* EOF */) {
+      const memberNameToken = this.advance();
+      if (!this.isWordToken(memberNameToken)) {
+        this.throwError(`Parse error: Expected member name in Enum at line ${memberNameToken.line}`);
+      }
+      const memberName = this.makeIdentifier(memberNameToken);
+      let value;
+      if (this.match(120 /* OperatorEquals */)) {
+        value = this.parseExpression();
+      }
+      members.push({ name: memberName, value });
+      this.skipNewlines();
+    }
+    if (this.peek().type === 10 /* KeywordEnd */) {
+      this.advance();
+      if (!this.match(59 /* KeywordEnum */)) {
+        this.throwError(`Parse error: Expected 'Enum' after 'End' at line ${this.peek().line}`);
+      }
+    }
+    return { type: "EnumDeclaration", name, members };
+  }
+  parseClassDeclaration() {
+    this.advance();
+    const nameToken = this.advance();
+    if (nameToken.type !== 0 /* Identifier */) {
+      this.throwError(`Parse error: Expected class name after 'Class' at line ${nameToken.line}`);
+    }
+    return this.parseClassBody(nameToken.value, true);
+  }
+  parseClassBody(className, untilEndClass) {
+    const fields = [];
+    const procedures = [];
+    const body = [];
+    this.skipNewlines();
+    while (this.peek().type !== 136 /* EOF */) {
+      if (untilEndClass && this.peek().type === 10 /* KeywordEnd */ && this.peek(1).type === 69 /* KeywordClass */) {
+        break;
+      }
+      const tok = this.peek();
+      if (tok.type === 135 /* Newline */) {
+        this.skipNewlines();
+        continue;
+      }
+      let scope;
+      if (tok.type === 57 /* KeywordPublic */ || tok.type === 58 /* KeywordPrivate */ || tok.type === 60 /* KeywordFriend */) {
+        scope = tok.value.toLowerCase();
+        this.advance();
+      }
+      const inner = this.peek();
+      if (inner.type === 17 /* KeywordSub */ || inner.type === 18 /* KeywordFunction */ || inner.type === 19 /* KeywordProperty */) {
+        const proc = this.parseProcedureDeclaration(scope);
+        proc.moduleName = className;
+        procedures.push(proc);
+        body.push(proc);
+      } else if (inner.type === 22 /* KeywordDim */) {
+        this.advance();
+        const field = this.parseDimStatement(false, true);
+        field.scope = scope ?? "public";
+        fields.push(field);
+        body.push(field);
+      } else if (inner.type === 105 /* KeywordImplements */) {
+        const impl = this.parseImplementsDirective();
+        body.push(impl);
+      } else if (inner.type === 102 /* KeywordEvent */) {
+        const event = this.parseEventDeclaration(scope);
+        body.push(event);
+      } else if (inner.type === 68 /* KeywordStatic */) {
+        this.advance();
+        const field = this.parseDimStatement(true, true);
+        field.scope = scope ?? "public";
+        fields.push(field);
+        body.push(field);
+      } else if (scope !== void 0 && inner.type === 0 /* Identifier */) {
+        const field = this.parseDimStatement(false, true);
+        field.scope = scope;
+        fields.push(field);
+        body.push(field);
+      } else {
+        this.advance();
+      }
+      this.skipNewlines();
+    }
+    if (untilEndClass && this.peek().type === 10 /* KeywordEnd */) {
+      this.advance();
+      if (!this.match(69 /* KeywordClass */)) {
+        this.throwError(`Parse error: Expected 'Class' after 'End' at line ${this.peek().line}`);
+      }
+    }
+    return { type: "ClassDeclaration", name: className, fields, procedures, body };
+  }
+  parseForStatement() {
+    this.advance();
+    if (this.peek().type === 55 /* KeywordEach */) {
+      return this.parseForEachStatementBody();
+    }
+    const idToken = this.advance();
+    if (!this.isIdentifier(idToken)) {
+      this.throwError(`Parse error: Expected identifier after 'For' at line ${idToken.line} `);
+    }
+    const identifier = this.makeIdentifier(idToken);
+    if (!this.match(120 /* OperatorEquals */)) {
+      this.throwError(`Parse error: Expected '=' in For statement at line ${this.peek().line} `);
+    }
+    const startExpr = this.parseExpression();
+    if (!this.match(4 /* KeywordTo */)) {
+      this.throwError(`Parse error: Expected 'To' in For statement at line ${this.peek().line} `);
+    }
+    const endExpr = this.parseExpression();
+    let stepExpr;
+    if (this.match(43 /* KeywordStep */)) {
+      stepExpr = this.parseExpression();
+    }
+    this.skipNewlines();
+    const body = [];
+    while (this.peek().type !== 5 /* KeywordNext */ && this.peek().type !== 136 /* EOF */ && !this.isAtEndTerminator()) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+      this.skipNewlines();
+    }
+    if (!this.match(5 /* KeywordNext */)) {
+      this.throwError(`Parse error: Expected 'Next' at line ${this.peek().line} `);
+    }
+    let nextIdentifier;
+    if (this.isIdentifier(this.peek())) {
+      const nextIdToken = this.advance();
+      nextIdentifier = this.makeIdentifier(nextIdToken);
+      if (nextIdentifier.name.toLowerCase() !== identifier.name.toLowerCase()) {
+        this.throwError(
+          `Compile error: Variable reference not valid in 'Next' (expected '${identifier.name}', got '${nextIdentifier.name}')`,
+          nextIdToken
+        );
+      }
+    }
+    return {
+      type: "ForStatement",
+      identifier,
+      start: startExpr,
+      end: endExpr,
+      step: stepExpr,
+      body,
+      nextIdentifier
+    };
+  }
+  parseForEachStatementBody() {
+    this.advance();
+    const varToken = this.advance();
+    if (!this.isIdentifier(varToken)) {
+      this.throwError(`Parse error: Expected identifier after 'For Each' at line ${varToken.line}`);
+    }
+    const variable = this.makeIdentifier(varToken);
+    if (!this.match(56 /* KeywordIn */)) {
+      this.throwError(`Parse error: Expected 'In' in For Each statement at line ${this.peek().line}`);
+    }
+    const collection = this.parseExpression();
+    this.skipNewlines();
+    const body = [];
+    while (this.peek().type !== 5 /* KeywordNext */ && this.peek().type !== 136 /* EOF */ && !this.isAtEndTerminator()) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+      this.skipNewlines();
+    }
+    if (!this.match(5 /* KeywordNext */)) {
+      this.throwError(`Parse error: Expected 'Next' at line ${this.peek().line}`);
+    }
+    let nextIdentifier;
+    if (this.isIdentifier(this.peek())) {
+      const nextIdToken = this.advance();
+      nextIdentifier = this.makeIdentifier(nextIdToken);
+      if (nextIdentifier.name.toLowerCase() !== variable.name.toLowerCase()) {
+        this.throwError(
+          `Compile error: Variable reference not valid in 'Next' (expected '${variable.name}', got '${nextIdentifier.name}')`,
+          nextIdToken
+        );
+      }
+    }
+    return {
+      type: "ForEachStatement",
+      variable,
+      collection,
+      body,
+      nextIdentifier
+    };
+  }
+  parseIfStatement() {
+    this.advance();
+    const condition = this.parseExpression();
+    if (!this.match(7 /* KeywordThen */)) {
+      this.throwError(`Parse error: Expected 'Then' after condition at line ${this.peek().line}`);
+    }
+    const isMultiLine = this.peek().type === 135 /* Newline */;
+    const consequent = [];
+    let alternate = null;
+    if (!isMultiLine) {
+      while (this.peek().type !== 135 /* Newline */ && this.peek().type !== 136 /* EOF */ && this.peek().type !== 9 /* KeywordElse */) {
+        const stmt = this.parseStatement(false);
+        if (stmt) consequent.push(stmt);
+      }
+      if (this.peek().type === 9 /* KeywordElse */) {
+        this.advance();
+        alternate = [];
+        while (this.peek().type !== 135 /* Newline */ && this.peek().type !== 136 /* EOF */) {
+          const stmt = this.parseStatement(false);
+          if (stmt) alternate.push(stmt);
+        }
+      }
+      return {
+        type: "IfStatement",
+        condition,
+        consequent,
+        alternate
+      };
+    }
+    this.skipNewlines();
+    while (!this.isAtEndTerminator() && this.peek().type !== 9 /* KeywordElse */ && this.peek().type !== 8 /* KeywordElseIf */ && this.peek().type !== 136 /* EOF */) {
+      const stmt = this.parseStatement();
+      if (stmt) consequent.push(stmt);
+      this.skipNewlines();
+    }
+    if (this.peek().type === 8 /* KeywordElseIf */) {
+      alternate = this.parseIfStatement();
+    } else if (this.match(9 /* KeywordElse */)) {
+      this.skipNewlines();
+      alternate = [];
+      while (!this.isAtEndTerminator() && this.peek().type !== 136 /* EOF */) {
+        const stmt = this.parseStatement();
+        if (stmt) alternate.push(stmt);
+        this.skipNewlines();
+      }
+    }
+    if (this.peek().type === 10 /* KeywordEnd */) {
+      this.advance();
+      if (!this.match(6 /* KeywordIf */)) {
+        this.throwError(`Parse error: Expected 'If' after 'End' at line ${this.peek().line}`);
+      }
+    }
+    return {
+      type: "IfStatement",
+      condition,
+      consequent,
+      alternate
+    };
+  }
+  parseDoWhileStatement() {
+    this.advance();
+    let conditionType;
+    let conditionPosition;
+    let condition;
+    if (this.peek().type === 12 /* KeywordWhile */) {
+      this.advance();
+      conditionType = "while";
+      conditionPosition = "pre";
+      condition = this.parseExpression();
+    } else if (this.peek().type === 15 /* KeywordUntil */) {
+      this.advance();
+      conditionType = "until";
+      conditionPosition = "pre";
+      condition = this.parseExpression();
+    }
+    this.skipNewlines();
+    const body = [];
+    while (this.peek().type !== 14 /* KeywordLoop */ && this.peek().type !== 136 /* EOF */ && !this.isAtEndTerminator()) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+      this.skipNewlines();
+    }
+    if (!this.match(14 /* KeywordLoop */)) {
+      this.throwError(`Parse error: Expected 'Loop' at line ${this.peek().line} `);
+    }
+    if (this.peek().type === 12 /* KeywordWhile */) {
+      this.advance();
+      conditionType = "while";
+      conditionPosition = "post";
+      condition = this.parseExpression();
+    } else if (this.peek().type === 15 /* KeywordUntil */) {
+      this.advance();
+      conditionType = "until";
+      conditionPosition = "post";
+      condition = this.parseExpression();
+    }
+    return {
+      type: "DoWhileStatement",
+      conditionType,
+      conditionPosition,
+      condition,
+      body
+    };
+  }
+  parseWhileStatement() {
+    this.advance();
+    const condition = this.parseExpression();
+    this.skipNewlines();
+    const body = [];
+    while (this.peek().type !== 13 /* KeywordWend */ && this.peek().type !== 136 /* EOF */ && !this.isAtEndTerminator()) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+      this.skipNewlines();
+    }
+    if (!this.match(13 /* KeywordWend */)) {
+      this.throwError(`Parse error: Expected 'Wend' at line ${this.peek().line}`);
+    }
+    return { type: "WhileStatement", condition, body };
+  }
+  parseSelectCaseStatement() {
+    this.advance();
+    if (!this.match(54 /* KeywordCase */)) {
+      this.throwError(`Parse error: Expected 'Case' after 'Select' at line ${this.peek().line}`);
+    }
+    const expression = this.parseExpression();
+    this.skipNewlines();
+    const cases = [];
+    let elseBody = null;
+    while (!this.isAtEndTerminator() && this.peek().type !== 136 /* EOF */) {
+      if (this.peek().type !== 54 /* KeywordCase */) {
+        this.throwError(`Parse error: Expected 'Case' in Select Case at line ${this.peek().line}`);
+      }
+      this.advance();
+      if (this.peek().type === 9 /* KeywordElse */) {
+        this.advance();
+        this.skipNewlines();
+        elseBody = [];
+        while (!this.isAtEndTerminator() && this.peek().type !== 54 /* KeywordCase */ && this.peek().type !== 136 /* EOF */) {
+          const stmt = this.parseStatement();
+          if (stmt) elseBody.push(stmt);
+          this.skipNewlines();
+        }
+        continue;
+      }
+      const ranges = [];
+      ranges.push(this.parseRangeClause());
+      while (this.match(126 /* OperatorComma */)) {
+        ranges.push(this.parseRangeClause());
+      }
+      this.skipNewlines();
+      const body = [];
+      while (!this.isAtEndTerminator() && this.peek().type !== 54 /* KeywordCase */ && this.peek().type !== 136 /* EOF */) {
+        const stmt = this.parseStatement();
+        if (stmt) body.push(stmt);
+        this.skipNewlines();
+      }
+      cases.push({ ranges, body });
+    }
+    if (this.peek().type === 10 /* KeywordEnd */) {
+      this.advance();
+      if (!this.match(53 /* KeywordSelect */)) {
+        this.throwError(`Parse error: Expected 'Select' after 'End' at line ${this.peek().line}`);
+      }
+    }
+    return { type: "SelectCaseStatement", expression, cases, elseBody };
+  }
+  parseWithStatement() {
+    this.advance();
+    const expression = this.parseExpression();
+    this.skipNewlines();
+    const body = [];
+    while (!this.isAtEndTerminator() && this.peek().type !== 136 /* EOF */) {
+      const stmt = this.parseStatement();
+      if (stmt) body.push(stmt);
+      this.skipNewlines();
+    }
+    if (this.peek().type === 10 /* KeywordEnd */) {
+      this.advance();
+      if (!this.match(61 /* KeywordWith */)) {
+        this.throwError(`Parse error: Expected 'With' after 'End' at line ${this.peek().line}`);
+      }
+    }
+    return { type: "WithStatement", expression, body };
+  }
+  parseRangeClause() {
+    const isKeyword = this.peek().type === 51 /* KeywordIs */;
+    if (isKeyword) this.advance();
+    const compOp = this.peek();
+    if (compOp.type === 120 /* OperatorEquals */ || compOp.type === 121 /* OperatorNotEquals */ || compOp.type === 122 /* OperatorLessThan */ || compOp.type === 123 /* OperatorGreaterThan */ || compOp.type === 124 /* OperatorLessThanOrEqual */ || compOp.type === 125 /* OperatorGreaterThanOrEqual */) {
+      this.advance();
+      const value = this.parseExpression();
+      return { kind: "comparison", operator: compOp.value, value };
+    }
+    if (isKeyword) {
+      this.throwError(`Parse error: Expected comparison operator after 'Is' at line ${this.peek().line}`);
+    }
+    const startExpr = this.parseExpression();
+    if (this.match(4 /* KeywordTo */)) {
+      const endExpr = this.parseExpression();
+      return { kind: "to", start: startExpr, end: endExpr };
+    }
+    return { kind: "expression", value: startExpr };
+  }
+  parseExpression() {
+    return this.parseLogicalImp();
+  }
+  parseLogicalImp() {
+    let left = this.parseLogicalEqv();
+    while (this.peek().type === 66 /* KeywordImp */) {
+      const operator = this.advance().value;
+      const right = this.parseLogicalEqv();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseLogicalEqv() {
+    let left = this.parseLogicalXor();
+    while (this.peek().type === 65 /* KeywordEqv */) {
+      const operator = this.advance().value;
+      const right = this.parseLogicalXor();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseLogicalXor() {
+    let left = this.parseLogicalOr();
+    while (this.peek().type === 64 /* KeywordXor */) {
+      const operator = this.advance().value;
+      const right = this.parseLogicalOr();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseLogicalOr() {
+    let left = this.parseLogicalAnd();
+    while (this.peek().type === 27 /* KeywordOr */) {
+      const operator = this.advance().value;
+      const right = this.parseLogicalAnd();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseLogicalAnd() {
+    let left = this.parseLogicalNot();
+    while (this.peek().type === 26 /* KeywordAnd */) {
+      const operator = this.advance().value;
+      const right = this.parseLogicalNot();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseLogicalNot() {
+    if (this.peek().type === 28 /* KeywordNot */) {
+      const notTok = this.tokens[this.pos];
+      this.advance();
+      const argument = this.parseEquality();
+      const node = { type: "UnaryExpression", operator: "Not", argument };
+      node.loc = { start: { line: notTok.line, column: notTok.column }, end: argument.loc?.end ?? { line: notTok.line, column: notTok.column } };
+      return node;
+    }
+    return this.parseEquality();
+  }
+  makeBinaryLoc(left, right) {
+    if (!left.loc || !right.loc) return void 0;
+    return { start: left.loc.start, end: right.loc.end };
+  }
+  parseEquality() {
+    let left = this.parseRelational();
+    while (this.peek().type === 120 /* OperatorEquals */ || this.peek().type === 121 /* OperatorNotEquals */ || this.peek().type === 51 /* KeywordIs */ || this.peek().type === 63 /* KeywordLike */) {
+      const operator = this.advance().value;
+      const right = this.parseRelational();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseRelational() {
+    let left = this.parseConcatenation();
+    while (this.peek().type === 122 /* OperatorLessThan */ || this.peek().type === 123 /* OperatorGreaterThan */ || this.peek().type === 124 /* OperatorLessThanOrEqual */ || this.peek().type === 125 /* OperatorGreaterThanOrEqual */) {
+      const operator = this.advance().value;
+      const right = this.parseConcatenation();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseConcatenation() {
+    let left = this.parseAdditive();
+    while (this.peek().type === 117 /* OperatorAmpersand */) {
+      const operator = this.advance().value;
+      const right = this.parseAdditive();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseAdditive() {
+    let left = this.parseModulo();
+    while (this.peek().type === 112 /* OperatorPlus */ || this.peek().type === 113 /* OperatorMinus */) {
+      const operator = this.advance().value;
+      const right = this.parseModulo();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseModulo() {
+    let left = this.parseIntDivision();
+    while (this.peek().type === 118 /* KeywordMod */) {
+      const operator = this.advance().value;
+      const right = this.parseIntDivision();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseIntDivision() {
+    let left = this.parseMultiplicative();
+    while (this.peek().type === 116 /* OperatorIntDivide */) {
+      const operator = this.advance().value;
+      const right = this.parseMultiplicative();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseMultiplicative() {
+    let left = this.parseUnary();
+    while (this.peek().type === 114 /* OperatorMultiply */ || this.peek().type === 115 /* OperatorDivide */) {
+      const operator = this.advance().value;
+      const right = this.parseUnary();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parseUnary() {
+    if (this.peek().type === 113 /* OperatorMinus */ || this.peek().type === 112 /* OperatorPlus */) {
+      const opTok = this.tokens[this.pos];
+      const operator = this.advance().value;
+      const argument = this.parseUnary();
+      const node = { type: "UnaryExpression", operator, argument };
+      node.loc = { start: { line: opTok.line, column: opTok.column }, end: argument.loc?.end ?? { line: opTok.line, column: opTok.column } };
+      return node;
+    }
+    return this.parseExponentiation();
+  }
+  parseExponentiation() {
+    let left = this.parsePrimary();
+    while (this.peek().type === 119 /* OperatorPower */) {
+      const operator = this.advance().value;
+      const right = this.parsePrimary();
+      left = { type: "BinaryExpression", operator, left, right, loc: this.makeBinaryLoc(left, right) };
+    }
+    return left;
+  }
+  parsePrimary(stopBeforeSpacedLParen = false) {
+    const startTok = this.tokens[this.pos];
+    const token = this.advance();
+    let expr;
+    if (token.type === 1 /* Number */) {
+      const m = token.value.match(/[%&@!#^]$/);
+      const typeSuffix = m ? m[0] : void 0;
+      const cleanVal = token.value.replace(/[%&@!#^]$/, "");
+      const isFloat = !cleanVal.startsWith("0x") && !cleanVal.startsWith("0o") && /[.eE]/.test(cleanVal) ? true : void 0;
+      expr = { type: "NumberLiteral", value: Number(cleanVal), typeSuffix, isFloat };
+    } else if (token.type === 2 /* String */) {
+      expr = { type: "StringLiteral", value: token.value };
+    } else if (token.type === 134 /* Date */) {
+      expr = { type: "DateLiteral", value: token.value };
+    } else if (token.type === 138 /* ForeignName */) {
+      expr = { type: "Identifier", name: token.value, foreign: true };
+    } else if (token.type === 0 /* Identifier */ || _Parser.CONTEXTUAL_KW.has(token.type) || _Parser.COMPAT_KW_EXPR.has(token.type)) {
+      expr = { type: "Identifier", name: token.value };
+    } else if (token.type === 110 /* KeywordAddressOf */) {
+      const procName = this.consume(0 /* Identifier */, "Expected procedure name after 'AddressOf'");
+      expr = { type: "AddressOfExpression", procedureName: { type: "Identifier", name: procName.value } };
+    } else if (token.type === 44 /* KeywordEmpty */) {
+      expr = { type: "Identifier", name: token.value };
+    } else if (token.type === 49 /* KeywordNothing */) {
+      expr = { type: "Identifier", name: "Nothing" };
+    } else if (token.type === 67 /* KeywordNull */) {
+      expr = { type: "Identifier", name: "Null" };
+    } else if (token.type === 70 /* KeywordMe */) {
+      expr = { type: "Identifier", name: "Me" };
+    } else if (token.type === 35 /* KeywordError */) {
+      expr = { type: "Identifier", name: "Error" };
+    } else if (token.type === 24 /* KeywordNew */) {
+      const classNameToken = this.advance();
+      if (!this.isNameToken(classNameToken)) {
+        this.throwError(`Parse error: Expected class name after 'New' at line ${classNameToken.line}`);
+      }
+      let className = classNameToken.value;
+      if (this.peek().type === 129 /* OperatorDot */) {
+        this.advance();
+        className += "." + this.advance().value;
+      }
+      expr = { type: "NewExpression", className };
+    } else if (token.type === 127 /* OperatorLParen */) {
+      const innerExpr = this.parseExpression();
+      if (!this.match(128 /* OperatorRParen */)) {
+        this.throwMissingRParen();
+      }
+      expr = { type: "ParenthesizedExpression", expression: innerExpr };
+    } else if (token.type === 62 /* KeywordTypeOf */) {
+      expr = this.parseRelational();
+      if (!this.match(51 /* KeywordIs */)) {
+        this.throwError(`Parse error: Expected 'Is' after 'TypeOf' at line ${this.peek().line}`);
+      }
+      const typeToken = this.advance();
+      if (typeToken.type !== 0 /* Identifier */ && typeToken.type !== 25 /* KeywordCollection */) {
+        this.throwError(`Parse error: Expected type name after 'Is' at line ${typeToken.line}`);
+      }
+      expr = { type: "TypeOfIsExpression", expression: expr, typeName: typeToken.value };
+    } else if (token.type === 129 /* OperatorDot */) {
+      const propToken = this.advance();
+      if (!this.isNameToken(propToken)) {
+        this.throwError(`Parse error: Expected identifier after '.' at line ${propToken.line}`);
+      }
+      const property = { type: "Identifier", name: propToken.value };
+      expr = { type: "ImplicitWithObjectExpression", property };
+    } else if (token.type === 135 /* Newline */) {
+      const prevToken = this.tokens[Math.max(0, this.pos - 2)];
+      if (prevToken && this.isContinuationEndToken(prevToken.type)) {
+        this.throwError(
+          `\u884C\u7D99\u7D9A\u6587\u5B57 '_' \u304C\u5FC5\u8981\u3067\u3059\uFF08'${prevToken.value}' \u306E\u5F8C\u3067\u6539\u884C\u3055\u308C\u3066\u3044\u307E\u3059\uFF09`,
+          token
+        );
+      } else {
+        this.throwError(`Parse error: Unexpected token in expression '${this.tokenDisplay(token.value)}' at line ${token.line} `, token);
+      }
+    } else {
+      this.throwError(`Parse error: Unexpected token in expression '${this.tokenDisplay(token.value)}' at line ${token.line} `, token);
+    }
+    expr.loc = this.exprLoc(startTok, this.tokens[this.pos - 1]);
+    while (true) {
+      if (this.match(129 /* OperatorDot */)) {
+        if (this.peek().type === 136 /* EOF */) this.throwError("Expected property name after '.'");
+        const propToken = this.advance();
+        const property = { type: "Identifier", name: propToken.value };
+        expr = { type: "MemberExpression", object: expr, property };
+        expr.loc = this.exprLoc(startTok, this.tokens[this.pos - 1]);
+      } else if (this.match(132 /* OperatorExclamation */)) {
+        if (this.peek().type === 136 /* EOF */) this.throwError("Expected identifier after '!'");
+        const propToken = this.advance();
+        const property = { type: "Identifier", name: propToken.value };
+        expr = { type: "DictionaryAccessExpression", object: expr, property };
+        expr.loc = this.exprLoc(startTok, this.tokens[this.pos - 1]);
+      } else if (this.peek().type === 127 /* OperatorLParen */) {
+        if (stopBeforeSpacedLParen && this.hasSpaceBeforeCurrentToken()) {
+          break;
+        }
+        this.advance();
+        const args2 = [];
+        if (this.peek().type !== 128 /* OperatorRParen */) {
+          args2.push(this.parseCallArgument());
+          while (this.match(126 /* OperatorComma */)) {
+            args2.push(this.parseCallArgument());
+          }
+        }
+        if (!this.match(128 /* OperatorRParen */)) {
+          this.throwMissingRParen();
+        }
+        expr = { type: "CallExpression", callee: expr, args: args2 };
+        expr.loc = this.exprLoc(startTok, this.tokens[this.pos - 1]);
+      } else {
+        break;
+      }
+    }
+    return expr;
+  }
+  // Parse a call argument, handling named arguments (e.g., shift:=xlUp)
+  parseCallArgument() {
+    const next = this.peek().type;
+    if (next === 126 /* OperatorComma */ || next === 128 /* OperatorRParen */ || this.isAtTerminator()) {
+      return { type: "MissingArgument" };
+    }
+    if (this.pos + 1 < this.tokens.length && this.tokens[this.pos + 1].type === 131 /* OperatorColonEquals */ && typeof this.peek().value === "string" && /^[A-Za-z_]\w*$/.test(this.peek().value)) {
+      const nameToken = this.advance();
+      this.advance();
+      const value = this.parseExpression();
+      return { type: "NamedArgument", name: nameToken.value, value };
+    }
+    return this.parseExpression();
+  }
+  parseOnGoToSubStatement() {
+    this.advance();
+    const expression = this.parseExpression();
+    let isGoSub = false;
+    if (this.match(36 /* KeywordGoTo */)) {
+      isGoSub = false;
+    } else if (this.match(37 /* KeywordGoSub */)) {
+      isGoSub = true;
+    } else {
+      this.throwError(`Parse error: Expected 'GoTo' or 'GoSub' after 'On' expression at line ${this.peek().line}`);
+    }
+    const labels = [];
+    while (true) {
+      const labelToken = this.advance();
+      if (labelToken.type !== 0 /* Identifier */ && labelToken.type !== 1 /* Number */) {
+        this.throwError(`Parse error: Expected label (identifier or number) in On...GoTo/GoSub at line ${labelToken.line}`);
+      }
+      labels.push(labelToken.value);
+      if (!this.match(126 /* OperatorComma */)) {
+        break;
+      }
+    }
+    return { type: "OnGoToSubStatement", expression, isGoSub, labels };
+  }
+  parseGoSubStatement() {
+    this.advance();
+    const labelToken = this.advance();
+    if (labelToken.type !== 0 /* Identifier */ && labelToken.type !== 1 /* Number */) {
+      this.throwError(`Parse error: Expected label after GoSub at line ${labelToken.line}`);
+    }
+    return { type: "GoSubStatement", label: labelToken.value };
+  }
+  parseLSetStatement() {
+    this.advance();
+    const left = this.parsePrimary();
+    if (!this.match(120 /* OperatorEquals */)) {
+      this.throwError(`Parse error: Expected '=' in LSet statement at line ${this.peek().line}`);
+    }
+    const right = this.parseExpression();
+    return { type: "LSetStatement", left, right };
+  }
+  parseRSetStatement() {
+    this.advance();
+    const left = this.parsePrimary();
+    if (!this.match(120 /* OperatorEquals */)) {
+      this.throwError(`Parse error: Expected '=' in RSet statement at line ${this.peek().line}`);
+    }
+    const right = this.parseExpression();
+    return { type: "RSetStatement", left, right };
+  }
+  parseErrorStatement() {
+    this.advance();
+    const errorNumber = this.parseExpression();
+    return { type: "ErrorStatement", errorNumber };
+  }
+  parseEventDeclaration(scope) {
+    this.advance();
+    const idToken = this.consume(0 /* Identifier */, "Expected identifier after 'Event'");
+    const name = { type: "Identifier", name: idToken.value };
+    const parameters = [];
+    if (this.match(127 /* OperatorLParen */)) {
+      if (this.peek().type !== 128 /* OperatorRParen */) {
+        parameters.push(this.parseParameter());
+        while (this.match(126 /* OperatorComma */)) {
+          parameters.push(this.parseParameter());
+        }
+      }
+      this.consume(128 /* OperatorRParen */, "Expected ')' after event parameters");
+    }
+    return { type: "EventDeclaration", name, parameters, scope };
+  }
+  parseRaiseEventStatement() {
+    this.advance();
+    const idToken = this.consume(0 /* Identifier */, "Expected identifier after 'RaiseEvent'");
+    const eventName = { type: "Identifier", name: idToken.value };
+    const args2 = [];
+    if (this.match(127 /* OperatorLParen */)) {
+      if (this.peek().type !== 128 /* OperatorRParen */) {
+        args2.push(this.parseExpression());
+        while (this.match(126 /* OperatorComma */)) {
+          args2.push(this.parseExpression());
+        }
+      }
+      this.consume(128 /* OperatorRParen */, "Expected ')' after RaiseEvent arguments");
+    }
+    return { type: "RaiseEventStatement", eventName, args: args2 };
+  }
+  parseImplementsDirective() {
+    this.advance();
+    const idToken = this.consume(0 /* Identifier */, "Expected interface name after 'Implements'");
+    return { type: "ImplementsDirective", interfaceName: idToken.value };
+  }
+  parseAppActivateStatement() {
+    this.advance();
+    const title = this.parseExpression();
+    let wait;
+    if (this.match(126 /* OperatorComma */)) {
+      wait = this.parseExpression();
+    }
+    return { type: "AppActivateStatement", title, wait };
+  }
+  parseSendKeysStatement() {
+    this.advance();
+    const keys = this.parseExpression();
+    let wait;
+    if (this.match(126 /* OperatorComma */)) {
+      wait = this.parseExpression();
+    }
+    return { type: "SendKeysStatement", keys, wait };
+  }
+  parseLockStatement() {
+    this.advance();
+    this.match(111 /* OperatorHash */);
+    const fileNumber = this.parseExpression();
+    let recordRange;
+    if (this.match(126 /* OperatorComma */)) {
+      const start = this.parseExpression();
+      let end;
+      if (this.match(4 /* KeywordTo */)) {
+        end = this.parseExpression();
+      }
+      recordRange = { start, end };
+    }
+    return { type: "LockStatement", fileNumber, recordRange };
+  }
+  parseUnlockStatement() {
+    this.advance();
+    this.match(111 /* OperatorHash */);
+    const fileNumber = this.parseExpression();
+    let recordRange;
+    if (this.match(126 /* OperatorComma */)) {
+      const start = this.parseExpression();
+      let end;
+      if (this.match(4 /* KeywordTo */)) {
+        end = this.parseExpression();
+      }
+      recordRange = { start, end };
+    }
+    return { type: "UnlockStatement", fileNumber, recordRange };
+  }
+  parseWidthStatement() {
+    this.advance();
+    this.consume(111 /* OperatorHash */, "Expected '#' after Width");
+    const fileNumber = this.parseExpression();
+    this.consume(126 /* OperatorComma */, "Expected ',' after file number");
+    const width = this.parseExpression();
+    return { type: "WidthStatement", fileNumber, width };
+  }
+};
+
+// ../../test-libs/vba-parse-check.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+function checkFile(filePath) {
+  const src = fs.readFileSync(filePath, "utf8");
+  const diags = [];
+  const lexer = new Lexer(src);
+  let tokens;
+  try {
+    tokens = lexer.tokenize();
+  } catch (e) {
+    if (e instanceof LexError) {
+      return [{
+        file: filePath,
+        line: e.line,
+        column: e.column,
+        severity: "error",
+        source: "lexer",
+        message: e.message.replace(/ \(line \d+\)$/, "")
+      }];
+    }
+    throw e;
+  }
+  for (const d of lexer.diagnostics) {
+    diags.push({
+      file: filePath,
+      line: d.line,
+      column: d.column,
+      severity: "error",
+      source: "lexer",
+      message: d.message
+    });
+  }
+  const ast = new Parser(tokens, { errorRecovery: true }).parse();
+  for (const d of ast.diagnostics) {
+    diags.push({
+      file: filePath,
+      line: d.loc.start.line,
+      column: d.loc.start.column,
+      severity: d.severity === "error" ? "error" : "warning",
+      source: "parser",
+      message: d.message
+    });
+  }
+  return diags;
+}
+function collectFiles(target) {
+  const stat = fs.statSync(target);
+  if (stat.isFile()) return [target];
+  return fs.readdirSync(target).filter((f) => /\.(bas|cls|frm)$/i.test(f)).map((f) => path.join(target, f));
+}
+var args = process.argv.slice(2);
+var jsonMode = args.includes("--json");
+var targets = args.filter((a) => !a.startsWith("--"));
+if (targets.length === 0) {
+  process.stderr.write("Usage: vba-parse-check <file|dir> [--json]\n");
+  process.exit(1);
+}
+var allDiags = [];
+for (const target of targets) {
+  for (const file of collectFiles(target)) {
+    allDiags.push(...checkFile(file));
+  }
+}
+if (jsonMode) {
+  process.stdout.write(JSON.stringify(allDiags, null, 2) + "\n");
+} else {
+  if (allDiags.length === 0) {
+    process.stdout.write("No errors found.\n");
+  } else {
+    for (const d of allDiags) {
+      process.stdout.write(
+        `${d.file}:${d.line}:${d.column}: ${d.severity} [${d.source}] ${d.message}
+`
+      );
+    }
+    process.exit(1);
+  }
+}