@jbearak/sight 0.14.6 → 0.15.0

package/dist/sight-server.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jbearak/sight",
-    version: "0.14.6",
+    version: "0.15.0",
     type: "module",
     workspaces: [
       "client"
@@ -115,6 +115,7 @@ var init_package = __esm(() => {
     license: "GPL-3.0",
     dependencies: {
       "@jbearak/dta-parser": "^0.6.0",
+      ignore: "7.0.5",
       picomatch: "^4.0.2",
       "smol-toml": "^1.6.1",
       "vscode-languageserver": "^9.0.1",
@@ -917,7 +918,10 @@ function map_public_config_to_partial_config(raw, warn) {
   }
   const workspace = object_value(raw, "workspace", "workspace", warn);
   if (workspace) {
-    warn_unknown_keys(workspace, ["exclude"], "workspace", warn);
+    warn_unknown_keys(workspace, ["exclude", "respectGitignore"], "workspace", warn);
+    const mapped_workspace = {};
+    assign_boolean(mapped_workspace, "respectGitignore", workspace, "respectGitignore", "workspace.respectGitignore", warn);
+    maybe_assign_object(root, "workspace", mapped_workspace);
   }
   const canonical_exclude = workspace ? pick_key(workspace, "exclude", warn, "workspace.exclude") : undefined;
   const legacy_exclude = pick_key(raw, "exclude", warn, "exclude");
@@ -13310,6 +13314,8 @@ var init_parser = __esm(() => {
     pending_trivia = [];
     context_tracker = null;
     inside_program = false;
+    if_brace_scan_end = -1;
+    if_brace_scan_result = false;
     static OPENING_DELIMITER_PATTERN = /^(`")+$/;
     static CLOSING_DELIMITER_PATTERN = /^("')+$/;
     parse(tokens, context_tracker) {
@@ -13317,6 +13323,8 @@ var init_parser = __esm(() => {
       this.current = 0;
       this.errors = [];
       this.pending_trivia = [];
+      this.if_brace_scan_end = -1;
+      this.if_brace_scan_result = false;
       this.context_tracker = context_tracker || null;
       const nodes = [];
       while (!this.isAtEnd()) {
@@ -13346,7 +13354,7 @@ var init_parser = __esm(() => {
         errors: this.errors
       };
     }
-    parseStatement() {
+    parseStatement(consume_terminator = true) {
       const leading_trivia = [...this.pending_trivia, ...this.collectTrivia()];
       this.pending_trivia = [];
       if (this.isAtEnd()) {
@@ -13433,7 +13441,7 @@ var init_parser = __esm(() => {
       if (node && this.isNodeWithTrivia(node) && trailing_trivia.length > 0) {
         node.trailingTrivia = trailing_trivia;
       }
-      if (this.check("STATEMENT_TERMINATOR")) {
+      if (consume_terminator && this.check("STATEMENT_TERMINATOR")) {
         this.advance();
       }
       return node;
@@ -14650,13 +14658,31 @@ var init_parser = __esm(() => {
       }
       return false;
     }
+    hasIfBrace() {
+      if (this.current <= this.if_brace_scan_end) {
+        return this.if_brace_scan_result;
+      }
+      for (let i = this.current;i < this.tokens.length; i++) {
+        const token = this.tokens[i];
+        if (token.type === "LBRACE" || token.type === "EOF" || token.type === "STATEMENT_TERMINATOR" && !is_swallowed_continuation_terminator(token, this.tokens[i - 1]?.type === "CONTINUATION")) {
+          this.if_brace_scan_end = i;
+          this.if_brace_scan_result = token.type === "LBRACE";
+          return this.if_brace_scan_result;
+        }
+      }
+      return false;
+    }
     parseIfStatement() {
       const ifToken = this.advance();
+      const has_brace = this.hasIfBrace();
       const condition_tokens = [];
       const preceded_by_continuation = [];
       const continuation = new ContinuationTracker;
       const condition_start_line = ifToken.range.start.line;
       let paren_depth = 0;
+      let bracket_depth = 0;
+      let previous_operand;
+      let is_single_statement = false;
       while (!this.check("LBRACE") && !this.isAtEnd()) {
         if (this.check("CONTINUATION")) {
           const cont_token = this.peek();
@@ -14668,7 +14694,15 @@ var init_parser = __esm(() => {
         if (this.check("STATEMENT_TERMINATOR")) {
           break;
         }
-        const token = this.advance();
+        const token = this.peek();
+        const follows_continuation = continuation.collect(token);
+        const joins_operand = previous_operand && previous_operand.type !== "RPAREN" && previous_operand.type !== "RBRACKET" && (this.isAdjacentToken(previous_operand, token) || follows_continuation && token.range.start.character === 0);
+        const starts_nested_if = this.checkWord("if");
+        if ((!has_brace || starts_nested_if) && paren_depth === 0 && bracket_depth === 0 && previous_operand && !joins_operand && (token.type === "WORD" || this.isMacroRefToken(token) || token.type === "MATA_INLINE" || token.type === "PYTHON_INLINE")) {
+          is_single_statement = true;
+          break;
+        }
+        this.advance();
         if (token.type === "LPAREN") {
           paren_depth++;
         } else if (token.type === "RPAREN") {
@@ -14678,8 +14712,16 @@ var init_parser = __esm(() => {
             paren_depth = 0;
           }
         }
+        if (token.type === "LBRACKET") {
+          bracket_depth++;
+        } else if (token.type === "RBRACKET") {
+          bracket_depth = Math.max(0, bracket_depth - 1);
+        }
+        if (token.type !== "COMMENT_LINE" && token.type !== "COMMENT_BLOCK") {
+          previous_operand = token.type === "WORD" || token.type === "NUMBER" || token.type === "STRING" || this.isMacroRefToken(token) || token.type === "RPAREN" || token.type === "RBRACKET" ? token : undefined;
+        }
         condition_tokens.push(token);
-        preceded_by_continuation.push(continuation.collect(token));
+        preceded_by_continuation.push(follows_continuation);
       }
       const condition = this.reconstruct_value_tokens(condition_tokens, preceded_by_continuation).trim();
       if (paren_depth > 0) {
@@ -14690,7 +14732,11 @@ var init_parser = __esm(() => {
       }
       const body = [];
       let blockEndingTrivia;
-      if (this.check("LBRACE")) {
+      if (is_single_statement) {
+        const statement = this.parseStatement(false);
+        if (statement)
+          body.push(statement);
+      } else if (this.check("LBRACE")) {
         const lbrace_index = this.current;
         const lbrace_token = this.advance();
         const has_condition_before = lbrace_token.range.start.line === condition_start_line;
@@ -14708,9 +14754,10 @@ var init_parser = __esm(() => {
       }
       return {
         type: "if",
+        ...is_single_statement ? { is_single_statement: true } : {},
         condition: condition.trim(),
         body,
-        range: this.makeRange(ifToken.range.start, this.previous().range.end),
+        range: this.makeRange(ifToken.range.start, is_single_statement && body.length > 0 ? body[body.length - 1].range.end : this.previous().range.end),
         blockEndingTrivia
       };
     }
@@ -20742,6 +20789,61 @@ async function with_parse_timeout(operation, timeout_ms = PARSE_TIMEOUT_MS) {
 }
 var PARSE_TIMEOUT_MS = 5000;
 
+// src/source-analysis/index.ts
+import * as path4 from "path";
+function analyze_source(content, uri) {
+  const lexer = new StataLexer;
+  const parser = new StataParser;
+  const analyzer = new SemanticAnalyzer;
+  const directive_parser = new DirectiveParser;
+  const lex_result = lexer.tokenize(content);
+  const directive_result = directive_parser.parse(content, uri, lex_result.tokens);
+  const parse_result = parser.parse(lex_result.tokens);
+  const analysis = analyzer.analyze(parse_result.ast, uri, undefined, undefined, lex_result.tokens);
+  return {
+    tokens: lex_result.tokens,
+    analysis,
+    directives: directive_result
+  };
+}
+function prepare_forward_calls(options) {
+  let command_calls = options.command_calls;
+  try {
+    const caller_dir = path4.dirname(URI.parse(options.uri).fsPath);
+    const { timeline } = build_cd_timeline({
+      starting_wd: options.working_directory,
+      caller_dir,
+      cd_commands: options.cd_commands,
+      workspace_roots: options.workspace_roots,
+      fs: options.fs
+    });
+    command_calls = apply_cd_timeline(command_calls, timeline);
+  } catch (error) {
+    if (!options.recover_command_projection) {
+      throw error;
+    }
+  }
+  const directive_calls = options.directive_calls.map((my_directive) => ({
+    type: my_directive.type,
+    raw_path: my_directive.raw_path,
+    call_site_line: my_directive.call_site_line,
+    range: my_directive.range,
+    source: "directive",
+    is_static: true,
+    caller_uri: options.uri,
+    working_directory: options.working_directory
+  }));
+  return [...command_calls, ...directive_calls];
+}
+var init_source_analysis = __esm(() => {
+  init_esm();
+  init_analyzer();
+  init_directive_parser();
+  init_lexer();
+  init_parser();
+  init_file_path_utils();
+});
+
 // src/utils/polling-cancellation-token.ts
 function polling_cancellation_token(should_continue, parent) {
   return {
@@ -20757,7 +20859,6 @@ var no_op_cancellation_event = () => ({ dispose: () => {
 
 // src/document-store.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
 
 class DocumentStore {
   documents = new Map;
@@ -21156,17 +21257,16 @@ class DocumentStore {
     const directive_parser = new DirectiveParser;
     let resolved_working_directory;
     let staged_effects;
+    let parsed_directives;
     try {
       const directive_result = directive_parser.parse(content, uri, lex_result.result.tokens);
+      parsed_directives = directive_result;
       staged_effects = this.stage_cross_file_effects(directive_result, effective_scope_resolver_config);
       if (directive_result.working_directory) {
         resolved_working_directory = this.resolve_working_directory(directive_result.working_directory, uri);
       } else if (this.scope_resolver) {
         try {
-          const scope_result = await this.scope_resolver.resolve(uri, content, effective_scope_resolver_config, cancellation_token, { register_dependencies: false });
-          if (scope_result.inherited_working_directory) {
-            resolved_working_directory = scope_result.inherited_working_directory;
-          }
+          resolved_working_directory = await this.scope_resolver.resolve_document_working_directory(uri, directive_result, effective_scope_resolver_config, cancellation_token);
         } catch {}
       }
     } catch {}
@@ -21220,36 +21320,19 @@ class DocumentStore {
       };
     }
     const diagnostics = this.build_diagnostics(lex_result.result.errors, parse_result.result.errors, analyze_result.result.diagnostics);
-    let restamped_command_calls = analyze_result.result.forward_calls;
+    let the_forward_directives = [];
     try {
-      const my_caller_dir = path4.dirname(URI.parse(uri).fsPath);
-      const { timeline: cd_timeline } = build_cd_timeline({
-        starting_wd: resolved_working_directory,
-        caller_dir: my_caller_dir,
-        cd_commands: analyze_result.result.cd_commands,
-        workspace_roots: this.workspace_roots
-      });
-      restamped_command_calls = apply_cd_timeline(analyze_result.result.forward_calls, cd_timeline);
-    } catch {}
-    let all_forward_calls = restamped_command_calls;
-    try {
-      const directive_parser2 = new DirectiveParser;
-      const directive_result = directive_parser2.parse_forward_call_directives(content, uri, lex_result.result.tokens);
-      const directive_forward_calls = directive_result.forward_calls.map((d) => ({
-        type: d.type,
-        raw_path: d.raw_path,
-        call_site_line: d.call_site_line,
-        range: d.range,
-        source: "directive",
-        is_static: true,
-        caller_uri: uri,
-        working_directory: resolved_working_directory
-      }));
-      all_forward_calls = [
-        ...restamped_command_calls,
-        ...directive_forward_calls
-      ];
+      the_forward_directives = parsed_directives ? parsed_directives.forward_calls ?? [] : directive_parser.parse_forward_call_directives(content, uri, lex_result.result.tokens).forward_calls;
     } catch {}
+    const all_forward_calls = prepare_forward_calls({
+      uri,
+      command_calls: analyze_result.result.forward_calls,
+      directive_calls: the_forward_directives,
+      cd_commands: analyze_result.result.cd_commands,
+      working_directory: resolved_working_directory,
+      workspace_roots: this.workspace_roots,
+      recover_command_projection: true
+    });
     return {
       state: {
         uri,
@@ -21415,8 +21498,7 @@ var init_document_store = __esm(() => {
   init_context_tracker();
   init_directive_parser();
   init_workspace_roots();
-  init_file_path_utils();
-  init_esm();
+  init_source_analysis();
   import_vscode_languageserver = __toESM(require_main4(), 1);
 });
 
@@ -22665,9 +22747,6 @@ function scope_resolver_config_for(config) {
 
 class ScopeResolver {
   directive_parser;
-  lexer;
-  parser;
-  analyzer;
   file_cache;
   scope_cache;
   uri_to_cache_keys;
@@ -22682,9 +22761,6 @@ class ScopeResolver {
   resolve_fs;
   constructor(logger2, content_provider, cache_capacities) {
     this.directive_parser = new DirectiveParser;
-    this.lexer = new StataLexer;
-    this.parser = new StataParser;
-    this.analyzer = new SemanticAnalyzer;
     this.file_cache = new BoundedLruMap(cache_capacities?.max_cached_files ?? DEFAULT_MAX_CACHED_FILES, {
       on_evict: (_key, entry) => {
         this.cache_metrics.file.evictions++;
@@ -23364,6 +23440,16 @@ class ScopeResolver {
     };
     return this.discover_working_directory(the_backward_directives, new Set, 0, my_config, new Map, current_uri, undefined, true);
   }
+  async resolve_document_working_directory(file_uri, directive_result, config = {}, token) {
+    if (token?.isCancellationRequested || directive_result.working_directory) {
+      return;
+    }
+    const my_config = { ...DEFAULT_CONFIG2, ...config };
+    const { directives: effective_directives } = this.get_effective_backward_directives(file_uri, directive_result.directives, my_config, directive_result.standalone !== undefined);
+    const normalized_directives = this.normalize_directives(effective_directives, []);
+    const working_directory = await this.discover_working_directory(normalized_directives, new Set([file_uri]), 1, my_config, new Map, file_uri, token, true);
+    return token?.isCancellationRequested ? undefined : working_directory;
+  }
   async discover_working_directory(directives, visited, depth, config, request_cache, current_uri, token, skip_backward_registration) {
     if (depth > config.max_backward_depth) {
       return;
@@ -23733,9 +23819,10 @@ class ScopeResolver {
     }
   }
   parse_content(uri, content, inherited_working_directory) {
-    const my_directive_result = this.directive_parser.parse(content, uri);
-    const my_lex_result = this.lexer.tokenize(content);
-    const my_parse_result = this.parser.parse(my_lex_result.tokens);
+    const {
+      directives: my_directive_result,
+      analysis: my_analysis
+    } = analyze_source(content, uri);
     const my_workspace_root = get_workspace_root_for_uri(this.workspace_roots, uri);
     let own_working_directory;
     if (my_directive_result.working_directory) {
@@ -23748,32 +23835,15 @@ class ScopeResolver {
       }
     }
     const effective_working_directory = own_working_directory ?? inherited_working_directory;
-    const my_analysis = this.analyzer.analyze(my_parse_result.ast, uri, undefined, {
-      working_directory: effective_working_directory
-    }, my_lex_result.tokens);
-    const my_caller_dir = path6.dirname(URI.parse(uri).fsPath);
-    const { timeline: cd_timeline } = build_cd_timeline({
-      starting_wd: effective_working_directory,
-      caller_dir: my_caller_dir,
+    const all_forward_calls = prepare_forward_calls({
+      uri,
+      command_calls: my_analysis.forward_calls,
+      directive_calls: my_directive_result.forward_calls ?? [],
       cd_commands: my_analysis.cd_commands,
+      working_directory: effective_working_directory,
       workspace_roots: this.workspace_roots,
       fs: this.resolve_fs
     });
-    const restamped_command_calls = apply_cd_timeline(my_analysis.forward_calls, cd_timeline);
-    const directive_forward_calls = (my_directive_result.forward_calls ?? []).map((d) => ({
-      type: d.type,
-      raw_path: d.raw_path,
-      call_site_line: d.call_site_line,
-      range: d.range,
-      source: "directive",
-      is_static: true,
-      caller_uri: uri,
-      working_directory: effective_working_directory
-    }));
-    const all_forward_calls = [
-      ...restamped_command_calls,
-      ...directive_forward_calls
-    ];
     return {
       symbols: my_analysis.symbols,
       directives: my_directive_result.directives,
@@ -24607,9 +24677,8 @@ var init_scope_resolver = __esm(() => {
   init_esm();
   init_types();
   init_directive_parser();
-  init_lexer();
-  init_parser();
   init_analyzer();
+  init_source_analysis();
   init_logger();
   init_lru_cache();
   init_dofile_locals();
@@ -25062,6 +25131,476 @@ var init_source_discovery_policy = __esm(() => {
   init_workspace_roots();
 });
 
+// node_modules/ignore/index.js
+var require_ignore = __commonJS((exports, module) => {
+  function makeArray(subject) {
+    return Array.isArray(subject) ? subject : [subject];
+  }
+  var UNDEFINED = undefined;
+  var EMPTY = "";
+  var SPACE = " ";
+  var ESCAPE = "\\";
+  var REGEX_TEST_BLANK_LINE = /^\s+$/;
+  var REGEX_INVALID_TRAILING_BACKSLASH = /(?:[^\\]|^)\\$/;
+  var REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION = /^\\!/;
+  var REGEX_REPLACE_LEADING_EXCAPED_HASH = /^\\#/;
+  var REGEX_SPLITALL_CRLF = /\r?\n/g;
+  var REGEX_TEST_INVALID_PATH = /^\.{0,2}\/|^\.{1,2}$/;
+  var REGEX_TEST_TRAILING_SLASH = /\/$/;
+  var SLASH = "/";
+  var TMP_KEY_IGNORE = "node-ignore";
+  if (typeof Symbol !== "undefined") {
+    TMP_KEY_IGNORE = Symbol.for("node-ignore");
+  }
+  var KEY_IGNORE = TMP_KEY_IGNORE;
+  var define2 = (object, key, value) => {
+    Object.defineProperty(object, key, { value });
+    return value;
+  };
+  var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
+  var RETURN_FALSE = () => false;
+  var sanitizeRange = (range) => range.replace(REGEX_REGEXP_RANGE, (match, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match : EMPTY);
+  var cleanRangeBackSlash = (slashes) => {
+    const { length } = slashes;
+    return slashes.slice(0, length - length % 2);
+  };
+  var REPLACERS = [
+    [
+      /^\uFEFF/,
+      () => EMPTY
+    ],
+    [
+      /((?:\\\\)*?)(\\?\s+)$/,
+      (_, m1, m2) => m1 + (m2.indexOf("\\") === 0 ? SPACE : EMPTY)
+    ],
+    [
+      /(\\+?)\s/g,
+      (_, m1) => {
+        const { length } = m1;
+        return m1.slice(0, length - length % 2) + SPACE;
+      }
+    ],
+    [
+      /[\\$.|*+(){^]/g,
+      (match) => `\\${match}`
+    ],
+    [
+      /(?!\\)\?/g,
+      () => "[^/]"
+    ],
+    [
+      /^\//,
+      () => "^"
+    ],
+    [
+      /\//g,
+      () => "\\/"
+    ],
+    [
+      /^\^*\\\*\\\*\\\//,
+      () => "^(?:.*\\/)?"
+    ],
+    [
+      /^(?=[^^])/,
+      function startingReplacer() {
+        return !/\/(?!$)/.test(this) ? "(?:^|\\/)" : "^";
+      }
+    ],
+    [
+      /\\\/\\\*\\\*(?=\\\/|$)/g,
+      (_, index, str) => index + 6 < str.length ? "(?:\\/[^\\/]+)*" : "\\/.+"
+    ],
+    [
+      /(^|[^\\]+)(\\\*)+(?=.+)/g,
+      (_, p1, p2) => {
+        const unescaped = p2.replace(/\\\*/g, "[^\\/]*");
+        return p1 + unescaped;
+      }
+    ],
+    [
+      /\\\\\\(?=[$.|*+(){^])/g,
+      () => ESCAPE
+    ],
+    [
+      /\\\\/g,
+      () => ESCAPE
+    ],
+    [
+      /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
+      (match, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+    ],
+    [
+      /(?:[^*])$/,
+      (match) => /\/$/.test(match) ? `${match}$` : `${match}(?=$|\\/$)`
+    ]
+  ];
+  var REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
+  var MODE_IGNORE = "regex";
+  var MODE_CHECK_IGNORE = "checkRegex";
+  var UNDERSCORE = "_";
+  var TRAILING_WILD_CARD_REPLACERS = {
+    [MODE_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]+` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    },
+    [MODE_CHECK_IGNORE](_, p1) {
+      const prefix = p1 ? `${p1}[^/]*` : "[^/]*";
+      return `${prefix}(?=$|\\/$)`;
+    }
+  };
+  var makeRegexPrefix = (pattern) => REPLACERS.reduce((prev, [matcher, replacer]) => prev.replace(matcher, replacer.bind(pattern)), pattern);
+  var isString = (subject) => typeof subject === "string";
+  var checkPattern = (pattern) => pattern && isString(pattern) && !REGEX_TEST_BLANK_LINE.test(pattern) && !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) && pattern.indexOf("#") !== 0;
+  var splitPattern = (pattern) => pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
+
+  class IgnoreRule {
+    constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+      this.pattern = pattern;
+      this.mark = mark;
+      this.negative = negative;
+      define2(this, "body", body);
+      define2(this, "ignoreCase", ignoreCase);
+      define2(this, "regexPrefix", prefix);
+    }
+    get regex() {
+      const key = UNDERSCORE + MODE_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_IGNORE, key);
+    }
+    get checkRegex() {
+      const key = UNDERSCORE + MODE_CHECK_IGNORE;
+      if (this[key]) {
+        return this[key];
+      }
+      return this._make(MODE_CHECK_IGNORE, key);
+    }
+    _make(mode, key) {
+      const str = this.regexPrefix.replace(REGEX_REPLACE_TRAILING_WILDCARD, TRAILING_WILD_CARD_REPLACERS[mode]);
+      const regex = this.ignoreCase ? new RegExp(str, "i") : new RegExp(str);
+      return define2(this, key, regex);
+    }
+  }
+  var createRule = ({
+    pattern,
+    mark
+  }, ignoreCase) => {
+    let negative = false;
+    let body = pattern;
+    if (body.indexOf("!") === 0) {
+      negative = true;
+      body = body.substr(1);
+    }
+    body = body.replace(REGEX_REPLACE_LEADING_EXCAPED_EXCLAMATION, "!").replace(REGEX_REPLACE_LEADING_EXCAPED_HASH, "#");
+    const regexPrefix = makeRegexPrefix(body);
+    return new IgnoreRule(pattern, mark, body, ignoreCase, negative, regexPrefix);
+  };
+
+  class RuleManager {
+    constructor(ignoreCase) {
+      this._ignoreCase = ignoreCase;
+      this._rules = [];
+    }
+    _add(pattern) {
+      if (pattern && pattern[KEY_IGNORE]) {
+        this._rules = this._rules.concat(pattern._rules._rules);
+        this._added = true;
+        return;
+      }
+      if (isString(pattern)) {
+        pattern = {
+          pattern
+        };
+      }
+      if (checkPattern(pattern.pattern)) {
+        const rule = createRule(pattern, this._ignoreCase);
+        this._added = true;
+        this._rules.push(rule);
+      }
+    }
+    add(pattern) {
+      this._added = false;
+      makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(this._add, this);
+      return this._added;
+    }
+    test(path10, checkUnignored, mode) {
+      let ignored = false;
+      let unignored = false;
+      let matchedRule;
+      this._rules.forEach((rule) => {
+        const { negative } = rule;
+        if (unignored === negative && ignored !== unignored || negative && !ignored && !unignored && !checkUnignored) {
+          return;
+        }
+        const matched = rule[mode].test(path10);
+        if (!matched) {
+          return;
+        }
+        ignored = !negative;
+        unignored = negative;
+        matchedRule = negative ? UNDEFINED : rule;
+      });
+      const ret = {
+        ignored,
+        unignored
+      };
+      if (matchedRule) {
+        ret.rule = matchedRule;
+      }
+      return ret;
+    }
+  }
+  var throwError = (message, Ctor) => {
+    throw new Ctor(message);
+  };
+  var checkPath = (path10, originalPath, doThrow) => {
+    if (!isString(path10)) {
+      return doThrow(`path must be a string, but got \`${originalPath}\``, TypeError);
+    }
+    if (!path10) {
+      return doThrow(`path must not be empty`, TypeError);
+    }
+    if (checkPath.isNotRelative(path10)) {
+      const r = "`path.relative()`d";
+      return doThrow(`path should be a ${r} string, but got "${originalPath}"`, RangeError);
+    }
+    return true;
+  };
+  var isNotRelative = (path10) => REGEX_TEST_INVALID_PATH.test(path10);
+  checkPath.isNotRelative = isNotRelative;
+  checkPath.convert = (p) => p;
+
+  class Ignore {
+    constructor({
+      ignorecase = true,
+      ignoreCase = ignorecase,
+      allowRelativePaths = false
+    } = {}) {
+      define2(this, KEY_IGNORE, true);
+      this._rules = new RuleManager(ignoreCase);
+      this._strictPathCheck = !allowRelativePaths;
+      this._initCache();
+    }
+    _initCache() {
+      this._ignoreCache = Object.create(null);
+      this._testCache = Object.create(null);
+    }
+    add(pattern) {
+      if (this._rules.add(pattern)) {
+        this._initCache();
+      }
+      return this;
+    }
+    addPattern(pattern) {
+      return this.add(pattern);
+    }
+    _test(originalPath, cache, checkUnignored, slices) {
+      const path10 = originalPath && checkPath.convert(originalPath);
+      checkPath(path10, originalPath, this._strictPathCheck ? throwError : RETURN_FALSE);
+      return this._t(path10, cache, checkUnignored, slices);
+    }
+    checkIgnore(path10) {
+      if (!REGEX_TEST_TRAILING_SLASH.test(path10)) {
+        return this.test(path10);
+      }
+      const slices = path10.split(SLASH).filter(Boolean);
+      slices.pop();
+      if (slices.length) {
+        const parent = this._t(slices.join(SLASH) + SLASH, this._testCache, true, slices);
+        if (parent.ignored) {
+          return parent;
+        }
+      }
+      return this._rules.test(path10, false, MODE_CHECK_IGNORE);
+    }
+    _t(path10, cache, checkUnignored, slices) {
+      if (path10 in cache) {
+        return cache[path10];
+      }
+      if (!slices) {
+        slices = path10.split(SLASH).filter(Boolean);
+      }
+      slices.pop();
+      if (!slices.length) {
+        return cache[path10] = this._rules.test(path10, checkUnignored, MODE_IGNORE);
+      }
+      const parent = this._t(slices.join(SLASH) + SLASH, cache, checkUnignored, slices);
+      return cache[path10] = parent.ignored ? parent : this._rules.test(path10, checkUnignored, MODE_IGNORE);
+    }
+    ignores(path10) {
+      return this._test(path10, this._ignoreCache, false).ignored;
+    }
+    createFilter() {
+      return (path10) => !this.ignores(path10);
+    }
+    filter(paths) {
+      return makeArray(paths).filter(this.createFilter());
+    }
+    test(path10) {
+      return this._test(path10, this._testCache, true);
+    }
+  }
+  var factory = (options) => new Ignore(options);
+  var isPathValid = (path10) => checkPath(path10 && checkPath.convert(path10), path10, RETURN_FALSE);
+  var setupWindows = () => {
+    const makePosix = (str) => /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str) ? str : str.replace(/\\/g, "/");
+    checkPath.convert = makePosix;
+    const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
+    checkPath.isNotRelative = (path10) => REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path10) || isNotRelative(path10);
+  };
+  if (typeof process !== "undefined" && process.platform === "win32") {
+    setupWindows();
+  }
+  module.exports = factory;
+  factory.default = factory;
+  module.exports.isPathValid = isPathValid;
+  define2(module.exports, Symbol.for("setupWindows"), setupWindows);
+});
+
+// src/utils/gitignore-matcher.ts
+import * as fs9 from "fs";
+import * as path10 from "path";
+function rebase_patterns(content, relative_directory) {
+  const pattern_content = content.startsWith("\uFEFF") ? content.slice(1) : content;
+  const the_lines = pattern_content.split(IGNORE_LINE_BREAK);
+  if (relative_directory === "")
+    return the_lines;
+  LITERAL_DIRECTORY_METACHARACTERS.lastIndex = 0;
+  const prefix = relative_directory.replace(LITERAL_DIRECTORY_METACHARACTERS, "\\$&");
+  const the_patterns = [];
+  for (const my_line of the_lines) {
+    if (BLANK_PATTERN.test(my_line) || my_line.startsWith("#"))
+      continue;
+    const negative = my_line.startsWith("!");
+    const body = negative ? my_line.slice(1) : my_line;
+    const shape = body.replace(TRAILING_PATTERN_WHITESPACE, "");
+    if (shape === "" || shape === "/")
+      continue;
+    const anchored = body.startsWith("/") || MIDDLE_SLASH.test(shape);
+    const relative_pattern = (body.startsWith("/") ? body.slice(1) : body).replace(ESCAPED_PATTERN_PREFIX, "$1");
+    the_patterns.push(`${negative ? "!" : ""}/${prefix}/` + `${anchored ? "" : "**/"}${relative_pattern}`);
+  }
+  return the_patterns;
+}
+function is_missing(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+function contains_path(root, target) {
+  const relative6 = path10.relative(root, target);
+  return relative6 !== ".." && !relative6.startsWith(`..${path10.sep}`) && !path10.isAbsolute(relative6);
+}
+function create_gitignore_matcher(workspace_roots, respect_gitignore = true) {
+  if (!respect_gitignore || workspace_roots.length === 0) {
+    return DISABLED_MATCHER;
+  }
+  let warned = false;
+  function warn_unreadable(file_path, error) {
+    if (warned || is_missing(error))
+      return;
+    warned = true;
+    const detail = error instanceof Error ? error.message : String(error);
+    logger.warn(`Cannot read Gitignore rules at ${file_path}: ${detail}. ` + "Continuing with the available rules.");
+  }
+  function find_rule_root(workspace_root) {
+    let directory = workspace_root;
+    while (true) {
+      const marker_path = path10.join(directory, ".git");
+      try {
+        const marker = fs9.lstatSync(marker_path);
+        if (marker.isDirectory() || marker.isFile())
+          return directory;
+      } catch (error) {
+        warn_unreadable(marker_path, error);
+      }
+      const parent = path10.dirname(directory);
+      if (parent === directory)
+        return workspace_root;
+      directory = parent;
+    }
+  }
+  function read_rules(scope, directory, inherited_rules) {
+    const ignore_path = path10.join(directory, ".gitignore");
+    try {
+      if (fs9.lstatSync(ignore_path).isFile()) {
+        const content = fs9.readFileSync(ignore_path, "utf8");
+        const relative_directory = path10.relative(scope.rule_root, directory).split(path10.sep).join("/");
+        return import_ignore.default({ ignorecase: false }).add(inherited_rules ?? []).add(rebase_patterns(content, relative_directory));
+      }
+    } catch (error) {
+      warn_unreadable(ignore_path, error);
+    }
+    return inherited_rules ?? import_ignore.default({ ignorecase: false });
+  }
+  function matches_rules(context, absolute_path, kind) {
+    if (context.ignored)
+      return true;
+    const relative6 = path10.relative(context.rule_root, absolute_path).split(path10.sep).join("/");
+    return context.rules.ignores(kind === "directory" ? `${relative6}/` : relative6);
+  }
+  function directory_context(scope, directory) {
+    const cached = scope.directories.get(directory);
+    if (cached)
+      return cached;
+    const parent = path10.relative(scope.rule_root, directory) === "" ? undefined : directory_context(scope, path10.dirname(directory));
+    const ignored = parent !== undefined && matches_rules(parent, directory, "directory");
+    const context = {
+      rule_root: scope.rule_root,
+      ignored,
+      rules: ignored && parent ? parent.rules : read_rules(scope, directory, parent?.rules)
+    };
+    scope.directories.set(directory, context);
+    return context;
+  }
+  const the_scopes = Array.from(new Set(workspace_roots.map((my_root) => path10.resolve(my_root)))).sort((a, b) => b.length - a.length).map((workspace_root) => ({
+    workspace_root,
+    rule_root: find_rule_root(workspace_root),
+    directories: new Map
+  }));
+  const the_watch_directories = new Map;
+  for (const my_scope of the_scopes) {
+    the_watch_directories.set(my_scope.workspace_root, true);
+    let directory = my_scope.workspace_root;
+    while (directory !== my_scope.rule_root) {
+      directory = path10.dirname(directory);
+      if (!the_watch_directories.has(directory)) {
+        the_watch_directories.set(directory, false);
+      }
+    }
+  }
+  return {
+    watch_directories: Array.from(the_watch_directories, ([directory, recursive]) => ({ directory, recursive })),
+    is_ignored(absolute_path, kind) {
+      const target = path10.resolve(absolute_path);
+      for (const my_scope of the_scopes) {
+        if (!contains_path(my_scope.workspace_root, target))
+          continue;
+        if (path10.relative(my_scope.workspace_root, target) === "") {
+          return false;
+        }
+        const context = directory_context(my_scope, path10.dirname(target));
+        return matches_rules(context, target, kind);
+      }
+      return false;
+    }
+  };
+}
+var import_ignore, DISABLED_MATCHER, IGNORE_LINE_BREAK, BLANK_PATTERN, TRAILING_PATTERN_WHITESPACE, MIDDLE_SLASH, LITERAL_DIRECTORY_METACHARACTERS, ESCAPED_PATTERN_PREFIX;
+var init_gitignore_matcher = __esm(() => {
+  init_logger();
+  import_ignore = __toESM(require_ignore(), 1);
+  DISABLED_MATCHER = {
+    is_ignored: () => false,
+    watch_directories: []
+  };
+  IGNORE_LINE_BREAK = /\r?\n/;
+  BLANK_PATTERN = /^\s*$/;
+  TRAILING_PATTERN_WHITESPACE = /\s+$/;
+  MIDDLE_SLASH = /\/(?!$)/;
+  LITERAL_DIRECTORY_METACHARACTERS = /[\\*[\]]/g;
+  ESCAPED_PATTERN_PREFIX = /^\\([!#])/;
+});
+
 // node_modules/picomatch/lib/constants.js
 var require_constants = __commonJS((exports, module) => {
   var WIN_SLASH = "\\\\/";
@@ -25260,8 +25799,8 @@ var require_utils = __commonJS((exports) => {
     }
     return output;
   };
-  exports.basename = (path10, { windows } = {}) => {
-    const segs = path10.split(windows ? /[\\/]/ : "/");
+  exports.basename = (path11, { windows } = {}) => {
+    const segs = path11.split(windows ? /[\\/]/ : "/");
     const last = segs[segs.length - 1];
     if (last === "") {
       return segs[segs.length - 2];
@@ -26742,7 +27281,7 @@ var require_picomatch2 = __commonJS((exports, module) => {
 });
 
 // src/utils/exclude-matcher.ts
-import path10 from "path";
+import path11 from "path";
 function normalize_pattern(raw) {
   const trimmed = raw.trim();
   if (trimmed === "")
@@ -26764,13 +27303,13 @@ function derive_dir_pattern(pattern) {
   return stripped === "" ? pattern : stripped;
 }
 function relative_to_containing_root(abs_path, workspace_roots) {
-  const target = path10.resolve(abs_path);
+  const target = path11.resolve(abs_path);
   let best = null;
   let best_root_length = -1;
   for (const my_root of workspace_roots) {
-    const root = path10.resolve(my_root);
-    const my_relative = path10.relative(root, target);
-    const contained = my_relative === "" || my_relative !== ".." && !my_relative.startsWith(`..${path10.sep}`) && !path10.isAbsolute(my_relative);
+    const root = path11.resolve(my_root);
+    const my_relative = path11.relative(root, target);
+    const contained = my_relative === "" || my_relative !== ".." && !my_relative.startsWith(`..${path11.sep}`) && !path11.isAbsolute(my_relative);
     if (contained && root.length > best_root_length) {
       best = my_relative;
       best_root_length = root.length;
@@ -26778,7 +27317,7 @@ function relative_to_containing_root(abs_path, workspace_roots) {
   }
   if (best === null)
     return null;
-  return best.split(path10.sep).join("/");
+  return best.split(path11.sep).join("/");
 }
 function create_exclude_matcher(patterns) {
   const compiled = [];
@@ -26818,12 +27357,12 @@ function create_exclude_matcher(patterns) {
   return {
     is_empty: false,
     is_excluded_file(abs_path, workspace_roots) {
-      const relative5 = relative_to_containing_root(abs_path, workspace_roots);
-      if (relative5 === null || relative5 === "")
+      const relative6 = relative_to_containing_root(abs_path, workspace_roots);
+      if (relative6 === null || relative6 === "")
         return false;
       let excluded = false;
       for (const my_rule of compiled) {
-        if (my_rule.match(relative5)) {
+        if (my_rule.match(relative6)) {
           excluded = !my_rule.is_negated;
         }
       }
@@ -26832,8 +27371,8 @@ function create_exclude_matcher(patterns) {
     is_excluded_dir(abs_path, workspace_roots) {
       if (dir_match === null)
         return false;
-      const relative5 = relative_to_containing_root(abs_path, workspace_roots);
-      return relative5 !== null && relative5 !== "" && dir_match(relative5);
+      const relative6 = relative_to_containing_root(abs_path, workspace_roots);
+      return relative6 !== null && relative6 !== "" && dir_match(relative6);
     }
   };
 }
@@ -26849,15 +27388,13 @@ var init_exclude_matcher = __esm(() => {
 });
 
 // src/indexer/index.ts
-import * as fs9 from "fs";
-import * as path11 from "path";
+import * as fs10 from "fs";
+import * as path12 from "path";
 var MAX_PARALLEL = 4, YIELD_INTERVAL_MS = 100, INDEX_DEBOUNCE_MS = 200, WorkspaceIndexer;
 var init_indexer = __esm(() => {
   init_esm();
-  init_lexer();
-  init_parser();
   init_analyzer();
-  init_directive_parser();
+  init_source_analysis();
   init_scope_resolver();
   init_context_tracker();
   init_logger();
@@ -26867,6 +27404,7 @@ var init_indexer = __esm(() => {
   init_findalias_resolver();
   init_file_path_utils();
   init_source_discovery_policy();
+  init_gitignore_matcher();
   init_exclude_matcher();
   WorkspaceIndexer = class WorkspaceIndexer {
     symbol_index = new Map;
@@ -26874,10 +27412,6 @@ var init_indexer = __esm(() => {
     token_index = new Map;
     context_ranges_index = new Map;
     enabled = true;
-    lexer = new StataLexer;
-    parser = new StataParser;
-    analyzer = new SemanticAnalyzer;
-    directive_parser = new DirectiveParser;
     ado_paths = [];
     help_search_paths = [];
     findalias_resolver = new FindaliasResolver;
@@ -26892,6 +27426,8 @@ var init_indexer = __esm(() => {
     cancelled = false;
     size_threshold_bytes = 512 * 1024;
     exclude_matcher = create_exclude_matcher([]);
+    respect_gitignore = true;
+    gitignore_matcher = create_gitignore_matcher([]);
     skipped_files = new Map;
     max_indexed_files = 1000;
     max_files_reached = false;
@@ -27001,16 +27537,17 @@ var init_indexer = __esm(() => {
     async initialize(workspace_folders, ado_paths = []) {
       const generation = ++this.scan_generation;
       this.cancelled = false;
-      if (!this.enabled) {
-        this.dependency_graph?.mark_scan_complete();
-        return;
-      }
       this.ado_paths = ado_paths;
-      this.workspace_roots = workspace_folders.map((f) => path11.resolve(f));
+      this.workspace_roots = workspace_folders.map((f) => path12.resolve(f));
       this.scan_roots = [
         ...this.workspace_roots,
-        ...ado_paths.map((my_path) => path11.resolve(my_path))
+        ...ado_paths.map((my_path) => path12.resolve(my_path))
       ];
+      this.gitignore_matcher = create_gitignore_matcher(this.workspace_roots, this.respect_gitignore);
+      if (!this.enabled) {
+        this.dependency_graph?.mark_scan_complete();
+        return;
+      }
       this.help_search_paths = discover_stata_ado_paths();
       const start_time = Date.now();
       for (const folder of [...workspace_folders, ...this.ado_paths]) {
@@ -27032,8 +27569,10 @@ var init_indexer = __esm(() => {
     async scan_directory(dir_path, generation) {
       if (!this.is_active_generation(generation))
         return;
+      if (this.gitignore_matcher.is_ignored(dir_path, "directory"))
+        return;
       try {
-        const entries = await fs9.promises.readdir(dir_path, {
+        const entries = await fs10.promises.readdir(dir_path, {
           withFileTypes: true
         });
         if (!this.is_active_generation(generation))
@@ -27042,7 +27581,7 @@ var init_indexer = __esm(() => {
         for (const entry of entries) {
           if (!this.is_active_generation(generation))
             break;
-          const entry_path = path11.join(dir_path, entry.name);
+          const entry_path = path12.join(dir_path, entry.name);
           if (entry.isDirectory()) {
             if (entry.name.startsWith(".")) {
               continue;
@@ -27052,6 +27591,8 @@ var init_indexer = __esm(() => {
             }
             await this.scan_directory(entry_path, generation);
           } else if (entry.isFile() && hasStataExtension(entry.name)) {
+            if (this.is_gitignored(entry_path))
+              continue;
             if (!this.exclude_matcher.is_empty && this.exclude_matcher.is_excluded_file(entry_path, this.workspace_roots)) {
               continue;
             }
@@ -27074,7 +27615,7 @@ var init_indexer = __esm(() => {
           const now = Date.now();
           if (now - last_yield_time.value > YIELD_INTERVAL_MS) {
             last_yield_time.value = now;
-            await new Promise((resolve10) => setImmediate(resolve10));
+            await new Promise((resolve11) => setImmediate(resolve11));
           }
         }
       };
@@ -27120,6 +27661,8 @@ var init_indexer = __esm(() => {
       const file_uri = URI.file(file_path).toString();
       if (is_hidden_source_path(file_path, this.scan_roots))
         return;
+      if (this.is_gitignored(file_path))
+        return;
       if (!this.exclude_matcher.is_empty && this.exclude_matcher.is_excluded_file(file_path, this.workspace_roots)) {
         this.clear_stale_entry(file_uri);
         return;
@@ -27128,7 +27671,7 @@ var init_indexer = __esm(() => {
       if (!already_indexed && this.should_skip_for_max_indexed_files(file_uri))
         return;
       try {
-        const stats = await fs9.promises.stat(file_path);
+        const stats = await fs10.promises.stat(file_path);
         if (!this.is_active_generation(generation))
           return;
         if (stats.size > this.size_threshold_bytes) {
@@ -27138,56 +27681,41 @@ var init_indexer = __esm(() => {
           this.metrics.files_skipped++;
           return;
         }
-        const content = await fs9.promises.readFile(file_path, "utf8");
+        const content = await fs10.promises.readFile(file_path, "utf8");
         if (!this.is_active_generation(generation))
           return;
         if (!already_indexed && this.should_skip_for_max_indexed_files(file_uri))
           return;
-        if (path11.extname(file_path).toLowerCase() === ".mata") {
+        if (path12.extname(file_path).toLowerCase() === ".mata") {
           await this.index_mata_file(content, file_uri, generation);
           return;
         }
-        const directive_result = this.directive_parser.parse(content, file_uri);
-        const lexResult = this.lexer.tokenize(content);
-        const parseResult = this.parser.parse(lexResult.tokens);
+        const source_analysis = analyze_source(content, file_uri);
+        const directive_result = source_analysis.directives;
+        const analyzeResult = source_analysis.analysis;
         const workspace_root = get_workspace_root_for_path(this.workspace_roots, file_path);
-        const analyzeResult = this.analyzer.analyze(parseResult.ast, file_uri, undefined, undefined, lexResult.tokens);
         const own_working_directory = directive_result.working_directory ? resolve_working_directory_directive(directive_result.working_directory, workspace_root) : undefined;
         let effective_working_directory = own_working_directory;
         if (own_working_directory === undefined && this.scope_resolver) {
           effective_working_directory = await this.scope_resolver.resolve_inherited_working_directory(directive_result.directives, file_uri, directive_result.standalone !== undefined, this.scope_resolver_config);
         }
-        const my_caller_dir = path11.dirname(file_path);
-        const { timeline: cd_timeline } = build_cd_timeline({
-          starting_wd: effective_working_directory,
-          caller_dir: my_caller_dir,
+        const all_forward_calls = prepare_forward_calls({
+          uri: file_uri,
+          command_calls: analyzeResult.forward_calls,
+          directive_calls: directive_result.forward_calls ?? [],
           cd_commands: analyzeResult.cd_commands,
+          working_directory: effective_working_directory,
           workspace_roots: this.workspace_roots
         });
-        const stamped_analyzer_calls = apply_cd_timeline(analyzeResult.forward_calls, cd_timeline);
         const context_tracker = new ContextTracker;
-        context_tracker.initialize_from_tokens(lexResult.tokens, content);
+        context_tracker.initialize_from_tokens(source_analysis.tokens, content);
         const context_ranges = context_tracker.get_all_context_ranges();
         if (!this.is_active_generation(generation))
           return;
         if (!already_indexed && this.should_skip_for_max_indexed_files(file_uri))
           return;
-        let all_forward_calls = stamped_analyzer_calls;
-        if (directive_result.forward_calls && directive_result.forward_calls.length > 0) {
-          const directive_forward_calls = directive_result.forward_calls.map((d) => ({
-            type: d.type,
-            raw_path: d.raw_path,
-            call_site_line: d.call_site_line,
-            range: d.range,
-            source: "directive",
-            is_static: true,
-            caller_uri: file_uri,
-            working_directory: effective_working_directory
-          }));
-          all_forward_calls = [
-            ...stamped_analyzer_calls,
-            ...directive_forward_calls
-          ].sort((a, b) => a.call_site_line - b.call_site_line);
+        if ((directive_result.forward_calls?.length ?? 0) > 0) {
+          all_forward_calls.sort((a, b) => a.call_site_line - b.call_site_line);
         }
         if (this.dependency_graph) {
           const graph_result = this.dependency_graph.update_caller(file_uri, all_forward_calls);
@@ -27195,7 +27723,7 @@ var init_indexer = __esm(() => {
             this.on_graph_change_callback(graph_result.changed_callees);
           }
         }
-        this.token_index.set(file_uri, lexResult.tokens);
+        this.token_index.set(file_uri, source_analysis.tokens);
         this.context_ranges_index.set(file_uri, context_ranges);
         const is_new_entry = !this.symbol_index.has(file_uri);
         this.symbol_index.set(file_uri, {
@@ -27274,6 +27802,8 @@ var init_indexer = __esm(() => {
         return;
       if (is_hidden_source_path(file_path, this.scan_roots))
         return;
+      if (this.is_gitignored(file_path))
+        return;
       const existing = this.pending_updates.get(file_path);
       if (existing) {
         clearTimeout(existing);
@@ -27298,7 +27828,7 @@ var init_indexer = __esm(() => {
             break;
           this.update_queue.delete(file_path);
           await this.index_file(file_path, generation);
-          await new Promise((resolve10) => setImmediate(resolve10));
+          await new Promise((resolve11) => setImmediate(resolve11));
         }
       } finally {
         this.is_processing_queue = false;
@@ -27330,10 +27860,12 @@ var init_indexer = __esm(() => {
       this.version = 0;
       this.cancelled = false;
       this.workspace_roots = [];
+      this.gitignore_matcher = create_gitignore_matcher([]);
     }
     configure(config) {
       this.scope_resolver_config = scope_resolver_config_for(config);
       this.exclude_matcher = create_exclude_matcher(config.exclude ?? []);
+      this.respect_gitignore = config.workspace?.respectGitignore !== false;
       const threshold = config?.indexing?.maxFileSizeBytes;
       if (typeof threshold === "number" && threshold > 0) {
         this.size_threshold_bytes = threshold;
@@ -27348,6 +27880,9 @@ var init_indexer = __esm(() => {
         this.enabled = true;
       }
     }
+    is_gitignored(file_path) {
+      return this.gitignore_matcher.is_ignored(file_path, "file");
+    }
     get_skipped_files() {
       return new Map(this.skipped_files);
     }
@@ -27557,17 +28092,17 @@ var init_indexer = __esm(() => {
         ...this.help_search_paths
       ];
       for (const my_dir of the_search_dirs) {
-        const my_subdir_path = path11.join(my_dir, my_first_letter, my_basename);
+        const my_subdir_path = path12.join(my_dir, my_first_letter, my_basename);
         try {
-          await fs9.promises.access(my_subdir_path);
+          await fs10.promises.access(my_subdir_path);
           return my_subdir_path;
         } catch {}
-        const my_direct_path = path11.join(my_dir, my_basename);
+        const my_direct_path = path12.join(my_dir, my_basename);
         try {
-          await fs9.promises.access(my_direct_path);
+          await fs10.promises.access(my_direct_path);
           return my_direct_path;
         } catch {}
-        if (!this.workspace_roots.includes(path11.resolve(my_dir))) {
+        if (!this.workspace_roots.includes(path12.resolve(my_dir))) {
           continue;
         }
         const my_recursive_match = await this.find_sthlp_file_recursive(my_dir, my_basename);
@@ -27591,14 +28126,14 @@ var init_indexer = __esm(() => {
         ...this.help_search_paths
       ];
       for (const my_dir of the_search_dirs) {
-        const my_subdir_path = path11.join(my_dir, my_first_letter, my_basename);
+        const my_subdir_path = path12.join(my_dir, my_first_letter, my_basename);
         try {
-          await fs9.promises.access(my_subdir_path);
+          await fs10.promises.access(my_subdir_path);
           return my_subdir_path;
         } catch {}
-        const my_direct_path = path11.join(my_dir, my_basename);
+        const my_direct_path = path12.join(my_dir, my_basename);
         try {
-          await fs9.promises.access(my_direct_path);
+          await fs10.promises.access(my_direct_path);
           return my_direct_path;
         } catch {}
       }
@@ -27606,9 +28141,9 @@ var init_indexer = __esm(() => {
     }
     async list_matching_sthlp(dir, prefix) {
       try {
-        const the_entries = await fs9.promises.readdir(dir);
+        const the_entries = await fs10.promises.readdir(dir);
         const the_matches = the_entries.filter((my_entry) => my_entry.startsWith(prefix) && my_entry.endsWith(".sthlp")).sort();
-        return the_matches.map((my_entry) => path11.join(dir, my_entry));
+        return the_matches.map((my_entry) => path12.join(dir, my_entry));
       } catch {
         return [];
       }
@@ -27632,7 +28167,7 @@ var init_indexer = __esm(() => {
         const my_prefix = `${my_variant}_`;
         const my_first_letter = my_variant.charAt(0).toLowerCase();
         for (const my_dir of the_search_dirs) {
-          const my_subdir = path11.join(my_dir, my_first_letter);
+          const my_subdir = path12.join(my_dir, my_first_letter);
           const the_subdir_matches = await this.list_matching_sthlp(my_subdir, my_prefix);
           for (const my_match of the_subdir_matches) {
             if (!the_seen.has(my_match)) {
@@ -27670,14 +28205,14 @@ var init_indexer = __esm(() => {
         }
         let the_entries;
         try {
-          the_entries = await fs9.promises.readdir(my_entry.path, {
+          the_entries = await fs10.promises.readdir(my_entry.path, {
             withFileTypes: true
           });
         } catch {
           continue;
         }
         for (const my_dirent of the_entries) {
-          const my_path = path11.join(my_entry.path, my_dirent.name);
+          const my_path = path12.join(my_entry.path, my_dirent.name);
           if (my_dirent.isDirectory()) {
             if (!WorkspaceIndexer.EXCLUDED_DIRS.has(my_dirent.name)) {
               the_dirs.push({
@@ -27687,7 +28222,7 @@ var init_indexer = __esm(() => {
             }
             continue;
           }
-          if (my_dirent.name === basename6 && await entry_is_file_async(my_dirent, my_path, fs9.promises)) {
+          if (my_dirent.name === basename6 && await entry_is_file_async(my_dirent, my_path, fs10.promises)) {
             return my_path;
           }
         }
@@ -27696,9 +28231,9 @@ var init_indexer = __esm(() => {
     }
     resolve_program(name, referring_uri) {
       const referring_path = URI.parse(referring_uri).fsPath;
-      const current_dir = path11.dirname(referring_path);
-      const local_ado = path11.join(current_dir, `${name}.ado`);
-      if (fs9.existsSync(local_ado)) {
+      const current_dir = path12.dirname(referring_path);
+      const local_ado = path12.join(current_dir, `${name}.ado`);
+      if (fs10.existsSync(local_ado)) {
         const local_uri = URI.file(local_ado).toString();
         const entry = this.symbol_index.get(local_uri);
         return entry?.symbols.programs.get(name);
@@ -27717,7 +28252,7 @@ var init_indexer = __esm(() => {
       }
       try {
         const file_path = URI.parse(file_uri).fsPath;
-        const content = await fs9.promises.readFile(file_path, "utf8");
+        const content = await fs10.promises.readFile(file_path, "utf8");
         const resolve_config = build_scope_resolver_config(cross_file_config);
         const resolved_scope = await scope_resolver.resolve(file_uri, content, resolve_config);
         return resolved_scope.symbols;
@@ -28005,8 +28540,7 @@ class IndentationDiagnosticAnalyzer {
         }
         return;
       }
-      const is_control_flow = node.type === "program" || node.type === "if" || node.type === "else" || node.type === "foreach" || node.type === "forvalues" || node.type === "while" || node.type === "frame";
-      if (is_control_flow && node.body) {
+      if (this.is_block_node_type(node) && "body" in node && node.body) {
         for (const child of node.body) {
           const child_start_line = child.range.start.line;
           if (child_start_line === start_line) {
@@ -28052,9 +28586,8 @@ class IndentationDiagnosticAnalyzer {
         }
         return;
       }
-      if (this.is_block_node_type(node)) {
-        const block_node = node;
-        for (const my_child of block_node.body) {
+      if (this.is_block_node_type(node) && "body" in node && node.body) {
+        for (const my_child of node.body) {
           const child_start_line = my_child.range.start.line;
           if (child_start_line === start_line) {
             walk_node(my_child, depth);
@@ -28067,6 +28600,10 @@ class IndentationDiagnosticAnalyzer {
             expected_depths.set(end_line, depth);
           }
         }
+      } else if ("body" in node && node.body) {
+        for (const my_child of node.body) {
+          walk_node(my_child, depth);
+        }
       }
     };
     for (const my_node of document.ast.nodes) {
@@ -28080,7 +28617,7 @@ class IndentationDiagnosticAnalyzer {
     return expected_depths;
   }
   is_block_node_type(node) {
-    return node.type === "program" || node.type === "if" || node.type === "else" || node.type === "foreach" || node.type === "forvalues" || node.type === "while" || node.type === "frame";
+    return node.type === "program" || node.type === "if" && !node.is_single_statement || node.type === "else" || node.type === "foreach" || node.type === "forvalues" || node.type === "while" || node.type === "frame";
   }
   should_skip_unnecessary_check(line, lineIndex, block_comment_lines2, continuation_lines) {
     if (block_comment_lines2.has(lineIndex)) {
@@ -31502,8 +32039,8 @@ function format_help_link(topic, display) {
 }
 
 // src/providers/completion.ts
-import * as fs10 from "fs";
-import * as path12 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
 function coerce_macro_map(value) {
   if (value instanceof Map) {
     return value;
@@ -32269,15 +32806,15 @@ class CompletionProvider {
           const path_parts = clean_path.split("/");
           search_prefix = path_parts.pop() || "";
           const dir_path = path_parts.join("/");
-          base_dir = path12.resolve(workspace_root, dir_path);
+          base_dir = path13.resolve(workspace_root, dir_path);
         } else {
           search_prefix = clean_path;
         }
       }
-      if (!fs10.existsSync(base_dir) || !fs10.statSync(base_dir).isDirectory()) {
+      if (!fs11.existsSync(base_dir) || !fs11.statSync(base_dir).isDirectory()) {
         return completions;
       }
-      const entries = fs10.readdirSync(base_dir, { withFileTypes: true });
+      const entries = fs11.readdirSync(base_dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith(".")) {
           continue;
@@ -32285,7 +32822,7 @@ class CompletionProvider {
         if (search_prefix && !entry.name.toLowerCase().startsWith(search_prefix.toLowerCase())) {
           continue;
         }
-        const entry_kind = classify_entry_sync(entry, path12.join(base_dir, entry.name), fs10);
+        const entry_kind = classify_entry_sync(entry, path13.join(base_dir, entry.name), fs11);
         if (entry_kind === "directory") {
           completions.push({
             label: entry.name + "/",
@@ -32313,17 +32850,17 @@ class CompletionProvider {
   get_workspace_root(document_uri) {
     try {
       const file_path = document_uri.replace(/^file:\/\//, "");
-      let current_dir = path12.dirname(file_path);
-      while (current_dir !== path12.dirname(current_dir)) {
+      let current_dir = path13.dirname(file_path);
+      while (current_dir !== path13.dirname(current_dir)) {
         const markers = [".git", "sight.toml", ".sight.json", "package.json", ".vscode"];
         for (const marker of markers) {
-          if (fs10.existsSync(path12.join(current_dir, marker))) {
+          if (fs11.existsSync(path13.join(current_dir, marker))) {
             return current_dir;
           }
         }
-        current_dir = path12.dirname(current_dir);
+        current_dir = path13.dirname(current_dir);
       }
-      return path12.dirname(file_path);
+      return path13.dirname(file_path);
     } catch {
       return null;
     }
@@ -33581,7 +34118,7 @@ var init_help_resolver = __esm(() => {
 });
 
 // src/server-handlers.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 function create_initialize_handler(on_capabilities_detected, on_initialization_options_detected, on_root_uri_detected) {
   return (params) => {
     const capabilities = params.capabilities;
@@ -33808,7 +34345,7 @@ function create_shutdown_handler(deps, disposables) {
       const SHUTDOWN_TIMEOUT_MS = 500;
       await Promise.race([
         deps.document_store.dispose(),
-        new Promise((resolve11) => setTimeout(resolve11, SHUTDOWN_TIMEOUT_MS))
+        new Promise((resolve12) => setTimeout(resolve12, SHUTDOWN_TIMEOUT_MS))
       ]);
     }
     deps?.scope_resolver?.dispose();
@@ -33825,10 +34362,14 @@ function create_exit_handler(on_exit) {
     }
   };
 }
-function create_did_change_watched_files_handler(deps, parse_uri, on_file_changed, on_project_config_changed) {
+function create_did_change_watched_files_handler(deps, parse_uri, on_file_changed, on_project_config_changed, on_gitignore_changed) {
   return (params) => {
     for (const my_event of params.changes) {
       const file_path = parse_uri(my_event.uri);
+      if (GITIGNORE_PATH.test(file_path)) {
+        on_gitignore_changed?.(my_event.uri);
+        continue;
+      }
       if (is_project_config_event_path(file_path)) {
         on_project_config_changed?.(my_event.uri);
         continue;
@@ -33911,7 +34452,7 @@ function create_shared_ihlp_resolver(deps, max_size = MAX_IHLP_CACHE_SIZE) {
     const my_cached = the_cache.get(my_path);
     if (my_cached !== undefined) {
       try {
-        const my_stat = await fs11.promises.stat(my_path);
+        const my_stat = await fs12.promises.stat(my_path);
         if (my_stat.mtimeMs === my_cached.mtime_ms) {
           the_cache.delete(my_path);
           the_cache.set(my_path, my_cached);
@@ -33924,8 +34465,8 @@ function create_shared_ihlp_resolver(deps, max_size = MAX_IHLP_CACHE_SIZE) {
       }
     }
     try {
-      const my_stat = await fs11.promises.stat(my_path);
-      const my_content = await fs11.promises.readFile(my_path, "utf-8");
+      const my_stat = await fs12.promises.stat(my_path);
+      const my_content = await fs12.promises.readFile(my_path, "utf-8");
       if (the_cache.size >= max_size) {
         const my_first = the_cache.keys().next().value;
         if (my_first !== undefined) {
@@ -33962,7 +34503,7 @@ function create_resolve_sthlp_file_handler(deps, shared_ihlp) {
     if (!deps.workspace_indexer)
       return null;
     try {
-      const my_content = await fs11.promises.readFile(file_path, "utf-8");
+      const my_content = await fs12.promises.readFile(file_path, "utf-8");
       return await expand_includes(my_content, my_ihlp_resolver);
     } catch {
       return null;
@@ -34041,7 +34582,7 @@ function create_expand_includes_handler(deps, shared_ihlp) {
     return { content: my_result };
   };
 }
-var import_node7, DEFAULT_SETTINGS, MAX_IHLP_CACHE_SIZE = 500, MAX_RESOLVE_STHLP_NEGATIVE_CACHE_SIZE = 1000;
+var import_node7, DEFAULT_SETTINGS, GITIGNORE_PATH, MAX_IHLP_CACHE_SIZE = 500, MAX_RESOLVE_STHLP_NEGATIVE_CACHE_SIZE = 1000;
 var init_server_handlers = __esm(() => {
   init_completion();
   init_context_tracker();
@@ -34090,6 +34631,9 @@ var init_server_handlers = __esm(() => {
     adoPaths: [],
     indexWorkspace: true,
     exclude: [],
+    workspace: {
+      respectGitignore: true
+    },
     cross_file: {
       index_workspace: true,
       max_indexed_files: 1000,
@@ -34110,6 +34654,7 @@ var init_server_handlers = __esm(() => {
     },
     debug: false
   };
+  GITIGNORE_PATH = /(?:^|[/\\])\.gitignore$/;
 });
 
 // src/utils/config-validator.ts
@@ -34251,6 +34796,13 @@ function validate_comment_formatting_config(config, log_warning) {
   if (typeof config.indexWorkspace === "boolean") {
     validated_config.indexWorkspace = config.indexWorkspace;
   }
+  if (config.workspace?.respectGitignore !== undefined) {
+    if (typeof config.workspace.respectGitignore === "boolean") {
+      validated_config.workspace.respectGitignore = config.workspace.respectGitignore;
+    } else {
+      log_warning?.("Invalid workspace.respectGitignore: " + `${config.workspace.respectGitignore}. ` + "Using default: " + `${DEFAULT_SETTINGS.workspace.respectGitignore}`);
+    }
+  }
   if (typeof config.debug === "boolean") {
     validated_config.debug = config.debug;
   }
@@ -34562,46 +35114,50 @@ var init_shared = __esm(() => {
 });
 
 // src/cli/source-files.ts
-import * as fs12 from "fs";
-import * as path13 from "path";
+import * as fs13 from "fs";
+import * as path14 from "path";
 import { TextDecoder } from "util";
 function canonicalize_existing_path(file_path) {
-  return fs12.realpathSync.native(file_path);
+  return fs13.realpathSync.native(file_path);
 }
 function workspace_relative(workspace_root, file_path) {
-  const relative6 = path13.relative(workspace_root, file_path);
-  const inside = relative6 !== ".." && !relative6.startsWith(`..${path13.sep}`) && !path13.isAbsolute(relative6);
-  return { relative: relative6, inside };
+  const relative7 = path14.relative(workspace_root, file_path);
+  const inside = relative7 !== ".." && !relative7.startsWith(`..${path14.sep}`) && !path14.isAbsolute(relative7);
+  return { relative: relative7, inside };
 }
 function relative_path(workspace_root, file_path) {
-  const { relative: relative6 } = workspace_relative(workspace_root, file_path);
-  if (relative6 === "") {
+  const { relative: relative7 } = workspace_relative(workspace_root, file_path);
+  if (relative7 === "") {
     return ".";
   }
-  return path13.isAbsolute(relative6) ? file_path : relative6.split(path13.sep).join("/");
+  return path14.isAbsolute(relative7) ? file_path : relative7.split(path14.sep).join("/");
 }
 function is_within_workspace(workspace_root, file_path) {
-  const { relative: relative6, inside } = workspace_relative(workspace_root, file_path);
-  return relative6 === "" || relative6.length > 0 && inside;
+  const { relative: relative7, inside } = workspace_relative(workspace_root, file_path);
+  return relative7 === "" || relative7.length > 0 && inside;
 }
-function walk_sources(dir_path, out, operator_errors, workspace_roots, exclude_matcher) {
+function walk_sources(dir_path, out, operator_errors, workspace_roots, exclude_matcher, gitignore_matcher) {
+  if (gitignore_matcher.is_ignored(dir_path, "directory"))
+    return;
   let entries;
   try {
-    entries = fs12.readdirSync(dir_path, { withFileTypes: true });
+    entries = fs13.readdirSync(dir_path, { withFileTypes: true });
   } catch (error) {
     operator_errors.push(`cannot read directory: ${dir_path}: ${error_message(error)}`);
     return;
   }
   for (const entry of entries) {
-    const entry_path = path13.join(dir_path, entry.name);
+    const entry_path = path14.join(dir_path, entry.name);
     if (entry.isDirectory()) {
       if (entry.name.startsWith("."))
         continue;
       if (!exclude_matcher.is_empty && exclude_matcher.is_excluded_dir(entry_path, workspace_roots)) {
         continue;
       }
-      walk_sources(entry_path, out, operator_errors, workspace_roots, exclude_matcher);
+      walk_sources(entry_path, out, operator_errors, workspace_roots, exclude_matcher, gitignore_matcher);
     } else if (entry.isFile() && hasStataExtension(entry.name)) {
+      if (gitignore_matcher.is_ignored(entry_path, "file"))
+        continue;
       if (!exclude_matcher.is_empty && exclude_matcher.is_excluded_file(entry_path, workspace_roots)) {
         continue;
       }
@@ -34609,20 +35165,21 @@ function walk_sources(dir_path, out, operator_errors, workspace_roots, exclude_m
     }
   }
 }
-function collect_report_targets(input_paths, workspace_root, cwd, exclude_patterns = []) {
+function collect_report_targets(input_paths, workspace_root, cwd, exclude_patterns = [], respect_gitignore = true) {
   const operator_errors = [];
   const source_paths = [];
-  let normalized_root = path13.resolve(workspace_root);
+  let normalized_root = path14.resolve(workspace_root);
   try {
     normalized_root = canonicalize_existing_path(normalized_root);
   } catch {}
   const exclude_matcher = create_exclude_matcher(exclude_patterns);
   const exclude_roots = [normalized_root];
+  const gitignore_matcher = create_gitignore_matcher(exclude_roots, respect_gitignore);
   const has_explicit_paths = input_paths.length > 0;
   const paths_to_collect = input_paths.length > 0 ? input_paths : [normalized_root];
   for (const input_path of paths_to_collect) {
-    const resolved_path = path13.resolve(cwd, input_path);
-    if (!fs12.existsSync(resolved_path)) {
+    const resolved_path = path14.resolve(cwd, input_path);
+    if (!fs13.existsSync(resolved_path)) {
       operator_errors.push(`path does not exist: ${input_path}`);
       continue;
     }
@@ -34635,13 +35192,13 @@ function collect_report_targets(input_paths, workspace_root, cwd, exclude_patter
     }
     let stat;
     try {
-      stat = fs12.statSync(absolute_path);
+      stat = fs13.statSync(absolute_path);
     } catch (error) {
       operator_errors.push(`cannot stat path: ${input_path}: ${error_message(error)}`);
       continue;
     }
     if (stat.isDirectory()) {
-      walk_sources(absolute_path, source_paths, operator_errors, exclude_roots, exclude_matcher);
+      walk_sources(absolute_path, source_paths, operator_errors, exclude_roots, exclude_matcher, gitignore_matcher);
     } else if (stat.isFile() && hasStataExtension(absolute_path)) {
       source_paths.push(absolute_path);
     }
@@ -34730,7 +35287,7 @@ function decode_error_diagnostic(offset) {
 function read_source_file(file_path) {
   let bytes;
   try {
-    bytes = fs12.readFileSync(file_path);
+    bytes = fs13.readFileSync(file_path);
   } catch (error) {
     return {
       kind: "read-error",
@@ -34754,6 +35311,7 @@ var init_source_files = __esm(() => {
   init_file_path_utils();
   init_exclude_matcher();
   init_diagnostic_code_description();
+  init_gitignore_matcher();
   init_shared();
   import_vscode_languageserver6 = __toESM(require_main4(), 1);
 });
@@ -34768,8 +35326,8 @@ __export(exports_check, {
   collect_check_diagnostics: () => collect_check_diagnostics,
   build_check_context: () => build_check_context
 });
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 function parse_required_option_value(argv, index, flag, value_kind, inline_value) {
   if (inline_value !== undefined) {
     if (inline_value.length === 0) {
@@ -34935,7 +35493,7 @@ function load_check_config(options) {
       warnings: validation_warnings
     };
   }
-  const loaded = options.config_path ? load_toml_file(path14.resolve(options.cwd, options.config_path)) : discover_and_load_project_config(options.workspace_root);
+  const loaded = options.config_path ? load_toml_file(path15.resolve(options.cwd, options.config_path)) : discover_and_load_project_config(options.workspace_root);
   if (loaded.kind === "load-failed") {
     return {
       kind: "operator-error",
@@ -35031,7 +35589,7 @@ async function collect_check_diagnostics(context, workspace_root, config, target
     const uri = URI.file(target.path).toString();
     let stats;
     try {
-      stats = fs13.statSync(target.path);
+      stats = fs14.statSync(target.path);
     } catch (error) {
       records.push(diagnostic_record(target.relative_path, unreadable_diagnostic(read_error_detail(error))));
       return records;
@@ -35042,7 +35600,7 @@ async function collect_check_diagnostics(context, workspace_root, config, target
       }
       return records;
     }
-    if (is_within_workspace(workspace_root, target.path) && files_indexed >= config.cross_file.max_indexed_files && !context.workspace_indexer.has_indexed_file(uri) && !is_hidden_source_path(target.path, scan_roots) && !exclude_matcher.is_excluded_file(target.path, [workspace_root])) {
+    if (is_within_workspace(workspace_root, target.path) && files_indexed >= config.cross_file.max_indexed_files && !context.workspace_indexer.has_indexed_file(uri) && !context.workspace_indexer.is_gitignored(target.path) && !is_hidden_source_path(target.path, scan_roots) && !exclude_matcher.is_excluded_file(target.path, [workspace_root])) {
       records.push(diagnostic_record(target.relative_path, index_limit_diagnostic()));
       return records;
     }
@@ -35126,10 +35684,10 @@ async function run_check_with_cwd(argv, cwd, output = DEFAULT_OUTPUT) {
 `);
     return EXIT_OK;
   }
-  const resolved_workspace_root = path14.resolve(cwd, result.args.workspace ?? ".");
+  const resolved_workspace_root = path15.resolve(cwd, result.args.workspace ?? ".");
   let is_workspace_directory = false;
   try {
-    is_workspace_directory = fs13.statSync(resolved_workspace_root).isDirectory();
+    is_workspace_directory = fs14.statSync(resolved_workspace_root).isDirectory();
   } catch {
     is_workspace_directory = false;
   }
@@ -35161,7 +35719,7 @@ async function run_check_with_cwd(argv, cwd, output = DEFAULT_OUTPUT) {
 `);
     return EXIT_OPERATOR_ERROR;
   }
-  const target_result = collect_report_targets(result.args.paths, workspace_root, cwd, config_result.config.exclude);
+  const target_result = collect_report_targets(result.args.paths, workspace_root, cwd, config_result.config.exclude, config_result.config.workspace.respectGitignore);
   if (target_result.operator_errors.length > 0) {
     for (const message of target_result.operator_errors) {
       output.stderr(`sight check: ${message}
@@ -35490,7 +36048,7 @@ function is_position_in_range3(position, range) {
 }
 
 // src/providers/hover.ts
-import * as path15 from "path";
+import * as path16 from "path";
 function has_definition_index(hit) {
   return typeof hit.definition_index === "number";
 }
@@ -36840,7 +37398,7 @@ ${source_info}${footer}`
     if (this.looks_like_uri_scheme(uri_or_path)) {
       return null;
     }
-    return path15.resolve(uri_or_path);
+    return path16.resolve(uri_or_path);
   }
   escape_markdown_link_text(text) {
     return text.replace(/[\\[\]()]/g, "\\$&");
@@ -36860,11 +37418,11 @@ ${source_info}${footer}`
     if (workspace_fs_path === null) {
       return fs_path;
     }
-    const relative7 = path15.relative(workspace_fs_path, fs_path);
-    if (relative7.startsWith("..") || path15.isAbsolute(relative7)) {
+    const relative8 = path16.relative(workspace_fs_path, fs_path);
+    if (relative8.startsWith("..") || path16.isAbsolute(relative8)) {
       return fs_path;
     }
-    return relative7;
+    return relative8;
   }
   format_source_link(source_uri, current_uri, workspace_root) {
     const source_path = this.normalize_file_path(source_uri);
@@ -37215,7 +37773,7 @@ var init_hover = __esm(() => {
 });
 
 // src/providers/definition.ts
-import * as path16 from "path";
+import * as path17 from "path";
 
 class DefinitionProvider {
   workspace_roots = [];
@@ -37960,7 +38518,7 @@ class DefinitionProvider {
     if (!the_call) {
       return { matched: false, path: null };
     }
-    const current_dir = path16.dirname(URI.parse(document.uri).fsPath);
+    const current_dir = path17.dirname(URI.parse(document.uri).fsPath);
     const my_outcome = resolve_forward_call_rich(file_path, current_dir, the_call.working_directory, { workspace_roots: this.workspace_roots });
     if (my_outcome.kind === "exact" || my_outcome.kind === "case_only") {
       return { matched: true, path: my_outcome.path };
@@ -37969,8 +38527,8 @@ class DefinitionProvider {
   }
   resolve_file_path(current_uri, file_path) {
     const current_path = URI.parse(current_uri).fsPath;
-    const current_dir = path16.dirname(current_path);
-    const resolved_path = path16.resolve(current_dir, file_path);
+    const current_dir = path17.dirname(current_path);
+    const resolved_path = path17.resolve(current_dir, file_path);
     const the_roots_set = new Set(this.workspace_roots);
     the_roots_set.add(current_dir);
     const the_roots = Array.from(the_roots_set);
@@ -38544,7 +39102,7 @@ class ReferencesProvider {
         }
         file_count++;
         if (file_count % 10 === 0) {
-          await new Promise((resolve15) => setTimeout(resolve15, 0));
+          await new Promise((resolve16) => setTimeout(resolve16, 0));
           if (cancellation_token?.isCancellationRequested) {
             break;
           }
@@ -38970,7 +39528,7 @@ var init_section_detector = __esm(() => {
 });
 
 // src/providers/symbols.ts
-import * as path17 from "path";
+import * as path18 from "path";
 function is_position_in_range4(position, range) {
   if (position.line < range.start.line) {
     return false;
@@ -39366,7 +39924,7 @@ class SymbolProvider {
       }
     }
     for (const document of all_documents) {
-      const my_basename = path17.basename(document.uri);
+      const my_basename = path18.basename(document.uri);
       for (const my_program of document.symbols.programs.values()) {
         if (my_program.name.toLowerCase().includes(lower_query)) {
           symbols.push({
@@ -39623,6 +40181,13 @@ class IndentationAnalyzer {
       this.process_embedded_block_node(node);
       return;
     }
+    if (node.type === "if" && node.is_single_statement) {
+      this.process_regular_node(node);
+      for (const my_child of node.body) {
+        this.walk_node(my_child);
+      }
+      return;
+    }
     if (this.is_block_node(node)) {
       if (node.type === "command") {
         const cmd = node;
@@ -41297,6 +41862,12 @@ class PrettyPrinter {
     return spaced.replace(/\(\s+/g, "(").replace(/\s+\)/g, ")");
   }
   printControlFlow(node) {
+    if (node.type === "if" && node.is_single_statement) {
+      const body_node = node.body[0];
+      const body = body_node ? this.printNode(body_node) : "";
+      const inline_body = body.trimStart().slice(0, -this.getStatementTerminator().length);
+      return `${this.getIndent()}if ${node.condition || ""} ${inline_body}`;
+    }
     const the_lines = [];
     let header = this.getIndent();
     switch (node.type) {
@@ -41339,7 +41910,7 @@ class PrettyPrinter {
   }
   printEmbeddedBlock(node) {
     if (node.is_single_line) {
-      return `${this.getIndent()}${node.start_command} ${node.content}${this.getStatementTerminator()}`;
+      return `${this.getIndent()}${node.start_command} ${node.content}`;
     }
     const the_lines = [];
     the_lines.push(`${this.getIndent()}${node.start_command}`);
@@ -41811,8 +42382,8 @@ class DocumentDebounceManager {
     if (prev_resolver) {
       prev_resolver();
     }
-    const promise = new Promise((resolve15) => {
-      this.pending_resolvers.set(uri, resolve15);
+    const promise = new Promise((resolve16) => {
+      this.pending_resolvers.set(uri, resolve16);
     });
     this.pending_promises.set(uri, promise);
     const timer = setTimeout(() => {
@@ -41838,9 +42409,9 @@ class DocumentDebounceManager {
     if (this.parse_queue.length >= this.MAX_QUEUE_LENGTH) {
       logger.warn(`Parse queue full, dropping ${uri} v${version}`);
       this.metrics.dropped_parses++;
-      const resolve15 = this.pending_resolvers.get(uri);
-      if (resolve15) {
-        resolve15();
+      const resolve16 = this.pending_resolvers.get(uri);
+      if (resolve16) {
+        resolve16();
         this.pending_resolvers.delete(uri);
         this.pending_promises.delete(uri);
       }
@@ -41863,7 +42434,7 @@ class DocumentDebounceManager {
     }
     this.active_parses++;
     try {
-      await new Promise((resolve15) => setImmediate(resolve15));
+      await new Promise((resolve16) => setImmediate(resolve16));
       await callback();
     } catch (error) {
       logger.error(`Parse error for ${uri}: ${error}`);
@@ -41895,9 +42466,9 @@ class DocumentDebounceManager {
       clearTimeout(existing);
       this.pending_timers.delete(uri);
     }
-    const resolve15 = this.pending_resolvers.get(uri);
-    if (resolve15) {
-      resolve15();
+    const resolve16 = this.pending_resolvers.get(uri);
+    if (resolve16) {
+      resolve16();
       this.pending_resolvers.delete(uri);
       this.pending_promises.delete(uri);
     }
@@ -72719,7 +73290,8 @@ __export(exports_server_factory, {
   create_server: () => create_server,
   build_non_capability_settings_from_sources: () => build_non_capability_settings_from_sources
 });
-import * as fs14 from "fs";
+import * as fs15 from "fs";
+import * as path19 from "path";
 function create_transport_connection(transport) {
   if (transport === "stdio") {
     return import_node8.createConnection(process.stdin, process.stdout);
@@ -72755,6 +73327,7 @@ function indexing_affecting_signature(config) {
   return JSON.stringify({
     adoPaths: config?.adoPaths ?? null,
     exclude: config?.exclude ?? null,
+    respectGitignore: config?.workspace?.respectGitignore ?? true,
     indexWorkspace: config?.indexWorkspace ?? null,
     index_workspace: config?.cross_file?.index_workspace ?? null,
     max_indexed_files: config?.cross_file?.max_indexed_files ?? null,
@@ -72797,6 +73370,13 @@ async function create_server(options) {
   let project_config_candidate_dirs = [];
   let active_workspace_roots = [];
   let project_config_watch_registration = undefined;
+  let gitignore_watch_registration;
+  let gitignore_watch_seq = 0;
+  let gitignore_watch_directories = [];
+  let gitignore_refresh_pending = false;
+  let gitignore_refresh_scheduled = false;
+  let gitignore_change_seq = 0;
+  let workspace_indexing_seq = 0;
   let last_applied_indexing_signature = "";
   let config_change_seq = 0;
   let init_options_config = undefined;
@@ -72898,6 +73478,65 @@ async function create_server(options) {
     }
     previous_registration?.dispose();
   }
+  async function refresh_gitignore_watchers() {
+    const my_seq = ++gitignore_watch_seq;
+    if (!server_capabilities.has_watched_files_dynamic_registration_capability) {
+      return;
+    }
+    const watchers = gitignore_watch_directories.map(({ directory, recursive }) => ({
+      globPattern: {
+        baseUri: URI.file(directory).toString(),
+        pattern: recursive ? "**/.gitignore" : ".gitignore"
+      },
+      kind: import_node8.WatchKind.Create | import_node8.WatchKind.Change | import_node8.WatchKind.Delete
+    }));
+    const registration = watchers.length > 0 ? await connection.client.register(import_node8.DidChangeWatchedFilesNotification.type, { watchers }) : undefined;
+    if (my_seq !== gitignore_watch_seq || shutdown_requested) {
+      registration?.dispose();
+      return;
+    }
+    const previous_registration = gitignore_watch_registration;
+    gitignore_watch_registration = registration;
+    previous_registration?.dispose();
+  }
+  function is_relevant_gitignore(uri) {
+    const directory = path19.dirname(URI.parse(uri).fsPath);
+    return gitignore_watch_directories.some((watch) => {
+      const relative9 = path19.relative(watch.directory, directory);
+      return relative9 === "" || watch.recursive && relative9 !== ".." && !relative9.startsWith(`..${path19.sep}`) && !path19.isAbsolute(relative9);
+    });
+  }
+  function schedule_gitignore_refresh() {
+    if (gitignore_refresh_scheduled || shutdown_requested)
+      return;
+    gitignore_refresh_scheduled = true;
+    queueMicrotask(() => {
+      const my_change_seq = gitignore_change_seq;
+      const my_config_seq = config_change_seq;
+      get_document_settings("").then((settings) => {
+        if (shutdown_requested || !gitignore_refresh_pending || my_change_seq !== gitignore_change_seq || my_config_seq !== config_change_seq) {
+          return;
+        }
+        configure_workspace_indexing(settings, active_workspace_roots, true);
+      }).catch((error) => {
+        connection.console.log(`[indexer] Gitignore refresh failed: ${error_message(error)}`);
+      }).finally(() => {
+        gitignore_refresh_scheduled = false;
+        if (gitignore_refresh_pending && (my_change_seq !== gitignore_change_seq || my_config_seq !== config_change_seq)) {
+          schedule_gitignore_refresh();
+        }
+      });
+    });
+  }
+  function on_gitignore_changed(uri) {
+    if (shutdown_requested || !is_relevant_gitignore(uri))
+      return;
+    gitignore_refresh_pending = true;
+    gitignore_change_seq++;
+    workspace_indexing_seq++;
+    workspace_indexer?.cancel();
+    schedule_gitignore_refresh();
+  }
   function build_non_capability_settings() {
     return build_non_capability_settings_from_sources({
       init_options_config,
@@ -73106,10 +73745,16 @@ async function create_server(options) {
     scope_resolver?.reset_reverse_deps();
   }
   function configure_workspace_indexing(settings, folder_paths, reset_indexes) {
+    const my_indexing_seq = ++workspace_indexing_seq;
+    gitignore_refresh_pending = false;
     if (reset_indexes) {
       reset_workspace_indexing_state();
     }
     last_applied_indexing_signature = indexing_affecting_signature(settings);
+    gitignore_watch_directories = create_gitignore_matcher(folder_paths, settings.workspace.respectGitignore).watch_directories;
+    refresh_gitignore_watchers().catch((error) => {
+      connection.console.log(`[indexer] Gitignore watcher registration failed: ` + error_message(error));
+    });
     configure_completion_provider(settings);
     apply_cache_capacities(settings);
     if (workspace_indexer) {
@@ -73117,8 +73762,13 @@ async function create_server(options) {
       workspace_indexer.set_max_indexed_files(settings.cross_file?.max_indexed_files ?? 1000);
     }
     const indexing_enabled = settings.indexWorkspace !== false && settings.cross_file?.index_workspace !== false;
-    if (indexing_enabled && workspace_indexer && folder_paths.length > 0) {
+    if (workspace_indexer && folder_paths.length > 0) {
+      if (!indexing_enabled) {
+        workspace_indexer.set_help_search_paths(discover_stata_ado_paths());
+      }
       workspace_indexer.initialize(folder_paths, settings.adoPaths || []).then(() => {
+        if (my_indexing_seq !== workspace_indexing_seq || shutdown_requested)
+          return;
         resolve_sthlp_handler?.clear_negative_cache();
         if (dependency_graph?.is_scan_complete()) {
           revalidate_all_open_docs();
@@ -73160,7 +73810,7 @@ async function create_server(options) {
       global_settings = build_non_capability_settings();
     }
     const settings = await get_document_settings("");
-    const indexing_changed = indexing_affecting_signature(settings) !== last_applied_indexing_signature;
+    const indexing_changed = gitignore_refresh_pending || indexing_affecting_signature(settings) !== last_applied_indexing_signature;
     if (indexing_changed) {
       configure_workspace_indexing(settings, active_workspace_roots, true);
     } else {
@@ -73415,14 +74065,14 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
           return open_doc.getText();
         }
         const fs_path = URI.parse(uri).fsPath;
-        return fs14.promises.readFile(fs_path, "utf8");
+        return fs15.promises.readFile(fs_path, "utf8");
       },
       exists: async (uri) => {
         if (documents.get(uri))
           return true;
         const fs_path = URI.parse(uri).fsPath;
         try {
-          await fs14.promises.access(fs_path);
+          await fs15.promises.access(fs_path);
           return true;
         } catch {
           return false;
@@ -73504,7 +74154,7 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   }));
   function apply_runtime_settings_change(settings) {
     const new_signature = indexing_affecting_signature(settings);
-    if (new_signature !== last_applied_indexing_signature) {
+    if (gitignore_refresh_pending || new_signature !== last_applied_indexing_signature) {
       configure_workspace_indexing(settings, active_workspace_roots, true);
     } else {
       configure_completion_provider(settings);
@@ -73580,6 +74230,9 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
     }
     if (dependency_graph) {
       const affected_callees = new Set(dependency_graph.get_callees(e.document.uri));
+      if (workspace_indexer?.is_gitignored(URI.parse(e.document.uri).fsPath)) {
+        dependency_graph.remove_caller(e.document.uri);
+      }
       if (affected_callees.size > 0) {
         invalidate_and_revalidate_callees(affected_callees);
       }
@@ -73601,7 +74254,7 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
     }
   }, async () => {
     await reload_project_config_from_active_root();
-  }));
+  }, on_gitignore_changed));
   connection.onNotification(DIAGNOSTIC_RESOURCES_CHANGED_NOTIFICATION, (params) => {
     const next = diagnostic_uris_from_notification(params);
     if (next !== undefined) {
@@ -73636,6 +74289,9 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
   });
   connection.onShutdown(() => {
     shutdown_requested = true;
+    gitignore_watch_seq++;
+    workspace_indexing_seq++;
+    gitignore_watch_registration?.dispose();
     return shutdown_handler();
   });
   connection.onExit(create_exit_handler());
@@ -73673,6 +74329,7 @@ var init_server_factory = __esm(() => {
   init_file_path_utils();
   init_dependency_graph();
   init_esm();
+  init_gitignore_matcher();
   init_stata_install_paths();
   init_diagnostic_resources();
   init_v18();
@@ -73869,4 +74526,4 @@ export {
   is_cli_entry_point
 };
 
-//# debugId=A1706D274D80E2DC64756E2164756E21
+//# debugId=47C20F7ACC43ED9664756E2164756E21