@lokascript/language-server 2.0.0

package/dist/server.js

@@ -0,0 +1,1578 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import {
+  createConnection,
+  TextDocuments,
+  ProposedFeatures,
+  TextDocumentSyncKind,
+  CompletionItemKind,
+  MarkupKind,
+  DiagnosticSeverity,
+  SymbolKind,
+  CodeActionKind,
+  DidChangeConfigurationNotification,
+  TextEdit
+} from "vscode-languageserver/node.js";
+import { TextDocument } from "vscode-languageserver-textdocument";
+
+// src/types.ts
+var defaultSettings = {
+  mode: "auto",
+  language: "en",
+  maxDiagnostics: 100
+};
+
+// src/command-tiers.ts
+var HYPERSCRIPT_COMMANDS = [
+  // Core commands
+  "add",
+  "append",
+  "call",
+  "default",
+  "exit",
+  "fetch",
+  "for",
+  "get",
+  "go",
+  "halt",
+  "hide",
+  "if",
+  "increment",
+  "decrement",
+  "js",
+  "log",
+  "put",
+  "remove",
+  "repeat",
+  "return",
+  "send",
+  "set",
+  "show",
+  "take",
+  "tell",
+  "throw",
+  "toggle",
+  "transition",
+  "trigger",
+  "wait",
+  "while",
+  // Definitions
+  "behavior",
+  "def",
+  "init",
+  "on",
+  "eventsource",
+  "socket",
+  "worker"
+];
+var LOKASCRIPT_ONLY_COMMANDS = [
+  "make",
+  "settle",
+  "measure",
+  "transfer",
+  "morph",
+  "persist",
+  "install",
+  "process-partials"
+];
+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
+   */
+  dotNotation: /\b(my|your|its)\.\w+/,
+  /**
+   * Optional chaining: my?.value
+   */
+  optionalChaining: /\b(my|your|its)\?\.\w+/,
+  /**
+   * Extended 'as' conversions
+   */
+  extendedAsConversion: /\bas\s+(Int|Integer|Float|JSON|FormData|Date|URLSearchParams|Set|Map)\b/i,
+  /**
+   * Debounce/throttle modifiers with duration: .debounce(300), .throttle(1s)
+   */
+  temporalModifiers: /\.(debounce|throttle)\s*\(\s*\d+/i
+};
+function detectLokascriptFeatures(code) {
+  const detected = [];
+  for (const cmd of LOKASCRIPT_ONLY_COMMANDS) {
+    const pattern = new RegExp(`\\b${cmd}\\b`, "i");
+    if (pattern.test(code)) {
+      detected.push({
+        feature: "command",
+        description: `'${cmd}' command is a LokaScript extension`,
+        pattern: cmd
+      });
+    }
+  }
+  if (LOKASCRIPT_SYNTAX_PATTERNS.dotNotation.test(code)) {
+    detected.push({
+      feature: "syntax",
+      description: "Dot notation (my.property) is a LokaScript extension. Use 'my property' for _hyperscript compatibility",
+      pattern: "dot-notation"
+    });
+  }
+  if (LOKASCRIPT_SYNTAX_PATTERNS.optionalChaining.test(code)) {
+    detected.push({
+      feature: "syntax",
+      description: "Optional chaining (my?.property) is a LokaScript extension",
+      pattern: "optional-chaining"
+    });
+  }
+  const asMatch = code.match(LOKASCRIPT_SYNTAX_PATTERNS.extendedAsConversion);
+  if (asMatch) {
+    detected.push({
+      feature: "conversion",
+      description: `'as ${asMatch[1]}' is a LokaScript extension`,
+      pattern: `as-${asMatch[1].toLowerCase()}`
+    });
+  }
+  const temporalMatch = code.match(LOKASCRIPT_SYNTAX_PATTERNS.temporalModifiers);
+  if (temporalMatch) {
+    detected.push({
+      feature: "modifier",
+      description: `'.${temporalMatch[1]}()' modifier is a LokaScript extension`,
+      pattern: temporalMatch[1].toLowerCase()
+    });
+  }
+  return detected;
+}
+function getCommandsForMode(mode) {
+  return mode === "hyperscript" ? HYPERSCRIPT_COMMANDS : ALL_COMMANDS;
+}
+
+// src/extraction.ts
+function isHtmlDocument(uri, content) {
+  if (uri.endsWith(".html") || uri.endsWith(".htm")) return true;
+  if (content.trim().startsWith("<!DOCTYPE") || content.trim().startsWith("<html")) return true;
+  if (/<\w+[^>]*>/.test(content) && !content.trim().startsWith("on ")) return true;
+  return false;
+}
+function extractHyperscriptRegions(content) {
+  const regions = [];
+  const fullContent = content;
+  const doubleQuoteRegex = /_="([^"\\]*(?:\\.[^"\\]*)*)"/g;
+  let match;
+  while ((match = doubleQuoteRegex.exec(fullContent)) !== null) {
+    const code = match[1].replace(/\\"/g, '"');
+    const startOffset = match.index + 3;
+    const endOffset = match.index + match[0].length - 1;
+    const startPos = offsetToPosition(content, startOffset);
+    const endPos = offsetToPosition(content, endOffset);
+    regions.push({
+      code,
+      startLine: startPos.line,
+      startChar: startPos.character,
+      endLine: endPos.line,
+      endChar: endPos.character,
+      type: "attribute"
+    });
+  }
+  const singleQuoteRegex = /_='([^'\\]*(?:\\.[^'\\]*)*)'/g;
+  while ((match = singleQuoteRegex.exec(fullContent)) !== null) {
+    const code = match[1].replace(/\\'/g, "'");
+    const startOffset = match.index + 3;
+    const endOffset = match.index + match[0].length - 1;
+    const startPos = offsetToPosition(content, startOffset);
+    const endPos = offsetToPosition(content, endOffset);
+    regions.push({
+      code,
+      startLine: startPos.line,
+      startChar: startPos.character,
+      endLine: endPos.line,
+      endChar: endPos.character,
+      type: "attribute"
+    });
+  }
+  const scriptRegex = /<script\s+type=["']text\/hyperscript["'][^>]*>([\s\S]*?)<\/script>/gi;
+  while ((match = scriptRegex.exec(fullContent)) !== null) {
+    const code = match[1];
+    const startOffset = match.index + match[0].indexOf(">") + 1;
+    const endOffset = match.index + match[0].lastIndexOf("</script>");
+    const startPos = offsetToPosition(content, startOffset);
+    const endPos = offsetToPosition(content, endOffset);
+    regions.push({
+      code,
+      startLine: startPos.line,
+      startChar: startPos.character,
+      endLine: endPos.line,
+      endChar: endPos.character,
+      type: "script"
+    });
+  }
+  return regions;
+}
+function offsetToPosition(content, offset) {
+  let line = 0;
+  let character = 0;
+  const maxOffset = Math.min(offset, content.length);
+  for (let i = 0; i < maxOffset; i++) {
+    if (content[i] === "\r" && content[i + 1] === "\n") {
+      line++;
+      character = 0;
+      i++;
+    } else if (content[i] === "\n") {
+      line++;
+      character = 0;
+    } else if (content[i] === "\r") {
+      line++;
+      character = 0;
+    } else {
+      character++;
+    }
+  }
+  return { line, character };
+}
+function findRegionAtPosition(regions, line, character) {
+  for (const region of regions) {
+    const afterStart = line > region.startLine || line === region.startLine && character >= region.startChar;
+    const beforeEnd = line < region.endLine || line === region.endLine && character <= region.endChar;
+    if (afterStart && beforeEnd) {
+      const localLine = line - region.startLine;
+      let localChar;
+      if (line === region.startLine) {
+        localChar = character - region.startChar;
+      } else {
+        localChar = character;
+      }
+      return { region, localLine, localChar };
+    }
+  }
+  return null;
+}
+function findLineInRegion(code, offset) {
+  let line = 0;
+  for (let i = 0; i < offset && i < code.length; i++) {
+    if (code[i] === "\n") line++;
+  }
+  return line;
+}
+function findCharInLine(code, offset) {
+  let lastNewline = -1;
+  for (let i = 0; i < offset && i < code.length; i++) {
+    if (code[i] === "\n") lastNewline = i;
+  }
+  return offset - lastNewline - 1;
+}
+
+// src/utils.ts
+function getWordAtPosition(line, character) {
+  let start = character;
+  let end = character;
+  const isWordChar = (char) => {
+    if (!char) return false;
+    return /[\p{L}\p{M}\p{N}_.-]/u.test(char);
+  };
+  while (start > 0 && isWordChar(line[start - 1])) {
+    start--;
+  }
+  while (end < line.length && isWordChar(line[end])) {
+    end++;
+  }
+  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();
+    if (trimmed) return trimmed;
+  }
+  return null;
+}
+
+// src/formatting.ts
+function formatHyperscript(code, indentStr = "  ") {
+  const lines = code.split("\n");
+  const formattedLines = [];
+  let indentLevel = 0;
+  const blockKeywords = /^(behavior|def|if|repeat|for|while)\b/i;
+  const dedentKeywords = /^(end|else)\b/i;
+  const onKeyword = /^on\b/i;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed) {
+      formattedLines.push("");
+      continue;
+    }
+    if (dedentKeywords.test(trimmed)) {
+      indentLevel = Math.max(0, indentLevel - 1);
+    }
+    const indent = indentStr.repeat(indentLevel);
+    formattedLines.push(indent + trimmed);
+    if (blockKeywords.test(trimmed) && !/\bend\s*$/i.test(trimmed)) {
+      indentLevel++;
+    }
+    if (onKeyword.test(trimmed)) {
+      const nextLine = findNextNonEmptyLine(lines, i + 1);
+      if (nextLine && !/^(end|on)\b/i.test(nextLine)) {
+        indentLevel++;
+      }
+    }
+    if (/^else\b/i.test(trimmed)) {
+      indentLevel++;
+    }
+  }
+  return formattedLines.join("\n");
+}
+
+// src/server.ts
+import * as semanticImport from "@lokascript/semantic";
+var semanticPackage = semanticImport;
+function getOtherLanguages() {
+  if (!semanticPackage?.getRegisteredLanguages) return [];
+  return semanticPackage.getRegisteredLanguages().filter((l) => l !== "en");
+}
+var interchangeLSP = null;
+var fromCoreASTFn = null;
+var parseFunction = null;
+var lspMetadata = null;
+try {
+  const core = await import("@hyperfixi/core");
+  parseFunction = core.parse;
+  fromCoreASTFn = core.fromCoreAST;
+  interchangeLSP = await import("@hyperfixi/core/ast-utils");
+} catch {
+  console.error("[lokascript-ls] @hyperfixi/core not available");
+}
+try {
+  lspMetadata = await import("@hyperfixi/core/lsp-metadata");
+} catch {
+  console.error(
+    "[lokascript-ls] @hyperfixi/core/lsp-metadata not available - using fallback keywords"
+  );
+}
+var FALLBACK_KEYWORDS = [
+  "toggle",
+  "add",
+  "remove",
+  "show",
+  "hide",
+  "put",
+  "set",
+  "get",
+  "fetch",
+  "wait",
+  "send",
+  "trigger",
+  "call",
+  "return",
+  "throw",
+  "halt",
+  "exit",
+  "go",
+  "log",
+  "on",
+  "me",
+  "you",
+  "it",
+  "result",
+  "if",
+  "else",
+  "then",
+  "end",
+  "repeat",
+  "for",
+  "while",
+  "behavior",
+  "def",
+  "init",
+  "first",
+  "last",
+  "next",
+  "previous",
+  "closest",
+  "parent",
+  "and",
+  "or",
+  "not",
+  "is",
+  "exists",
+  "empty",
+  "has"
+];
+var FALLBACK_HOVER_DOCS = {
+  toggle: {
+    title: "toggle",
+    description: "Toggles a class, attribute, or visibility state.",
+    example: "toggle .active on me"
+  },
+  add: {
+    title: "add",
+    description: "Adds a class or attribute to an element.",
+    example: "add .highlight to me"
+  },
+  remove: {
+    title: "remove",
+    description: "Removes a class, attribute, or element.",
+    example: "remove .highlight from me"
+  },
+  show: { title: "show", description: "Makes an element visible.", example: "show #modal" },
+  hide: { title: "hide", description: "Hides an element.", example: "hide #modal" },
+  put: {
+    title: "put",
+    description: "Sets the content of an element.",
+    example: 'put "Hello" into #message'
+  },
+  set: { title: "set", description: "Sets a variable or property.", example: "set :count to 0" },
+  get: {
+    title: "get",
+    description: "Gets a value from an element or variable.",
+    example: "get the value of #input"
+  },
+  fetch: {
+    title: "fetch",
+    description: "Makes an HTTP request.",
+    example: "fetch /api/data as json"
+  },
+  wait: { title: "wait", description: "Pauses execution for a duration.", example: "wait 1s" },
+  send: {
+    title: "send",
+    description: "Dispatches a custom event.",
+    example: "send myEvent to #target"
+  },
+  trigger: {
+    title: "trigger",
+    description: "Triggers an event on an element.",
+    example: "trigger click on #btn"
+  },
+  call: {
+    title: "call",
+    description: "Calls a function or method.",
+    example: "call myFunction()"
+  },
+  log: { title: "log", description: "Logs a value to the console.", example: 'log "Hello"' },
+  go: { title: "go", description: "Navigates to a URL.", example: "go to url /home" },
+  on: {
+    title: "on",
+    description: "Defines an event handler.",
+    example: "on click toggle .active"
+  },
+  if: {
+    title: "if",
+    description: "Conditional execution.",
+    example: "if .active toggle .active"
+  },
+  repeat: {
+    title: "repeat",
+    description: "Loops a specified number of times.",
+    example: 'repeat 5 times log "hello"'
+  },
+  behavior: {
+    title: "behavior",
+    description: "Defines a reusable behavior.",
+    example: "behavior Clickable\\n  on click toggle .active\\nend"
+  },
+  me: {
+    title: "me",
+    description: "References the current element.",
+    example: "toggle .active on me"
+  },
+  you: {
+    title: "you",
+    description: "References the element that triggered the event.",
+    example: "add .clicked to you"
+  },
+  it: {
+    title: "it",
+    description: "References the result of the last expression.",
+    example: "fetch /api/data then put it into #result"
+  },
+  result: {
+    title: "result",
+    description: "Alias for it - the result of the last expression.",
+    example: "call myFunction() then log result"
+  }
+};
+var FALLBACK_EVENT_NAMES = [
+  "click",
+  "dblclick",
+  "mouseenter",
+  "mouseleave",
+  "keydown",
+  "keyup",
+  "input",
+  "change",
+  "submit",
+  "load",
+  "focus",
+  "blur"
+];
+function resolveMode(settings) {
+  if (settings.mode === "hyperscript") return "hyperscript";
+  if (settings.mode === "hyperscript-i18n") return "hyperscript-i18n";
+  if (settings.mode === "lokascript") return "lokascript";
+  return semanticPackage ? "lokascript" : "hyperscript";
+}
+function getBranding(mode) {
+  return mode === "lokascript" ? "lokascript" : "hyperscript";
+}
+function isMultilingualEnabled(mode) {
+  return mode === "lokascript" || mode === "hyperscript-i18n";
+}
+function isHyperscriptCompatMode(mode) {
+  return mode === "hyperscript" || mode === "hyperscript-i18n";
+}
+var resolvedMode = "hyperscript";
+var envDefaultMode = process.env.HYPERSCRIPT_LS_DEFAULT_MODE;
+var connection = createConnection(ProposedFeatures.all);
+var documents = new TextDocuments(TextDocument);
+var cachedAnalyzer = null;
+function getSemanticAnalyzer() {
+  if (!semanticPackage) return null;
+  if (!cachedAnalyzer) {
+    cachedAnalyzer = semanticPackage.createSemanticAnalyzer();
+  }
+  return cachedAnalyzer;
+}
+var globalSettings = envDefaultMode ? { ...defaultSettings, mode: envDefaultMode } : defaultSettings;
+connection.onInitialize((params) => {
+  resolvedMode = resolveMode(globalSettings);
+  const brand = getBranding(resolvedMode);
+  connection.console.log(`${brand} Language Server initializing (mode: ${resolvedMode})...`);
+  return {
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+      completionProvider: {
+        triggerCharacters: [".", "#", "@", " ", ":"],
+        resolveProvider: false
+      },
+      hoverProvider: true,
+      documentSymbolProvider: true,
+      codeActionProvider: {
+        codeActionKinds: [CodeActionKind.QuickFix]
+      },
+      definitionProvider: true,
+      referencesProvider: true,
+      documentFormattingProvider: true
+    }
+  };
+});
+connection.onInitialized(() => {
+  connection.client.register(DidChangeConfigurationNotification.type, void 0);
+  const brand = getBranding(resolvedMode);
+  connection.console.log(`${brand} Language Server initialized`);
+});
+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})`);
+  }
+  translationCache = null;
+  reverseKeywordCache = null;
+  documents.all().forEach(validateDocument);
+});
+documents.onDidChangeContent((change) => {
+  validateDocument(change.document);
+});
+async function validateDocument(document) {
+  const text = document.getText();
+  const uri = document.uri;
+  let allDiagnostics = [];
+  if (isHtmlDocument(uri, text)) {
+    const regions = extractHyperscriptRegions(text);
+    for (const region of regions) {
+      const diagnostics = await getDiagnostics(region.code, globalSettings.language);
+      for (const diag of diagnostics) {
+        allDiagnostics.push({
+          ...diag,
+          range: {
+            start: {
+              line: region.startLine + diag.range.start.line,
+              character: diag.range.start.line === 0 ? region.startChar + diag.range.start.character : diag.range.start.character
+            },
+            end: {
+              line: region.startLine + diag.range.end.line,
+              character: diag.range.end.line === 0 ? region.startChar + diag.range.end.character : diag.range.end.character
+            }
+          }
+        });
+      }
+    }
+  } else {
+    allDiagnostics = await getDiagnostics(text, globalSettings.language);
+  }
+  connection.sendDiagnostics({ uri, diagnostics: allDiagnostics });
+}
+async function getDiagnostics(code, language) {
+  const diagnostics = [];
+  const brand = getBranding(resolvedMode);
+  if (isHyperscriptCompatMode(resolvedMode)) {
+    const lokascriptFeatures = detectLokascriptFeatures(code);
+    for (const feature of lokascriptFeatures) {
+      diagnostics.push({
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 0, character: code.split("\n")[0]?.length || code.length }
+        },
+        severity: DiagnosticSeverity.Error,
+        code: "lokascript-only",
+        source: brand,
+        message: `${feature.description} (not compatible with _hyperscript)`
+      });
+    }
+  }
+  const analyzer = isMultilingualEnabled(resolvedMode) ? getSemanticAnalyzer() : null;
+  if (analyzer) {
+    try {
+      let result = analyzer.analyze(code, language);
+      let usedLanguage = language;
+      if (result.confidence < 0.5) {
+        const languagesToTry = getOtherLanguages();
+        for (const lang of languagesToTry) {
+          if (lang === usedLanguage) continue;
+          try {
+            const tryResult = analyzer.analyze(code, lang);
+            if (tryResult.confidence > result.confidence) {
+              result = tryResult;
+              usedLanguage = lang;
+              if (result.confidence >= 0.7) break;
+            }
+          } catch (e) {
+            connection.console.log(`[${brand}-ls] Language detection failed for '${lang}': ${e}`);
+          }
+        }
+      }
+      if (result.errors && result.errors.length > 0) {
+        for (const err of result.errors) {
+          diagnostics.push({
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: 0, character: code.split("\n")[0]?.length || code.length }
+            },
+            severity: DiagnosticSeverity.Error,
+            code: "semantic-error",
+            source: brand,
+            message: err
+          });
+        }
+      }
+      if (result.confidence > 0 && result.confidence < 0.3) {
+        diagnostics.push({
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: code.length }
+          },
+          severity: DiagnosticSeverity.Warning,
+          code: "low-confidence",
+          source: brand,
+          message: `Code could not be fully parsed (${(result.confidence * 100).toFixed(0)}% confidence)`
+        });
+      }
+      if (result.confidence >= 0.5 && result.command) {
+        const cmd = result.command.name;
+        const roles = result.command.roles;
+        if (cmd === "toggle" && !roles.has("patient")) {
+          diagnostics.push({
+            range: { start: { line: 0, character: 0 }, end: { line: 0, character: code.length } },
+            severity: DiagnosticSeverity.Warning,
+            code: "missing-role",
+            source: brand,
+            message: "toggle command missing target (add .class, @attr, or selector)"
+          });
+        }
+        if (cmd === "put" && !roles.has("destination")) {
+          diagnostics.push({
+            range: { start: { line: 0, character: 0 }, end: { line: 0, character: code.length } },
+            severity: DiagnosticSeverity.Warning,
+            code: "missing-role",
+            source: brand,
+            message: 'put command missing destination (add "into #element")'
+          });
+        }
+      }
+    } catch (e) {
+      connection.console.log(`[${brand}-ls] Semantic parsing failed, trying fallback: ${e}`);
+    }
+  }
+  if (diagnostics.length === 0 && interchangeLSP && parseFunction && fromCoreASTFn) {
+    try {
+      const ast = parseFunction(code);
+      if (ast) {
+        const interchange = fromCoreASTFn(ast);
+        const nodes = interchange.type === "event" ? [interchange] : [interchange];
+        const astDiagnostics = interchangeLSP.interchangeToLSPDiagnostics(nodes, { source: brand });
+        diagnostics.push(...astDiagnostics);
+      }
+    } catch (parseError) {
+      diagnostics.push({
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 0, character: code.length }
+        },
+        severity: DiagnosticSeverity.Error,
+        code: "parse-error",
+        source: brand,
+        message: parseError.message || "Failed to parse"
+      });
+    }
+  }
+  if (diagnostics.length === 0) {
+    const simpleDiagnostics = runSimpleDiagnostics(code, language);
+    diagnostics.push(...simpleDiagnostics.map((d) => ({ ...d, source: brand })));
+  }
+  return diagnostics.slice(0, globalSettings.maxDiagnostics);
+}
+function runSimpleDiagnostics(code, _language) {
+  const diagnostics = [];
+  const lines = code.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const singleQuotes = (line.match(/'/g) || []).length;
+    const doubleQuotes = (line.match(/"/g) || []).length;
+    if (singleQuotes % 2 !== 0) {
+      diagnostics.push({
+        range: { start: { line: i, character: 0 }, end: { line: i, character: line.length } },
+        severity: DiagnosticSeverity.Error,
+        code: "unmatched-quote",
+        source: "lokascript",
+        message: "Unmatched single quote"
+      });
+    }
+    if (doubleQuotes % 2 !== 0) {
+      diagnostics.push({
+        range: { start: { line: i, character: 0 }, end: { line: i, character: line.length } },
+        severity: DiagnosticSeverity.Error,
+        code: "unmatched-quote",
+        source: "lokascript",
+        message: "Unmatched double quote"
+      });
+    }
+  }
+  const openParens = (code.match(/\(/g) || []).length;
+  const closeParens = (code.match(/\)/g) || []).length;
+  if (openParens !== closeParens) {
+    diagnostics.push({
+      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+      severity: DiagnosticSeverity.Error,
+      code: "unbalanced-parens",
+      source: "lokascript",
+      message: `Unbalanced parentheses: ${openParens} open, ${closeParens} close`
+    });
+  }
+  return diagnostics;
+}
+connection.onCompletion((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+  const text = document.getText();
+  const uri = document.uri;
+  const position = params.position;
+  const language = globalSettings.language;
+  if (isHtmlDocument(uri, text)) {
+    const regions = extractHyperscriptRegions(text);
+    const found = findRegionAtPosition(regions, position.line, position.character);
+    if (!found) {
+      return [];
+    }
+    const regionLines = found.region.code.split("\n");
+    let beforeCursor = "";
+    for (let i = 0; i <= found.localLine && i < regionLines.length; i++) {
+      if (i === found.localLine) {
+        beforeCursor += regionLines[i].slice(0, found.localChar);
+      } else {
+        beforeCursor += regionLines[i] + "\n";
+      }
+    }
+    const context = inferContext(beforeCursor);
+    return getContextualCompletions(context, language);
+  } else {
+    const offset = document.offsetAt(position);
+    const beforeCursor = text.slice(0, offset);
+    const context = inferContext(beforeCursor);
+    return getContextualCompletions(context, language);
+  }
+});
+function inferContext(beforeCursor) {
+  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";
+  const getKeyword = (eng) => {
+    if (!isMultilingualEnabled(resolvedMode) || !semanticPackage || effectiveLanguage === "en") {
+      return eng;
+    }
+    try {
+      const profile = semanticPackage.getProfile(effectiveLanguage);
+      if (profile?.keywords?.[eng]?.primary) {
+        return profile.keywords[eng].primary;
+      }
+    } catch (e) {
+      const brand = getBranding(resolvedMode);
+      connection.console.log(`[${brand}-ls] Keyword lookup failed for '${eng}': ${e}`);
+    }
+    return eng;
+  };
+  const commandMode = isHyperscriptCompatMode(resolvedMode) ? "hyperscript" : "lokascript";
+  const availableCommands = getCommandsForMode(commandMode);
+  const isCommandAvailable = (cmd) => availableCommands.includes(cmd);
+  switch (context) {
+    case "event":
+      const eventNames = lspMetadata?.EVENT_NAMES ?? FALLBACK_EVENT_NAMES;
+      for (const eventName of eventNames) {
+        completions.push({
+          label: eventName,
+          kind: CompletionItemKind.Event,
+          detail: `${eventName} event`
+        });
+      }
+      break;
+    case "command":
+      completions.push(
+        {
+          label: getKeyword("toggle"),
+          kind: CompletionItemKind.Method,
+          detail: "Toggle class/visibility",
+          insertText: `${getKeyword("toggle")} .\${1:class}`
+        },
+        {
+          label: getKeyword("add"),
+          kind: CompletionItemKind.Method,
+          detail: "Add class/attribute",
+          insertText: `${getKeyword("add")} .\${1:class} to \${2:me}`
+        },
+        {
+          label: getKeyword("remove"),
+          kind: CompletionItemKind.Method,
+          detail: "Remove class/element",
+          insertText: `${getKeyword("remove")} .\${1:class} from \${2:me}`
+        },
+        { label: getKeyword("show"), kind: CompletionItemKind.Method, detail: "Show element" },
+        { label: getKeyword("hide"), kind: CompletionItemKind.Method, detail: "Hide element" },
+        {
+          label: getKeyword("put"),
+          kind: CompletionItemKind.Method,
+          detail: "Set content",
+          insertText: `${getKeyword("put")} \${1:value} into \${2:target}`
+        },
+        {
+          label: getKeyword("set"),
+          kind: CompletionItemKind.Method,
+          detail: "Set variable",
+          insertText: `${getKeyword("set")} \${1:variable} to \${2:value}`
+        },
+        {
+          label: getKeyword("fetch"),
+          kind: CompletionItemKind.Method,
+          detail: "HTTP request",
+          insertText: `${getKeyword("fetch")} \${1:/api/endpoint}`
+        },
+        {
+          label: getKeyword("wait"),
+          kind: CompletionItemKind.Method,
+          detail: "Pause execution",
+          insertText: `${getKeyword("wait")} \${1:1s}`
+        },
+        {
+          label: getKeyword("send"),
+          kind: CompletionItemKind.Method,
+          detail: "Dispatch event",
+          insertText: `${getKeyword("send")} \${1:eventName} to \${2:target}`
+        },
+        { label: getKeyword("trigger"), kind: CompletionItemKind.Method, detail: "Trigger event" },
+        { label: getKeyword("log"), kind: CompletionItemKind.Method, detail: "Console log" },
+        { label: getKeyword("if"), kind: CompletionItemKind.Keyword, detail: "Conditional" },
+        { label: getKeyword("repeat"), kind: CompletionItemKind.Keyword, detail: "Loop" }
+      );
+      if (!isHyperscriptCompatMode(resolvedMode)) {
+        completions.push(
+          {
+            label: getKeyword("make"),
+            kind: CompletionItemKind.Method,
+            detail: "Create element or instance",
+            insertText: `${getKeyword("make")} a \${1:div}`
+          },
+          {
+            label: getKeyword("settle"),
+            kind: CompletionItemKind.Method,
+            detail: "Wait for CSS transitions"
+          },
+          {
+            label: getKeyword("measure"),
+            kind: CompletionItemKind.Method,
+            detail: "Get element dimensions"
+          },
+          {
+            label: getKeyword("morph"),
+            kind: CompletionItemKind.Method,
+            detail: "DOM morph with state preservation",
+            insertText: `${getKeyword("morph")} \${1:target} to \${2:content}`
+          },
+          {
+            label: getKeyword("persist"),
+            kind: CompletionItemKind.Method,
+            detail: "Save to browser storage",
+            insertText: `${getKeyword("persist")} \${1:value} as \${2:key}`
+          },
+          {
+            label: getKeyword("install"),
+            kind: CompletionItemKind.Method,
+            detail: "Install behavior on element",
+            insertText: `${getKeyword("install")} \${1:Behavior}`
+          }
+        );
+      }
+      break;
+    case "expression":
+      completions.push(
+        { label: "me", kind: CompletionItemKind.Variable, detail: "Current element" },
+        { label: "you", kind: CompletionItemKind.Variable, detail: "Event target" },
+        { label: "it", kind: CompletionItemKind.Variable, detail: "Last result" },
+        { label: "result", kind: CompletionItemKind.Variable, detail: "Last result (alias)" },
+        { label: "first", kind: CompletionItemKind.Keyword, detail: "First in collection" },
+        { label: "last", kind: CompletionItemKind.Keyword, detail: "Last in collection" },
+        { label: "next", kind: CompletionItemKind.Keyword, detail: "Next sibling" },
+        { label: "previous", kind: CompletionItemKind.Keyword, detail: "Previous sibling" },
+        { label: "closest", kind: CompletionItemKind.Keyword, detail: "Closest ancestor" },
+        { label: "parent", kind: CompletionItemKind.Keyword, detail: "Parent element" }
+      );
+      break;
+    case "selector":
+      completions.push(
+        {
+          label: "#",
+          kind: CompletionItemKind.Snippet,
+          detail: "ID selector",
+          insertText: "#${1:id}"
+        },
+        {
+          label: ".",
+          kind: CompletionItemKind.Snippet,
+          detail: "Class selector",
+          insertText: ".${1:class}"
+        },
+        {
+          label: "<",
+          kind: CompletionItemKind.Snippet,
+          detail: "Tag selector",
+          insertText: "<${1:tag}/>"
+        }
+      );
+      break;
+    default:
+      completions.push(
+        { label: getKeyword("on"), kind: CompletionItemKind.Keyword, detail: "Event handler" },
+        { label: getKeyword("init"), kind: CompletionItemKind.Keyword, detail: "Initialization" },
+        {
+          label: getKeyword("behavior"),
+          kind: CompletionItemKind.Class,
+          detail: "Define behavior"
+        },
+        { label: getKeyword("def"), kind: CompletionItemKind.Function, detail: "Define function" }
+      );
+  }
+  return completions;
+}
+connection.onHover((params) => {
+  try {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) return null;
+    const text = document.getText();
+    const uri = document.uri;
+    const position = params.position;
+    if (isHtmlDocument(uri, text)) {
+      const regions = extractHyperscriptRegions(text);
+      const found = findRegionAtPosition(regions, position.line, position.character);
+      if (!found) {
+        return null;
+      }
+      const regionLines = found.region.code.split("\n");
+      const currentLine2 = regionLines[found.localLine];
+      if (!currentLine2) return null;
+      const word2 = getWordAtPosition(currentLine2, found.localChar);
+      if (!word2) return null;
+      const doc2 = getHoverDocumentation(word2.text, globalSettings.language);
+      if (!doc2) return null;
+      const startChar = found.localLine === 0 ? found.region.startChar + word2.start : word2.start;
+      const endChar = found.localLine === 0 ? found.region.startChar + word2.end : word2.end;
+      return {
+        contents: { kind: MarkupKind.Markdown, value: doc2 },
+        range: {
+          start: { line: position.line, character: startChar },
+          end: { line: position.line, character: endChar }
+        }
+      };
+    }
+    const lines = text.split("\n");
+    const currentLine = lines[position.line];
+    if (!currentLine) return null;
+    const word = getWordAtPosition(currentLine, position.character);
+    if (!word) return null;
+    const doc = getHoverDocumentation(word.text, globalSettings.language);
+    if (!doc) return null;
+    return {
+      contents: { kind: MarkupKind.Markdown, value: doc },
+      range: {
+        start: { line: position.line, character: word.start },
+        end: { line: position.line, character: word.end }
+      }
+    };
+  } catch (error) {
+    connection.console.error(`Hover error: ${error}`);
+    return null;
+  }
+});
+function getHoverDocumentation(word, language) {
+  const wordLower = word.toLowerCase();
+  const canonicalKey = isMultilingualEnabled(resolvedMode) ? resolveCanonicalKeyword(wordLower, language) : wordLower;
+  const docs = lspMetadata?.HOVER_DOCS ?? FALLBACK_HOVER_DOCS;
+  const doc = docs[canonicalKey];
+  if (!doc) return null;
+  let content = `**${doc.title}**`;
+  if (isMultilingualEnabled(resolvedMode) && wordLower !== canonicalKey) {
+    content = `**${word}** (${canonicalKey})`;
+  }
+  content += `
+
+${doc.description}`;
+  content += `
+
+\`\`\`hyperscript
+${doc.example}
+\`\`\``;
+  if (isMultilingualEnabled(resolvedMode)) {
+    const translations = getKeywordTranslations(canonicalKey);
+    if (translations) {
+      content += `
+
+**Translations:** ${translations}`;
+    }
+  }
+  return content;
+}
+var translationCache = null;
+function buildTranslationCache() {
+  const cache = /* @__PURE__ */ new Map();
+  if (!semanticPackage) return cache;
+  const langMap = {
+    es: "Spanish",
+    ja: "Japanese",
+    ko: "Korean",
+    de: "German",
+    fr: "French"
+  };
+  const canonicalKeywords = [
+    "toggle",
+    "add",
+    "remove",
+    "show",
+    "hide",
+    "put",
+    "set",
+    "get",
+    "fetch",
+    "wait",
+    "send",
+    "trigger",
+    "call",
+    "log",
+    "go",
+    "on",
+    "if",
+    "repeat",
+    "behavior",
+    "me",
+    "you",
+    "it",
+    "result"
+  ];
+  for (const canonicalKey of canonicalKeywords) {
+    const translations = [];
+    for (const [lang, langName] of Object.entries(langMap)) {
+      try {
+        const profile = semanticPackage.getProfile(lang);
+        const kw = profile?.keywords?.[canonicalKey];
+        if (kw) {
+          const trans = kw;
+          if (trans.primary && trans.primary !== canonicalKey) {
+            translations.push(`${langName}: \`${trans.primary}\``);
+          }
+        }
+      } catch (e) {
+        connection.console.log(`[lokascript-ls] Translation cache: profile '${lang}' not found`);
+      }
+    }
+    if (translations.length > 0) {
+      cache.set(canonicalKey, translations.join(" \xB7 "));
+    }
+  }
+  return cache;
+}
+function getKeywordTranslations(canonicalKey) {
+  if (!translationCache) {
+    translationCache = buildTranslationCache();
+  }
+  return translationCache.get(canonicalKey) || null;
+}
+var reverseKeywordCache = null;
+function buildReverseKeywordCache() {
+  const cache = /* @__PURE__ */ new Map();
+  if (!semanticPackage) return cache;
+  const languagesToTry = getOtherLanguages();
+  for (const lang of languagesToTry) {
+    try {
+      const profile = semanticPackage.getProfile(lang);
+      if (profile?.keywords) {
+        for (const [canonicalKey, translation] of Object.entries(profile.keywords)) {
+          const trans = translation;
+          if (trans.primary) {
+            cache.set(trans.primary.toLowerCase(), canonicalKey);
+          }
+          if (trans.alternatives) {
+            for (const alt of trans.alternatives) {
+              cache.set(alt.toLowerCase(), canonicalKey);
+            }
+          }
+        }
+      }
+      if (profile?.references) {
+        for (const [engRef, translatedRef] of Object.entries(profile.references)) {
+          if (typeof translatedRef === "string") {
+            cache.set(translatedRef.toLowerCase(), engRef);
+          }
+        }
+      }
+    } catch (e) {
+      connection.console.log(`[lokascript-ls] Reverse keyword cache: profile '${lang}' not found`);
+    }
+  }
+  return cache;
+}
+function resolveCanonicalKeyword(word, _language) {
+  const canonicalKeywords = lspMetadata?.ALL_KEYWORDS ?? FALLBACK_KEYWORDS;
+  if (canonicalKeywords.includes(word)) return word;
+  if (!reverseKeywordCache) {
+    reverseKeywordCache = buildReverseKeywordCache();
+  }
+  return reverseKeywordCache.get(word) || word;
+}
+connection.onDefinition((params) => {
+  try {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) return null;
+    const text = document.getText();
+    const uri = document.uri;
+    const position = params.position;
+    let targetWord = null;
+    if (isHtmlDocument(uri, text)) {
+      const regions = extractHyperscriptRegions(text);
+      const found = findRegionAtPosition(regions, position.line, position.character);
+      if (!found) {
+        return null;
+      }
+      const regionLines = found.region.code.split("\n");
+      const currentLine = regionLines[found.localLine];
+      if (!currentLine) return null;
+      const word = getWordAtPosition(currentLine, found.localChar);
+      if (!word) return null;
+      targetWord = word.text;
+    } else {
+      const lines = text.split("\n");
+      const currentLine = lines[position.line];
+      if (!currentLine) return null;
+      const word = getWordAtPosition(currentLine, position.character);
+      if (!word) return null;
+      targetWord = word.text;
+    }
+    if (!targetWord) return null;
+    const locations = [];
+    const behaviorVariants = getKeywordVariants("behavior");
+    const defVariants = getKeywordVariants("def");
+    const behaviorPattern = new RegExp(
+      `\\b(${behaviorVariants.join("|")})\\s+(${escapeRegExp(targetWord)})\\b`,
+      "gi"
+    );
+    const defPattern = new RegExp(
+      `\\b(${defVariants.join("|")})\\s+(${escapeRegExp(targetWord)})\\b`,
+      "gi"
+    );
+    if (isHtmlDocument(uri, text)) {
+      const regions = extractHyperscriptRegions(text);
+      for (const region of regions) {
+        for (const match of region.code.matchAll(behaviorPattern)) {
+          const matchLine = findLineInRegion(region.code, match.index ?? 0);
+          const matchChar = findCharInLine(region.code, match.index ?? 0);
+          locations.push({
+            uri: params.textDocument.uri,
+            range: {
+              start: {
+                line: region.startLine + matchLine,
+                character: matchLine === 0 ? region.startChar + matchChar : matchChar
+              },
+              end: {
+                line: region.startLine + matchLine,
+                character: (matchLine === 0 ? region.startChar + matchChar : matchChar) + match[0].length
+              }
+            }
+          });
+        }
+        for (const match of region.code.matchAll(defPattern)) {
+          const matchLine = findLineInRegion(region.code, match.index ?? 0);
+          const matchChar = findCharInLine(region.code, match.index ?? 0);
+          locations.push({
+            uri: params.textDocument.uri,
+            range: {
+              start: {
+                line: region.startLine + matchLine,
+                character: matchLine === 0 ? region.startChar + matchChar : matchChar
+              },
+              end: {
+                line: region.startLine + matchLine,
+                character: (matchLine === 0 ? region.startChar + matchChar : matchChar) + match[0].length
+              }
+            }
+          });
+        }
+      }
+    } else {
+      for (const match of text.matchAll(behaviorPattern)) {
+        const pos = offsetToPosition(text, match.index ?? 0);
+        locations.push({
+          uri: params.textDocument.uri,
+          range: {
+            start: pos,
+            end: { line: pos.line, character: pos.character + match[0].length }
+          }
+        });
+      }
+      for (const match of text.matchAll(defPattern)) {
+        const pos = offsetToPosition(text, match.index ?? 0);
+        locations.push({
+          uri: params.textDocument.uri,
+          range: {
+            start: pos,
+            end: { line: pos.line, character: pos.character + match[0].length }
+          }
+        });
+      }
+    }
+    if (locations.length === 0) return null;
+    if (locations.length === 1) return locations[0];
+    return locations;
+  } catch (error) {
+    connection.console.error(`Go to Definition error: ${error}`);
+    return null;
+  }
+});
+function getKeywordVariants(eng) {
+  const variants = [eng];
+  if (!semanticPackage) return variants;
+  for (const lang of getOtherLanguages()) {
+    try {
+      const profile = semanticPackage.getProfile(lang);
+      if (profile?.keywords?.[eng]) {
+        const trans = profile.keywords[eng];
+        if (trans.primary && !variants.includes(trans.primary)) {
+          variants.push(trans.primary);
+        }
+        if (trans.alternatives) {
+          for (const alt of trans.alternatives) {
+            if (!variants.includes(alt)) {
+              variants.push(alt);
+            }
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return variants;
+}
+connection.onReferences((params) => {
+  try {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) return null;
+    const text = document.getText();
+    const uri = document.uri;
+    const position = params.position;
+    let targetWord = null;
+    if (isHtmlDocument(uri, text)) {
+      const regions = extractHyperscriptRegions(text);
+      const found = findRegionAtPosition(regions, position.line, position.character);
+      if (!found) return null;
+      const regionLines = found.region.code.split("\n");
+      const currentLine = regionLines[found.localLine];
+      if (!currentLine) return null;
+      const word = getWordAtPosition(currentLine, found.localChar);
+      if (!word) return null;
+      targetWord = word.text;
+    } else {
+      const lines = text.split("\n");
+      const currentLine = lines[position.line];
+      if (!currentLine) return null;
+      const word = getWordAtPosition(currentLine, position.character);
+      if (!word) return null;
+      targetWord = word.text;
+    }
+    if (!targetWord) return null;
+    const locations = [];
+    const wordPattern = new RegExp(`\\b${escapeRegExp(targetWord)}\\b`, "gi");
+    if (isHtmlDocument(uri, text)) {
+      const regions = extractHyperscriptRegions(text);
+      for (const region of regions) {
+        for (const match of region.code.matchAll(wordPattern)) {
+          const matchLine = findLineInRegion(region.code, match.index ?? 0);
+          const matchChar = findCharInLine(region.code, match.index ?? 0);
+          locations.push({
+            uri: params.textDocument.uri,
+            range: {
+              start: {
+                line: region.startLine + matchLine,
+                character: matchLine === 0 ? region.startChar + matchChar : matchChar
+              },
+              end: {
+                line: region.startLine + matchLine,
+                character: (matchLine === 0 ? region.startChar + matchChar : matchChar) + match[0].length
+              }
+            }
+          });
+        }
+      }
+    } else {
+      for (const match of text.matchAll(wordPattern)) {
+        const pos = offsetToPosition(text, match.index ?? 0);
+        locations.push({
+          uri: params.textDocument.uri,
+          range: {
+            start: pos,
+            end: { line: pos.line, character: pos.character + match[0].length }
+          }
+        });
+      }
+    }
+    return locations.length > 0 ? locations : null;
+  } catch (error) {
+    connection.console.error(`Find References error: ${error}`);
+    return null;
+  }
+});
+connection.onDocumentFormatting((params) => {
+  try {
+    const document = documents.get(params.textDocument.uri);
+    if (!document) return null;
+    const text = document.getText();
+    const uri = document.uri;
+    const options = params.options;
+    const indentStr = options.insertSpaces ? " ".repeat(options.tabSize) : "	";
+    if (isHtmlDocument(uri, text)) {
+      connection.console.log("[lokascript-ls] Formatting not supported for HTML documents");
+      return null;
+    }
+    const formatted = formatHyperscript(text, indentStr);
+    if (formatted !== text) {
+      return [
+        TextEdit.replace(
+          {
+            start: { line: 0, character: 0 },
+            end: { line: document.lineCount, character: 0 }
+          },
+          formatted
+        )
+      ];
+    }
+    return null;
+  } catch (error) {
+    connection.console.error(`Document Formatting error: ${error}`);
+    return null;
+  }
+});
+connection.onDocumentSymbol((params) => {
+  const document = documents.get(params.textDocument.uri);
+  if (!document) return [];
+  const text = document.getText();
+  const uri = document.uri;
+  const language = globalSettings.language;
+  if (isHtmlDocument(uri, text)) {
+    const regions = extractHyperscriptRegions(text);
+    const allSymbols = [];
+    for (const region of regions) {
+      const symbols = extractSymbols(region.code, language);
+      for (const symbol of symbols) {
+        allSymbols.push({
+          ...symbol,
+          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
+            },
+            end: {
+              line: region.startLine + symbol.range.end.line,
+              character: symbol.range.end.line === 0 ? region.startChar + symbol.range.end.character : symbol.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
+            },
+            end: {
+              line: region.startLine + symbol.selectionRange.end.line,
+              character: symbol.selectionRange.end.line === 0 ? region.startChar + symbol.selectionRange.end.character : symbol.selectionRange.end.character
+            }
+          }
+        });
+      }
+    }
+    return allSymbols;
+  } else {
+    return extractSymbols(text, language);
+  }
+});
+function extractSymbols(code, language) {
+  const symbols = [];
+  const lines = code.split("\n");
+  const getVariants = (eng) => {
+    const variants = [eng];
+    if (!semanticPackage || language === "en") return variants;
+    try {
+      const profile = semanticPackage.getProfile(language);
+      if (profile?.keywords?.[eng]) {
+        const trans = profile.keywords[eng];
+        if (trans.primary) variants.push(trans.primary);
+        if (trans.alternatives) variants.push(...trans.alternatives);
+      }
+    } catch (e) {
+      connection.console.log(
+        `[lokascript-ls] Symbol extraction: variant lookup failed for '${eng}'`
+      );
+    }
+    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;
+}
+connection.onCodeAction((params) => {
+  const diagnostics = params.context.diagnostics;
+  const actions = [];
+  for (const diagnostic of diagnostics) {
+    if (diagnostic.code === "missing-role" && diagnostic.message.includes("toggle")) {
+      actions.push({
+        title: "Add class target to toggle",
+        kind: CodeActionKind.QuickFix,
+        diagnostics: [diagnostic],
+        edit: {
+          changes: {
+            [params.textDocument.uri]: [
+              {
+                range: diagnostic.range,
+                newText: "toggle .${1:classname}"
+              }
+            ]
+          }
+        }
+      });
+    }
+    if (diagnostic.code === "missing-role" && diagnostic.message.includes("put")) {
+      actions.push({
+        title: "Add destination to put command",
+        kind: CodeActionKind.QuickFix,
+        diagnostics: [diagnostic],
+        edit: {
+          changes: {
+            [params.textDocument.uri]: [
+              {
+                range: diagnostic.range,
+                newText: "put ${1:value} into ${2:#element}"
+              }
+            ]
+          }
+        }
+      });
+    }
+  }
+  return actions;
+});
+documents.listen(connection);
+connection.listen();