@jbearak/sight 0.12.0 → 0.13.0

package/dist/sight-server.js

@@ -52,7 +52,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@jbearak/sight",
-    version: "0.12.0",
+    version: "0.13.0",
     type: "module",
     workspaces: [
       "client"
@@ -633,6 +633,13 @@ function warn_unknown_key(key_path, raw_key, warn) {
     message: `Unknown project config key '${key_path}.${raw_key}'; ignoring`
   });
 }
+function warn_compat_collision(canonical_path, alias_path, warn) {
+  warn?.({
+    code: "normalized-key-collision",
+    key_path: canonical_path,
+    message: `Both '${canonical_path}' and compatibility alias '${alias_path}' ` + `are set; using '${canonical_path}'`
+  });
+}
 function normalize_severity_value(value, key_path, allowed, warn) {
   if (typeof value !== "string") {
     warn_invalid_value(key_path, value, warn);
@@ -734,25 +741,40 @@ function maybe_assign_object(target, key, value) {
   }
 }
 function map_diagnostics(raw, warn) {
-  warn_unknown_keys(raw, ["enabled", "indentation", "severity"], "diagnostics", warn);
+  warn_unknown_keys(raw, ["enabled", "indentation", "severity", "undefinedVariableSeverity"], "diagnostics", warn);
   const mapped = {};
   assign_boolean(mapped, "enabled", raw, "enabled", "diagnostics.enabled", warn);
   assign_boolean(mapped, "indentation", raw, "indentation", "diagnostics.indentation", warn);
   const severity = object_value(raw, "severity", "diagnostics.severity", warn);
+  const mapped_severity = {};
+  let canonical_undefined_variable;
   if (severity) {
     warn_unknown_keys(severity, DIAGNOSTIC_SEVERITY_KEYS, "diagnostics.severity", warn);
-    const mapped_severity = {};
     for (const my_key of DIAGNOSTIC_SEVERITY_KEYS) {
       const value = pick_key(severity, my_key, warn, `diagnostics.severity.${my_key}`);
       if (value !== undefined) {
+        if (my_key === "undefinedVariable") {
+          canonical_undefined_variable = value;
+        }
         const normalized = normalize_severity_value(value, `diagnostics.severity.${my_key}`, SEVERITIES, warn);
         if (normalized) {
           mapped_severity[my_key] = normalized;
         }
       }
     }
-    maybe_assign_object(mapped, "severity", mapped_severity);
   }
+  const legacy_undefined_variable = pick_key(raw, "undefinedVariableSeverity", warn, "diagnostics.undefinedVariableSeverity");
+  if (legacy_undefined_variable !== undefined) {
+    if (canonical_undefined_variable !== undefined) {
+      warn_compat_collision("diagnostics.severity.undefinedVariable", "diagnostics.undefinedVariableSeverity", warn);
+    } else {
+      const normalized = normalize_severity_value(legacy_undefined_variable, "diagnostics.undefinedVariableSeverity", SEVERITIES, warn);
+      if (normalized) {
+        mapped_severity.undefinedVariable = normalized;
+      }
+    }
+  }
+  maybe_assign_object(mapped, "severity", mapped_severity);
   return Object.keys(mapped).length > 0 ? mapped : undefined;
 }
 function map_formatting(raw, warn) {
@@ -800,7 +822,12 @@ function map_cross_file(raw, warn) {
     "maxForwardDepth",
     "maxChainDepth",
     "maxCalleeRevalidations",
-    "diagnostics"
+    "maxCachedFiles",
+    "maxCachedScopes",
+    "maxCachedForwardClosures",
+    "diagnostics",
+    "missingFileSeverity",
+    "caseMismatchSeverity"
   ], "crossFile", warn);
   const mapped = {};
   assign_boolean(mapped, "index_workspace", raw, "indexWorkspace", "crossFile.indexWorkspace", warn);
@@ -811,10 +838,15 @@ function map_cross_file(raw, warn) {
   assign_number(mapped, "max_forward_depth", raw, "maxForwardDepth", "crossFile.maxForwardDepth", warn);
   assign_number(mapped, "max_chain_depth", raw, "maxChainDepth", "crossFile.maxChainDepth", warn);
   assign_number(mapped, "max_callee_revalidations", raw, "maxCalleeRevalidations", "crossFile.maxCalleeRevalidations", warn);
+  assign_number(mapped, "max_cached_files", raw, "maxCachedFiles", "crossFile.maxCachedFiles", warn);
+  assign_number(mapped, "max_cached_scopes", raw, "maxCachedScopes", "crossFile.maxCachedScopes", warn);
+  assign_number(mapped, "max_cached_forward_closures", raw, "maxCachedForwardClosures", "crossFile.maxCachedForwardClosures", warn);
   const diagnostics = object_value(raw, "diagnostics", "crossFile.diagnostics", warn);
+  const mapped_diagnostics = {};
+  let canonical_missing_file;
+  let canonical_case_mismatch;
   if (diagnostics) {
     warn_unknown_keys(diagnostics, ["missingFile", "maxDepth", "callSiteIdentification", "caseMismatch"], "crossFile.diagnostics", warn);
-    const mapped_diagnostics = {};
     for (const [public_key, internal_key] of [
       ["missingFile", "missing_file"],
       ["maxDepth", "max_depth"],
@@ -823,6 +855,9 @@ function map_cross_file(raw, warn) {
       const key_path = `crossFile.diagnostics.${public_key}`;
       const value = pick_key(diagnostics, public_key, warn, key_path);
       if (value !== undefined) {
+        if (public_key === "missingFile") {
+          canonical_missing_file = value;
+        }
         const normalized = normalize_severity_value(value, key_path, CROSS_FILE_SEVERITIES, warn);
         if (normalized) {
           mapped_diagnostics[internal_key] = normalized;
@@ -832,13 +867,36 @@ function map_cross_file(raw, warn) {
     const case_mismatch_key_path = "crossFile.diagnostics.caseMismatch";
     const case_mismatch_value = pick_key(diagnostics, "caseMismatch", warn, case_mismatch_key_path);
     if (case_mismatch_value !== undefined) {
+      canonical_case_mismatch = case_mismatch_value;
       const normalized = normalize_severity_value(case_mismatch_value, case_mismatch_key_path, CROSS_FILE_CASE_MISMATCH_SEVERITIES, warn);
       if (normalized) {
         mapped_diagnostics["case_mismatch"] = normalized;
       }
     }
-    maybe_assign_object(mapped, "diagnostics", mapped_diagnostics);
   }
+  const legacy_missing_file = pick_key(raw, "missingFileSeverity", warn, "crossFile.missingFileSeverity");
+  if (legacy_missing_file !== undefined) {
+    if (canonical_missing_file !== undefined) {
+      warn_compat_collision("crossFile.diagnostics.missingFile", "crossFile.missingFileSeverity", warn);
+    } else {
+      const normalized = normalize_severity_value(legacy_missing_file, "crossFile.missingFileSeverity", CROSS_FILE_SEVERITIES, warn);
+      if (normalized) {
+        mapped_diagnostics.missing_file = normalized;
+      }
+    }
+  }
+  const legacy_case_mismatch = pick_key(raw, "caseMismatchSeverity", warn, "crossFile.caseMismatchSeverity");
+  if (legacy_case_mismatch !== undefined) {
+    if (canonical_case_mismatch !== undefined) {
+      warn_compat_collision("crossFile.diagnostics.caseMismatch", "crossFile.caseMismatchSeverity", warn);
+    } else {
+      const normalized = normalize_severity_value(legacy_case_mismatch, "crossFile.caseMismatchSeverity", CROSS_FILE_CASE_MISMATCH_SEVERITIES, warn);
+      if (normalized) {
+        mapped_diagnostics.case_mismatch = normalized;
+      }
+    }
+  }
+  maybe_assign_object(mapped, "diagnostics", mapped_diagnostics);
   return Object.keys(mapped).length > 0 ? mapped : undefined;
 }
 function map_public_config_to_partial_config(raw, warn) {
@@ -857,12 +915,21 @@ function map_public_config_to_partial_config(raw, warn) {
       warn_invalid_value("adoPaths", ado_paths, warn);
     }
   }
-  const exclude = pick_key(raw, "exclude", warn, "exclude");
+  const workspace = object_value(raw, "workspace", "workspace", warn);
+  if (workspace) {
+    warn_unknown_keys(workspace, ["exclude"], "workspace", warn);
+  }
+  const canonical_exclude = workspace ? pick_key(workspace, "exclude", warn, "workspace.exclude") : undefined;
+  const legacy_exclude = pick_key(raw, "exclude", warn, "exclude");
+  const exclude = canonical_exclude !== undefined ? canonical_exclude : legacy_exclude;
+  if (canonical_exclude !== undefined && legacy_exclude !== undefined) {
+    warn_compat_collision("workspace.exclude", "exclude", warn);
+  }
   if (exclude !== undefined) {
     if (Array.isArray(exclude) && exclude.every((item) => typeof item === "string")) {
       mapped.exclude = exclude;
     } else {
-      warn_invalid_value("exclude", exclude, warn);
+      warn_invalid_value(canonical_exclude !== undefined ? "workspace.exclude" : "exclude", exclude, warn);
     }
   }
   assign_string_member(root, "lineCommentStyle", raw, "lineCommentStyle", "lineCommentStyle", LINE_COMMENT_STYLES, warn);
@@ -941,6 +1008,7 @@ var init_schema = __esm(() => {
     "indexWorkspace",
     "adoPaths",
     "exclude",
+    "workspace",
     "lineCommentStyle",
     "debug",
     "diagnostics",
@@ -12199,13 +12267,6 @@ class StataLexer {
       while (this.peek() === " " || this.peek() === "\t" || this.peek() === "\r") {
         this.advance();
       }
-      if (this.state.delimiterMode === "semicolon") {
-        return {
-          type: "WHITESPACE",
-          value: this.source.substring(this.position_to_offset(startLine, startColumn), this.position),
-          range: this.makeRange(startLine, startColumn, this.line, this.column)
-        };
-      }
       return null;
     }
     if (char === `
@@ -12214,17 +12275,11 @@ class StataLexer {
         return {
           type: "STATEMENT_TERMINATOR",
           value: `
-`,
-          range: this.makeRange(startLine, startColumn, this.line, this.column)
-        };
-      } else {
-        return {
-          type: "WHITESPACE",
-          value: `
 `,
           range: this.makeRange(startLine, startColumn, this.line, this.column)
         };
       }
+      return null;
     }
     if (char === ";") {
       if (this.state.delimiterMode === "semicolon") {
@@ -13205,6 +13260,34 @@ function is_swallowed_continuation_terminator(my_token, in_continuation) {
 }
 
 // src/parser/index.ts
+class ContinuationTracker {
+  required_line = -1;
+  prev_collected_line = null;
+  prev_collected_end = null;
+  chain_clean = true;
+  note_continuation(continuation_token) {
+    const cont_line = continuation_token.range.start.line;
+    if (cont_line !== this.required_line) {
+      return;
+    }
+    const cont_col = continuation_token.range.start.character;
+    const is_first_on_prev_line = this.prev_collected_end !== null && this.required_line === this.prev_collected_line && cont_line === this.prev_collected_end.line;
+    const has_leading_gap = is_first_on_prev_line ? cont_col > this.prev_collected_end.character : cont_col > 0;
+    if (has_leading_gap) {
+      this.chain_clean = false;
+    }
+    this.required_line += 1;
+  }
+  collect(token) {
+    const token_line = token.range.start.line;
+    const follows_continuation = this.prev_collected_line !== null && token_line > this.prev_collected_line && token_line === this.required_line && this.chain_clean;
+    this.prev_collected_line = token_line;
+    this.prev_collected_end = token.range.end;
+    this.required_line = token_line;
+    this.chain_clean = true;
+    return follows_continuation;
+  }
+}
 var PREFIX_COMMANDS, StataParser;
 var init_parser = __esm(() => {
   init_types();
@@ -13274,7 +13357,7 @@ var init_parser = __esm(() => {
         node = this.parseEmbeddedLanguageBlock("python");
       } else if (this.check("WORD") && this.isPrefixCommand(this.peek().value)) {
         node = this.parseCommand();
-      } else if (this.checkWord("program") && this.peekNext()?.value === "define") {
+      } else if (this.checkWord("program") && this.tokens[this.current + 1]?.value === "define") {
         node = this.parseProgramDefinition();
       } else if (this.checkWord("syntax")) {
         node = this.parseSyntaxCommand();
@@ -13408,9 +13491,18 @@ var init_parser = __esm(() => {
           content += my_token.value;
           if (i < content_tokens.length - 1) {
             const next_token = content_tokens[i + 1];
-            const gap = next_token.range.start.character - my_token.range.end.character;
-            if (gap > 0) {
-              content += " ".repeat(gap);
+            if (next_token.range.start.line === my_token.range.end.line) {
+              const gap = next_token.range.start.character - my_token.range.end.character;
+              if (gap > 0) {
+                content += " ".repeat(gap);
+              }
+            } else if (next_token.range.start.line > my_token.range.end.line) {
+              const line_gap = next_token.range.start.line - my_token.range.end.line;
+              content += `
+`.repeat(line_gap);
+              if (next_token.range.start.character > 0) {
+                content += " ".repeat(next_token.range.start.character);
+              }
             }
           }
         }
@@ -13449,12 +13541,20 @@ var init_parser = __esm(() => {
       const body = [];
       const was_inside_program = this.inside_program;
       this.inside_program = true;
-      while (!this.isAtEnd() && !this.checkWord("end")) {
+      while (!this.isAtEnd()) {
+        const my_trivia = this.collectTrivia();
+        if (my_trivia.length > 0) {
+          this.pending_trivia.push(...my_trivia);
+        }
+        if (this.checkWord("end") || this.isAtEnd()) {
+          break;
+        }
         const stmt = this.parseStatement();
         if (stmt) {
           body.push(stmt);
         }
       }
+      const program_block_ending_trivia = this.checkWord("end") ? this.drainBlockEndingTrivia() : undefined;
       this.inside_program = was_inside_program;
       if (this.checkWord("end")) {
         this.advance();
@@ -13467,7 +13567,8 @@ var init_parser = __esm(() => {
         name: program_name,
         body,
         signature: merged_signature,
-        range: this.makeRange(start_token.range.start, this.previous().range.end)
+        range: this.makeRange(start_token.range.start, this.previous().range.end),
+        blockEndingTrivia: program_block_ending_trivia
       };
     }
     extract_and_merge_signatures(body) {
@@ -13538,20 +13639,20 @@ var init_parser = __esm(() => {
       let paren_depth = 0;
       const value_tokens = [];
       const preceded_by_continuation = [];
-      let continuation_pending = false;
+      const continuation = new ContinuationTracker;
       while (!this.check("STATEMENT_TERMINATOR") && !this.isAtEnd()) {
-        if (this.skipContinuation()) {
-          continuation_pending = true;
-          continue;
+        if (this.check("CONTINUATION")) {
+          const cont_token = this.peek();
+          if (this.skipContinuation()) {
+            continuation.note_continuation(cont_token);
+            continue;
+          }
         }
         const token_type = this.peek().type;
         if (token_type === "COMMENT_LINE" || token_type === "COMMENT_BLOCK") {
           break;
         }
         const token = this.advance();
-        if (token.type === "WHITESPACE") {
-          continue;
-        }
         if (token.type === "LPAREN") {
           paren_depth++;
         } else if (token.type === "RPAREN") {
@@ -13562,8 +13663,7 @@ var init_parser = __esm(() => {
           }
         }
         value_tokens.push(token);
-        preceded_by_continuation.push(continuation_pending);
-        continuation_pending = false;
+        preceded_by_continuation.push(continuation.collect(token));
       }
       const value = prefix_value + this.reconstruct_value_tokens(value_tokens, preceded_by_continuation);
       if (paren_depth > 0) {
@@ -13593,17 +13693,26 @@ var init_parser = __esm(() => {
       const function_name = this.advance().value;
       this.skipMacroDefinitionTrivia();
       const arg_tokens = [];
+      const value_tokens = [];
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
       while (!this.check("STATEMENT_TERMINATOR") && !this.isAtEnd()) {
-        if (this.skipContinuation()) {
-          continue;
+        if (this.check("CONTINUATION")) {
+          const cont_token = this.peek();
+          if (this.skipContinuation()) {
+            continuation.note_continuation(cont_token);
+            continue;
+          }
         }
         if (this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK")) {
           break;
         }
         const token = this.advance();
         arg_tokens.push(token);
+        value_tokens.push(token);
+        preceded_by_continuation.push(continuation.collect(token));
       }
-      const args_trimmed = this.reconstructTokensWithSpacing(arg_tokens).trim();
+      const args_trimmed = this.reconstruct_value_tokens(value_tokens, preceded_by_continuation).trim();
       const extended_function = {
         name: function_name,
         args: args_trimmed,
@@ -13742,12 +13851,8 @@ var init_parser = __esm(() => {
         const has_condition_before = lbrace_token.range.start.line === command_start_line;
         this.validate_open_brace(lbrace_token, lbrace_index, has_condition_before);
         const body = [];
-        while (!this.check("RBRACE") && !this.isAtEnd()) {
-          const stmt = this.parseStatement();
-          if (stmt) {
-            body.push(stmt);
-          }
-        }
+        const { body: my_body, blockEndingTrivia } = this.parseBraceBody();
+        body.push(...my_body);
         if (this.check("RBRACE")) {
           const rbrace_index = this.current;
           const rbrace_token = this.advance();
@@ -13760,7 +13865,8 @@ var init_parser = __esm(() => {
           fullName: "{",
           expression: undefined,
           body,
-          range: this.makeRange(start_token.range.start, this.previous().range.end)
+          range: this.makeRange(start_token.range.start, this.previous().range.end),
+          blockEndingTrivia
         };
       }
       if (!this.check("WORD") && !this.check("MACRO_REF_LOCAL") && !this.check("MACRO_REF_GLOBAL")) {
@@ -13782,24 +13888,25 @@ var init_parser = __esm(() => {
       if (commandName === "args") {
         return this.parseArgsCommand(command_token, prefixes);
       }
-      if (commandName === "frame" && this.check("WORD")) {
+      if (commandName === "frame") {
         const saved_pos = this.current;
-        const frame_name_token = this.advance();
-        this.skipTrivia();
-        if (this.check("COLON")) {
-          this.advance();
-          const frame_prefix = {
-            type: "prefix",
-            name: "frame",
-            fullName: "frame",
-            frameName: frame_name_token.value,
-            has_colon: true,
-            range: this.makeRange(command_token.range.start, this.previous().range.end)
-          };
-          return this.parseFramePrefixedCommand(frame_prefix, prefixes, start_token);
-        } else {
-          this.current = saved_pos;
+        if (this.check("WORD")) {
+          const frame_name_token = this.advance();
+          this.skipTrivia();
+          if (this.check("COLON")) {
+            this.advance();
+            const frame_prefix = {
+              type: "prefix",
+              name: "frame",
+              fullName: "frame",
+              frameName: frame_name_token.value,
+              has_colon: true,
+              range: this.makeRange(command_token.range.start, this.previous().range.end)
+            };
+            return this.parseFramePrefixedCommand(frame_prefix, prefixes, start_token);
+          }
         }
+        this.current = saved_pos;
       }
       return this.parseCommandBody(command_token, prefixes, start_token);
     }
@@ -13917,6 +14024,9 @@ var init_parser = __esm(() => {
               const parsed = this.parse_option_argument_inside_parens();
               option.argument = parsed.argument;
               option.argument_range = parsed.argument_range;
+              if (parsed.argument_unclosed) {
+                option.argument_unclosed = true;
+              }
             }
             options.push(option);
           } else {
@@ -13939,19 +14049,41 @@ var init_parser = __esm(() => {
     }
     parse_option_argument_inside_parens() {
       this.advance();
-      let argument = "";
       const arg_tokens = [];
-      while (!this.check("RPAREN") && !this.isAtEnd()) {
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
+      let paren_depth = 1;
+      while (!this.isAtEnd() && paren_depth > 0) {
+        if (this.check("STATEMENT_TERMINATOR")) {
+          break;
+        }
+        if (this.check("CONTINUATION")) {
+          const cont_token = this.peek();
+          if (this.skipContinuation()) {
+            continuation.note_continuation(cont_token);
+            continue;
+          }
+        }
+        if (this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK")) {
+          this.advance();
+          continue;
+        }
         const t = this.advance();
+        if (t.type === "LPAREN") {
+          paren_depth++;
+        } else if (t.type === "RPAREN") {
+          paren_depth--;
+          if (paren_depth === 0) {
+            break;
+          }
+        }
         arg_tokens.push(t);
-        argument += t.value;
+        preceded_by_continuation.push(continuation.collect(t));
       }
-      if (this.check("RPAREN")) {
-        this.advance();
-      }
-      const non_ws = arg_tokens.filter((t) => t.type !== "WHITESPACE");
-      const argument_range = non_ws.length > 0 ? { start: non_ws[0].range.start, end: non_ws[non_ws.length - 1].range.end } : undefined;
-      return { argument, argument_range };
+      const argument_unclosed = paren_depth > 0 ? true : undefined;
+      const argument = this.reconstruct_value_tokens(arg_tokens, preceded_by_continuation);
+      const argument_range = arg_tokens.length > 0 ? { start: arg_tokens[0].range.start, end: arg_tokens[arg_tokens.length - 1].range.end } : undefined;
+      return { argument, argument_range, argument_unclosed };
     }
     parseFilePathArgument() {
       if (this.check("STRING")) {
@@ -13967,13 +14099,18 @@ var init_parser = __esm(() => {
       const start_token = this.advance();
       let path3 = start_token.value;
       let end_range = start_token.range.end;
+      let prev_token = start_token;
       while (!this.isAtEnd()) {
-        if (this.check("WHITESPACE") || this.check("COMMA") || this.check("STATEMENT_TERMINATOR") || this.isTrivia()) {
+        if (this.check("COMMA") || this.check("STATEMENT_TERMINATOR") || this.isTrivia()) {
+          break;
+        }
+        if (!this.isAdjacentToken(prev_token, this.peek())) {
           break;
         }
         const token = this.advance();
         path3 += token.value;
         end_range = token.range.end;
+        prev_token = token;
       }
       return {
         name: path3,
@@ -13982,39 +14119,56 @@ var init_parser = __esm(() => {
     }
     parseParenthesizedGroup() {
       const paren_start = this.advance();
-      const paren_parts = [];
+      const inner_tokens = [];
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
       let paren_depth = 1;
-      let last_was_word = false;
+      const collect = (my_token) => {
+        inner_tokens.push(my_token);
+        preceded_by_continuation.push(continuation.collect(my_token));
+      };
       while (!this.isAtEnd() && paren_depth > 0) {
+        if (this.check("STATEMENT_TERMINATOR")) {
+          break;
+        }
+        if (this.check("CONTINUATION")) {
+          const cont_token = this.peek();
+          if (this.skipContinuation()) {
+            continuation.note_continuation(cont_token);
+            continue;
+          }
+        }
         if (this.check("LPAREN")) {
           paren_depth++;
-          paren_parts.push(this.advance().value);
-          last_was_word = false;
+          collect(this.advance());
         } else if (this.check("RPAREN")) {
           paren_depth--;
           if (paren_depth > 0) {
-            paren_parts.push(this.advance().value);
+            collect(this.advance());
           }
-          last_was_word = false;
         } else {
-          const current_is_word = this.check("WORD") || this.check("NUMBER") || this.check("MACRO_REF_LOCAL") || this.check("MACRO_REF_GLOBAL");
-          if (last_was_word && current_is_word) {
-            paren_parts.push(" ");
-          }
-          paren_parts.push(this.advance().value);
-          last_was_word = current_is_word;
+          collect(this.advance());
         }
       }
-      const paren_content = paren_parts.join("");
-      const paren_end_pos = this.check("RPAREN") ? this.peek().range.end : this.previous().range.end;
-      if (this.check("RPAREN")) {
+      const paren_content = this.reconstruct_value_tokens(inner_tokens, preceded_by_continuation);
+      const closed_group = paren_depth === 0 && this.check("RPAREN");
+      const paren_end_pos = closed_group ? this.peek().range.end : this.previous().range.end;
+      if (closed_group) {
         this.advance();
       }
       if (!paren_content.trim()) {
-        return null;
+        if (closed_group) {
+          return null;
+        }
+        return {
+          name: "(",
+          recovery_only: true,
+          range: this.makeRange(paren_start.range.start, paren_end_pos)
+        };
       }
+      const group_name = closed_group ? `(${paren_content})` : `(${paren_content}`;
       return {
-        name: `(${paren_content})`,
+        name: group_name,
         range: this.makeRange(paren_start.range.start, paren_end_pos)
       };
     }
@@ -14071,6 +14225,9 @@ var init_parser = __esm(() => {
               const parsed = this.parse_option_argument_inside_parens();
               option.argument = parsed.argument;
               option.argument_range = parsed.argument_range;
+              if (parsed.argument_unclosed) {
+                option.argument_unclosed = true;
+              }
             }
             options.push(option);
           } else {
@@ -14123,8 +14280,22 @@ var init_parser = __esm(() => {
       let allows_arbitrary_options = false;
       const seen_option_names = new Set;
       const syntax_tokens = [];
-      while (!this.check("STATEMENT_TERMINATOR") && !this.isAtEnd() && !this.isTrivia()) {
-        syntax_tokens.push(this.advance());
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
+      while (!this.check("STATEMENT_TERMINATOR") && !this.isAtEnd()) {
+        if (this.check("CONTINUATION")) {
+          const cont_token = this.peek();
+          if (this.skipContinuation()) {
+            continuation.note_continuation(cont_token);
+            continue;
+          }
+        }
+        if (this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK")) {
+          break;
+        }
+        const my_token = this.advance();
+        syntax_tokens.push(my_token);
+        preceded_by_continuation.push(continuation.collect(my_token));
       }
       let token_idx = 0;
       while (token_idx < syntax_tokens.length) {
@@ -14145,7 +14316,7 @@ var init_parser = __esm(() => {
         const my_token = syntax_tokens[token_idx];
         if (my_token.type === "OPERATOR" && my_token.value === "*") {
           if (token_idx + 1 < syntax_tokens.length && syntax_tokens[token_idx + 1].type === "WORD") {
-            const opt_result2 = this.parse_option_spec(syntax_tokens, token_idx);
+            const opt_result2 = this.parse_option_spec(syntax_tokens, token_idx, preceded_by_continuation);
             if (opt_result2) {
               const opt_name_lower = opt_result2.spec.name;
               seen_option_names.add(opt_name_lower);
@@ -14160,7 +14331,7 @@ var init_parser = __esm(() => {
           }
           continue;
         }
-        const opt_result = this.parse_option_spec(syntax_tokens, token_idx);
+        const opt_result = this.parse_option_spec(syntax_tokens, token_idx, preceded_by_continuation);
         if (opt_result) {
           const opt_name_lower = opt_result.spec.name;
           seen_option_names.add(opt_name_lower);
@@ -14269,7 +14440,7 @@ var init_parser = __esm(() => {
       };
       return { spec, next_idx: current_idx };
     }
-    parse_option_spec(tokens, start_idx) {
+    parse_option_spec(tokens, start_idx, preceded_by_continuation = []) {
       if (start_idx >= tokens.length) {
         return null;
       }
@@ -14302,6 +14473,7 @@ var init_parser = __esm(() => {
       if (current_idx < tokens.length && tokens[current_idx].type === "LPAREN") {
         current_idx++;
         const type_tokens = [];
+        const type_flags = [];
         let paren_depth = 1;
         while (current_idx < tokens.length && paren_depth > 0) {
           const my_token = tokens[current_idx];
@@ -14314,6 +14486,7 @@ var init_parser = __esm(() => {
             }
           }
           type_tokens.push(my_token);
+          type_flags.push(preceded_by_continuation[current_idx] ?? false);
           current_idx++;
         }
         if (current_idx < tokens.length && tokens[current_idx].type === "RPAREN") {
@@ -14336,25 +14509,25 @@ var init_parser = __esm(() => {
             argument_type = first_part;
             for (let i = 1;i < type_tokens.length; i++) {
               if (type_tokens[i].type === "WORD" && type_tokens[i].value === "default" && i + 1 < type_tokens.length && type_tokens[i + 1].type === "LPAREN") {
-                let default_str = "";
+                const default_tokens = [];
+                const default_flags = [];
                 let default_paren_depth = 1;
                 let j = i + 2;
                 while (j < type_tokens.length && default_paren_depth > 0) {
                   const my_token = type_tokens[j];
                   if (my_token.type === "LPAREN") {
                     default_paren_depth++;
-                    default_str += my_token.value;
                   } else if (my_token.type === "RPAREN") {
                     default_paren_depth--;
-                    if (default_paren_depth > 0) {
-                      default_str += my_token.value;
+                    if (default_paren_depth === 0) {
+                      break;
                     }
-                  } else {
-                    default_str += my_token.value;
                   }
+                  default_tokens.push(my_token);
+                  default_flags.push(type_flags[j] ?? false);
                   j++;
                 }
-                default_value = default_str.trim();
+                default_value = this.reconstruct_value_tokens(default_tokens, default_flags).trim();
                 break;
               }
             }
@@ -14455,11 +14628,17 @@ var init_parser = __esm(() => {
     parseIfStatement() {
       const ifToken = this.advance();
       const condition_tokens = [];
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
       const condition_start_line = ifToken.range.start.line;
       let paren_depth = 0;
       while (!this.check("LBRACE") && !this.isAtEnd()) {
-        if (this.skipContinuation()) {
-          continue;
+        if (this.check("CONTINUATION")) {
+          const cont_token = this.peek();
+          if (this.skipContinuation()) {
+            continuation.note_continuation(cont_token);
+            continue;
+          }
         }
         if (this.check("STATEMENT_TERMINATOR")) {
           break;
@@ -14474,11 +14653,10 @@ var init_parser = __esm(() => {
             paren_depth = 0;
           }
         }
-        if (token.type !== "WHITESPACE") {
-          condition_tokens.push(token);
-        }
+        condition_tokens.push(token);
+        preceded_by_continuation.push(continuation.collect(token));
       }
-      const condition = this.reconstructTokensWithSpacing(condition_tokens).trim();
+      const condition = this.reconstruct_value_tokens(condition_tokens, preceded_by_continuation).trim();
       if (paren_depth > 0) {
         this.addError("Unbalanced parentheses in if condition: missing closing parenthesis", ifToken.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
@@ -14486,17 +14664,15 @@ var init_parser = __esm(() => {
         this.addError("Empty if condition", ifToken.range, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
       const body = [];
+      let blockEndingTrivia;
       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;
         this.validate_open_brace(lbrace_token, lbrace_index, has_condition_before);
-        while (!this.check("RBRACE") && !this.isAtEnd()) {
-          const stmt = this.parseStatement();
-          if (stmt) {
-            body.push(stmt);
-          }
-        }
+        const { body: my_body, blockEndingTrivia: my_block_ending_trivia } = this.parseBraceBody();
+        body.push(...my_body);
+        blockEndingTrivia = my_block_ending_trivia;
         if (this.check("RBRACE")) {
           const rbrace_index = this.current;
           const rbrace_token = this.advance();
@@ -14509,7 +14685,8 @@ var init_parser = __esm(() => {
         type: "if",
         condition: condition.trim(),
         body,
-        range: this.makeRange(ifToken.range.start, this.previous().range.end)
+        range: this.makeRange(ifToken.range.start, this.previous().range.end),
+        blockEndingTrivia
       };
     }
     parseElseStatement() {
@@ -14523,17 +14700,17 @@ var init_parser = __esm(() => {
         };
       }
       const body = [];
+      let blockEndingTrivia;
+      let is_brace_else = false;
       if (this.check("LBRACE")) {
+        is_brace_else = true;
         const lbrace_index = this.current;
         const lbrace_token = this.advance();
         const has_condition_before = lbrace_token.range.start.line === elseToken.range.start.line;
         this.validate_open_brace(lbrace_token, lbrace_index, has_condition_before);
-        while (!this.check("RBRACE") && !this.isAtEnd()) {
-          const stmt = this.parseStatement();
-          if (stmt) {
-            body.push(stmt);
-          }
-        }
+        const { body: my_body, blockEndingTrivia: my_block_ending_trivia } = this.parseBraceBody();
+        body.push(...my_body);
+        blockEndingTrivia = my_block_ending_trivia;
         if (this.check("RBRACE")) {
           const rbrace_index = this.current;
           const rbrace_token = this.advance();
@@ -14547,10 +14724,12 @@ var init_parser = __esm(() => {
           body.push(stmt);
         }
       }
+      const end_position = !is_brace_else && body.length > 0 ? body[body.length - 1].range.end : this.previous().range.end;
       return {
         type: "else",
         body,
-        range: this.makeRange(elseToken.range.start, this.previous().range.end)
+        range: this.makeRange(elseToken.range.start, end_position),
+        blockEndingTrivia
       };
     }
     parseLoopStatement() {
@@ -14566,9 +14745,9 @@ var init_parser = __esm(() => {
       const is_foreach_spec = this.check("WORD") && (this.peek().value === "in" || this.peek().value === "of");
       if (is_forvalues_spec || is_foreach_spec) {
         const specType = this.advance().value;
-        let loop_spec_body = "";
-        let prev_spec_token = null;
-        let continuation_pending = false;
+        const spec_tokens = [];
+        const preceded_by_continuation = [];
+        const continuation = new ContinuationTracker;
         while (!this.check("LBRACE") && !this.isAtEnd()) {
           if (this.check("STATEMENT_TERMINATOR")) {
             if (is_swallowed_continuation_terminator(this.tokens[this.current], this.current > 0 && this.tokens[this.current - 1].type === "CONTINUATION")) {
@@ -14579,44 +14758,24 @@ var init_parser = __esm(() => {
           }
           const token = this.advance();
           if (token.type === "CONTINUATION") {
-            continuation_pending = true;
-            continue;
-          }
-          if (token.type === "WHITESPACE") {
+            continuation.note_continuation(token);
             continue;
           }
-          if (prev_spec_token !== null) {
-            const same_line = prev_spec_token.range.end.line === token.range.start.line;
-            let needs_separator;
-            if (same_line) {
-              needs_separator = token.range.start.character - prev_spec_token.range.end.character > 0;
-            } else if (continuation_pending) {
-              needs_separator = token.range.start.character > 0;
-            } else {
-              needs_separator = true;
-            }
-            if (needs_separator) {
-              loop_spec_body += " ";
-            }
-          }
-          loop_spec_body += token.value;
-          prev_spec_token = token;
-          continuation_pending = false;
+          spec_tokens.push(token);
+          preceded_by_continuation.push(continuation.collect(token));
         }
-        loopSpec = specType + " " + loop_spec_body.trim();
+        loopSpec = specType + " " + this.reconstruct_value_tokens(spec_tokens, preceded_by_continuation).trim();
       }
       const body = [];
+      let blockEndingTrivia;
       if (this.check("LBRACE")) {
         const lbrace_index = this.current;
         const lbrace_token = this.advance();
         const has_condition_before = lbrace_token.range.start.line === loop_start_line;
         this.validate_open_brace(lbrace_token, lbrace_index, has_condition_before);
-        while (!this.check("RBRACE") && !this.isAtEnd()) {
-          const stmt = this.parseStatement();
-          if (stmt) {
-            body.push(stmt);
-          }
-        }
+        const { body: my_body, blockEndingTrivia: my_block_ending_trivia } = this.parseBraceBody();
+        body.push(...my_body);
+        blockEndingTrivia = my_block_ending_trivia;
         if (this.check("RBRACE")) {
           const rbrace_index = this.current;
           const rbrace_token = this.advance();
@@ -14630,17 +14789,24 @@ var init_parser = __esm(() => {
         loopVar,
         loopSpec,
         body,
-        range: this.makeRange(loopToken.range.start, this.previous().range.end)
+        range: this.makeRange(loopToken.range.start, this.previous().range.end),
+        blockEndingTrivia
       };
     }
     parseWhileStatement() {
       const whileToken = this.advance();
       const while_start_line = whileToken.range.start.line;
       const condition_tokens = [];
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
       let paren_depth = 0;
       while (!this.check("LBRACE") && !this.isAtEnd()) {
-        if (this.skipContinuation()) {
-          continue;
+        if (this.check("CONTINUATION")) {
+          const cont_token = this.peek();
+          if (this.skipContinuation()) {
+            continuation.note_continuation(cont_token);
+            continue;
+          }
         }
         if (this.check("STATEMENT_TERMINATOR")) {
           break;
@@ -14655,11 +14821,10 @@ var init_parser = __esm(() => {
             paren_depth = 0;
           }
         }
-        if (token.type !== "WHITESPACE") {
-          condition_tokens.push(token);
-        }
+        condition_tokens.push(token);
+        preceded_by_continuation.push(continuation.collect(token));
       }
-      const condition = this.reconstructTokensWithSpacing(condition_tokens).trim();
+      const condition = this.reconstruct_value_tokens(condition_tokens, preceded_by_continuation).trim();
       if (paren_depth > 0) {
         this.addError("Unbalanced parentheses in while condition: missing closing parenthesis", whileToken.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
@@ -14667,17 +14832,15 @@ var init_parser = __esm(() => {
         this.addError("Empty while condition", whileToken.range, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
       const body = [];
+      let blockEndingTrivia;
       if (this.check("LBRACE")) {
         const lbrace_index = this.current;
         const lbrace_token = this.advance();
         const has_condition_before = lbrace_token.range.start.line === while_start_line;
         this.validate_open_brace(lbrace_token, lbrace_index, has_condition_before);
-        while (!this.check("RBRACE") && !this.isAtEnd()) {
-          const stmt = this.parseStatement();
-          if (stmt) {
-            body.push(stmt);
-          }
-        }
+        const { body: my_body, blockEndingTrivia: my_block_ending_trivia } = this.parseBraceBody();
+        body.push(...my_body);
+        blockEndingTrivia = my_block_ending_trivia;
         if (this.check("RBRACE")) {
           const rbrace_index = this.current;
           const rbrace_token = this.advance();
@@ -14690,7 +14853,8 @@ var init_parser = __esm(() => {
         type: "while",
         condition: condition.trim(),
         body,
-        range: this.makeRange(whileToken.range.start, this.previous().range.end)
+        range: this.makeRange(whileToken.range.start, this.previous().range.end),
+        blockEndingTrivia
       };
     }
     parseStringStatement() {
@@ -14698,9 +14862,7 @@ var init_parser = __esm(() => {
       const statement_tokens = [];
       while (!this.check("STATEMENT_TERMINATOR") && !this.isAtEnd()) {
         const token = this.advance();
-        if (token.type !== "WHITESPACE") {
-          statement_tokens.push(token);
-        }
+        statement_tokens.push(token);
       }
       const content = this.reconstructTokensWithSpacing(statement_tokens);
       return {
@@ -14711,15 +14873,15 @@ var init_parser = __esm(() => {
       };
     }
     parseFrameBlock() {
+      const frame_index = this.current;
       const frame_token = this.advance();
       const frame_start_line = frame_token.range.start.line;
       this.skipTrivia();
       if (!this.check("WORD")) {
-        this.current--;
+        this.current = frame_index;
         return null;
       }
       const name_token = this.peek();
-      const saved_position = this.current;
       this.advance();
       this.skipTrivia();
       if (this.check("COLON")) {
@@ -14735,7 +14897,7 @@ var init_parser = __esm(() => {
         return this.parseFramePrefixedCommand(frame_prefix, [], frame_token);
       }
       if (!this.check("LBRACE")) {
-        this.current = saved_position - 1;
+        this.current = frame_index;
         return null;
       }
       const frame_name = name_token.value;
@@ -14743,13 +14905,7 @@ var init_parser = __esm(() => {
       const lbrace_token = this.advance();
       const has_condition_before = lbrace_token.range.start.line === frame_start_line;
       this.validate_open_brace(lbrace_token, lbrace_index, has_condition_before);
-      const body = [];
-      while (!this.check("RBRACE") && !this.isAtEnd()) {
-        const stmt = this.parseStatement();
-        if (stmt) {
-          body.push(stmt);
-        }
-      }
+      const { body, blockEndingTrivia } = this.parseBraceBody();
       if (this.check("RBRACE")) {
         const rbrace_index = this.current;
         const rbrace_token = this.advance();
@@ -14761,7 +14917,8 @@ var init_parser = __esm(() => {
         type: "frame",
         frameName: frame_name,
         body,
-        range: this.makeRange(frame_token.range.start, this.previous().range.end)
+        range: this.makeRange(frame_token.range.start, this.previous().range.end),
+        blockEndingTrivia
       };
     }
     parseUnabCommandBody(command_token) {
@@ -14822,6 +14979,9 @@ var init_parser = __esm(() => {
               const parsed = this.parse_option_argument_inside_parens();
               option.argument = parsed.argument;
               option.argument_range = parsed.argument_range;
+              if (parsed.argument_unclosed) {
+                option.argument_unclosed = true;
+              }
             }
             options.push(option);
           } else {
@@ -14848,7 +15008,7 @@ var init_parser = __esm(() => {
     }
     collectTrivia() {
       const trivia = [];
-      while (this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK") || this.check("CONTINUATION") || this.check("WHITESPACE")) {
+      while (this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK") || this.check("CONTINUATION")) {
         const token = this.advance();
         if (token.type === "COMMENT_LINE") {
           const style = token.value.startsWith("*") ? "star" : "slash";
@@ -14881,12 +15041,42 @@ var init_parser = __esm(() => {
         this.advance();
       }
     }
+    parseBraceBody() {
+      const body = [];
+      while (!this.isAtEnd()) {
+        const my_trivia = this.collectTrivia();
+        if (my_trivia.length > 0) {
+          this.pending_trivia.push(...my_trivia);
+        }
+        if (this.check("RBRACE") || this.isAtEnd()) {
+          break;
+        }
+        const stmt = this.parseStatement();
+        if (stmt) {
+          body.push(stmt);
+        }
+      }
+      const blockEndingTrivia = this.check("RBRACE") ? this.drainBlockEndingTrivia() : undefined;
+      return { body, blockEndingTrivia };
+    }
+    drainBlockEndingTrivia() {
+      if (this.pending_trivia.length === 0) {
+        return;
+      }
+      const has_continuation = this.pending_trivia.some((my_trivia) => my_trivia.type === "comment" && my_trivia.style === "continuation");
+      if (has_continuation) {
+        return;
+      }
+      const block_ending_trivia = this.pending_trivia;
+      this.pending_trivia = [];
+      return block_ending_trivia;
+    }
     skipMacroDefinitionTrivia() {
       while (!this.isAtEnd()) {
         if (this.skipContinuation()) {
           continue;
         }
-        if (this.check("WHITESPACE") || this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK")) {
+        if (this.check("COMMENT_LINE") || this.check("COMMENT_BLOCK")) {
           this.advance();
           continue;
         }
@@ -14903,7 +15093,7 @@ var init_parser = __esm(() => {
           }
           continue;
         }
-        if (token.type === "COMMENT_LINE" || token.type === "COMMENT_BLOCK" || token.type === "WHITESPACE") {
+        if (token.type === "COMMENT_LINE" || token.type === "COMMENT_BLOCK") {
           offset++;
           continue;
         }
@@ -14985,11 +15175,6 @@ var init_parser = __esm(() => {
     peek() {
       return this.tokens[this.current];
     }
-    peekNext() {
-      if (this.current + 1 >= this.tokens.length)
-        return;
-      return this.tokens[this.current + 1];
-    }
     previous() {
       return this.tokens[this.current - 1];
     }
@@ -15007,12 +15192,18 @@ var init_parser = __esm(() => {
       return this.context_tracker;
     }
     parseExpression() {
-      let expression = "";
+      const the_tokens = [];
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
       let paren_depth = 0;
       const start_pos = this.current;
       while (!this.isAtEnd()) {
         const token = this.peek();
+        if (token.type === "STATEMENT_TERMINATOR") {
+          break;
+        }
         if (this.skipContinuation()) {
+          continuation.note_continuation(token);
           continue;
         }
         if (token.type === "LPAREN") {
@@ -15025,7 +15216,7 @@ var init_parser = __esm(() => {
           }
         }
         if (paren_depth === 0) {
-          if (token.type === "COMMA" || token.type === "STATEMENT_TERMINATOR") {
+          if (token.type === "COMMA") {
             break;
           }
           if (token.type === "WORD" && (token.value === "if" || token.value === "in")) {
@@ -15035,13 +15226,11 @@ var init_parser = __esm(() => {
         if (token.type === "COMMENT_LINE" || token.type === "COMMENT_BLOCK") {
           break;
         }
-        const tokenValue = this.advance().value;
-        if (token.type === "WHITESPACE") {
-          expression += " ";
-        } else {
-          expression += tokenValue;
-        }
+        this.advance();
+        the_tokens.push(token);
+        preceded_by_continuation.push(continuation.collect(token));
       }
+      const expression = this.reconstruct_value_tokens(the_tokens, preceded_by_continuation);
       if (paren_depth > 0) {
         const end_pos = this.current > 0 ? this.previous().range : this.peek().range;
         this.addError("Unbalanced parentheses: missing closing parenthesis", end_pos, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
@@ -15073,7 +15262,9 @@ var init_parser = __esm(() => {
       return false;
     }
     parseQualifierExpressionWithStrayDetection(qualifier_type, stop_at_in, check_empty) {
-      let expression = "";
+      const the_tokens = [];
+      const preceded_by_continuation = [];
+      const continuation = new ContinuationTracker;
       let paren_depth = 0;
       let bracket_depth = 0;
       const start_token = this.peek();
@@ -15082,6 +15273,9 @@ var init_parser = __esm(() => {
       let in_string_context = false;
       while (!this.isAtEnd()) {
         const token = this.peek();
+        if (token.type === "STATEMENT_TERMINATOR") {
+          break;
+        }
         if (token.type === "LPAREN") {
           paren_depth++;
           state_stack.push("INITIAL");
@@ -15112,10 +15306,11 @@ var init_parser = __esm(() => {
           }
         }
         if (this.skipContinuation()) {
+          continuation.note_continuation(token);
           continue;
         }
         if (paren_depth === 0 && bracket_depth === 0) {
-          if (token.type === "STATEMENT_TERMINATOR" || token.type === "COMMA") {
+          if (token.type === "COMMA") {
             break;
           }
           if (stop_at_in && token.type === "WORD" && token.value === "in") {
@@ -15138,7 +15333,7 @@ var init_parser = __esm(() => {
             this.addError(`Unexpected token '${token.value}' after comparison expression. Did you mean to use '&' or '|'?`, token.range, "STRAY_TOKEN_IN_CONDITION" /* STRAY_TOKEN_IN_CONDITION */);
           }
         }
-        if (token.type !== "WHITESPACE" && token.type !== "LPAREN" && token.type !== "RPAREN" && bracket_depth === 0) {
+        if (token.type !== "LPAREN" && token.type !== "RPAREN" && bracket_depth === 0) {
           const current_state_for_transition = state_stack[state_stack.length - 1];
           if (token.type === "OPERATOR") {
             if (token.value === "=" && prev_token && prev_token.type === "OPERATOR" && prev_token.value === "~") {
@@ -15166,17 +15361,14 @@ var init_parser = __esm(() => {
           }
           prev_token = token;
         }
-        const tokenValue = this.advance().value;
-        if (token.type === "WHITESPACE") {
-          expression += " ";
-        } else {
-          expression += tokenValue;
-        }
+        this.advance();
+        the_tokens.push(token);
+        preceded_by_continuation.push(continuation.collect(token));
       }
       if (paren_depth > 0) {
         this.addError(`Unbalanced parentheses in ${qualifier_type} qualifier: missing closing parenthesis`, start_token.range, "UNBALANCED_PARENTHESES" /* UNBALANCED_PARENTHESES */);
       }
-      const trimmed_expression = expression.trim();
+      const trimmed_expression = this.reconstruct_value_tokens(the_tokens, preceded_by_continuation).trim();
       if (check_empty && trimmed_expression === "") {
         this.addError(`Empty ${qualifier_type} qualifier expression`, start_token.range, "MISSING_EXPRESSION_AFTER_EQUALS" /* MISSING_EXPRESSION_AFTER_EQUALS */);
       }
@@ -15219,7 +15411,6 @@ var init_parser = __esm(() => {
     }
     scan_code_on_same_line(start_pos, line) {
       const trivia_types = [
-        "WHITESPACE",
         "COMMENT_LINE",
         "COMMENT_BLOCK",
         "CONTINUATION"
@@ -15258,7 +15449,6 @@ var init_parser = __esm(() => {
     }
     find_code_before_on_same_line(end_pos, line) {
       const trivia_types = [
-        "WHITESPACE",
         "COMMENT_LINE",
         "COMMENT_BLOCK",
         "CONTINUATION"
@@ -15378,12 +15568,12 @@ var init_parser = __esm(() => {
             if (gap > 0) {
               the_parts.push(" ".repeat(gap));
             }
-          } else {
-            const spaces_from_line_start = my_token.range.start.character;
-            if (spaces_from_line_start > 0) {
-              the_parts.push(" ".repeat(spaces_from_line_start));
-            } else {
-              the_parts.push(" ");
+          } else if (my_token.range.start.line > prev_token.range.end.line) {
+            const line_gap = my_token.range.start.line - prev_token.range.end.line;
+            the_parts.push(`
+`.repeat(line_gap));
+            if (my_token.range.start.character > 0) {
+              the_parts.push(" ".repeat(my_token.range.start.character));
             }
           }
         }
@@ -16551,10 +16741,6 @@ function parse_macro_def_head(statement_tokens) {
   const run = [];
   while (i < statement_tokens.length) {
     const my_tok = statement_tokens[i];
-    if (my_tok.type === "WHITESPACE") {
-      i++;
-      continue;
-    }
     if (!NAME_TOKEN_TYPES.has(my_tok.type))
       break;
     if (run.length > 0 && !tokens_adjacent(run[run.length - 1], my_tok))
@@ -17046,6 +17232,57 @@ var init_macro_creating_commands = __esm(() => {
   ];
 });
 
+// src/utils/token-utils.ts
+function position_before2(a, b) {
+  return a.line < b.line || a.line === b.line && a.character < b.character;
+}
+function position_at_or_before(a, b) {
+  return a.line < b.line || a.line === b.line && a.character <= b.character;
+}
+function find_last_token_starting_at_or_before(tokens, position) {
+  let low = 0;
+  let high = tokens.length - 1;
+  let best = -1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const start = tokens[mid].range.start;
+    if (position_at_or_before(start, position)) {
+      best = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return best;
+}
+function find_last_token_starting_before(tokens, position) {
+  let low = 0;
+  let high = tokens.length - 1;
+  let best = -1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const start = tokens[mid].range.start;
+    if (position_before2(start, position)) {
+      best = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+  return best;
+}
+function find_token_index_at_position(tokens, position) {
+  const candidate = find_last_token_starting_at_or_before(tokens, position);
+  if (candidate === -1) {
+    return -1;
+  }
+  const end = tokens[candidate].range.end;
+  if (position_before2(position, end)) {
+    return candidate;
+  }
+  return -1;
+}
+
 // src/utils/statement-span.ts
 function next_statement_line_span(tokens, from_index) {
   let my_first_index = from_index + 1;
@@ -17086,13 +17323,101 @@ function next_statement_line_span(tokens, from_index) {
   }
   return { start_line, end_line };
 }
-var LEADING_TRIVIA_TYPES, BODY_OPENER_TYPES, CONTINUATION_NEUTRAL_TYPES;
+function inline_embedded_statement_end(tokens, opener_index) {
+  let my_last_content_index = opener_index;
+  let my_i = opener_index + 1;
+  while (my_i < tokens.length && tokens[my_i].type !== "STATEMENT_TERMINATOR" && tokens[my_i].type !== "EOF") {
+    my_last_content_index = my_i;
+    my_i++;
+  }
+  const end_line = tokens[my_last_content_index].range.end.line;
+  const end_index = my_i < tokens.length && tokens[my_i].type === "STATEMENT_TERMINATOR" ? my_i : my_last_content_index;
+  return { end_index, end_line };
+}
+function logical_statement_start(tokens, position, min_line = 0) {
+  if (tokens === undefined || tokens.length === 0) {
+    return;
+  }
+  let search_index = find_last_token_starting_before(tokens, position);
+  while (search_index >= 0 && tokens[search_index].type === "EOF") {
+    search_index--;
+  }
+  if (search_index < 0) {
+    return;
+  }
+  let boundary_index = -1;
+  let my_steps = 0;
+  for (let my_i = search_index;my_i >= 0; my_i--) {
+    if (++my_steps > MAX_STATEMENT_TOKENS) {
+      return;
+    }
+    const my_token = tokens[my_i];
+    if (my_token.range.start.line < min_line) {
+      break;
+    }
+    if (is_swallowed_continuation_terminator(my_token, my_i > 0 && tokens[my_i - 1].type === "CONTINUATION")) {
+      continue;
+    }
+    if (LOGICAL_BOUNDARY_TYPES.has(my_token.type)) {
+      boundary_index = my_i;
+      break;
+    }
+  }
+  let boundary_opens_embedded_body = false;
+  if (boundary_index >= 0) {
+    const my_boundary_type = tokens[boundary_index].type;
+    if (my_boundary_type === "MATA_START" || my_boundary_type === "PYTHON_START") {
+      boundary_opens_embedded_body = true;
+    } else if (my_boundary_type === "LBRACE") {
+      for (let my_j = boundary_index - 1;my_j >= 0; my_j--) {
+        const my_prev_type = tokens[my_j].type;
+        if (CONTINUATION_NEUTRAL_TYPES.has(my_prev_type) || my_prev_type === "WHITESPACE") {
+          continue;
+        }
+        boundary_opens_embedded_body = my_prev_type === "MATA_START" || my_prev_type === "PYTHON_START";
+        break;
+      }
+    }
+  }
+  let first_index = -1;
+  for (let my_i = boundary_index + 1;my_i < tokens.length; my_i++) {
+    const my_token = tokens[my_i];
+    if (my_token.type === "EOF") {
+      break;
+    }
+    if (my_token.range.start.line < min_line) {
+      continue;
+    }
+    if (!STATEMENT_LEADING_TRIVIA_TYPES.has(my_token.type)) {
+      first_index = my_i;
+      break;
+    }
+  }
+  if (first_index !== -1 && !boundary_opens_embedded_body) {
+    const my_start = tokens[first_index].range.start;
+    const at_or_before_cursor = my_start.line < position.line || my_start.line === position.line && my_start.character <= position.character;
+    if (at_or_before_cursor) {
+      return {
+        index: first_index,
+        line: my_start.line,
+        character: my_start.character
+      };
+    }
+  }
+  const resume_character = boundary_index >= 0 && tokens[boundary_index].range.end.line === position.line ? Math.min(tokens[boundary_index].range.end.character, position.character) : 0;
+  return {
+    index: first_index >= 0 ? first_index : boundary_index + 1,
+    line: position.line,
+    character: resume_character
+  };
+}
+var LEADING_TRIVIA_TYPES, BODY_OPENER_TYPES, CONTINUATION_NEUTRAL_TYPES, LOGICAL_BOUNDARY_TYPES, STATEMENT_LEADING_TRIVIA_TYPES, MAX_STATEMENT_TOKENS = 4096;
 var init_statement_span = __esm(() => {
   LEADING_TRIVIA_TYPES = new Set([
-    "WHITESPACE",
     "COMMENT_LINE",
     "COMMENT_BLOCK",
     "CONTINUATION",
+    "WHITESPACE",
     "STATEMENT_TERMINATOR",
     "DELIMIT_DIRECTIVE"
   ]);
@@ -17102,10 +17427,26 @@ var init_statement_span = __esm(() => {
     "PYTHON_START"
   ]);
   CONTINUATION_NEUTRAL_TYPES = new Set([
-    "WHITESPACE",
     "COMMENT_LINE",
     "COMMENT_BLOCK"
   ]);
+  LOGICAL_BOUNDARY_TYPES = new Set([
+    "STATEMENT_TERMINATOR",
+    "LBRACE",
+    "RBRACE",
+    "DELIMIT_DIRECTIVE",
+    "MATA_START",
+    "PYTHON_START",
+    "END_MATA",
+    "END_PYTHON"
+  ]);
+  STATEMENT_LEADING_TRIVIA_TYPES = new Set([
+    "COMMENT_LINE",
+    "COMMENT_BLOCK",
+    "CONTINUATION",
+    "WHITESPACE",
+    "STATEMENT_TERMINATOR"
+  ]);
 });
 
 // src/analyzer/index.ts
@@ -17212,9 +17553,7 @@ class SemanticAnalyzer {
     };
   }
   extract_comment_directives(ast) {
-    for (const node of ast.nodes) {
-      this.extract_directives_from_node(node);
-    }
+    this.extract_directives_from_nodes(ast.nodes);
   }
   extract_comment_directives_from_tokens(tokens, symbols, dofile_scope) {
     this.parse_declaration_directives_from_tokens(tokens, symbols, dofile_scope);
@@ -17348,25 +17687,45 @@ class SemanticAnalyzer {
         break;
     }
   }
-  extract_directives_from_node(node) {
-    if (this.has_trivia(node) && node.leadingTrivia) {
-      for (const trivia of node.leadingTrivia) {
-        this.parse_directive(trivia, node);
+  extract_directives_from_nodes(nodes, outer_successor) {
+    for (let my_index = 0;my_index < nodes.length; my_index++) {
+      const node = nodes[my_index];
+      if (this.has_trivia(node) && node.leadingTrivia) {
+        for (const trivia of node.leadingTrivia) {
+          this.parse_directive(trivia, node);
+        }
       }
-    }
-    if (node.type === "program") {
-      for (const child of node.body) {
-        this.extract_directives_from_node(child);
+      const following_node = nodes[my_index + 1] ?? outer_successor;
+      const node_with_block_ending_trivia = node;
+      if (node_with_block_ending_trivia.blockEndingTrivia) {
+        for (const trivia of node_with_block_ending_trivia.blockEndingTrivia) {
+          this.parse_directive(trivia, following_node);
+        }
       }
-    } else if (this.is_control_flow(node)) {
-      for (const child of node.body) {
-        this.extract_directives_from_node(child);
+      const the_child_body = this.directive_recursion_body(node);
+      if (the_child_body) {
+        this.extract_directives_from_nodes(the_child_body, following_node);
       }
     }
   }
+  directive_recursion_body(node) {
+    if (node.type === "program") {
+      return node.body;
+    }
+    if (node.type === "frame") {
+      return node.body;
+    }
+    if (this.is_control_flow(node)) {
+      return node.body;
+    }
+    if (node.type === "command" && node.body) {
+      return node.body;
+    }
+    return;
+  }
   parse_directive(trivia, following_node) {
     const content = trivia.content.trim();
-    if (has_ignore_directive(content) || has_ignore_next_directive(content)) {
+    if (following_node && (has_ignore_directive(content) || has_ignore_next_directive(content))) {
       const line_to_ignore = following_node.range.start.line;
       this.config.ignored_lines.add(line_to_ignore);
     }
@@ -17386,9 +17745,10 @@ class SemanticAnalyzer {
       if (token.range.start.line !== line) {
         break;
       }
-      if (token.type !== "WHITESPACE") {
-        return false;
+      if (token.type === "WHITESPACE") {
+        continue;
       }
+      return false;
     }
     return true;
   }
@@ -17508,12 +17868,16 @@ class SemanticAnalyzer {
       }
     }
   }
+  semantic_varlist(node) {
+    return (node.varlist ?? []).filter((item) => item.recovery_only !== true);
+  }
   extract_c_locals(nodes) {
     const c_locals = [];
     for (const node of nodes) {
       if (node.type === "command") {
-        if (node.fullName === "c_local" && node.varlist && node.varlist.length > 0) {
-          const name = node.varlist[0].name;
+        const varlist = this.semantic_varlist(node);
+        if (node.fullName === "c_local" && varlist.length > 0) {
+          const name = varlist[0].name;
           if (is_valid_identifier(name)) {
             c_locals.push(name);
           }
@@ -17544,8 +17908,9 @@ class SemanticAnalyzer {
     const global_set = new Set;
     for (const node of nodes) {
       if (node.type === "command") {
-        if (node.fullName === "c_local" && node.varlist && node.varlist.length > 0) {
-          const macro_name = node.varlist[0].name;
+        const varlist = this.semantic_varlist(node);
+        if (node.fullName === "c_local" && varlist.length > 0) {
+          const macro_name = varlist[0].name;
           if (macro_name.startsWith("`") && macro_name.endsWith("'")) {
             const inner_name = macro_name.slice(1, -1);
             const local_name = inner_name.toLowerCase();
@@ -17553,8 +17918,8 @@ class SemanticAnalyzer {
               local_set.add(local_name);
             }
           }
-        } else if (node.fullName === "global" && node.varlist && node.varlist.length > 0) {
-          const macro_name = node.varlist[0].name;
+        } else if (node.fullName === "global" && varlist.length > 0) {
+          const macro_name = varlist[0].name;
           if (macro_name.startsWith("`") && macro_name.endsWith("'")) {
             const inner_name = macro_name.slice(1, -1);
             const global_name = inner_name.toLowerCase();
@@ -17763,12 +18128,13 @@ class SemanticAnalyzer {
     };
   }
   extract_command_path(node) {
-    if (!node.varlist || node.varlist.length === 0) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length === 0) {
       return null;
     }
     let raw_path = "";
     let has_macro = false;
-    const first_item = node.varlist[0];
+    const first_item = varlist[0];
     const first_name = first_item.name;
     const is_complete_double_quoted = first_name.startsWith('"') && first_name.endsWith('"') && first_name.length > 1;
     const is_complete_single_quoted = first_name.startsWith("'") && first_name.endsWith("'") && first_name.length > 1;
@@ -17779,8 +18145,8 @@ class SemanticAnalyzer {
       const quote_char = first_name[0];
       raw_path = first_name;
       has_macro = raw_path.includes("`") || raw_path.includes("$");
-      for (let i = 1;i < node.varlist.length; i++) {
-        const item_name = node.varlist[i].name;
+      for (let i = 1;i < varlist.length; i++) {
+        const item_name = varlist[i].name;
         raw_path += item_name;
         if (item_name.includes("`") || item_name.includes("$")) {
           has_macro = true;
@@ -17900,28 +18266,30 @@ class SemanticAnalyzer {
     }
   }
   extract_scalar_symbol(node, symbols, node_index) {
-    if (!node.varlist || node.varlist.length === 0) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length === 0) {
       return;
     }
-    const scalar_name = node.varlist[0].name;
-    this.add_or_append_definition(symbols.scalars, scalar_name, node_index, node.varlist[0].range, () => ({
+    const scalar_name = varlist[0].name;
+    this.add_or_append_definition(symbols.scalars, scalar_name, node_index, varlist[0].range, () => ({
       name: scalar_name,
-      location: { uri: this.uri, range: node.varlist[0].range },
+      location: { uri: this.uri, range: varlist[0].range },
       sourceUri: this.uri,
-      definition_line: node.varlist[0].range.start.line
+      definition_line: varlist[0].range.start.line
     }));
   }
   extract_matrix_symbol(node, symbols, node_index) {
-    if (!node.varlist || node.varlist.length === 0) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length === 0) {
       return;
     }
-    const first = node.varlist[0]?.name;
-    const second = node.varlist[1]?.name;
+    const first = varlist[0]?.name;
+    const second = varlist[1]?.name;
     const matrix_name = first && first === "define" ? second : first;
     if (!matrix_name) {
       return;
     }
-    const name_range = first && first === "define" && node.varlist[1] ? node.varlist[1].range : node.varlist[0].range;
+    const name_range = first && first === "define" && varlist[1] ? varlist[1].range : varlist[0].range;
     this.add_or_append_definition(symbols.matrices, matrix_name, node_index, name_range, () => ({
       name: matrix_name,
       location: { uri: this.uri, range: name_range },
@@ -17930,22 +18298,23 @@ class SemanticAnalyzer {
     }));
   }
   pick_new_variable(node) {
-    if (!node.varlist || node.varlist.length === 0) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length === 0) {
       return;
     }
-    if (is_stata_storage_type(node.varlist[0].name)) {
-      if (node.varlist.length > 1) {
-        return node.varlist[1];
+    if (is_stata_storage_type(varlist[0].name)) {
+      if (varlist.length > 1) {
+        return varlist[1];
       }
       this.current_diagnostics.push({
-        message: `Missing variable name after storage type \`${node.varlist[0].name}'`,
-        range: node.varlist[0].range,
+        message: `Missing variable name after storage type \`${varlist[0].name}'`,
+        range: varlist[0].range,
         code: "MISSING_VARIABLE_NAME" /* MISSING_VARIABLE_NAME */,
         severity: "error"
       });
       return;
     }
-    return node.varlist[0];
+    return varlist[0];
   }
   extract_gen_variable(node, symbols) {
     const new_var = this.pick_new_variable(node);
@@ -17978,10 +18347,11 @@ class SemanticAnalyzer {
     symbols.variables.set(new_var.name, var_symbol);
   }
   extract_input_variables(node, symbols) {
-    if (!node.varlist) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length === 0) {
       return;
     }
-    for (const var_node of node.varlist) {
+    for (const var_node of varlist) {
       if (this.is_macro_reference(var_node.name)) {
         continue;
       }
@@ -18018,28 +18388,29 @@ class SemanticAnalyzer {
     return false;
   }
   extract_rename_variables(node, symbols) {
-    if (!node.varlist || node.varlist.length < 2) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length < 2) {
       return;
     }
-    if (node.varlist.length !== 2 && !(node.varlist[0].name.startsWith("(") && node.varlist[1].name.startsWith("("))) {
+    if (varlist.length !== 2 && !(varlist[0].name.startsWith("(") && varlist[1].name.startsWith("("))) {
       return;
     }
-    const first_item = node.varlist[0].name;
-    const second_item = node.varlist[1].name;
+    const first_item = varlist[0].name;
+    const second_item = varlist[1].name;
     if (first_item.startsWith("(") && second_item.startsWith("(")) {
       if (this.contains_wildcard(first_item) || this.contains_wildcard(second_item)) {
         return;
       }
-      this.extract_grouped_rename_variables(second_item, node.varlist[1].range, symbols);
+      this.extract_grouped_rename_variables(second_item, varlist[1].range, symbols);
       return;
     }
     if (this.contains_wildcard(first_item) || this.contains_wildcard(second_item)) {
       return;
     }
-    if (this.has_adjacent_wildcard_token(node.varlist[0].range) || this.has_adjacent_wildcard_token(node.varlist[1].range)) {
+    if (this.has_adjacent_wildcard_token(varlist[0].range) || this.has_adjacent_wildcard_token(varlist[1].range)) {
       return;
     }
-    const new_var = node.varlist[1];
+    const new_var = varlist[1];
     if (this.is_macro_reference(new_var.name)) {
       return;
     }
@@ -18052,7 +18423,7 @@ class SemanticAnalyzer {
     symbols.variables.set(new_var.name, var_symbol);
   }
   extract_grouped_rename_variables(group_content, group_range, symbols) {
-    const inner = group_content.slice(1, -1).trim();
+    const inner = (group_content.endsWith(")") ? group_content.slice(1, -1) : group_content.slice(1)).trim();
     const the_names = inner.split(/\s+/).filter((n) => n.length > 0);
     for (const my_name of the_names) {
       if (this.contains_wildcard(my_name)) {
@@ -18071,14 +18442,15 @@ class SemanticAnalyzer {
     }
   }
   extract_confirm_variable(node, symbols) {
-    if (!node.varlist || node.varlist.length < 2) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length < 2) {
       return;
     }
-    const first_item = node.varlist[0].name.toLowerCase();
+    const first_item = varlist[0].name.toLowerCase();
     if (first_item !== "variable" && first_item !== "var") {
       return;
     }
-    const var_node = node.varlist[1];
+    const var_node = varlist[1];
     if (this.is_macro_reference(var_node.name)) {
       return;
     }
@@ -18091,10 +18463,11 @@ class SemanticAnalyzer {
     symbols.variables.set(var_node.name, var_symbol);
   }
   extract_tempvar_macro(node, symbols, current_scope, node_index) {
-    if (!node.varlist) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length === 0) {
       return;
     }
-    for (const var_node of node.varlist) {
+    for (const var_node of varlist) {
       this.register_local_macro(current_scope, symbols, var_node.name, node_index, var_node.range, () => ({
         name: var_node.name,
         scope: "local",
@@ -18107,8 +18480,9 @@ class SemanticAnalyzer {
     }
   }
   extract_unab_macro(node, symbols, current_scope, node_index) {
-    if (node.varlist && node.varlist.length > 0) {
-      const macro_node = node.varlist[0];
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length > 0) {
+      const macro_node = varlist[0];
       const macro_name = macro_node.name;
       this.register_local_macro(current_scope, symbols, macro_name, node_index, macro_node.range, () => ({
         name: macro_name,
@@ -18122,8 +18496,9 @@ class SemanticAnalyzer {
     }
   }
   extract_args_macros(node, symbols, current_scope, node_index) {
-    if (node.varlist && node.varlist.length > 0) {
-      for (const my_var_node of node.varlist) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length > 0) {
+      for (const my_var_node of varlist) {
         const macro_name = my_var_node.name;
         this.register_local_macro(current_scope, symbols, macro_name, node_index, my_var_node.range, () => ({
           name: macro_name,
@@ -18138,12 +18513,13 @@ class SemanticAnalyzer {
     }
   }
   extract_gettoken_macros(node, symbols, current_scope, node_index) {
-    if (!node.varlist || node.varlist.length === 0) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length === 0) {
       return;
     }
-    const max_macros = Math.min(node.varlist.length, 2);
+    const max_macros = Math.min(varlist.length, 2);
     for (let i = 0;i < max_macros; i++) {
-      const my_var_node = node.varlist[i];
+      const my_var_node = varlist[i];
       const macro_name = my_var_node.name;
       if (!is_valid_identifier(macro_name)) {
         continue;
@@ -18160,13 +18536,14 @@ class SemanticAnalyzer {
     }
   }
   extract_file_read_macro(node, symbols, current_scope, node_index) {
-    if (!node.varlist || node.varlist.length < 3) {
+    const varlist = this.semantic_varlist(node);
+    if (varlist.length < 3) {
       return;
     }
-    if (node.varlist[0].name !== "read") {
+    if (varlist[0].name !== "read") {
       return;
     }
-    const macro_node = node.varlist[2];
+    const macro_node = varlist[2];
     const macro_name = macro_node.name;
     if (!is_valid_identifier(macro_name)) {
       return;
@@ -18240,6 +18617,9 @@ class SemanticAnalyzer {
     if (!builtin_cmd && !program_options)
       return false;
     for (const my_option of node.options) {
+      if (my_option.argument_unclosed) {
+        continue;
+      }
       let matches = false;
       if (builtin_cmd) {
         for (const opt of builtin_cmd.local_options) {
@@ -18266,7 +18646,7 @@ class SemanticAnalyzer {
     if (node.fullName !== "macro" && node.fullName !== "mac") {
       return { names: [], unknown: false };
     }
-    const the_args = node.varlist ?? [];
+    const the_args = this.semantic_varlist(node);
     if (the_args.length < 2 || !/^dr(o(p)?)?$/.test(the_args[0].name)) {
       return { names: [], unknown: false };
     }
@@ -18297,18 +18677,20 @@ class SemanticAnalyzer {
         names.push(name);
     };
     if (cmd_name === "tempvar" || cmd_name === "tempfile" || cmd_name === "tempname" || cmd_name === "args") {
-      for (const my_var of node.varlist ?? [])
+      for (const my_var of this.semantic_varlist(node))
         push_literal(my_var.name);
     } else if (cmd_name === "unab") {
-      push_literal(node.varlist?.[0]?.name);
+      push_literal(this.semantic_varlist(node)[0]?.name);
     } else if (cmd_name === "gettoken" || cmd_name === "gettok") {
-      const max_macros = Math.min(node.varlist?.length ?? 0, 2);
+      const varlist = this.semantic_varlist(node);
+      const max_macros = Math.min(varlist.length, 2);
       for (let i = 0;i < max_macros; i++) {
-        push_literal(node.varlist[i].name);
+        push_literal(varlist[i].name);
       }
     } else if (cmd_name === "file" || cmd_name === "fil" || cmd_name === "fi") {
-      if ((node.varlist?.length ?? 0) >= 3 && node.varlist[0].name === "read") {
-        push_literal(node.varlist[2].name);
+      const varlist = this.semantic_varlist(node);
+      if (varlist.length >= 3 && varlist[0].name === "read") {
+        push_literal(varlist[2].name);
       }
     }
     return names;
@@ -18347,6 +18729,9 @@ class SemanticAnalyzer {
     }
     const the_created = [];
     for (const option of node.options) {
+      if (option.argument_unclosed) {
+        continue;
+      }
       const parse_result = parse_option_argument(option.argument);
       if (!parse_result.is_literal || !parse_result.identifier) {
         continue;
@@ -18696,19 +19081,17 @@ class SemanticAnalyzer {
     if (cmd_name === "generate" || cmd_name === "gen" || cmd_name === "egen" || cmd_name === "input" || cmd_name === "tempvar" || cmd_name === "unab") {
       return;
     }
-    if (node.varlist) {
-      for (const var_node of node.varlist) {
-        const is_defined = this.is_variable_defined(var_node.name, symbols, var_node.range.start.line);
-        if (!is_defined) {
-          diagnostics.push({
-            message: format_undefined_variable_message(var_node.name),
-            range: var_node.range,
-            code: "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */,
-            severity: "information",
-            symbol_name: var_node.name,
-            reference_kind: "variable"
-          });
-        }
+    for (const var_node of this.semantic_varlist(node)) {
+      const is_defined = this.is_variable_defined(var_node.name, symbols, var_node.range.start.line);
+      if (!is_defined) {
+        diagnostics.push({
+          message: format_undefined_variable_message(var_node.name),
+          range: var_node.range,
+          code: "UNDEFINED_VARIABLE" /* UNDEFINED_VARIABLE */,
+          severity: "information",
+          symbol_name: var_node.name,
+          reference_kind: "variable"
+        });
       }
     }
   }
@@ -19750,12 +20133,10 @@ class ContextTracker {
           is_single_line: my_token.type === "MATA_INLINE"
         };
         if (my_token.type === "MATA_INLINE") {
-          my_current_range.end_delimiter = {
-            command: my_token.value,
-            range: my_token.range
-          };
-          this.context_ranges.push(this.complete_context_range_from_token(my_current_range));
+          const my_inline_end = inline_embedded_statement_end(tokens, my_i);
+          this.context_ranges.push(this.complete_context_range_from_token(my_current_range, my_inline_end.end_line));
           my_current_range = null;
+          my_i = my_inline_end.end_index;
         } else {
           this.context_stack.push("mata" /* MATA */);
           my_current_context = "mata" /* MATA */;
@@ -19777,12 +20158,10 @@ class ContextTracker {
           is_single_line: my_token.type === "PYTHON_INLINE"
         };
         if (my_token.type === "PYTHON_INLINE") {
-          my_current_range.end_delimiter = {
-            command: my_token.value,
-            range: my_token.range
-          };
-          this.context_ranges.push(this.complete_context_range_from_token(my_current_range));
+          const my_inline_end = inline_embedded_statement_end(tokens, my_i);
+          this.context_ranges.push(this.complete_context_range_from_token(my_current_range, my_inline_end.end_line));
           my_current_range = null;
+          my_i = my_inline_end.end_index;
         } else {
           this.context_stack.push("python" /* PYTHON */);
           my_current_context = "python" /* PYTHON */;
@@ -20086,11 +20465,11 @@ class ContextTracker {
     }
     return false;
   }
-  complete_context_range_from_token(partial_range) {
+  complete_context_range_from_token(partial_range, single_line_end_line) {
     const my_start_line = partial_range.start_delimiter.range.start.line;
     let my_end_line;
     if (partial_range.is_single_line) {
-      my_end_line = my_start_line;
+      my_end_line = single_line_end_line ?? my_start_line;
     } else {
       if (partial_range.end_delimiter) {
         my_end_line = partial_range.end_delimiter.range.start.line - 1;
@@ -20278,6 +20657,7 @@ var init_context_tracker = __esm(() => {
   init_types2();
   init_types();
   init_block_comment_utils();
+  init_statement_span();
   CONTEXT_TRIVIA_TOKEN_TYPES = new Set([
     "COMMENT_LINE",
     "COMMENT_BLOCK",
@@ -20961,6 +21341,221 @@ var init_document_store = __esm(() => {
   import_vscode_languageserver = __toESM(require_main4(), 1);
 });
 
+// src/utils/lru-cache.ts
+class LRUCache {
+  cache = new Map;
+  max_size;
+  hits = 0;
+  misses = 0;
+  evictions = 0;
+  current_generation = 0;
+  constructor(max_size = 100) {
+    this.max_size = max_size;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (entry !== undefined) {
+      this.hits++;
+      entry.access_count++;
+      this.cache.delete(key);
+      this.cache.set(key, entry);
+      return entry.value;
+    } else {
+      this.misses++;
+    }
+    return;
+  }
+  set(key, value) {
+    this.cache.delete(key);
+    if (this.cache.size >= this.max_size) {
+      this.evict_one();
+    }
+    this.cache.set(key, {
+      value,
+      generation: this.current_generation,
+      access_count: 1
+    });
+  }
+  evict_one() {
+    let victim_key;
+    let victim_score = Infinity;
+    for (const [key, entry] of this.cache) {
+      const score = entry.generation * 1000 + entry.access_count;
+      if (score < victim_score) {
+        victim_score = score;
+        victim_key = key;
+      }
+    }
+    if (victim_key !== undefined) {
+      this.cache.delete(victim_key);
+      this.evictions++;
+    }
+  }
+  advance_generation() {
+    this.current_generation++;
+  }
+  trim_to_top_n(n) {
+    if (this.cache.size <= n)
+      return;
+    const entries = Array.from(this.cache.entries()).sort((a, b) => b[1].access_count - a[1].access_count);
+    this.cache.clear();
+    for (let i = 0;i < Math.min(n, entries.length); i++) {
+      this.cache.set(entries[i][0], entries[i][1]);
+    }
+    this.evictions += entries.length - n;
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  get_stats() {
+    return { hits: this.hits, misses: this.misses, evictions: this.evictions };
+  }
+}
+
+class CompletionPrefixCache {
+  cache;
+  command_db_version = 0;
+  workspace_version = 0;
+  top_n_threshold;
+  constructor(max_size = 100, top_n_threshold = 200) {
+    this.cache = new LRUCache(max_size);
+    this.top_n_threshold = top_n_threshold;
+  }
+  make_key(prefix, context, document_version = 0) {
+    return `${context}:${prefix}:${this.command_db_version}:${this.workspace_version}:${document_version}`;
+  }
+  get_with_context(prefix, context, document_version = 0) {
+    return this.cache.get(this.make_key(prefix, context, document_version));
+  }
+  set_with_context(prefix, context, value, document_version = 0) {
+    const trimmed_value = this.apply_limit(value);
+    this.cache.set(this.make_key(prefix, context, document_version), trimmed_value);
+    return trimmed_value;
+  }
+  apply_limit(value) {
+    if (this.top_n_threshold > 0 && value.length > this.top_n_threshold) {
+      return value.slice(0, this.top_n_threshold);
+    }
+    return value;
+  }
+  has_with_context(prefix, context, document_version = 0) {
+    return this.cache.has(this.make_key(prefix, context, document_version));
+  }
+  invalidate_on_db_change(new_version) {
+    if (new_version !== this.command_db_version) {
+      this.command_db_version = new_version;
+      this.cache.clear();
+      this.cache.advance_generation();
+    }
+  }
+  invalidate_on_workspace_change(new_version) {
+    if (new_version !== this.workspace_version) {
+      this.workspace_version = new_version;
+      this.cache.clear();
+      this.cache.advance_generation();
+    }
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size();
+  }
+  get_stats() {
+    return this.cache.get_stats();
+  }
+}
+var BoundedLruMap;
+var init_lru_cache = __esm(() => {
+  BoundedLruMap = class BoundedLruMap {
+    map = new Map;
+    max_size;
+    on_evict;
+    constructor(max_size, options) {
+      this.max_size = Math.max(1, Math.floor(max_size));
+      this.on_evict = options?.on_evict;
+    }
+    get(key) {
+      if (!this.map.has(key)) {
+        return;
+      }
+      const value = this.map.get(key);
+      this.map.delete(key);
+      this.map.set(key, value);
+      return value;
+    }
+    peek(key) {
+      return this.map.get(key);
+    }
+    has(key) {
+      return this.map.has(key);
+    }
+    touch(key) {
+      if (!this.map.has(key)) {
+        return;
+      }
+      const value = this.map.get(key);
+      this.map.delete(key);
+      this.map.set(key, value);
+    }
+    set(key, value) {
+      if (this.map.has(key)) {
+        this.map.delete(key);
+      } else if (this.map.size >= this.max_size) {
+        this.evict_oldest();
+      }
+      this.map.set(key, value);
+      return this;
+    }
+    delete(key) {
+      return this.map.delete(key);
+    }
+    clear() {
+      this.map.clear();
+    }
+    get size() {
+      return this.map.size;
+    }
+    get capacity() {
+      return this.max_size;
+    }
+    set_max_size(new_max_size) {
+      this.max_size = Math.max(1, Math.floor(new_max_size));
+      while (this.map.size > this.max_size) {
+        this.evict_oldest();
+      }
+    }
+    keys() {
+      return this.map.keys();
+    }
+    values() {
+      return this.map.values();
+    }
+    entries() {
+      return this.map.entries();
+    }
+    [Symbol.iterator]() {
+      return this.map[Symbol.iterator]();
+    }
+    evict_oldest() {
+      const oldest = this.map.keys().next();
+      if (oldest.done) {
+        return;
+      }
+      const oldest_key = oldest.value;
+      const oldest_value = this.map.get(oldest_key);
+      this.map.delete(oldest_key);
+      this.on_evict?.(oldest_key, oldest_value);
+    }
+  };
+});
+
 // src/utils/dofile-locals.ts
 function is_dofile_local(symbol) {
   return symbol.containingScope === "dofile";
@@ -21261,14 +21856,20 @@ class ForwardScopeResolver {
   workspace_roots = [];
   resolve_fs;
   forward_closure_memo_enabled = true;
-  forward_closure_memo = new Map;
+  forward_closure_memo = new BoundedLruMap(DEFAULT_MAX_CACHED_FORWARD_CLOSURES, {
+    on_evict: (key, entry) => {
+      this.memo_metrics.evictions++;
+      this.prune_memo_uri_to_keys_for_entry(key, entry);
+    }
+  });
   memo_uri_to_keys = new Map;
   last_seen_graph_version;
   memo_invalidation_epoch = 0;
   memo_metrics = {
     hits: 0,
     misses: 0,
-    invalidations: 0
+    invalidations: 0,
+    evictions: 0
   };
   standalone_in_flight = new Set;
   active_probe_collectors = [];
@@ -21291,8 +21892,16 @@ class ForwardScopeResolver {
   get_forward_closure_metrics() {
     return { ...this.memo_metrics };
   }
+  get_forward_closure_memo_size() {
+    return this.forward_closure_memo.size;
+  }
   reset_forward_closure_metrics() {
-    this.memo_metrics = { hits: 0, misses: 0, invalidations: 0 };
+    this.memo_metrics = {
+      hits: 0,
+      misses: 0,
+      invalidations: 0,
+      evictions: 0
+    };
   }
   invalidate_forward_closure_for_uri(uri) {
     this.memo_invalidation_epoch++;
@@ -21316,12 +21925,16 @@ class ForwardScopeResolver {
     this.memo_uri_to_keys.clear();
   }
   delete_memo_entry(key) {
-    const my_entry = this.forward_closure_memo.get(key);
+    const my_entry = this.forward_closure_memo.peek(key);
     if (!my_entry) {
       return false;
     }
     this.forward_closure_memo.delete(key);
-    for (const my_dep_uri of my_entry.dependent_uris) {
+    this.prune_memo_uri_to_keys_for_entry(key, my_entry);
+    return true;
+  }
+  prune_memo_uri_to_keys_for_entry(key, entry) {
+    for (const my_dep_uri of entry.dependent_uris) {
       const my_key_set = this.memo_uri_to_keys.get(my_dep_uri);
       if (my_key_set) {
         my_key_set.delete(key);
@@ -21330,7 +21943,9 @@ class ForwardScopeResolver {
         }
       }
     }
-    return true;
+  }
+  set_forward_closure_memo_capacity(max_entries) {
+    this.forward_closure_memo.set_max_size(max_entries);
   }
   is_memo_usable() {
     return this.dependency_graph === undefined || this.dependency_graph.is_scan_complete();
@@ -21743,6 +22358,10 @@ class ForwardScopeResolver {
     });
   }
   store_memo_entry(key, entry) {
+    const my_previous = this.forward_closure_memo.peek(key);
+    if (my_previous) {
+      this.prune_memo_uri_to_keys_for_entry(key, my_previous);
+    }
     this.forward_closure_memo.set(key, entry);
     for (const my_dep_uri of entry.dependent_uris) {
       let my_key_set = this.memo_uri_to_keys.get(my_dep_uri);
@@ -21916,13 +22535,14 @@ class ForwardScopeResolver {
     this.clear_forward_closure_memo();
   }
 }
-var DEFAULT_CONFIG;
+var DEFAULT_CONFIG, DEFAULT_MAX_CACHED_FORWARD_CLOSURES = 2000;
 var init_forward_scope_resolver = __esm(() => {
   init_esm();
   init_types();
   init_analyzer();
   init_file_path_utils();
   init_workspace_roots();
+  init_lru_cache();
   init_dofile_locals();
   init_visible_symbols();
   DEFAULT_CONFIG = {
@@ -21981,13 +22601,23 @@ class ScopeResolver {
   workspace_roots = [];
   dependency_graph;
   resolve_fs;
-  constructor(logger2, content_provider) {
+  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 Map;
-    this.scope_cache = new Map;
+    this.file_cache = new BoundedLruMap(cache_capacities?.max_cached_files ?? DEFAULT_MAX_CACHED_FILES, {
+      on_evict: (_key, entry) => {
+        this.cache_metrics.file.evictions++;
+        this.forward_scope_resolver?.invalidate_forward_closure_for_uri?.(entry.uri);
+      }
+    });
+    this.scope_cache = new BoundedLruMap(cache_capacities?.max_cached_scopes ?? DEFAULT_MAX_CACHED_SCOPES, {
+      on_evict: (key) => {
+        this.cache_metrics.scope.evictions++;
+        this.prune_uri_to_cache_keys_for_key(key);
+      }
+    });
     this.uri_to_cache_keys = new Map;
     this.cache_metrics = this.create_metrics();
     this.logger = logger2;
@@ -22082,8 +22712,8 @@ class ScopeResolver {
   }
   create_metrics() {
     const metrics = {
-      scope: { hits: 0, misses: 0, invalidations: 0 },
-      file: { hits: 0, misses: 0, invalidations: 0 }
+      scope: { hits: 0, misses: 0, invalidations: 0, evictions: 0 },
+      file: { hits: 0, misses: 0, invalidations: 0, evictions: 0 }
     };
     return {
       ...metrics,
@@ -22098,6 +22728,24 @@ class ScopeResolver {
       }
     };
   }
+  set_cache_capacities(capacities) {
+    if (capacities.max_cached_files !== undefined) {
+      this.file_cache.set_max_size(capacities.max_cached_files);
+    }
+    if (capacities.max_cached_scopes !== undefined) {
+      this.scope_cache.set_max_size(capacities.max_cached_scopes);
+    }
+  }
+  prune_uri_to_cache_keys_for_key(cache_key) {
+    const key_uri = this.extract_uri_from_cache_key(cache_key);
+    const key_set = this.uri_to_cache_keys.get(key_uri);
+    if (key_set) {
+      key_set.delete(cache_key);
+      if (key_set.size === 0) {
+        this.uri_to_cache_keys.delete(key_uri);
+      }
+    }
+  }
   make_file_cache_key(uri, working_directory) {
     return working_directory ? `${uri}|${working_directory}` : uri;
   }
@@ -22110,14 +22758,7 @@ class ScopeResolver {
     }
     for (const my_key of keys_to_remove) {
       this.scope_cache.delete(my_key);
-      const key_uri = this.extract_uri_from_cache_key(my_key);
-      const key_set = this.uri_to_cache_keys.get(key_uri);
-      if (key_set) {
-        key_set.delete(my_key);
-        if (key_set.size === 0) {
-          this.uri_to_cache_keys.delete(key_uri);
-        }
-      }
+      this.prune_uri_to_cache_keys_for_key(my_key);
     }
     return keys_to_remove.length;
   }
@@ -22638,9 +23279,9 @@ class ScopeResolver {
       ...config,
       backward_dependencies: "explicit"
     };
-    return this.discover_working_directory(the_backward_directives, new Set, 0, my_config, new Map, current_uri);
+    return this.discover_working_directory(the_backward_directives, new Set, 0, my_config, new Map, current_uri, undefined, true);
   }
-  async discover_working_directory(directives, visited, depth, config, request_cache, current_uri, token) {
+  async discover_working_directory(directives, visited, depth, config, request_cache, current_uri, token, skip_backward_registration) {
     if (depth > config.max_backward_depth) {
       return;
     }
@@ -22661,7 +23302,8 @@ class ScopeResolver {
       try {
         my_parent_result = await this.get_parsed_file(my_parent_uri, my_real_path, {
           request_cache,
-          backward_dependencies: config.backward_dependencies ?? "auto"
+          backward_dependencies: config.backward_dependencies ?? "auto",
+          skip_backward_registration
         });
       } catch (error) {
         my_parent_result = { error: String(error) };
@@ -22691,7 +23333,7 @@ class ScopeResolver {
       } = this.get_effective_backward_directives(my_parent_uri, my_parent_result.directives, config, my_parent_result.is_standalone);
       if (effective_parent_directives.length > 0) {
         visited.add(my_parent_uri);
-        const my_deeper_wd = await this.discover_working_directory(effective_parent_directives, visited, depth + 1, config, request_cache, my_parent_uri, token);
+        const my_deeper_wd = await this.discover_working_directory(effective_parent_directives, visited, depth + 1, config, request_cache, my_parent_uri, token, skip_backward_registration);
         visited.delete(my_parent_uri);
         if (my_deeper_wd) {
           return my_deeper_wd;
@@ -22930,8 +23572,9 @@ class ScopeResolver {
   }
   parse_file(uri, content) {
     const content_hash = this.hash_content(content);
-    const cached = this.file_cache.get(uri);
+    const cached = this.file_cache.peek(uri);
     if (cached && cached.content_hash === content_hash) {
+      this.file_cache.touch(uri);
       return {
         symbols: cached.symbols,
         directives: cached.directives,
@@ -22948,6 +23591,7 @@ class ScopeResolver {
     try {
       const my_parse_result = this.parse_content(uri, content);
       this.file_cache.set(uri, {
+        uri,
         content,
         content_hash,
         size: Buffer.byteLength(content, "utf8"),
@@ -23088,11 +23732,14 @@ class ScopeResolver {
   async _get_parsed_file_impl(uri, fs_path, options) {
     const inherited_wd = options?.working_directory;
     const cache_key = this.make_file_cache_key(uri, inherited_wd);
-    const cached = this.file_cache.get(cache_key);
+    const cached = this.file_cache.peek(cache_key);
     if (options?.skip_disk_if_cached && cached) {
       this.log(`[get_parsed_file] file_cache HIT for ${cache_key} (skip_disk_if_cached)`);
       this.cache_metrics.file.hits++;
-      this.upgrade_registration_on_cache_hit(uri, cached, options?.backward_dependencies);
+      this.file_cache.touch(cache_key);
+      if (!options?.skip_backward_registration) {
+        this.upgrade_registration_on_cache_hit(uri, cached, options?.backward_dependencies);
+      }
       return this.cache_entry_to_parsed_result(cached, cached.content, cached.content_hash);
     }
     let mtimeMs;
@@ -23104,7 +23751,10 @@ class ScopeResolver {
       if (cached && mtimeMs !== undefined && size !== undefined && cached.mtimeMs !== undefined && cached.mtimeMs === mtimeMs && cached.size !== undefined && cached.size === size) {
         this.cache_metrics.file.hits++;
         this.log(`[get_parsed_file] File cache HIT for ${uri} (mtime match, skipped read)`);
-        this.upgrade_registration_on_cache_hit(uri, cached, options?.backward_dependencies);
+        this.file_cache.touch(cache_key);
+        if (!options?.skip_backward_registration) {
+          this.upgrade_registration_on_cache_hit(uri, cached, options?.backward_dependencies);
+        }
         return this.cache_entry_to_parsed_result(cached, cached.content, cached.content_hash);
       }
     }
@@ -23122,11 +23772,14 @@ class ScopeResolver {
             const fallback_mtimeMs = fallback_stats?.mtimeMs;
             const fallback_size = fallback_stats?.size;
             const fallback_cache_key = this.make_file_cache_key(fallback_uri, inherited_wd);
-            const fallback_cached = this.file_cache.get(fallback_cache_key);
+            const fallback_cached = this.file_cache.peek(fallback_cache_key);
             if (fallback_cached && fallback_mtimeMs !== undefined && fallback_size !== undefined && fallback_cached.mtimeMs !== undefined && fallback_cached.mtimeMs === fallback_mtimeMs && fallback_cached.size !== undefined && fallback_cached.size === fallback_size) {
               this.cache_metrics.file.hits++;
               this.log(`[get_parsed_file] File cache HIT for ${fallback_uri} (mtime match, skipped read)`);
-              this.upgrade_registration_on_cache_hit(fallback_uri, fallback_cached, options?.backward_dependencies);
+              this.file_cache.touch(fallback_cache_key);
+              if (!options?.skip_backward_registration) {
+                this.upgrade_registration_on_cache_hit(fallback_uri, fallback_cached, options?.backward_dependencies);
+              }
               return this.cache_entry_to_parsed_result(fallback_cached, fallback_cached.content, fallback_cached.content_hash);
             }
           }
@@ -23145,12 +23798,15 @@ class ScopeResolver {
       }
     }
     const actual_cache_key = this.make_file_cache_key(actual_uri, inherited_wd);
-    const actual_cached = this.file_cache.get(actual_cache_key);
+    const actual_cached = this.file_cache.peek(actual_cache_key);
     const disk_hash = this.hash_content(content);
     if (actual_cached && actual_cached.content_hash === disk_hash) {
       this.cache_metrics.file.hits++;
       this.log(`[get_parsed_file] File cache HIT for ${actual_uri} (hash match)`);
-      this.upgrade_registration_on_cache_hit(actual_uri, actual_cached, options?.backward_dependencies);
+      this.file_cache.touch(actual_cache_key);
+      if (!options?.skip_backward_registration) {
+        this.upgrade_registration_on_cache_hit(actual_uri, actual_cached, options?.backward_dependencies);
+      }
       return this.cache_entry_to_parsed_result(actual_cached, content, disk_hash);
     } else if (actual_cached) {
       this.log(`[get_parsed_file] File cache STALE for ${actual_uri} (cached hash=${actual_cached.content_hash}, disk hash=${disk_hash})`);
@@ -23166,6 +23822,7 @@ class ScopeResolver {
         mtimeMs = stats?.mtimeMs;
       }
       this.file_cache.set(actual_cache_key, {
+        uri: actual_uri,
         content,
         content_hash: disk_hash,
         mtimeMs,
@@ -23178,16 +23835,18 @@ class ScopeResolver {
         working_directory_directive: parse_result.working_directory_directive,
         is_standalone: parse_result.is_standalone,
         diagnostics: parse_result.diagnostics,
-        registered_backward_mode: options?.backward_dependencies ?? "explicit"
+        registered_backward_mode: options?.skip_backward_registration ? undefined : options?.backward_dependencies ?? "explicit"
       });
-      this.apply_backward_directive_registration(actual_uri, parse_result.directives, { backward_dependencies: options?.backward_dependencies ?? "explicit" }, parse_result.is_standalone);
+      if (!options?.skip_backward_registration) {
+        this.apply_backward_directive_registration(actual_uri, parse_result.directives, { backward_dependencies: options?.backward_dependencies ?? "explicit" }, parse_result.is_standalone);
+      }
       this.register_forward_call_relationships_from_cache(actual_uri, parse_result.forward_calls, parse_result.symbols);
       return { content, content_hash: disk_hash, ...parse_result };
     } catch (error) {
       this.warn(`ScopeResolver: Parse error for ${actual_uri}: ${error_message(error)}`);
       const empty_symbols = create_empty_symbol_table();
       const my_recovered = this.recover_header_facts(actual_uri, content);
-      if (my_recovered.recovered) {
+      if (my_recovered.recovered && !options?.skip_backward_registration) {
         this.apply_backward_directive_registration(actual_uri, my_recovered.directives, {
           backward_dependencies: options?.backward_dependencies ?? "explicit"
         }, my_recovered.is_standalone);
@@ -23429,6 +24088,12 @@ class ScopeResolver {
       }
     };
   }
+  get_cache_sizes() {
+    return {
+      scope: this.scope_cache.size,
+      file: this.file_cache.size
+    };
+  }
   reset_cache_metrics() {
     this.cache_metrics = this.create_metrics();
   }
@@ -23633,14 +24298,7 @@ class ScopeResolver {
       }
       for (const my_key of keys_to_remove) {
         this.scope_cache.delete(my_key);
-        const key_uri = this.extract_uri_from_cache_key(my_key);
-        const key_set = this.uri_to_cache_keys.get(key_uri);
-        if (key_set) {
-          key_set.delete(my_key);
-          if (key_set.size === 0) {
-            this.uri_to_cache_keys.delete(key_uri);
-          }
-        }
+        this.prune_uri_to_cache_keys_for_key(my_key);
         this.cache_metrics.scope.invalidations++;
       }
     }
@@ -23694,6 +24352,10 @@ class ScopeResolver {
   }
   upgrade_registration_on_cache_hit(uri, cached, requested_mode) {
     if (requested_mode !== "auto") {
+      if (requested_mode === "explicit" && cached.registered_backward_mode === undefined) {
+        this.apply_backward_directive_registration(uri, cached.directives, { backward_dependencies: "explicit" }, cached.is_standalone);
+        cached.registered_backward_mode = "explicit";
+      }
       return;
     }
     if (cached.directives.length > 0 && cached.registered_backward_mode === "auto") {
@@ -23857,7 +24519,7 @@ class ScopeResolver {
     this.reset_reverse_deps();
   }
 }
-var DEFAULT_CONFIG2;
+var DEFAULT_CONFIG2, DEFAULT_MAX_CACHED_FILES = 2000, DEFAULT_MAX_CACHED_SCOPES = 1000;
 var init_scope_resolver = __esm(() => {
   init_esm();
   init_types();
@@ -23866,6 +24528,7 @@ var init_scope_resolver = __esm(() => {
   init_parser();
   init_analyzer();
   init_logger();
+  init_lru_cache();
   init_dofile_locals();
   init_workspace_roots();
   init_file_path_utils();
@@ -27003,13 +27666,14 @@ class IndentationDiagnosticAnalyzer {
     const stataRanges = this.getStataRanges(document);
     const block_comment_lines2 = this.compute_block_comment_lines(lines, document.tokens);
     const continuation_lines = document.tokens ? this.compute_continuation_lines(document.tokens) : new Set;
+    const structural_taint = this.compute_structural_taint(document);
     for (const range of stataRanges) {
       diagnostics.push(...this.find_comment_indentation_issues(lines, range, block_comment_lines2, indent_size));
       diagnostics.push(...this.find_block_indentation_issues(document, lines, range, block_comment_lines2, indent_size, continuation_lines));
       const expected_depths = this.compute_expected_depths(document, range);
-      diagnostics.push(...this.find_unnecessary_indentation_issues(document, lines, range, block_comment_lines2, indent_size, expected_depths, continuation_lines));
+      diagnostics.push(...this.find_ast_depth_indentation_issues(lines, range, block_comment_lines2, indent_size, expected_depths, continuation_lines, structural_taint));
     }
-    return diagnostics;
+    return this.dedupe_by_line_and_code(diagnostics);
   }
   compute_continuation_lines(tokens) {
     const continuation_lines = new Set;
@@ -27234,7 +27898,12 @@ class IndentationDiagnosticAnalyzer {
       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) {
         for (const child of node.body) {
-          walk_node(child, current_depth + 1);
+          const child_start_line = child.range.start.line;
+          if (child_start_line === start_line) {
+            walk_node(child, current_depth);
+          } else {
+            walk_node(child, current_depth + 1);
+          }
         }
         const end_line = node.range.end.line;
         if (end_line !== start_line && end_line >= range.start && end_line <= range.end) {
@@ -27277,7 +27946,7 @@ class IndentationDiagnosticAnalyzer {
         const block_node = node;
         for (const my_child of block_node.body) {
           const child_start_line = my_child.range.start.line;
-          if (child_start_line === start_line && this.is_block_node_type(my_child)) {
+          if (child_start_line === start_line) {
             walk_node(my_child, depth);
           } else {
             walk_node(my_child, depth + 1);
@@ -27319,14 +27988,15 @@ class IndentationDiagnosticAnalyzer {
     }
     return false;
   }
-  find_unnecessary_indentation_issues(document, lines, range, block_comment_lines2, indent_size, expected_depths, continuation_lines) {
+  find_ast_depth_indentation_issues(lines, range, block_comment_lines2, indent_size, expected_depths, continuation_lines, structural_taint) {
     const diagnostics = [];
     for (let i = range.start;i <= range.end && i < lines.length; i++) {
       const line = lines[i];
-      if (this.should_skip_unnecessary_check(line, i, block_comment_lines2, continuation_lines)) {
+      if (this.should_skip_unnecessary_check(line, i, block_comment_lines2, continuation_lines) || structural_taint.has(i)) {
         continue;
       }
       const actual_indent = this.get_line_indentation(line, indent_size);
+      const has_known_depth = expected_depths.has(i);
       const expected_depth = expected_depths.get(i) ?? 0;
       const expected_indent = expected_depth * indent_size;
       if (actual_indent > expected_indent) {
@@ -27338,12 +28008,94 @@ class IndentationDiagnosticAnalyzer {
           code: "UNNECESSARY_INDENTATION" /* UNNECESSARY_INDENTATION */,
           ...diagnostic_code_description_fields("UNNECESSARY_INDENTATION" /* UNNECESSARY_INDENTATION */)
         });
+      } else if (has_known_depth && actual_indent < expected_indent) {
+        diagnostics.push({
+          severity: import_node.DiagnosticSeverity.Information,
+          range: import_node.Range.create(import_node.Position.create(i, 0), import_node.Position.create(i, actual_indent)),
+          message: "Line appears under-indented for its block depth. Use Format Document to fix.",
+          source: "sight",
+          code: "MISSING_INDENTATION" /* MISSING_INDENTATION */,
+          ...diagnostic_code_description_fields("MISSING_INDENTATION" /* MISSING_INDENTATION */)
+        });
       }
     }
     return diagnostics;
   }
+  compute_structural_taint(document) {
+    const tainted_lines = new Set;
+    const the_error_lines = [];
+    for (const my_diagnostic of document.diagnostics) {
+      const my_code = typeof my_diagnostic.code === "string" ? my_diagnostic.code : "";
+      if (STRUCTURAL_NESTING_ERROR_CODES.has(my_code)) {
+        the_error_lines.push(my_diagnostic.range.start.line);
+      }
+    }
+    if (the_error_lines.length === 0) {
+      return tainted_lines;
+    }
+    if (!document.ast) {
+      for (const my_error_line of the_error_lines) {
+        tainted_lines.add(my_error_line);
+      }
+      return tainted_lines;
+    }
+    for (const my_error_line of the_error_lines) {
+      const my_block = this.find_smallest_block_containing(document.ast, my_error_line);
+      if (my_block) {
+        for (let my_line = my_block.range.start.line;my_line <= my_block.range.end.line; my_line++) {
+          tainted_lines.add(my_line);
+        }
+      } else {
+        tainted_lines.add(my_error_line);
+      }
+    }
+    return tainted_lines;
+  }
+  find_smallest_block_containing(ast, line) {
+    let best = null;
+    const walk = (node) => {
+      const start_line = node.range.start.line;
+      const end_line = node.range.end.line;
+      if (line < start_line || line > end_line) {
+        return;
+      }
+      if (this.is_indentation_block_node(node)) {
+        if (best === null || end_line - start_line <= best.range.end.line - best.range.start.line) {
+          best = node;
+        }
+      }
+      if ("body" in node && Array.isArray(node.body)) {
+        for (const my_child of node.body) {
+          walk(my_child);
+        }
+      }
+    };
+    for (const my_node of ast.nodes) {
+      walk(my_node);
+    }
+    return best;
+  }
+  is_indentation_block_node(node) {
+    if (this.is_block_node_type(node)) {
+      return true;
+    }
+    return node.type === "command" && "name" in node && node.name === "{";
+  }
+  dedupe_by_line_and_code(diagnostics) {
+    const seen_line_codes = new Set;
+    const deduped = [];
+    for (const my_diagnostic of diagnostics) {
+      const my_key = `${my_diagnostic.range.start.line}:${my_diagnostic.code}`;
+      if (seen_line_codes.has(my_key)) {
+        continue;
+      }
+      seen_line_codes.add(my_key);
+      deduped.push(my_diagnostic);
+    }
+    return deduped;
+  }
 }
-var import_node, CONTROL_FLOW_RE, FIRST_WORD_RE;
+var import_node, CONTROL_FLOW_RE, FIRST_WORD_RE, STRUCTURAL_NESTING_ERROR_CODES;
 var init_indentation_diagnostics = __esm(() => {
   init_types2();
   init_types();
@@ -27351,6 +28103,17 @@ var init_indentation_diagnostics = __esm(() => {
   import_node = __toESM(require_main4(), 1);
   CONTROL_FLOW_RE = /^(if|foreach|while|program|mata|python)\b/;
   FIRST_WORD_RE = /^(\w+)\b/;
+  STRUCTURAL_NESTING_ERROR_CODES = new Set([
+    "OPEN_BRACE_ALONE",
+    "ORPHAN_CLOSE_BRACE",
+    "BRACE_NOT_ALONE",
+    "BRACE_ELSE_SAME_LINE",
+    "CODE_AFTER_OPEN_BRACE",
+    "UNCLOSED_BLOCK",
+    "MISSING_PROGRAM_END",
+    "UNBALANCED_QUOTES",
+    "UNBALANCED_BLOCK_COMMENT"
+  ]);
 });
 
 // src/utils/diagnostic-severity.ts
@@ -29930,137 +30693,6 @@ var init_command_database = __esm(() => {
   command_database = new CommandDatabase;
 });
 
-// src/utils/lru-cache.ts
-class LRUCache {
-  cache = new Map;
-  max_size;
-  hits = 0;
-  misses = 0;
-  evictions = 0;
-  current_generation = 0;
-  constructor(max_size = 100) {
-    this.max_size = max_size;
-  }
-  get(key) {
-    const entry = this.cache.get(key);
-    if (entry !== undefined) {
-      this.hits++;
-      entry.access_count++;
-      this.cache.delete(key);
-      this.cache.set(key, entry);
-      return entry.value;
-    } else {
-      this.misses++;
-    }
-    return;
-  }
-  set(key, value) {
-    this.cache.delete(key);
-    if (this.cache.size >= this.max_size) {
-      this.evict_one();
-    }
-    this.cache.set(key, {
-      value,
-      generation: this.current_generation,
-      access_count: 1
-    });
-  }
-  evict_one() {
-    let victim_key;
-    let victim_score = Infinity;
-    for (const [key, entry] of this.cache) {
-      const score = entry.generation * 1000 + entry.access_count;
-      if (score < victim_score) {
-        victim_score = score;
-        victim_key = key;
-      }
-    }
-    if (victim_key !== undefined) {
-      this.cache.delete(victim_key);
-      this.evictions++;
-    }
-  }
-  advance_generation() {
-    this.current_generation++;
-  }
-  trim_to_top_n(n) {
-    if (this.cache.size <= n)
-      return;
-    const entries = Array.from(this.cache.entries()).sort((a, b) => b[1].access_count - a[1].access_count);
-    this.cache.clear();
-    for (let i = 0;i < Math.min(n, entries.length); i++) {
-      this.cache.set(entries[i][0], entries[i][1]);
-    }
-    this.evictions += entries.length - n;
-  }
-  has(key) {
-    return this.cache.has(key);
-  }
-  clear() {
-    this.cache.clear();
-  }
-  size() {
-    return this.cache.size;
-  }
-  get_stats() {
-    return { hits: this.hits, misses: this.misses, evictions: this.evictions };
-  }
-}
-
-class CompletionPrefixCache {
-  cache;
-  command_db_version = 0;
-  workspace_version = 0;
-  top_n_threshold;
-  constructor(max_size = 100, top_n_threshold = 200) {
-    this.cache = new LRUCache(max_size);
-    this.top_n_threshold = top_n_threshold;
-  }
-  make_key(prefix, context, document_version = 0) {
-    return `${context}:${prefix}:${this.command_db_version}:${this.workspace_version}:${document_version}`;
-  }
-  get_with_context(prefix, context, document_version = 0) {
-    return this.cache.get(this.make_key(prefix, context, document_version));
-  }
-  set_with_context(prefix, context, value, document_version = 0) {
-    const trimmed_value = this.apply_limit(value);
-    this.cache.set(this.make_key(prefix, context, document_version), trimmed_value);
-    return trimmed_value;
-  }
-  apply_limit(value) {
-    if (this.top_n_threshold > 0 && value.length > this.top_n_threshold) {
-      return value.slice(0, this.top_n_threshold);
-    }
-    return value;
-  }
-  has_with_context(prefix, context, document_version = 0) {
-    return this.cache.has(this.make_key(prefix, context, document_version));
-  }
-  invalidate_on_db_change(new_version) {
-    if (new_version !== this.command_db_version) {
-      this.command_db_version = new_version;
-      this.cache.clear();
-      this.cache.advance_generation();
-    }
-  }
-  invalidate_on_workspace_change(new_version) {
-    if (new_version !== this.workspace_version) {
-      this.workspace_version = new_version;
-      this.cache.clear();
-      this.cache.advance_generation();
-    }
-  }
-  clear() {
-    this.cache.clear();
-  }
-  size() {
-    return this.cache.size();
-  }
-  get_stats() {
-    return this.cache.get_stats();
-  }
-}
-
 // src/utils/symbol-index-cache.ts
 class SymbolIndexCache {
   filtered_views = new Map;
@@ -30429,12 +31061,58 @@ function compute_ranking_key(factors) {
   const name = factors.alphabetical_order.toLowerCase();
   return `${scope_priority}${directive_priority}${symbol_priority_padded}|${parent_uri}|${name}`;
 }
+function stata_region_floor_line(document, position) {
+  const the_ranges = document.context_ranges;
+  if (!the_ranges || the_ranges.length === 0) {
+    return 0;
+  }
+  let floor_line = 0;
+  for (const my_range of the_ranges) {
+    if (my_range.context === "stata" /* STATA */) {
+      continue;
+    }
+    if (my_range.start_delimiter?.command?.endsWith(":")) {
+      continue;
+    }
+    if (my_range.range.end.line < position.line) {
+      floor_line = Math.max(floor_line, my_range.range.end.line + 1);
+    }
+  }
+  return floor_line;
+}
+function build_logical_text_before_cursor(document, position, tokens, start, physical_text_before_cursor) {
+  if (start === undefined || tokens === undefined) {
+    return physical_text_before_cursor;
+  }
+  const current_line = get_line_text(document, position.line);
+  const physical_current = current_line.substring(start.line === position.line ? start.character : 0, position.character);
+  if (start.line === position.line) {
+    return physical_current;
+  }
+  const the_parts = [];
+  for (let my_i = start.index;my_i < tokens.length && tokens[my_i].range.start.line < position.line; my_i++) {
+    const my_token = tokens[my_i];
+    if (LOGICAL_FLATTEN_SKIP_TYPES.has(my_token.type)) {
+      continue;
+    }
+    the_parts.push(my_token.value);
+  }
+  const prior_text = the_parts.join(" ");
+  return prior_text === "" ? physical_current : prior_text + " " + physical_current;
+}
 function detect_completion_context(document, position, tokens, command_db) {
   if (position.line >= get_line_count(document)) {
     return { type: "fallback" };
   }
   const current_line = get_line_text(document, position.line);
   const text_before_cursor = current_line.substring(0, position.character);
+  let cached_logical_text;
+  const get_logical_text = () => {
+    if (cached_logical_text === undefined) {
+      cached_logical_text = build_logical_text_before_cursor(document, position, tokens, logical_statement_start(tokens, position, stata_region_floor_line(document, position)), text_before_cursor);
+    }
+    return cached_logical_text;
+  };
   const extended_macro_context = detect_extended_macro_context(text_before_cursor, position);
   if (extended_macro_context) {
     return extended_macro_context;
@@ -30443,7 +31121,7 @@ function detect_completion_context(document, position, tokens, command_db) {
   if (directive_context && !is_cursor_in_block_comment(document, position)) {
     return directive_context;
   }
-  const command_path_context = detect_command_path_context(text_before_cursor);
+  const command_path_context = detect_command_path_context(get_logical_text());
   if (command_path_context) {
     return command_path_context;
   }
@@ -30451,18 +31129,18 @@ function detect_completion_context(document, position, tokens, command_db) {
   if (macro_context) {
     return macro_context;
   }
-  const option_context = detect_option_context(text_before_cursor, document, position);
+  const option_context = detect_option_context(get_logical_text(), document, position);
   if (option_context) {
     return option_context;
   }
-  const subcommand_context = detect_subcommand_context(text_before_cursor, command_db);
+  const subcommand_context = detect_subcommand_context(get_logical_text(), command_db);
   if (subcommand_context) {
     return subcommand_context;
   }
-  if (is_command_context(text_before_cursor)) {
+  if (is_command_context(get_logical_text())) {
     return { type: "command" };
   }
-  if (is_variable_context(text_before_cursor)) {
+  if (is_variable_context(get_logical_text())) {
     return { type: "variable" };
   }
   return { type: "fallback" };
@@ -30575,6 +31253,9 @@ function extract_command_name(text) {
   }
   const the_words = working_text.split(/\s+/).filter((w) => w.length > 0);
   for (const my_word of the_words) {
+    if (my_word === ":") {
+      continue;
+    }
     const lower_word = my_word.toLowerCase();
     if (!PREFIX_COMMANDS2.includes(lower_word)) {
       return my_word;
@@ -30866,7 +31547,7 @@ class CompletionProvider {
       if (my_current_context === "stata" /* STATA */ && is_cursor_in_block_comment(document, position, { require_tokens: true })) {
         return [];
       }
-      const context = detect_completion_context(document, position, undefined, this.command_db);
+      const context = detect_completion_context(document, position, my_current_context === "stata" /* STATA */ ? document.tokens : undefined, this.command_db);
       if (my_current_context !== "stata" /* STATA */ && context.type !== "macro") {
         const my_boundary_completions = this.get_block_boundary_completions(document, position);
         return my_boundary_completions;
@@ -31202,7 +31883,8 @@ class CompletionProvider {
       return "";
     }
     const current_line = get_line_text(document, position.line);
-    const text_before_cursor = current_line.substring(0, position.character);
+    const physical_text_before_cursor = current_line.substring(0, position.character);
+    const text_before_cursor = build_logical_text_before_cursor(document, position, document.tokens, logical_statement_start(document.tokens, position, stata_region_floor_line(document, position)), physical_text_before_cursor);
     let paren_depth = 0;
     let in_string = false;
     let last_comma_pos = -1;
@@ -32216,12 +32898,13 @@ class CompletionProvider {
     return position.line >= body_start && position.line < program.range.end.line;
   }
 }
-var import_vscode_languageserver4, DIRECTIVE_PATH_CONTEXT_PATTERN;
+var import_vscode_languageserver4, DIRECTIVE_PATH_CONTEXT_PATTERN, LOGICAL_FLATTEN_SKIP_TYPES;
 var init_completion = __esm(() => {
   init_command_database();
   init_scoped_locals();
   init_dofile_locals();
   init_types2();
+  init_lru_cache();
   init_scope_resolver();
   init_scope_resolver();
   init_analyzer();
@@ -32230,8 +32913,18 @@ var init_completion = __esm(() => {
   init_comment_utils();
   init_logger();
   init_macro_completion();
+  init_statement_span();
   import_vscode_languageserver4 = __toESM(require_main4(), 1);
   DIRECTIVE_PATH_CONTEXT_PATTERN = new RegExp(`^\\s*(${DIRECTIVE_BODY_PREFIX_PATTERN}[a-zA-Z-]+)\\s*:?\\s*(.*)$`);
+  LOGICAL_FLATTEN_SKIP_TYPES = new Set([
+    "WHITESPACE",
+    "COMMENT_LINE",
+    "COMMENT_BLOCK",
+    "CONTINUATION",
+    "STATEMENT_TERMINATOR",
+    "DELIMIT_DIRECTIVE",
+    "EOF"
+  ]);
 });
 
 // src/utils/marker-scanner.ts
@@ -32495,7 +33188,8 @@ function create_completion_handler(deps) {
       const config = await deps.get_document_settings(params.textDocument.uri);
       const graph_version = deps.dependency_graph ? deps.dependency_graph.get_version() : undefined;
       const items = await deps.completion_provider.get_completions(document_state, params.position, trigger_character, deps.scope_resolver || undefined, workspace_symbols, scope_resolver_config_for(config), workspace_version, token, graph_version);
-      const completion_context = detect_completion_context(document_state, params.position, document_state.tokens);
+      const probe_context = document_state.context_tracker ? document_state.context_tracker.get_context_at_position(params.position) : "stata" /* STATA */;
+      const completion_context = detect_completion_context(document_state, params.position, probe_context === "stata" /* STATA */ ? document_state.tokens : undefined);
       const is_macro_context = completion_context.type === "macro";
       return { isIncomplete: is_macro_context, items };
     }
@@ -32853,6 +33547,7 @@ var import_node7, DEFAULT_SETTINGS, MAX_IHLP_CACHE_SIZE = 500, MAX_RESOLVE_STHLP
 var init_server_handlers = __esm(() => {
   init_completion();
   init_context_tracker();
+  init_types2();
   init_scope_resolver();
   init_include_expander();
   init_marker_scanner();
@@ -32865,7 +33560,7 @@ var init_server_handlers = __esm(() => {
       severity: {
         undefinedMacro: "warning",
         undefinedVariable: "off",
-        styleWarnings: "hint",
+        styleWarnings: "information",
         malformedOperator: "warning",
         spacedCompoundOperator: "information",
         invalidOperatorSequence: "error",
@@ -32906,6 +33601,9 @@ var init_server_handlers = __esm(() => {
       max_forward_depth: 10,
       max_chain_depth: 20,
       max_callee_revalidations: 10,
+      max_cached_files: 2000,
+      max_cached_scopes: 1000,
+      max_cached_forward_closures: 2000,
       diagnostics: {
         missing_file: "warning",
         max_depth: "information",
@@ -33084,6 +33782,15 @@ function validate_comment_formatting_config(config, log_warning) {
     if (typeof cross_file.max_callee_revalidations === "number" && cross_file.max_callee_revalidations > 0) {
       validated_config.cross_file.max_callee_revalidations = cross_file.max_callee_revalidations;
     }
+    if (typeof cross_file.max_cached_files === "number" && cross_file.max_cached_files > 0) {
+      validated_config.cross_file.max_cached_files = cross_file.max_cached_files;
+    }
+    if (typeof cross_file.max_cached_scopes === "number" && cross_file.max_cached_scopes > 0) {
+      validated_config.cross_file.max_cached_scopes = cross_file.max_cached_scopes;
+    }
+    if (typeof cross_file.max_cached_forward_closures === "number" && cross_file.max_cached_forward_closures > 0) {
+      validated_config.cross_file.max_cached_forward_closures = cross_file.max_cached_forward_closures;
+    }
     if (cross_file.diagnostics) {
       const valid_severities = ["error", "warning", "information", "info", "off"];
       const valid_case_mismatch_severities = [
@@ -33766,10 +34473,16 @@ async function build_check_context(workspace_root, config) {
       }
     },
     warn: (message) => console.error(message)
+  }, undefined, {
+    max_cached_files: config.cross_file.max_cached_files,
+    max_cached_scopes: config.cross_file.max_cached_scopes
   });
   const forward_scope_resolver = new ForwardScopeResolver(scope_resolver, {
     max_forward_depth: config.cross_file.max_forward_depth
   });
+  if (config.cross_file.max_cached_forward_closures !== undefined) {
+    forward_scope_resolver.set_forward_closure_memo_capacity(config.cross_file.max_cached_forward_closures);
+  }
   const diagnostics_provider = new DiagnosticsProvider({
     sendDiagnostics: () => {
       return;
@@ -34235,57 +34948,6 @@ var init_main = __esm(() => {
   })(TextDocument || (TextDocument = {}));
 });
 
-// src/utils/token-utils.ts
-function position_before2(a, b) {
-  return a.line < b.line || a.line === b.line && a.character < b.character;
-}
-function position_at_or_before(a, b) {
-  return a.line < b.line || a.line === b.line && a.character <= b.character;
-}
-function find_last_token_starting_at_or_before(tokens, position) {
-  let low = 0;
-  let high = tokens.length - 1;
-  let best = -1;
-  while (low <= high) {
-    const mid = low + high >>> 1;
-    const start = tokens[mid].range.start;
-    if (position_at_or_before(start, position)) {
-      best = mid;
-      low = mid + 1;
-    } else {
-      high = mid - 1;
-    }
-  }
-  return best;
-}
-function find_last_token_starting_before(tokens, position) {
-  let low = 0;
-  let high = tokens.length - 1;
-  let best = -1;
-  while (low <= high) {
-    const mid = low + high >>> 1;
-    const start = tokens[mid].range.start;
-    if (position_before2(start, position)) {
-      best = mid;
-      low = mid + 1;
-    } else {
-      high = mid - 1;
-    }
-  }
-  return best;
-}
-function find_token_index_at_position(tokens, position) {
-  const candidate = find_last_token_starting_at_or_before(tokens, position);
-  if (candidate === -1) {
-    return -1;
-  }
-  const end = tokens[candidate].range.end;
-  if (position_before2(position, end)) {
-    return candidate;
-  }
-  return -1;
-}
-
 // src/utils/string-literal-utils.ts
 function is_cursor_in_string_literal(document, position) {
   if (!document.tokens || document.tokens.length === 0) {
@@ -38481,27 +39143,20 @@ class IndentationAnalyzer {
     if (!this.has_trivia(node))
       return;
     const node_with_trivia = node;
-    if (node_with_trivia.leadingTrivia) {
-      for (const my_trivia of node_with_trivia.leadingTrivia) {
-        if (my_trivia.type === "comment") {
-          const trivia_line = my_trivia.range.start.line;
-          if (!this.indentation_map.has(trivia_line)) {
-            const { delta, original_indent } = this.calculate_indent_delta(trivia_line, this.current_depth);
-            this.set_indentation(trivia_line, this.current_depth, false, false, false, false, delta, original_indent);
-          }
-        }
-      }
-    }
-    if (node_with_trivia.trailingTrivia) {
-      for (const my_trivia of node_with_trivia.trailingTrivia) {
-        if (my_trivia.type === "comment") {
-          const trivia_line = my_trivia.range.start.line;
-          if (!this.indentation_map.has(trivia_line)) {
-            const { delta, original_indent } = this.calculate_indent_delta(trivia_line, this.current_depth);
-            this.set_indentation(trivia_line, this.current_depth, false, false, false, false, delta, original_indent);
-          }
-        }
-      }
+    this.mark_comment_trivia_indentation(node_with_trivia.leadingTrivia);
+    this.mark_comment_trivia_indentation(node_with_trivia.trailingTrivia);
+  }
+  mark_comment_trivia_indentation(the_trivia) {
+    if (!the_trivia)
+      return;
+    for (const my_trivia of the_trivia) {
+      if (my_trivia.type !== "comment")
+        continue;
+      const trivia_line = my_trivia.range.start.line;
+      if (this.indentation_map.has(trivia_line))
+        continue;
+      const { delta, original_indent } = this.calculate_indent_delta(trivia_line, this.current_depth);
+      this.set_indentation(trivia_line, this.current_depth, false, false, false, false, delta, original_indent);
     }
   }
   is_block_node(node) {
@@ -38524,6 +39179,7 @@ class IndentationAnalyzer {
         this.walk_node(my_child);
       }
     }
+    this.process_block_ending_trivia(node);
     this.current_depth--;
     if (end_line !== start_line) {
       const end_delta_info = this.calculate_indent_delta(end_line, this.current_depth);
@@ -38556,6 +39212,7 @@ class IndentationAnalyzer {
         this.set_indentation(line, this.current_depth, false, false, false, false, delta, original_indent);
       }
     }
+    this.process_block_ending_trivia(node);
     this.current_depth--;
     if (end_line !== start_line) {
       const end_delta_info = this.calculate_indent_delta(end_line, this.current_depth);
@@ -38567,6 +39224,10 @@ class IndentationAnalyzer {
     const { delta, original_indent } = this.calculate_indent_delta(start_line, this.current_depth);
     this.set_indentation(start_line, this.current_depth, false, false, false, false, delta, original_indent);
   }
+  process_block_ending_trivia(node) {
+    const node_with_trivia = node;
+    this.mark_comment_trivia_indentation(node_with_trivia.blockEndingTrivia);
+  }
   process_continuations(tokens) {
     let continuation_indent = 0;
     let in_continuation = false;
@@ -40070,6 +40731,7 @@ class PrettyPrinter {
       for (const my_stmt of node.body) {
         the_parts.push(this.printNode(my_stmt));
       }
+      the_parts.push(this.printBlockEndingTrivia(node));
       this.current_indent--;
       the_parts.push(`${this.getIndent()}}`);
     }
@@ -40090,7 +40752,9 @@ class PrettyPrinter {
   printOption(option) {
     let result = option.name;
     if (option.argument !== undefined) {
-      result += `(${format_expression_spacing(option.argument)})`;
+      const close_paren = option.argument_unclosed ? "" : ")";
+      const argument = format_expression_spacing(option.argument);
+      result += `(${argument}${close_paren}`;
     }
     return result;
   }
@@ -40102,6 +40766,7 @@ class PrettyPrinter {
     for (const my_stmt of node.body) {
       the_lines.push(this.printNode(my_stmt));
     }
+    the_lines.push(this.printBlockEndingTrivia(node));
     this.current_indent--;
     the_lines.push(`${this.getIndent()}end`);
     return the_lines.join("");
@@ -40160,6 +40825,7 @@ class PrettyPrinter {
     for (const my_stmt of node.body) {
       the_lines.push(this.printNode(my_stmt));
     }
+    the_lines.push(this.printBlockEndingTrivia(node));
     this.current_indent--;
     the_lines.push(`${this.getIndent()}}`);
     return the_lines.join("");
@@ -40220,6 +40886,19 @@ class PrettyPrinter {
     }
     return the_parts.join("");
   }
+  printBlockEndingTrivia(node) {
+    if (!node.blockEndingTrivia || node.blockEndingTrivia.length === 0) {
+      return "";
+    }
+    const the_parts = [];
+    for (const my_trivia of node.blockEndingTrivia) {
+      the_parts.push(this.getIndent());
+      the_parts.push(this.printTrivia(my_trivia));
+      the_parts.push(`
+`);
+    }
+    return the_parts.join("");
+  }
   printTrivia(trivia) {
     return trivia.content;
   }
@@ -40315,28 +40994,17 @@ class CodeFormatter {
     const the_embedded_blocks = new Map;
     let my_placeholder_counter = 0;
     let my_modified_content = document.content;
-    const the_sorted_ranges = [...context_ranges].sort((a, b) => b.range.start.line - a.range.start.line);
-    for (const my_range of the_sorted_ranges) {
+    const the_replacement_units = this.coalesce_embedded_ranges(the_doc, context_ranges);
+    for (const my_unit of the_replacement_units) {
       if (my_placeholder_counter >= MAX_EMBEDDED_BLOCKS) {
         break;
       }
       const my_placeholder = `__EMBEDDED_BLOCK_${my_placeholder_counter}__`;
       the_embedded_blocks.set(my_placeholder, {
-        content: this.extract_block_content(the_doc, my_range),
-        range: my_range
+        content: my_unit.content,
+        range: my_unit.range
       });
-      let actual_range;
-      if (my_range.is_single_line) {
-        actual_range = my_range.range;
-      } else {
-        const actual_end_line = my_range.end_delimiter ? my_range.end_delimiter.range.start.line : my_range.range.end.line;
-        const end_line_text = get_line_text(the_doc, actual_end_line);
-        actual_range = {
-          start: my_range.range.start,
-          end: { line: actual_end_line, character: end_line_text.length }
-        };
-      }
-      my_modified_content = this.replace_range_in_content(my_modified_content, actual_range, my_placeholder);
+      my_modified_content = this.replace_range_in_content(my_modified_content, my_unit.actual_range, my_placeholder);
       my_placeholder_counter++;
     }
     const indent_size = options.tabSize ?? server_config?.formatting?.indentSize ?? 4;
@@ -40366,7 +41034,7 @@ class CodeFormatter {
           const indented_block_lines = block_lines.map((line, index) => {
             if (index === 0) {
               return leading_indent + line;
-            } else if (index === block_lines.length - 1 && line.trim() === expected_end_delimiter) {
+            } else if (!my_block_info.range.is_single_line && index === block_lines.length - 1 && line.trim() === expected_end_delimiter) {
               return leading_indent + line;
             } else {
               return line;
@@ -40391,6 +41059,90 @@ class CodeFormatter {
       newText: this.strip_trailing_whitespace(my_formatted_content)
     }];
   }
+  embedded_range_span(doc, context_range) {
+    if (context_range.is_single_line) {
+      return {
+        start_line: context_range.range.start.line,
+        end_line: context_range.range.end.line
+      };
+    }
+    const my_end_line = context_range.end_delimiter ? context_range.end_delimiter.range.start.line : context_range.range.end.line;
+    return { start_line: context_range.range.start.line, end_line: my_end_line };
+  }
+  coalesce_embedded_ranges(doc, context_ranges) {
+    const the_spans = context_ranges.map((my_range) => ({
+      my_range,
+      span: this.embedded_range_span(doc, my_range)
+    })).sort((a, b) => {
+      if (a.span.start_line !== b.span.start_line) {
+        return a.span.start_line - b.span.start_line;
+      }
+      return a.span.end_line - b.span.end_line;
+    });
+    const the_groups = [];
+    for (const my_item of the_spans) {
+      const my_last = the_groups[the_groups.length - 1];
+      if (my_last && my_item.span.start_line <= my_last.end_line) {
+        my_last.end_line = Math.max(my_last.end_line, my_item.span.end_line);
+        my_last.members.push(my_item.my_range);
+      } else {
+        the_groups.push({
+          start_line: my_item.span.start_line,
+          end_line: my_item.span.end_line,
+          members: [my_item.my_range]
+        });
+      }
+    }
+    const the_line_count = get_line_count(doc);
+    const the_units = [];
+    for (const my_group of the_groups) {
+      if (my_group.members.length === 1) {
+        const my_range = my_group.members[0];
+        const my_end_line_text2 = get_line_text(doc, my_group.end_line);
+        the_units.push({
+          content: this.extract_block_content(doc, my_range),
+          range: my_range,
+          actual_range: {
+            start: { line: my_group.start_line, character: 0 },
+            end: {
+              line: my_group.end_line,
+              character: my_end_line_text2.length
+            }
+          }
+        });
+        continue;
+      }
+      const my_lines = [];
+      for (let my_line = my_group.start_line;my_line <= my_group.end_line && my_line < the_line_count; my_line++) {
+        const my_text = get_line_text(doc, my_line);
+        my_lines.push(my_line === my_group.start_line ? my_text.trimStart() : my_text);
+      }
+      const my_end_line_text = get_line_text(doc, my_group.end_line);
+      const my_synthetic_range = {
+        context: my_group.members[0].context,
+        range: {
+          start: { line: my_group.start_line, character: 0 },
+          end: { line: my_group.end_line, character: Number.MAX_SAFE_INTEGER }
+        },
+        start_delimiter: my_group.members[0].start_delimiter,
+        is_single_line: true
+      };
+      the_units.push({
+        content: my_lines.join(`
+`),
+        range: my_synthetic_range,
+        actual_range: {
+          start: { line: my_group.start_line, character: 0 },
+          end: {
+            line: my_group.end_line,
+            character: my_end_line_text.length
+          }
+        }
+      });
+    }
+    the_units.sort((a, b) => b.actual_range.start.line - a.actual_range.start.line);
+    return the_units;
+  }
   extract_block_content(doc, context_range) {
     const the_start_line = context_range.range.start.line;
     const the_end_line = context_range.end_delimiter ? context_range.end_delimiter.range.start.line : context_range.range.end.line;
@@ -71745,6 +72497,13 @@ async function create_server(options) {
   function configure_completion_provider(settings) {
     completion_provider?.configure_completion(settings.completion);
   }
+  function apply_cache_capacities(settings) {
+    scope_resolver?.set_cache_capacities({
+      max_cached_files: settings.cross_file?.max_cached_files ?? DEFAULT_SETTINGS.cross_file.max_cached_files,
+      max_cached_scopes: settings.cross_file?.max_cached_scopes ?? DEFAULT_SETTINGS.cross_file.max_cached_scopes
+    });
+    forward_scope_resolver?.set_forward_closure_memo_capacity(settings.cross_file?.max_cached_forward_closures ?? DEFAULT_SETTINGS.cross_file.max_cached_forward_closures ?? 2000);
+  }
   function reset_workspace_indexing_state() {
     workspace_indexer?.reset();
     dependency_graph?.reset();
@@ -71757,6 +72516,7 @@ async function create_server(options) {
     }
     last_applied_indexing_signature = indexing_affecting_signature(settings);
     configure_completion_provider(settings);
+    apply_cache_capacities(settings);
     if (workspace_indexer) {
       workspace_indexer.configure(settings);
       workspace_indexer.set_max_indexed_files(settings.cross_file?.max_indexed_files ?? 1000);
@@ -71810,6 +72570,7 @@ async function create_server(options) {
       configure_workspace_indexing(settings, active_workspace_roots, true);
     } else {
       configure_completion_provider(settings);
+      apply_cache_capacities(settings);
       workspace_indexer?.configure(settings);
       revalidate_all_open_docs();
     }
@@ -72125,6 +72886,7 @@ ${scope_resolver.get_reverse_deps_debug_info()}`);
       configure_workspace_indexing(settings, active_workspace_roots, true);
     } else {
       configure_completion_provider(settings);
+      apply_cache_capacities(settings);
       workspace_indexer?.configure(settings);
       revalidate_all_open_docs();
     }
@@ -72472,4 +73234,4 @@ export {
   is_cli_entry_point
 };
 
-//# debugId=5FE144BA73C2961164756E2164756E21
+//# debugId=DFA4590C23722F1564756E2164756E21