vba-runner 0.1.0-alpha.0

package/dist/bin/vba-formatter.cjs

@@ -0,0 +1,1012 @@
+#!/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
+));
+
+// ../../test-libs/vba-formatter.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
+// ../../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/lsp/formatter.ts
+var KEYWORD_CANONICAL = /* @__PURE__ */ new Map([
+  [22 /* KeywordDim */, "Dim"],
+  [17 /* KeywordSub */, "Sub"],
+  [18 /* KeywordFunction */, "Function"],
+  [19 /* KeywordProperty */, "Property"],
+  [20 /* KeywordGet */, "Get"],
+  [21 /* KeywordLet */, "Let"],
+  [32 /* KeywordSet */, "Set"],
+  [10 /* KeywordEnd */, "End"],
+  [6 /* KeywordIf */, "If"],
+  [7 /* KeywordThen */, "Then"],
+  [9 /* KeywordElse */, "Else"],
+  [8 /* KeywordElseIf */, "ElseIf"],
+  [3 /* KeywordFor */, "For"],
+  [4 /* KeywordTo */, "To"],
+  [43 /* KeywordStep */, "Step"],
+  [5 /* KeywordNext */, "Next"],
+  [55 /* KeywordEach */, "Each"],
+  [56 /* KeywordIn */, "In"],
+  [11 /* KeywordDo */, "Do"],
+  [14 /* KeywordLoop */, "Loop"],
+  [12 /* KeywordWhile */, "While"],
+  [13 /* KeywordWend */, "Wend"],
+  [15 /* KeywordUntil */, "Until"],
+  [61 /* KeywordWith */, "With"],
+  [53 /* KeywordSelect */, "Select"],
+  [54 /* KeywordCase */, "Case"],
+  [48 /* KeywordType */, "Type"],
+  [59 /* KeywordEnum */, "Enum"],
+  [69 /* KeywordClass */, "Class"],
+  [57 /* KeywordPublic */, "Public"],
+  [58 /* KeywordPrivate */, "Private"],
+  [60 /* KeywordFriend */, "Friend"],
+  [68 /* KeywordStatic */, "Static"],
+  [31 /* KeywordConst */, "Const"],
+  [23 /* KeywordAs */, "As"],
+  [24 /* KeywordNew */, "New"],
+  [47 /* KeywordByVal */, "ByVal"],
+  [46 /* KeywordByRef */, "ByRef"],
+  [50 /* KeywordOptional */, "Optional"],
+  [101 /* KeywordParamArray */, "ParamArray"],
+  [33 /* KeywordCall */, "Call"],
+  [45 /* KeywordExit */, "Exit"],
+  [38 /* KeywordReturn */, "Return"],
+  [36 /* KeywordGoTo */, "GoTo"],
+  [37 /* KeywordGoSub */, "GoSub"],
+  [34 /* KeywordOn */, "On"],
+  [35 /* KeywordError */, "Error"],
+  [52 /* KeywordResume */, "Resume"],
+  [42 /* KeywordReDim */, "ReDim"],
+  [41 /* KeywordErase */, "Erase"],
+  [28 /* KeywordNot */, "Not"],
+  [26 /* KeywordAnd */, "And"],
+  [27 /* KeywordOr */, "Or"],
+  [64 /* KeywordXor */, "Xor"],
+  [65 /* KeywordEqv */, "Eqv"],
+  [66 /* KeywordImp */, "Imp"],
+  [118 /* KeywordMod */, "Mod"],
+  [51 /* KeywordIs */, "Is"],
+  [63 /* KeywordLike */, "Like"],
+  [49 /* KeywordNothing */, "Nothing"],
+  [44 /* KeywordEmpty */, "Empty"],
+  [67 /* KeywordNull */, "Null"],
+  [70 /* KeywordMe */, "Me"],
+  [29 /* KeywordOption */, "Option"],
+  [30 /* KeywordExplicit */, "Explicit"],
+  [79 /* KeywordBase */, "Base"],
+  [71 /* KeywordCompare */, "Compare"],
+  [16 /* KeywordStop */, "Stop"],
+  [81 /* KeywordOpen */, "Open"],
+  [82 /* KeywordClose */, "Close"],
+  [85 /* KeywordPrint */, "Print"],
+  [84 /* KeywordInput */, "Input"],
+  [87 /* KeywordOutput */, "Output"],
+  [88 /* KeywordAppend */, "Append"],
+  [89 /* KeywordRandom */, "Random"],
+  [90 /* KeywordAccess */, "Access"],
+  [91 /* KeywordRead */, "Read"],
+  [92 /* KeywordWrite */, "Write"],
+  [93 /* KeywordLock */, "Lock"],
+  [94 /* KeywordShared */, "Shared"],
+  [75 /* KeywordDeclare */, "Declare"],
+  [76 /* KeywordLib */, "Lib"],
+  [77 /* KeywordAlias */, "Alias"],
+  [78 /* KeywordPtrSafe */, "PtrSafe"],
+  [105 /* KeywordImplements */, "Implements"],
+  [102 /* KeywordEvent */, "Event"],
+  [103 /* KeywordRaiseEvent */, "RaiseEvent"],
+  [104 /* KeywordWithEvents */, "WithEvents"],
+  [62 /* KeywordTypeOf */, "TypeOf"],
+  [110 /* KeywordAddressOf */, "AddressOf"],
+  [25 /* KeywordCollection */, "Collection"],
+  [39 /* KeywordLSet */, "LSet"],
+  [40 /* KeywordRSet */, "RSet"],
+  [108 /* KeywordMid */, "Mid"],
+  [97 /* KeywordKill */, "Kill"],
+  [98 /* KeywordSeek */, "Seek"],
+  [99 /* KeywordReset */, "Reset"],
+  [100 /* KeywordUnlock */, "Unlock"],
+  [109 /* KeywordWidth */, "Width"],
+  [83 /* KeywordLine */, "Line"],
+  [86 /* KeywordPut */, "Put"],
+  [74 /* KeywordAttribute */, "Attribute"],
+  [80 /* KeywordModule */, "Module"],
+  [95 /* KeywordSpc */, "Spc"],
+  [96 /* KeywordTab */, "Tab"],
+  [106 /* KeywordAppActivate */, "AppActivate"],
+  [107 /* KeywordSendKeys */, "SendKeys"],
+  [72 /* KeywordBinary */, "Binary"],
+  [73 /* KeywordText */, "Text"]
+]);
+var PARAM_INTRO = /* @__PURE__ */ new Set([
+  127 /* OperatorLParen */,
+  126 /* OperatorComma */,
+  46 /* KeywordByRef */,
+  47 /* KeywordByVal */,
+  50 /* KeywordOptional */,
+  101 /* KeywordParamArray */
+]);
+function collectParamNames(tokens, startIdx, define) {
+  let i = startIdx;
+  while (i < tokens.length && tokens[i].type !== 127 /* OperatorLParen */) {
+    if (i > startIdx + 2) return;
+    i++;
+  }
+  i++;
+  let depth = 1;
+  while (i < tokens.length && depth > 0) {
+    const t = tokens[i];
+    if (t.type === 127 /* OperatorLParen */) {
+      depth++;
+      i++;
+      continue;
+    }
+    if (t.type === 128 /* OperatorRParen */) {
+      depth--;
+      i++;
+      continue;
+    }
+    if (depth === 1 && t.type === 0 /* Identifier */) {
+      const prev = tokens[i - 1];
+      if (prev && PARAM_INTRO.has(prev.type)) define(t.value);
+    }
+    i++;
+  }
+}
+function collectDefinitions(source) {
+  const moduleDefs = /* @__PURE__ */ new Map();
+  const procs = [];
+  let tokens;
+  try {
+    tokens = new Lexer(source).tokenize().filter((t) => t.type !== 135 /* Newline */ && t.type !== 136 /* EOF */);
+  } catch {
+    return { moduleDefs, procs };
+  }
+  const defModule = (name) => {
+    if (!moduleDefs.has(name.toLowerCase())) moduleDefs.set(name.toLowerCase(), name);
+  };
+  let currentProc = null;
+  const defLocal = (name) => {
+    const map = currentProc?.defs ?? moduleDefs;
+    if (!map.has(name.toLowerCase())) map.set(name.toLowerCase(), name);
+  };
+  let inTypeOrEnum = false;
+  let prevLine = -1;
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i];
+    const next = tokens[i + 1];
+    if (inTypeOrEnum) {
+      if (t.type === 10 /* KeywordEnd */) {
+        if (next?.type === 48 /* KeywordType */ || next?.type === 59 /* KeywordEnum */) {
+          inTypeOrEnum = false;
+        }
+        prevLine = t.line;
+        continue;
+      }
+      if (t.type === 0 /* Identifier */ && t.line !== prevLine) {
+        defModule(t.value);
+      }
+      prevLine = t.line;
+      continue;
+    }
+    if (ACCESS_MODIFIERS.has(t.type)) continue;
+    if (t.type === 10 /* KeywordEnd */) {
+      if (next?.type === 17 /* KeywordSub */ || next?.type === 18 /* KeywordFunction */ || next?.type === 19 /* KeywordProperty */) {
+        if (currentProc) {
+          procs.push({ startLine: currentProc.startLine, endLine: next.line, defs: currentProc.defs });
+          currentProc = null;
+        }
+      }
+      if (next?.type === 48 /* KeywordType */ || next?.type === 59 /* KeywordEnum */) {
+        inTypeOrEnum = false;
+      }
+      continue;
+    }
+    switch (t.type) {
+      case 22 /* KeywordDim */:
+      case 31 /* KeywordConst */:
+      case 68 /* KeywordStatic */: {
+        if (next?.type === 0 /* Identifier */) defLocal(next.value);
+        break;
+      }
+      case 42 /* KeywordReDim */: {
+        const skip = next?.value?.toLowerCase() === "preserve" ? tokens[i + 2] : next;
+        if (skip?.type === 0 /* Identifier */) defLocal(skip.value);
+        break;
+      }
+      case 17 /* KeywordSub */:
+      case 18 /* KeywordFunction */: {
+        if (next?.type === 0 /* Identifier */) {
+          defModule(next.value);
+          currentProc = { startLine: t.line, defs: /* @__PURE__ */ new Map() };
+          collectParamNames(tokens, i + 2, (name) => defLocal(name));
+        }
+        break;
+      }
+      case 19 /* KeywordProperty */: {
+        let nameIdx = i + 1;
+        const verb = tokens[nameIdx]?.value?.toLowerCase();
+        if (verb === "get" || verb === "let" || verb === "set") nameIdx++;
+        if (tokens[nameIdx]?.type === 0 /* Identifier */) {
+          defModule(tokens[nameIdx].value);
+          currentProc = { startLine: t.line, defs: /* @__PURE__ */ new Map() };
+          collectParamNames(tokens, nameIdx + 1, (name) => defLocal(name));
+        }
+        break;
+      }
+      case 48 /* KeywordType */:
+      case 59 /* KeywordEnum */: {
+        if (next?.type === 0 /* Identifier */) defModule(next.value);
+        inTypeOrEnum = true;
+        break;
+      }
+    }
+  }
+  return { moduleDefs, procs };
+}
+function format(source, options = {}) {
+  const indentSize = options.indentSize ?? 4;
+  const indentChar = options.indentChar ?? " ";
+  const doKeywordCase = options.keywordCase !== false;
+  const unit = indentChar.repeat(indentSize);
+  const physicalLines = source.split("\n");
+  const scopedDefs = collectDefinitions(source);
+  const keywordChangesByLine = /* @__PURE__ */ new Map();
+  {
+    let tokens;
+    try {
+      tokens = new Lexer(source).tokenize();
+    } catch {
+      tokens = [];
+    }
+    for (const token of tokens) {
+      let canonical;
+      if (doKeywordCase) {
+        canonical = KEYWORD_CANONICAL.get(token.type);
+      }
+      if (!canonical && token.type === 0 /* Identifier */) {
+        const lv = token.value.toLowerCase();
+        const proc = scopedDefs.procs.find(
+          (p) => token.line >= p.startLine && token.line <= p.endLine
+        );
+        canonical = proc ? proc.defs.get(lv) ?? scopedDefs.moduleDefs.get(lv) : scopedDefs.moduleDefs.get(lv);
+      }
+      if (!canonical) continue;
+      const value = token.value;
+      if (value === canonical) continue;
+      const lineIdx = token.line - 1;
+      if (!keywordChangesByLine.has(lineIdx)) keywordChangesByLine.set(lineIdx, []);
+      keywordChangesByLine.get(lineIdx).push({
+        startCol: token.column - 1,
+        endCol: token.column - 1 + value.length,
+        text: canonical
+      });
+    }
+  }
+  const edits = [];
+  let level = 0;
+  let selectDepth = 0;
+  let continuationAccum = [];
+  for (let i = 0; i < physicalLines.length; i++) {
+    const rawLine = physicalLines[i];
+    const hasCR = rawLine.endsWith("\r");
+    const line = hasCR ? rawLine.slice(0, -1) : rawLine;
+    const trimmed = line.trim();
+    if (trimmed === "") continue;
+    const prevLine = i > 0 ? physicalLines[i - 1].replace(/\r$/, "").trimEnd() : "";
+    const isContinuation = prevLine.endsWith(" _") || prevLine.endsWith("	_");
+    if (!isContinuation) {
+      continuationAccum = [trimmed];
+    } else {
+      continuationAccum.push(trimmed);
+    }
+    const isLastContinuation = isContinuation && !trimmed.endsWith(" _") && !trimmed.endsWith("	_");
+    const lineTokens = tokenizeLine(trimmed);
+    const first = lineTokens[0]?.type;
+    const second = lineTokens[1]?.type;
+    const isLabel = lineTokens.length >= 2 && lineTokens[0].type === 0 /* Identifier */ && lineTokens[1].type === 130 /* OperatorColon */;
+    let expectedLevel = level;
+    if (!isContinuation && !isLabel) {
+      const startsMultiLine = trimmed.endsWith(" _") || trimmed.endsWith("	_");
+      const { closerBefore, openerAfter } = classifyLine(lineTokens, selectDepth);
+      if (closerBefore) {
+        level = Math.max(0, level - 1);
+        if (first === 10 /* KeywordEnd */ && second === 53 /* KeywordSelect */) {
+          selectDepth = Math.max(0, selectDepth - 1);
+        }
+      }
+      expectedLevel = level;
+      if (openerAfter && !startsMultiLine) {
+        level++;
+        if (first === 53 /* KeywordSelect */ && second === 54 /* KeywordCase */) {
+          selectDepth++;
+        }
+      }
+    } else if (isLastContinuation && !isLabel) {
+      const logicalLine = continuationAccum.map((l) => l.replace(/[ \t]+_[ \t]*$/, "")).join(" ");
+      const logTokens = tokenizeLine(logicalLine);
+      const logFirst = logTokens[0]?.type;
+      const logSecond = logTokens[1]?.type;
+      const { openerAfter } = classifyLine(logTokens, selectDepth);
+      if (openerAfter) {
+        level++;
+        if (logFirst === 53 /* KeywordSelect */ && logSecond === 54 /* KeywordCase */) {
+          selectDepth++;
+        }
+      }
+    }
+    const expectedIndent = isContinuation ? "" : isLabel ? "" : unit.repeat(expectedLevel);
+    const actualIndent = leadingWhitespace(line);
+    const contentStart = actualIndent.length;
+    const changes = keywordChangesByLine.get(i) ?? [];
+    let content = line.slice(contentStart);
+    if (changes.length > 0) {
+      const contentChanges = changes.map((c) => ({ start: c.startCol - contentStart, end: c.endCol - contentStart, text: c.text })).filter((c) => c.start >= 0).sort((a, b) => b.start - a.start);
+      for (const c of contentChanges) {
+        content = content.slice(0, c.start) + c.text + content.slice(c.end);
+      }
+    }
+    const newLine = (isContinuation ? actualIndent : expectedIndent) + content + (hasCR ? "\r" : "");
+    if (newLine !== rawLine) {
+      edits.push({
+        range: {
+          start: { line: i, character: 0 },
+          end: { line: i, character: rawLine.length }
+        },
+        newText: newLine
+      });
+    }
+  }
+  return edits;
+}
+var BLOCK_OPEN = /* @__PURE__ */ new Set([
+  17 /* KeywordSub */,
+  18 /* KeywordFunction */,
+  19 /* KeywordProperty */,
+  3 /* KeywordFor */,
+  11 /* KeywordDo */,
+  12 /* KeywordWhile */,
+  61 /* KeywordWith */,
+  48 /* KeywordType */,
+  59 /* KeywordEnum */,
+  69 /* KeywordClass */
+]);
+var BLOCK_CLOSE_SINGLE = /* @__PURE__ */ new Set([
+  5 /* KeywordNext */,
+  13 /* KeywordWend */,
+  14 /* KeywordLoop */
+]);
+var ACCESS_MODIFIERS = /* @__PURE__ */ new Set([
+  57 /* KeywordPublic */,
+  58 /* KeywordPrivate */,
+  60 /* KeywordFriend */,
+  68 /* KeywordStatic */
+]);
+function classifyLine(tokens, selectDepth) {
+  if (tokens.length === 0) return { closerBefore: false, openerAfter: false };
+  let offset = 0;
+  while (offset < tokens.length && ACCESS_MODIFIERS.has(tokens[offset].type)) {
+    offset++;
+  }
+  const first = tokens[offset]?.type ?? tokens[0].type;
+  const second = tokens[offset + 1]?.type;
+  if (first === 10 /* KeywordEnd */ && second !== void 0) {
+    const isEndProc = second === 17 /* KeywordSub */ || second === 18 /* KeywordFunction */ || second === 19 /* KeywordProperty */;
+    const isEndBlock = second === 6 /* KeywordIf */ || second === 61 /* KeywordWith */ || second === 48 /* KeywordType */ || second === 59 /* KeywordEnum */ || second === 69 /* KeywordClass */ || second === 53 /* KeywordSelect */;
+    if (isEndProc || isEndBlock) {
+      return { closerBefore: true, openerAfter: false };
+    }
+  }
+  if (BLOCK_CLOSE_SINGLE.has(first)) {
+    return { closerBefore: true, openerAfter: false };
+  }
+  if (first === 9 /* KeywordElse */ || first === 8 /* KeywordElseIf */) {
+    return { closerBefore: true, openerAfter: true };
+  }
+  if (first === 54 /* KeywordCase */ && selectDepth > 0) {
+    return { closerBefore: true, openerAfter: true };
+  }
+  if (BLOCK_OPEN.has(first)) {
+    return { closerBefore: false, openerAfter: true };
+  }
+  if (first === 53 /* KeywordSelect */ && second === 54 /* KeywordCase */) {
+    return { closerBefore: false, openerAfter: true };
+  }
+  if (first === 6 /* KeywordIf */) {
+    const thenIdx = tokens.findIndex((t) => t.type === 7 /* KeywordThen */);
+    if (thenIdx !== -1) {
+      const afterThen = tokens.slice(thenIdx + 1).filter((t) => t.type !== 130 /* OperatorColon */);
+      if (afterThen.length === 0) {
+        return { closerBefore: false, openerAfter: true };
+      }
+    }
+    return { closerBefore: false, openerAfter: false };
+  }
+  return { closerBefore: false, openerAfter: false };
+}
+function tokenizeLine(trimmed) {
+  try {
+    return new Lexer(trimmed).tokenize().filter(
+      (t) => t.type !== 135 /* Newline */ && t.type !== 136 /* EOF */
+    );
+  } catch {
+    return [];
+  }
+}
+function leadingWhitespace(line) {
+  const match = line.match(/^[ \t]*/);
+  return match ? match[0] : "";
+}
+function applyEdits(source, edits) {
+  if (edits.length === 0) return source;
+  const lines = source.split("\n");
+  const sorted = [...edits].sort((a, b) => b.range.start.line - a.range.start.line);
+  for (const edit of sorted) {
+    const lineIdx = edit.range.start.line;
+    const origLine = lines[lineIdx];
+    lines[lineIdx] = origLine.slice(0, edit.range.start.character) + edit.newText + origLine.slice(edit.range.end.character);
+  }
+  return lines.join("\n");
+}
+
+// ../../test-libs/vba-formatter.ts
+var VBA_EXTENSIONS = /\.(bas|cls|frm)$/i;
+function collectFiles(target) {
+  const stat = fs.statSync(target);
+  if (stat.isFile()) return [target];
+  if (stat.isDirectory()) {
+    return fs.readdirSync(target).flatMap((entry) => {
+      const full = path.join(target, entry);
+      const s = fs.statSync(full);
+      if (s.isDirectory()) return collectFiles(full);
+      if (VBA_EXTENSIONS.test(entry)) return [full];
+      return [];
+    });
+  }
+  return [];
+}
+function buildDiff(original, formatted, filePath) {
+  const origLines = original.split("\n");
+  const fmtLines = formatted.split("\n");
+  const maxLen = Math.max(origLines.length, fmtLines.length);
+  const diffLines = [`--- ${filePath} (original)`, `+++ ${filePath} (formatted)`];
+  let hasDiff = false;
+  for (let i = 0; i < maxLen; i++) {
+    const orig = origLines[i] ?? "";
+    const fmtd = fmtLines[i] ?? "";
+    if (orig !== fmtd) {
+      hasDiff = true;
+      diffLines.push(`@@ line ${i + 1} @@`);
+      diffLines.push(`-${orig}`);
+      diffLines.push(`+${fmtd}`);
+    }
+  }
+  return hasDiff ? diffLines.join("\n") : "";
+}
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+    console.log(`Usage: vba-formatter <file-or-dir> [--check | --write] [options]
+
+Options:
+  --check            \u5DEE\u5206\u304C\u3042\u308C\u3070\u8868\u793A\u3057\u3066 exit code 1 \u3067\u7D42\u4E86
+  --write            \u30D5\u30A1\u30A4\u30EB\u3092\u4E0A\u66F8\u304D\uFF08\u6307\u5B9A\u3057\u306A\u3044\u5834\u5408\u306F stdout \u306B\u51FA\u529B\uFF09
+  --indent-size=N    \u30A4\u30F3\u30C7\u30F3\u30C8\u5E45\uFF08\u30C7\u30D5\u30A9\u30EB\u30C8: 4\uFF09
+  --no-keyword-case  \u30AD\u30FC\u30EF\u30FC\u30C9\u306E\u5927\u6587\u5B57\u5316\u3092\u7121\u52B9\u5316
+
+Example:
+  npx tsx test-libs/vba-formatter.ts src/vba/Main.bas
+  npx tsx test-libs/vba-formatter.ts src/vba/ --check
+  npx tsx test-libs/vba-formatter.ts src/vba/Main.bas --write --indent-size=2`);
+    process.exit(0);
+  }
+  const target = args.find((a) => !a.startsWith("-"));
+  const isCheck = args.includes("--check");
+  const isWrite = args.includes("--write");
+  const noKeywordCase = args.includes("--no-keyword-case");
+  const indentSizeArg = args.find((a) => a.startsWith("--indent-size="));
+  const indentSize = indentSizeArg ? parseInt(indentSizeArg.split("=")[1], 10) : 4;
+  if (!target || !fs.existsSync(target)) {
+    console.error(`Error: "${target ?? "(\u6307\u5B9A\u306A\u3057)"}" \u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093`);
+    process.exit(1);
+  }
+  const options = {
+    indentSize,
+    keywordCase: noKeywordCase ? false : "pascal"
+  };
+  const files = collectFiles(target);
+  if (files.length === 0) {
+    console.error(`Error: VBA\u30D5\u30A1\u30A4\u30EB\uFF08.bas/.cls/.frm\uFF09\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093: ${target}`);
+    process.exit(1);
+  }
+  let hasAnyDiff = false;
+  for (const filePath of files) {
+    const original = fs.readFileSync(filePath, "utf8");
+    const edits = format(original, options);
+    const formatted = applyEdits(original, edits);
+    const hasDiff = formatted !== original;
+    if (isCheck) {
+      if (hasDiff) {
+        hasAnyDiff = true;
+        const diff = buildDiff(original, formatted, filePath);
+        console.log(diff);
+      }
+    } else if (isWrite) {
+      if (hasDiff) {
+        fs.writeFileSync(filePath, formatted, "utf8");
+        console.log(`\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u6E08\u307F: ${filePath}`);
+      }
+    } else {
+      if (files.length > 1) {
+        console.error("Error: stdout \u30E2\u30FC\u30C9\u306F\u5358\u4E00\u30D5\u30A1\u30A4\u30EB\u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\u3002\u30C7\u30A3\u30EC\u30AF\u30C8\u30EA\u306B\u306F --check \u307E\u305F\u306F --write \u3092\u4F7F\u7528\u3057\u3066\u304F\u3060\u3055\u3044\u3002");
+        process.exit(1);
+      }
+      process.stdout.write(formatted);
+    }
+  }
+  if (isCheck && hasAnyDiff) {
+    process.exit(1);
+  }
+}
+main();