@lokascript/language-server 3.0.0 → 3.1.1

package/README.md

@@ -15,7 +15,7 @@ The language server supports four operating modes:
 
 ### Mode Selection
 
-- **auto** (default): If `@lokascript/semantic` is available, uses `lokascript` mode; otherwise uses `hyperscript` mode
+- **auto** (default): `lokascript` mode when the semantic package exposes its API; `hyperscript` mode in builds that replace it with a shim (the standalone `hyperscript-vscode` extension does this)
 - **hyperscript**: Enforces \_hyperscript-compatible syntax, English keywords only
 - **hyperscript-i18n**: Enforces \_hyperscript-compatible syntax with multilingual keyword support. Use this if you have original \_hyperscript with `@lokascript/hyperscript-adapter` for writing in non-English languages
 - **lokascript**: Enables all features including LokaScript extensions and multilingual support
@@ -50,9 +50,11 @@ This allows LokaScript users to maintain \_hyperscript compatibility by using `h
 
 ### Multilingual Support
 
-Works with hyperscript written in any of 21 supported languages:
+Works with hyperscript written in any of the 24 supported languages:
 
-en (English), es (Spanish), pt (Portuguese), fr (French), de (German), it (Italian), ru (Russian), pl (Polish), uk (Ukrainian), ja (Japanese), ko (Korean), zh (Chinese), ar (Arabic), he (Hebrew), tr (Turkish), id (Indonesian), ms (Malay), th (Thai), vi (Vietnamese), tl (Tagalog), sw (Swahili)
+ar (Arabic), bn (Bengali), de (German), en (English), es (Spanish), fr (French), he (Hebrew), hi (Hindi), id (Indonesian), it (Italian), ja (Japanese), ko (Korean), ms (Malay), pl (Polish), pt (Portuguese), qu (Quechua), ru (Russian), sw (Swahili), th (Thai), tl (Tagalog), tr (Turkish), uk (Ukrainian), vi (Vietnamese), zh (Chinese)
+
+In `lokascript` and `hyperscript-i18n` modes the server parses each region with the semantic front-end in the configured `language`, falling back to auto-detection across the other languages when that fails. When the front-end accepts a region in a non-English language, the English core parser's errors for that region are suppressed (the core parser is English-only, and its "unexpected token" on valid Spanish is noise, not a diagnostic).
 
 ### HTML Support
 
@@ -113,7 +115,13 @@ require('lspconfig').lokascript.setup{}
 
 ## Configuration
 
-The server accepts configuration via the LSP `workspace/configuration` mechanism:
+The server reads its settings three ways, and every field is optional (a partial object is merged over the defaults):
+
+1. `initializationOptions` on `initialize` (both VS Code extensions pass `{ language }` here);
+2. a `workspace/didChangeConfiguration` push carrying a `lokascript` or `hyperscript` section (vscode-languageclient only sends one when the client sets `synchronize.configurationSection`; both bundled extensions do);
+3. a `workspace/configuration` pull for the `lokascript` and `hyperscript` sections, made at startup and whenever a push arrives with no payload, for clients that advertise the capability.
+
+When both namespaces are present the `lokascript` one wins, unless the server was launched with `HYPERSCRIPT_LS_DEFAULT_MODE` set (the standalone hyperscript product), in which case `hyperscript` wins.
 
 ```json
 {
@@ -218,13 +226,10 @@ For users who prefer the `hyperscript` namespace:
 
 ## Dependencies
 
-The language server works best with these optional peer dependencies installed:
+- `@lokascript/semantic` and `@lokascript/framework` are **required** (regular dependencies): the semantic package registers the 24 languages at startup, and the framework renders the LSE bracket notation shown in hover. They used to be declared as optional peers while being imported statically, so a server installed without them crashed at startup instead of falling back.
+- `@hyperfixi/core` is an **optional** peer. With it the server surfaces real parse errors, complexity diagnostics and schema-inferred roles in hover; without it, diagnostics degrade to the pattern-based quote/bracket checks and hover uses built-in fallback docs.
 
-- `@lokascript/semantic` - Enables 21-language support and semantic analysis
-- `@lokascript/ast-toolkit` - Enables AST-based analysis and complexity metrics
-- `@lokascript/core` - Enables full hyperscript parsing and AST-based formatting
-
-Without these dependencies, the server falls back to pattern-based analysis (English only).
+A bundler that wants an English-only, dependency-free server (the standalone `hyperscript-vscode` extension) replaces the semantic, framework and core imports with throwing or empty shims at bundle time; the server's capability probes are written for that case.
 
 ## Development
 
@@ -247,7 +252,7 @@ npm test -- --coverage
 
 ## Architecture
 
-The language server is implemented as a single `server.ts` file that:
+The language server entry point is `server.ts` (LSP wiring and the request handlers), with the testable logic in sibling modules — `extraction.ts` (HTML region extraction and position mapping), `simple-diagnostics.ts`, `command-tiers.ts` (the _hyperscript-compatibility allowlists), `symbol-table.ts` (definition/references/rename), `document-symbols.ts`, `completion-context.ts`, `formatting.ts` and `localized-descriptions.ts`. Together they:
 
 1. **Extracts** hyperscript regions from HTML documents
 2. **Analyzes** code using semantic parsing (multilingual) or pattern-based fallback
@@ -299,13 +304,10 @@ npm test -- --run src/server.test.ts
 
 Test categories:
 
-- HTML document detection
-- Hyperscript region extraction
-- Position mapping (offset to line/character)
-- Go to Definition
-- Find References
-- Code Formatting
-- LSP integration tests
+- Unit tests against the shipped modules: HTML document detection, region extraction, position mapping, the symbol table (definition, references, rename), document symbols, completion context, formatting, diagnostics, and the compatibility allowlists
+- `lsp-integration.test.ts` spawns the built `dist/server.js` over stdio and speaks JSON-RPC: diagnostics publishing (including the non-English cases), completions, hover, symbols, definition, references, rename, formatting, code actions, configuration changes in both push and pull form, and the `lokascript/translateWithVerification` request
+
+`npm test` rebuilds this package first (`pretest`), and refreshes any stale sibling `dist/` the integration suite resolves through the workspace.
 
 ## License
 

package/dist/server.js

@@ -9,7 +9,6 @@ import {
   CompletionItemKind,
   MarkupKind,
   DiagnosticSeverity as DiagnosticSeverity2,
-  SymbolKind,
   CodeActionKind,
   DidChangeConfigurationNotification,
   TextEdit
@@ -161,10 +160,11 @@ var LOKASCRIPT_ONLY_COMMANDS = [
 var ALL_COMMANDS = [...HYPERSCRIPT_COMMANDS, ...LOKASCRIPT_ONLY_COMMANDS];
 var LOKASCRIPT_SYNTAX_PATTERNS = {
   /**
-   * Possessive dot notation: my.textContent, its.value, your.classList
-   * Original _hyperscript uses space: my textContent
+   * Possessive dot notation on `its`: its.value
+   * Upstream resolves `my.x` and `your.x` (they are plain symbols), so only
+   * `its.` is non-portable; write `its value` for _hyperscript compatibility.
    */
-  dotNotation: /\b(my|your|its)\.\w+/,
+  dotNotation: /\bits\.\w+/,
   /**
    * Optional chaining: my?.value
    */
@@ -172,17 +172,49 @@ var LOKASCRIPT_SYNTAX_PATTERNS = {
   /**
    * Extended 'as' conversions
    */
-  extendedAsConversion: /\bas\s+(Int|Integer|Float|JSON|FormData|Date|URLSearchParams|Set|Map)\b/i,
+  extendedAsConversion: /\bas\s+(Math|Values)\b/i,
   /**
    * Debounce/throttle modifiers with duration: .debounce(300), .throttle(1s)
    */
   temporalModifiers: /\.(debounce|throttle)\s*\(\s*\d+/i
 };
+function blankStringsAndComments(code) {
+  let out = "";
+  let i = 0;
+  while (i < code.length) {
+    const ch = code[i];
+    if (ch === "-" && code[i + 1] === "-") {
+      const eol = code.indexOf("\n", i);
+      const end = eol === -1 ? code.length : eol;
+      out += " ".repeat(end - i);
+      i = end;
+      continue;
+    }
+    const prev = i === 0 ? " " : code[i - 1];
+    const opensString = ch === '"' || ch === "`" || ch === "'" && /[\s(,\[=]/.test(prev);
+    if (opensString) {
+      let j = i + 1;
+      while (j < code.length && code[j] !== ch) {
+        if (code[j] === "\\") j++;
+        if (code[j] === "\n" && ch !== "`") break;
+        j++;
+      }
+      const end = Math.min(j + 1, code.length);
+      out += " ".repeat(end - i);
+      i = end;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
 function detectLokascriptFeatures(code) {
   const detected = [];
+  const scannable = blankStringsAndComments(code);
   for (const cmd of LOKASCRIPT_ONLY_COMMANDS) {
-    const pattern = new RegExp(`\\b${cmd}\\b`, "i");
-    if (pattern.test(code)) {
+    const pattern = cmd === "unless" ? /(?<=^[ \t]*|\bthen\s+|\bend\s+|\belse\s+)unless(?![\w-])/im : new RegExp(`(?<![\\w.:$@^#-])${cmd}(?![\\w-])(?!\\s*\\()`, "i");
+    if (pattern.test(scannable)) {
       detected.push({
         feature: "command",
         description: `'${cmd}' command is a LokaScript extension`,
@@ -226,6 +258,7 @@ function detectLokascriptFeatures(code) {
 // src/extraction.ts
 function isHtmlDocument(uri, content) {
   if (uri.endsWith(".html") || uri.endsWith(".htm")) return true;
+  if (/\.(hs|_hs|hyperscript)$/i.test(uri)) return false;
   if (content.trim().startsWith("<!DOCTYPE") || content.trim().startsWith("<html")) return true;
   if (/<\w+[^>]*>/.test(content) && !content.trim().startsWith("on ")) return true;
   return false;
@@ -376,6 +409,9 @@ function getWordAtPosition(line, character) {
   if (start === end) return null;
   return { text: line.slice(start, end), start, end };
 }
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function findNextNonEmptyLine(lines, startIndex) {
   for (let i = startIndex; i < lines.length; i++) {
     const trimmed = lines[i].trim();
@@ -425,7 +461,7 @@ import { DiagnosticSeverity } from "vscode-languageserver/node.js";
 function isPossessive(code, i) {
   if (i === 0) return false;
   const prev = code[i - 1];
-  if (!/[\w\-#.]/.test(prev)) return false;
+  if (!/[\w\-#.)\]>]/.test(prev)) return false;
   if (i + 1 >= code.length || code[i + 1] !== "s") return false;
   if (i + 2 >= code.length) return true;
   const after = code[i + 2];
@@ -459,6 +495,13 @@ function runSimpleDiagnostics(code, _language = "en") {
       col++;
       continue;
     }
+    if (ch === "-" && code[i + 1] === "-") {
+      const eol = code.indexOf("\n", i);
+      if (eol === -1) break;
+      col += eol - i;
+      i = eol - 1;
+      continue;
+    }
     switch (ch) {
       case "'":
         if (isPossessive(code, i)) {
@@ -632,14 +675,15 @@ function buildSymbolTable(regions, getKeywordVariants2) {
   const defaultKws = variants("default");
   const installKws = variants("install");
   const callKws = variants("call");
-  const behaviorDefPat = new RegExp(`\\b(${behaviorKws.join("|")})\\s+(\\w+)`, "gi");
-  const funcDefPat = new RegExp(`\\b(${defKws.join("|")})\\s+(\\w+)`, "gi");
-  const varDefPat = new RegExp(`\\b(${[...setKws, ...defaultKws].join("|")})\\s+([:$]\\w+)`, "gi");
-  const installPat = new RegExp(`\\b(${installKws.join("|")})\\s+(\\w+)`, "gi");
-  const callPat = new RegExp(`\\b(${callKws.join("|")})\\s+(\\w+)`, "gi");
-  const varRefPat = /[:$]\w+/g;
+  const kw = (words) => `(?<![\\p{L}\\p{N}_])(${words.map(escapeRegExp).join("|")})(?![\\p{L}\\p{N}_])`;
+  const behaviorDefPat = new RegExp(`${kw(behaviorKws)}\\s+(\\w+)`, "giu");
+  const funcDefPat = new RegExp(`${kw(defKws)}\\s+(\\w+)`, "giu");
+  const varDefPat = new RegExp(`${kw([...setKws, ...defaultKws])}\\s+([:$]\\w+)`, "giu");
+  const installPat = new RegExp(`${kw(installKws)}\\s+(\\w+)`, "giu");
+  const callPat = new RegExp(`${kw(callKws)}\\s+(\\w+)`, "giu");
+  const varRefPat = /(?<![\p{L}\p{N}_)\]\-])[:$]\w+/gu;
   const funcCallPat = /\b(\w+)\s*\(/g;
-  const caretWritePat = new RegExp(`\\b(${setKws.join("|")})\\s+\\^([A-Za-z_]\\w*)`, "gi");
+  const caretWritePat = new RegExp(`${kw(setKws)}\\s+\\^([A-Za-z_]\\w*)`, "giu");
   const caretRefPat = /\^([A-Za-z_]\w*)/g;
   const attrsRefPat = /\battrs\.([A-Za-z_]\w*)/g;
   function getOrCreate(name, kind, scope) {
@@ -662,6 +706,11 @@ function buildSymbolTable(regions, getKeywordVariants2) {
       character: toDocChar(region, localLine, localChar),
       length
     };
+    if (locationIndex.some(
+      (l) => l.name === entry.name && l.line === loc.line && l.start === loc.character
+    )) {
+      return;
+    }
     if (kind === "def") {
       entry.definitions.push(loc);
     } else {
@@ -881,6 +930,82 @@ function getSymbolTable(uri, version, regions, getKeywordVariants2) {
   return table;
 }
 
+// src/completion-context.ts
+function inferContext(beforeCursor) {
+  if (/\^\w*$/.test(beforeCursor)) return "caret";
+  if (/\battrs\.\w*$/.test(beforeCursor)) return "attrs-property";
+  const trimmed = beforeCursor.trim();
+  if (/\bon\s*$/.test(trimmed)) return "event";
+  if (/\bthen\s*$/.test(trimmed)) return "command";
+  if (/^(on\s+\w+\s*)$/.test(trimmed)) return "command";
+  if (/(to|from|into|on)\s*$/.test(trimmed)) return "selector";
+  if (/\bif\s*$/.test(trimmed)) return "expression";
+  if (/\bset\s+:\w+\s+to\s*$/.test(trimmed)) return "expression";
+  return "default";
+}
+
+// src/document-symbols.ts
+import { SymbolKind } from "vscode-languageserver/node.js";
+var COMMAND_POSITION = "(?<=^[ \\t]*|(?<![\\p{L}\\p{N}_])end\\s+)";
+var NOT_WORD_AFTER = "(?![\\p{L}\\p{N}_])";
+var NAME = "([\\p{L}\\p{N}_]+)";
+function alternation(words) {
+  return `(${words.map(escapeRegExp).join("|")})`;
+}
+function symbol(name, detail, kind, line, start, length) {
+  const range = {
+    start: { line, character: start },
+    end: { line, character: start + length }
+  };
+  return { name, detail, kind, range, selectionRange: range };
+}
+function extractDocumentSymbols(code, getVariants = (eng) => [eng]) {
+  const symbols = [];
+  const lines = code.split("\n");
+  const onPattern = new RegExp(
+    `${COMMAND_POSITION}${alternation(getVariants("on"))}\\s+(${NAME.slice(1, -1)}(?::[\\p{L}\\p{N}_]+)?(?:\\[.*?\\])?)`,
+    "giu"
+  );
+  const behaviorPattern = new RegExp(
+    `${COMMAND_POSITION}${alternation(getVariants("behavior"))}\\s+${NAME}`,
+    "giu"
+  );
+  const defPattern = new RegExp(
+    `${COMMAND_POSITION}${alternation(getVariants("def"))}\\s+${NAME}`,
+    "giu"
+  );
+  const initPattern = new RegExp(
+    `${COMMAND_POSITION}${alternation(getVariants("init"))}${NOT_WORD_AFTER}`,
+    "giu"
+  );
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const m of line.matchAll(onPattern)) {
+      const at = m.index ?? 0;
+      symbols.push(
+        symbol(`${m[1]} ${m[2]}`, "Event Handler", SymbolKind.Event, i, at, m[0].length)
+      );
+    }
+    for (const m of line.matchAll(behaviorPattern)) {
+      const at = m.index ?? 0;
+      symbols.push(
+        symbol(`${m[1]} ${m[2]}`, "Behavior Definition", SymbolKind.Class, i, at, m[0].length)
+      );
+    }
+    for (const m of line.matchAll(defPattern)) {
+      const at = m.index ?? 0;
+      symbols.push(
+        symbol(`${m[1]} ${m[2]}`, "Function Definition", SymbolKind.Function, i, at, m[0].length)
+      );
+    }
+    for (const m of line.matchAll(initPattern)) {
+      const at = m.index ?? 0;
+      symbols.push(symbol(m[1], "Initialization", SymbolKind.Constructor, i, at, m[1].length));
+    }
+  }
+  return symbols;
+}
+
 // src/localized-descriptions.ts
 var DESCRIPTIONS = {
   en: {
@@ -1241,7 +1366,7 @@ try {
     ({ schemaRoleInferrer: inferRoles } = await import("@hyperfixi/core/multilingual"));
   } catch {
     console.error(
-      "[lokascript-ls] @lokascript/semantic not available \u2014 hover shows roles for `set` and `go` only. Install the semantic package for full role inference."
+      "[lokascript-ls] @hyperfixi/core/multilingual not available \u2014 hover shows roles for `set` and `go` only. Install a core build that ships the multilingual entry."
     );
   }
   fromCoreASTFn = (node) => core.fromCoreAST(
@@ -1262,7 +1387,7 @@ try {
 }
 var frameworkIR = null;
 try {
-  const fw = await import("./dist-2GK6K2QJ.js");
+  const fw = await import("@lokascript/framework");
   frameworkIR = { fromInterchangeNode: fw.fromInterchangeNode, renderExplicit: fw.renderExplicit };
   console.error(
     "[lokascript-ls] @lokascript/framework loaded \u2014 LSE bracket notation in hover enabled"
@@ -1564,8 +1689,60 @@ function getSemanticAnalyzer() {
   }
   return cachedAnalyzer;
 }
-var globalSettings = envDefaultMode ? { ...defaultSettings, mode: envDefaultMode } : defaultSettings;
-connection.onInitialize((_params) => {
+var VALID_MODES = /* @__PURE__ */ new Set([
+  "hyperscript",
+  "hyperscript-i18n",
+  "lokascript",
+  "auto"
+]);
+function baseSettings() {
+  return envDefaultMode ? { ...defaultSettings, mode: envDefaultMode } : { ...defaultSettings };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function mergeSettings(base, partial) {
+  const out = { ...base };
+  if (!isRecord(partial)) return out;
+  const p = partial;
+  if (typeof p.mode === "string" && VALID_MODES.has(p.mode)) out.mode = p.mode;
+  if (typeof p.language === "string" && p.language.trim()) out.language = p.language.trim();
+  if (typeof p.maxDiagnostics === "number" && p.maxDiagnostics > 0) {
+    out.maxDiagnostics = Math.floor(p.maxDiagnostics);
+  }
+  return out;
+}
+var globalSettings = baseSettings();
+var hasConfigurationCapability = false;
+var configSections = envDefaultMode ? ["hyperscript", "lokascript"] : ["lokascript", "hyperscript"];
+function applySettings(next) {
+  globalSettings = next;
+  const previousMode = resolvedMode;
+  resolvedMode = resolveMode(globalSettings);
+  if (previousMode !== resolvedMode) {
+    connection.console.log(`Mode changed to '${resolvedMode}' (${getBranding(resolvedMode)})`);
+  }
+  translationCache = null;
+  reverseKeywordCache = null;
+  documents.all().forEach(validateDocument);
+}
+async function pullConfiguration() {
+  if (!hasConfigurationCapability) return;
+  try {
+    const items = await connection.workspace.getConfiguration(
+      configSections.map((section) => ({ section }))
+    );
+    const [primary, fallback] = Array.isArray(items) ? items : [];
+    let merged = mergeSettings(baseSettings(), fallback);
+    merged = mergeSettings(merged, primary);
+    applySettings(merged);
+  } catch (e) {
+    connection.console.log(`[lokascript-ls] workspace/configuration failed: ${e}`);
+  }
+}
+connection.onInitialize((params) => {
+  hasConfigurationCapability = !!params.capabilities.workspace?.configuration;
+  globalSettings = mergeSettings(baseSettings(), params.initializationOptions);
   resolvedMode = resolveMode(globalSettings);
   const brand = getBranding(resolvedMode);
   connection.console.log(`${brand} Language Server initializing (mode: ${resolvedMode})...`);
@@ -1592,19 +1769,20 @@ connection.onInitialized(() => {
   connection.client.register(DidChangeConfigurationNotification.type, void 0);
   const brand = getBranding(resolvedMode);
   connection.console.log(`${brand} Language Server initialized`);
+  void pullConfiguration();
 });
 connection.onDidChangeConfiguration((change) => {
-  const envDefaults = envDefaultMode ? { ...defaultSettings, mode: envDefaultMode } : defaultSettings;
-  globalSettings = change.settings?.lokascript || change.settings?.hyperscript || envDefaults;
-  const previousMode = resolvedMode;
-  resolvedMode = resolveMode(globalSettings);
-  if (previousMode !== resolvedMode) {
-    const brand = getBranding(resolvedMode);
-    connection.console.log(`Mode changed to '${resolvedMode}' (${brand})`);
+  const settings = change.settings;
+  const pushed = isRecord(settings) ? settings[configSections[0]] ?? settings[configSections[1]] : void 0;
+  if (pushed !== void 0) {
+    applySettings(mergeSettings(baseSettings(), pushed));
+    return;
   }
-  translationCache = null;
-  reverseKeywordCache = null;
-  documents.all().forEach(validateDocument);
+  if (hasConfigurationCapability) {
+    void pullConfiguration();
+    return;
+  }
+  applySettings(baseSettings());
 });
 documents.onDidChangeContent((change) => {
   validateDocument(change.document);
@@ -1660,6 +1838,7 @@ async function getDiagnostics(code, language) {
     }
   }
   const analyzer = isMultilingualEnabled(resolvedMode) ? getSemanticAnalyzer() : null;
+  let semanticParsedForeign = false;
   if (analyzer) {
     try {
       let result = analyzer.analyze(code, language);
@@ -1706,6 +1885,7 @@ async function getDiagnostics(code, language) {
           message: `Code could not be fully parsed (${(result.confidence * 100).toFixed(0)}% confidence)`
         });
       }
+      semanticParsedForeign = result.confidence >= 0.5 && usedLanguage !== "en";
       if (result.confidence >= 0.5 && result.command) {
         const cmd = result.command.name;
         const roles = result.command.roles;
@@ -1735,7 +1915,7 @@ async function getDiagnostics(code, language) {
   if (parseFunction && fromCoreASTFn) {
     try {
       const parseResult = parseFunction(code);
-      if (parseResult.errors?.length) {
+      if (parseResult.errors?.length && !semanticParsedForeign) {
         for (const err of parseResult.errors) {
           diagnostics.push({
             range: {
@@ -1766,16 +1946,18 @@ async function getDiagnostics(code, language) {
         }
       }
     } catch (parseError) {
-      diagnostics.push({
-        range: {
-          start: { line: 0, character: 0 },
-          end: { line: 0, character: Math.min(code.length, 80) }
-        },
-        severity: DiagnosticSeverity2.Error,
-        code: "parse-error",
-        source: brand,
-        message: parseError.message || "Failed to parse"
-      });
+      if (!semanticParsedForeign) {
+        diagnostics.push({
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: Math.min(code.length, 80) }
+          },
+          severity: DiagnosticSeverity2.Error,
+          code: "parse-error",
+          source: brand,
+          message: parseError.message || "Failed to parse"
+        });
+      }
     }
   }
   if (diagnostics.length === 0) {
@@ -1907,18 +2089,6 @@ function getAttrsCompletions() {
     }
   ];
 }
-function inferContext(beforeCursor) {
-  if (/\^\w*$/.test(beforeCursor)) return "caret";
-  if (/\battrs\.\w*$/.test(beforeCursor)) return "attrs-property";
-  const trimmed = beforeCursor.trim();
-  if (/\bon\s*$/.test(trimmed)) return "event";
-  if (/\bthen\s*$/.test(trimmed)) return "command";
-  if (/^(on\s+\w+\s*)$/.test(trimmed)) return "command";
-  if (/(to|from|into|on)\s*$/.test(trimmed)) return "selector";
-  if (/\bif\s*$/.test(trimmed)) return "expression";
-  if (/\bset\s+:\w+\s+to\s*$/.test(trimmed)) return "expression";
-  return "default";
-}
 function getContextualCompletions(context, language) {
   const completions = [];
   const effectiveLanguage = isMultilingualEnabled(resolvedMode) ? language : "en";
@@ -2551,27 +2721,27 @@ connection.onDocumentSymbol((params) => {
     const allSymbols = [];
     for (const region of regions) {
       const symbols = extractSymbols(region.code, language);
-      for (const symbol of symbols) {
+      for (const symbol2 of symbols) {
         allSymbols.push({
-          ...symbol,
+          ...symbol2,
           range: {
             start: {
-              line: region.startLine + symbol.range.start.line,
-              character: symbol.range.start.line === 0 ? region.startChar + symbol.range.start.character : symbol.range.start.character
+              line: region.startLine + symbol2.range.start.line,
+              character: symbol2.range.start.line === 0 ? region.startChar + symbol2.range.start.character : symbol2.range.start.character
             },
             end: {
-              line: region.startLine + symbol.range.end.line,
-              character: symbol.range.end.line === 0 ? region.startChar + symbol.range.end.character : symbol.range.end.character
+              line: region.startLine + symbol2.range.end.line,
+              character: symbol2.range.end.line === 0 ? region.startChar + symbol2.range.end.character : symbol2.range.end.character
             }
           },
           selectionRange: {
             start: {
-              line: region.startLine + symbol.selectionRange.start.line,
-              character: symbol.selectionRange.start.line === 0 ? region.startChar + symbol.selectionRange.start.character : symbol.selectionRange.start.character
+              line: region.startLine + symbol2.selectionRange.start.line,
+              character: symbol2.selectionRange.start.line === 0 ? region.startChar + symbol2.selectionRange.start.character : symbol2.selectionRange.start.character
             },
             end: {
-              line: region.startLine + symbol.selectionRange.end.line,
-              character: symbol.selectionRange.end.line === 0 ? region.startChar + symbol.selectionRange.end.character : symbol.selectionRange.end.character
+              line: region.startLine + symbol2.selectionRange.end.line,
+              character: symbol2.selectionRange.end.line === 0 ? region.startChar + symbol2.selectionRange.end.character : symbol2.selectionRange.end.character
             }
           }
         });
@@ -2583,8 +2753,6 @@ connection.onDocumentSymbol((params) => {
   }
 });
 function extractSymbols(code, language) {
-  const symbols = [];
-  const lines = code.split("\n");
   const getVariants = (eng) => {
     const variants = [eng];
     if (!semanticPackage || language === "en") return variants;
@@ -2602,82 +2770,7 @@ function extractSymbols(code, language) {
     }
     return variants;
   };
-  const onVariants = getVariants("on");
-  const behaviorVariants = getVariants("behavior");
-  const defVariants = getVariants("def");
-  const initVariants = getVariants("init");
-  const onPattern = new RegExp(`\\b(${onVariants.join("|")})\\s+(\\w+(?:\\[.*?\\])?)`, "gi");
-  const behaviorPattern = new RegExp(`\\b(${behaviorVariants.join("|")})\\s+(\\w+)`, "gi");
-  const defPattern = new RegExp(`\\b(${defVariants.join("|")})\\s+(\\w+)`, "gi");
-  const initPattern = new RegExp(`\\b(${initVariants.join("|")})\\b`, "gi");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    for (const match of line.matchAll(onPattern)) {
-      const matchIndex = match.index ?? 0;
-      symbols.push({
-        name: `${match[1]} ${match[2]}`,
-        detail: "Event Handler",
-        kind: SymbolKind.Event,
-        range: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[0].length }
-        },
-        selectionRange: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[0].length }
-        }
-      });
-    }
-    for (const match of line.matchAll(behaviorPattern)) {
-      const matchIndex = match.index ?? 0;
-      symbols.push({
-        name: `${match[1]} ${match[2]}`,
-        detail: "Behavior Definition",
-        kind: SymbolKind.Class,
-        range: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[0].length }
-        },
-        selectionRange: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[0].length }
-        }
-      });
-    }
-    for (const match of line.matchAll(defPattern)) {
-      const matchIndex = match.index ?? 0;
-      symbols.push({
-        name: `${match[1]} ${match[2]}`,
-        detail: "Function Definition",
-        kind: SymbolKind.Function,
-        range: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[0].length }
-        },
-        selectionRange: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[0].length }
-        }
-      });
-    }
-    for (const match of line.matchAll(initPattern)) {
-      const matchIndex = match.index ?? 0;
-      symbols.push({
-        name: match[1],
-        detail: "Initialization",
-        kind: SymbolKind.Constructor,
-        range: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[1].length }
-        },
-        selectionRange: {
-          start: { line: i, character: matchIndex },
-          end: { line: i, character: matchIndex + match[1].length }
-        }
-      });
-    }
-  }
-  return symbols;
+  return extractDocumentSymbols(code, getVariants);
 }
 connection.onCodeAction((params) => {
   const diagnostics = params.context.diagnostics;