@lokascript/language-server 2.0.0 → 2.2.0

package/dist/server.js

@@ -322,6 +322,1226 @@ function formatHyperscript(code, indentStr = "  ") {
   return formattedLines.join("\n");
 }
 
+// src/chevrotain-parser.ts
+import { CstParser } from "chevrotain";
+
+// src/generated/chevrotain-vocabulary.ts
+import { createToken, Lexer } from "chevrotain";
+var Identifier = createToken({ name: "Identifier", pattern: /[a-zA-Z\u00C0-\u024F\u0400-\u04FF\u0600-\u06FF\u0900-\u09FF\u0E00-\u0E7F\u3040-\u9FFF\uAC00-\uD7AF][\w\u00C0-\u024F\u0400-\u04FF\u0600-\u06FF\u0900-\u09FF\u0E00-\u0E7F\u3040-\u9FFF\uAC00-\uD7AF'-]*/ });
+var WhiteSpace = createToken({ name: "WhiteSpace", pattern: /\s+/ });
+var StringLiteral = createToken({ name: "StringLiteral", pattern: /'[^']*'|"[^"]*"/ });
+var NumberLiteral = createToken({ name: "NumberLiteral", pattern: /\d+(\.\d+)?/ });
+var URLLiteral = createToken({ name: "URLLiteral", pattern: /\/[a-zA-Z0-9_\-.\/]+/ });
+var CSSSelector = createToken({ name: "CSSSelector", pattern: /[#.][a-zA-Z_][\w-]*/ });
+var AttributeSelector = createToken({ name: "AttributeSelector", pattern: /@[a-zA-Z_][\w-]*/ });
+var HTMLSelector = createToken({ name: "HTMLSelector", pattern: /<[a-zA-Z][\w.-]*\/>/ });
+var LocalVariable = createToken({ name: "LocalVariable", pattern: /:[a-zA-Z_][\w]*/ });
+var GlobalVariable = createToken({ name: "GlobalVariable", pattern: /\$[a-zA-Z_][\w]*/ });
+var LParen = createToken({ name: "LParen", pattern: /\(/ });
+var RParen = createToken({ name: "RParen", pattern: /\)/ });
+var Comma = createToken({ name: "Comma", pattern: /,/ });
+var Dot = createToken({ name: "Dot", pattern: /\./ });
+var Kw_previous = createToken({ name: "Kw_previous", pattern: /previous/, longer_alt: Identifier });
+var Kw_closest = createToken({ name: "Kw_closest", pattern: /closest/, longer_alt: Identifier });
+var Kw_while = createToken({ name: "Kw_while", pattern: /while/, longer_alt: Identifier });
+var Kw_until = createToken({ name: "Kw_until", pattern: /until/, longer_alt: Identifier });
+var Kw_times = createToken({ name: "Kw_times", pattern: /times/, longer_alt: Identifier });
+var Kw_first = createToken({ name: "Kw_first", pattern: /first/, longer_alt: Identifier });
+var Kw_false = createToken({ name: "Kw_false", pattern: /false/, longer_alt: Identifier });
+var Kw_then = createToken({ name: "Kw_then", pattern: /then/, longer_alt: Identifier });
+var Kw_else = createToken({ name: "Kw_else", pattern: /else/, longer_alt: Identifier });
+var Kw_from = createToken({ name: "Kw_from", pattern: /from/, longer_alt: Identifier });
+var Kw_into = createToken({ name: "Kw_into", pattern: /into/, longer_alt: Identifier });
+var Kw_with = createToken({ name: "Kw_with", pattern: /with/, longer_alt: Identifier });
+var Kw_have = createToken({ name: "Kw_have", pattern: /have/, longer_alt: Identifier });
+var Kw_last = createToken({ name: "Kw_last", pattern: /last/, longer_alt: Identifier });
+var Kw_next = createToken({ name: "Kw_next", pattern: /next/, longer_alt: Identifier });
+var Kw_true = createToken({ name: "Kw_true", pattern: /true/, longer_alt: Identifier });
+var Kw_null = createToken({ name: "Kw_null", pattern: /null/, longer_alt: Identifier });
+var Kw_end = createToken({ name: "Kw_end", pattern: /end/, longer_alt: Identifier });
+var Kw_for = createToken({ name: "Kw_for", pattern: /for/, longer_alt: Identifier });
+var Kw_and = createToken({ name: "Kw_and", pattern: /and/, longer_alt: Identifier });
+var Kw_not = createToken({ name: "Kw_not", pattern: /not/, longer_alt: Identifier });
+var Kw_has = createToken({ name: "Kw_has", pattern: /has/, longer_alt: Identifier });
+var Kw_you = createToken({ name: "Kw_you", pattern: /you/, longer_alt: Identifier });
+var Kw_its = createToken({ name: "Kw_its", pattern: /its/, longer_alt: Identifier });
+var Kw_the = createToken({ name: "Kw_the", pattern: /the/, longer_alt: Identifier });
+var Kw_on = createToken({ name: "Kw_on", pattern: /on/, longer_alt: Identifier });
+var Kw_if = createToken({ name: "Kw_if", pattern: /if/, longer_alt: Identifier });
+var Kw_to = createToken({ name: "Kw_to", pattern: /to/, longer_alt: Identifier });
+var Kw_in = createToken({ name: "Kw_in", pattern: /in/, longer_alt: Identifier });
+var Kw_of = createToken({ name: "Kw_of", pattern: /of/, longer_alt: Identifier });
+var Kw_as = createToken({ name: "Kw_as", pattern: /as/, longer_alt: Identifier });
+var Kw_at = createToken({ name: "Kw_at", pattern: /at/, longer_alt: Identifier });
+var Kw_by = createToken({ name: "Kw_by", pattern: /by/, longer_alt: Identifier });
+var Kw_or = createToken({ name: "Kw_or", pattern: /or/, longer_alt: Identifier });
+var Kw_is = createToken({ name: "Kw_is", pattern: /is/, longer_alt: Identifier });
+var Kw_me = createToken({ name: "Kw_me", pattern: /me/, longer_alt: Identifier });
+var Kw_it = createToken({ name: "Kw_it", pattern: /it/, longer_alt: Identifier });
+var Kw_my = createToken({ name: "Kw_my", pattern: /my/, longer_alt: Identifier });
+var Kw_no = createToken({ name: "Kw_no", pattern: /no/, longer_alt: Identifier });
+var Cmd_transition = createToken({ name: "Cmd_transition", pattern: /transition/, longer_alt: Identifier });
+var Cmd_show = createToken({ name: "Cmd_show", pattern: /show/, longer_alt: Identifier });
+var Cmd_hide = createToken({ name: "Cmd_hide", pattern: /hide/, longer_alt: Identifier });
+var Cmd_increment = createToken({ name: "Cmd_increment", pattern: /increment/, longer_alt: Identifier });
+var Cmd_decrement = createToken({ name: "Cmd_decrement", pattern: /decrement/, longer_alt: Identifier });
+var Cmd_default = createToken({ name: "Cmd_default", pattern: /default/, longer_alt: Identifier });
+var Cmd_beep = createToken({ name: "Cmd_beep", pattern: /beep/, longer_alt: Identifier });
+var Cmd_pick = createToken({ name: "Cmd_pick", pattern: /pick/, longer_alt: Identifier });
+var Cmd_set = createToken({ name: "Cmd_set", pattern: /set/, longer_alt: Identifier });
+var Cmd_log = createToken({ name: "Cmd_log", pattern: /log/, longer_alt: Identifier });
+var Cmd_get = createToken({ name: "Cmd_get", pattern: /get/, longer_alt: Identifier });
+var Cmd_continue = createToken({ name: "Cmd_continue", pattern: /continue/, longer_alt: Identifier });
+var Cmd_behavior = createToken({ name: "Cmd_behavior", pattern: /behavior/, longer_alt: Identifier });
+var Cmd_compound = createToken({ name: "Cmd_compound", pattern: /compound/, longer_alt: Identifier });
+var Cmd_install = createToken({ name: "Cmd_install", pattern: /install/, longer_alt: Identifier });
+var Cmd_unless = createToken({ name: "Cmd_unless", pattern: /unless/, longer_alt: Identifier });
+var Cmd_repeat = createToken({ name: "Cmd_repeat", pattern: /repeat/, longer_alt: Identifier });
+var Cmd_return = createToken({ name: "Cmd_return", pattern: /return/, longer_alt: Identifier });
+var Cmd_throw = createToken({ name: "Cmd_throw", pattern: /throw/, longer_alt: Identifier });
+var Cmd_break = createToken({ name: "Cmd_break", pattern: /break/, longer_alt: Identifier });
+var Cmd_halt = createToken({ name: "Cmd_halt", pattern: /halt/, longer_alt: Identifier });
+var Cmd_call = createToken({ name: "Cmd_call", pattern: /call/, longer_alt: Identifier });
+var Cmd_tell = createToken({ name: "Cmd_tell", pattern: /tell/, longer_alt: Identifier });
+var Cmd_init = createToken({ name: "Cmd_init", pattern: /init/, longer_alt: Identifier });
+var Cmd_exit = createToken({ name: "Cmd_exit", pattern: /exit/, longer_alt: Identifier });
+var Cmd_js = createToken({ name: "Cmd_js", pattern: /js/, longer_alt: Identifier });
+var Cmd_trigger = createToken({ name: "Cmd_trigger", pattern: /trigger/, longer_alt: Identifier });
+var Cmd_send = createToken({ name: "Cmd_send", pattern: /send/, longer_alt: Identifier });
+var Cmd_prepend = createToken({ name: "Cmd_prepend", pattern: /prepend/, longer_alt: Identifier });
+var Cmd_measure = createToken({ name: "Cmd_measure", pattern: /measure/, longer_alt: Identifier });
+var Cmd_append = createToken({ name: "Cmd_append", pattern: /append/, longer_alt: Identifier });
+var Cmd_render = createToken({ name: "Cmd_render", pattern: /render/, longer_alt: Identifier });
+var Cmd_clone = createToken({ name: "Cmd_clone", pattern: /clone/, longer_alt: Identifier });
+var Cmd_focus = createToken({ name: "Cmd_focus", pattern: /focus/, longer_alt: Identifier });
+var Cmd_morph = createToken({ name: "Cmd_morph", pattern: /morph/, longer_alt: Identifier });
+var Cmd_take = createToken({ name: "Cmd_take", pattern: /take/, longer_alt: Identifier });
+var Cmd_make = createToken({ name: "Cmd_make", pattern: /make/, longer_alt: Identifier });
+var Cmd_blur = createToken({ name: "Cmd_blur", pattern: /blur/, longer_alt: Identifier });
+var Cmd_swap = createToken({ name: "Cmd_swap", pattern: /swap/, longer_alt: Identifier });
+var Cmd_copy = createToken({ name: "Cmd_copy", pattern: /copy/, longer_alt: Identifier });
+var Cmd_put = createToken({ name: "Cmd_put", pattern: /put/, longer_alt: Identifier });
+var Cmd_toggle = createToken({ name: "Cmd_toggle", pattern: /toggle/, longer_alt: Identifier });
+var Cmd_remove = createToken({ name: "Cmd_remove", pattern: /remove/, longer_alt: Identifier });
+var Cmd_add = createToken({ name: "Cmd_add", pattern: /add/, longer_alt: Identifier });
+var Cmd_settle = createToken({ name: "Cmd_settle", pattern: /settle/, longer_alt: Identifier });
+var Cmd_fetch = createToken({ name: "Cmd_fetch", pattern: /fetch/, longer_alt: Identifier });
+var Cmd_async = createToken({ name: "Cmd_async", pattern: /async/, longer_alt: Identifier });
+var Cmd_wait = createToken({ name: "Cmd_wait", pattern: /wait/, longer_alt: Identifier });
+var Cmd_go = createToken({ name: "Cmd_go", pattern: /go/, longer_alt: Identifier });
+var Event_intersection = createToken({ name: "Event_intersection", pattern: /intersection/, longer_alt: Identifier });
+var Event_mouseenter = createToken({ name: "Event_mouseenter", pattern: /mouseenter/, longer_alt: Identifier });
+var Event_mouseleave = createToken({ name: "Event_mouseleave", pattern: /mouseleave/, longer_alt: Identifier });
+var Event_mousedown = createToken({ name: "Event_mousedown", pattern: /mousedown/, longer_alt: Identifier });
+var Event_mousemove = createToken({ name: "Event_mousemove", pattern: /mousemove/, longer_alt: Identifier });
+var Event_dblclick = createToken({ name: "Event_dblclick", pattern: /dblclick/, longer_alt: Identifier });
+var Event_keypress = createToken({ name: "Event_keypress", pattern: /keypress/, longer_alt: Identifier });
+var Event_mutation = createToken({ name: "Event_mutation", pattern: /mutation/, longer_alt: Identifier });
+var Event_mouseup = createToken({ name: "Event_mouseup", pattern: /mouseup/, longer_alt: Identifier });
+var Event_keydown = createToken({ name: "Event_keydown", pattern: /keydown/, longer_alt: Identifier });
+var Event_change = createToken({ name: "Event_change", pattern: /change/, longer_alt: Identifier });
+var Event_submit = createToken({ name: "Event_submit", pattern: /submit/, longer_alt: Identifier });
+var Event_scroll = createToken({ name: "Event_scroll", pattern: /scroll/, longer_alt: Identifier });
+var Event_resize = createToken({ name: "Event_resize", pattern: /resize/, longer_alt: Identifier });
+var Event_click = createToken({ name: "Event_click", pattern: /click/, longer_alt: Identifier });
+var Event_keyup = createToken({ name: "Event_keyup", pattern: /keyup/, longer_alt: Identifier });
+var Event_input = createToken({ name: "Event_input", pattern: /input/, longer_alt: Identifier });
+var Event_every = createToken({ name: "Event_every", pattern: /every/, longer_alt: Identifier });
+var Event_load = createToken({ name: "Event_load", pattern: /load/, longer_alt: Identifier });
+var allTokens = [
+  // Whitespace
+  WhiteSpace,
+  // Literals
+  StringLiteral,
+  NumberLiteral,
+  URLLiteral,
+  // Selectors
+  CSSSelector,
+  AttributeSelector,
+  HTMLSelector,
+  // Variables
+  LocalVariable,
+  GlobalVariable,
+  // Punctuation
+  LParen,
+  RParen,
+  Comma,
+  Dot,
+  // Event names
+  Event_intersection,
+  Event_mouseenter,
+  Event_mouseleave,
+  Event_mousedown,
+  Event_mousemove,
+  Event_dblclick,
+  Event_keypress,
+  Event_mutation,
+  Event_mouseup,
+  Event_keydown,
+  Event_change,
+  Event_submit,
+  Event_scroll,
+  Event_resize,
+  Event_click,
+  Event_keyup,
+  Event_input,
+  Event_every,
+  Event_load,
+  // Command keywords
+  Cmd_transition,
+  Cmd_increment,
+  Cmd_decrement,
+  Cmd_continue,
+  Cmd_behavior,
+  Cmd_compound,
+  Cmd_trigger,
+  Cmd_prepend,
+  Cmd_default,
+  Cmd_install,
+  Cmd_measure,
+  Cmd_toggle,
+  Cmd_remove,
+  Cmd_append,
+  Cmd_settle,
+  Cmd_unless,
+  Cmd_repeat,
+  Cmd_return,
+  Cmd_render,
+  Cmd_fetch,
+  Cmd_throw,
+  Cmd_clone,
+  Cmd_focus,
+  Cmd_async,
+  Cmd_morph,
+  Cmd_break,
+  Cmd_show,
+  Cmd_hide,
+  Cmd_wait,
+  Cmd_take,
+  Cmd_make,
+  Cmd_halt,
+  Cmd_send,
+  Cmd_blur,
+  Cmd_call,
+  Cmd_tell,
+  Cmd_init,
+  Cmd_swap,
+  Cmd_beep,
+  Cmd_copy,
+  Cmd_exit,
+  Cmd_pick,
+  Cmd_add,
+  Cmd_put,
+  Cmd_set,
+  Cmd_log,
+  Cmd_get,
+  Cmd_go,
+  Cmd_js,
+  // Structural keywords
+  Kw_previous,
+  Kw_closest,
+  Kw_while,
+  Kw_until,
+  Kw_times,
+  Kw_first,
+  Kw_false,
+  Kw_then,
+  Kw_else,
+  Kw_from,
+  Kw_into,
+  Kw_with,
+  Kw_have,
+  Kw_last,
+  Kw_next,
+  Kw_true,
+  Kw_null,
+  Kw_end,
+  Kw_for,
+  Kw_and,
+  Kw_not,
+  Kw_has,
+  Kw_you,
+  Kw_its,
+  Kw_the,
+  Kw_on,
+  Kw_if,
+  Kw_to,
+  Kw_in,
+  Kw_of,
+  Kw_as,
+  Kw_at,
+  Kw_by,
+  Kw_or,
+  Kw_is,
+  Kw_me,
+  Kw_it,
+  Kw_my,
+  Kw_no,
+  // Identifier (catch-all)
+  Identifier
+];
+var hyperscriptLexer = new Lexer(allTokens, {
+  positionTracking: "full",
+  ensureOptimizations: true
+});
+var COMMAND_SCHEMAS = [
+  { action: "toggle", category: "dom-class", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "add", category: "dom-class", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "remove", category: "dom-class", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "put", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "reference", "expression"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "set", category: "variable", roles: [{ role: "destination", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "patient", required: true, expectedTypes: ["literal", "expression", "reference"] }], primaryRole: "destination" },
+  { action: "show", category: "dom-visibility", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference"] }, { role: "style", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
+  { action: "hide", category: "dom-visibility", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference"] }, { role: "style", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
+  { action: "on", category: "event", roles: [{ role: "event", required: true, expectedTypes: ["literal"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "event" },
+  { action: "trigger", category: "event", roles: [{ role: "event", required: true, expectedTypes: ["literal", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "event" },
+  { action: "wait", category: "async", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "patient" },
+  { action: "fetch", category: "async", roles: [{ role: "source", required: true, expectedTypes: ["literal", "expression"] }, { role: "responseType", required: false, expectedTypes: ["literal", "expression"] }, { role: "method", required: false, expectedTypes: ["literal"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "source" },
+  { action: "increment", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "quantity", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
+  { action: "decrement", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "quantity", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
+  { action: "append", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "expression"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "prepend", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "expression"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "log", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "reference", "expression"] }], primaryRole: "patient" },
+  { action: "get", category: "variable", roles: [{ role: "source", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "destination", required: false, expectedTypes: ["reference"] }], primaryRole: "source" },
+  { action: "take", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["selector"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "make", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector"] }], primaryRole: "patient" },
+  { action: "halt", category: "control-flow", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "reference", "expression"] }], primaryRole: "patient" },
+  { action: "settle", category: "async", roles: [{ role: "patient", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "throw", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "patient" },
+  { action: "send", category: "event", roles: [{ role: "event", required: true, expectedTypes: ["literal", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "event" },
+  { action: "if", category: "control-flow", roles: [{ role: "condition", required: true, expectedTypes: ["expression"] }], primaryRole: "condition" },
+  { action: "unless", category: "control-flow", roles: [{ role: "condition", required: true, expectedTypes: ["expression"] }], primaryRole: "condition" },
+  { action: "else", category: "control-flow", roles: [], primaryRole: "patient" },
+  { action: "repeat", category: "control-flow", roles: [{ role: "loopType", required: true, expectedTypes: ["literal"] }, { role: "quantity", required: false, expectedTypes: ["literal", "expression"] }, { role: "event", required: false, expectedTypes: ["literal", "expression"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "loopType" },
+  { action: "for", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["reference"] }, { role: "source", required: true, expectedTypes: ["selector", "reference", "expression"] }], primaryRole: "patient" },
+  { action: "while", category: "control-flow", roles: [{ role: "condition", required: true, expectedTypes: ["expression"] }], primaryRole: "condition" },
+  { action: "continue", category: "control-flow", roles: [], primaryRole: "patient" },
+  { action: "go", category: "navigation", roles: [{ role: "destination", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "destination" },
+  { action: "transition", category: "dom-visibility", roles: [{ role: "patient", required: true, expectedTypes: ["literal"] }, { role: "goal", required: true, expectedTypes: ["literal", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }, { role: "duration", required: false, expectedTypes: ["literal"] }, { role: "style", required: false, expectedTypes: ["literal"] }], primaryRole: "patient" },
+  { action: "clone", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "focus", category: "dom-content", roles: [{ role: "patient", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "blur", category: "dom-content", roles: [{ role: "patient", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "call", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["expression", "reference"] }], primaryRole: "patient" },
+  { action: "return", category: "control-flow", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "expression", "reference"] }], primaryRole: "patient" },
+  { action: "js", category: "control-flow", roles: [{ role: "patient", required: false, expectedTypes: ["expression"] }], primaryRole: "patient" },
+  { action: "async", category: "async", roles: [], primaryRole: "patient" },
+  { action: "tell", category: "control-flow", roles: [{ role: "destination", required: true, expectedTypes: ["selector", "reference"] }], primaryRole: "destination" },
+  { action: "default", category: "variable", roles: [{ role: "destination", required: true, expectedTypes: ["reference"] }, { role: "patient", required: true, expectedTypes: ["literal", "expression"] }], primaryRole: "destination" },
+  { action: "init", category: "control-flow", roles: [], primaryRole: "patient" },
+  { action: "behavior", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "reference", "expression"] }], primaryRole: "patient" },
+  { action: "install", category: "control-flow", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "reference", "expression"] }, { role: "destination", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "measure", category: "dom-content", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "expression"] }, { role: "source", required: false, expectedTypes: ["selector", "reference"] }], primaryRole: "patient" },
+  { action: "swap", category: "dom-content", roles: [{ role: "method", required: false, expectedTypes: ["literal"] }, { role: "destination", required: true, expectedTypes: ["selector", "reference"] }, { role: "patient", required: false, expectedTypes: ["literal", "expression", "selector"] }], primaryRole: "destination" },
+  { action: "morph", category: "dom-content", roles: [{ role: "destination", required: true, expectedTypes: ["selector", "reference"] }, { role: "patient", required: true, expectedTypes: ["literal", "expression", "selector"] }], primaryRole: "destination" },
+  { action: "beep", category: "variable", roles: [{ role: "patient", required: false, expectedTypes: ["literal", "selector", "reference", "expression"] }], primaryRole: "patient" },
+  { action: "break", category: "control-flow", roles: [], primaryRole: "patient" },
+  { action: "copy", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "selector", "reference", "expression"] }], primaryRole: "patient" },
+  { action: "exit", category: "control-flow", roles: [], primaryRole: "patient" },
+  { action: "pick", category: "variable", roles: [{ role: "patient", required: true, expectedTypes: ["literal", "expression", "reference"] }, { role: "source", required: false, expectedTypes: ["reference", "expression"] }], primaryRole: "patient" },
+  { action: "render", category: "dom-content", roles: [{ role: "patient", required: true, expectedTypes: ["selector", "reference", "expression"] }, { role: "style", required: false, expectedTypes: ["expression", "reference"] }], primaryRole: "patient" },
+  { action: "compound", category: "control-flow", roles: [], primaryRole: "patient" }
+];
+
+// src/chevrotain-parser.ts
+var HyperscriptParser = class extends CstParser {
+  constructor() {
+    super(allTokens, {
+      recoveryEnabled: true,
+      maxLookahead: 3
+    });
+    this.performSelfAnalysis();
+  }
+  // -------------------------------------------------------------------------
+  // Top-level rules
+  // -------------------------------------------------------------------------
+  program = this.RULE("program", () => {
+    this.MANY(() => {
+      this.SUBRULE(this.statement);
+    });
+  });
+  statement = this.RULE("statement", () => {
+    this.OR([
+      { ALT: () => this.SUBRULE(this.eventHandler) },
+      { ALT: () => this.SUBRULE(this.commandChain) },
+      { ALT: () => this.SUBRULE(this.behaviorDef) }
+    ]);
+  });
+  // -------------------------------------------------------------------------
+  // Event handlers
+  // -------------------------------------------------------------------------
+  eventHandler = this.RULE("eventHandler", () => {
+    this.CONSUME(Kw_on);
+    this.SUBRULE(this.eventName);
+    this.OPTION(() => {
+      this.SUBRULE(this.eventModifiers);
+    });
+    this.OPTION2(() => {
+      this.SUBRULE(this.commandChain);
+    });
+    this.OPTION3(() => {
+      this.CONSUME(Kw_end);
+    });
+  });
+  eventName = this.RULE("eventName", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(Event_click) },
+      { ALT: () => this.CONSUME(Event_dblclick) },
+      { ALT: () => this.CONSUME(Event_mousedown) },
+      { ALT: () => this.CONSUME(Event_mouseup) },
+      { ALT: () => this.CONSUME(Event_mousemove) },
+      { ALT: () => this.CONSUME(Event_mouseenter) },
+      { ALT: () => this.CONSUME(Event_mouseleave) },
+      { ALT: () => this.CONSUME(Event_keydown) },
+      { ALT: () => this.CONSUME(Event_keyup) },
+      { ALT: () => this.CONSUME(Event_input) },
+      { ALT: () => this.CONSUME(Event_change) },
+      { ALT: () => this.CONSUME(Event_submit) },
+      { ALT: () => this.CONSUME(Event_load) },
+      { ALT: () => this.CONSUME(Event_scroll) },
+      { ALT: () => this.CONSUME(Event_resize) },
+      { ALT: () => this.CONSUME(Event_mutation) },
+      { ALT: () => this.CONSUME(Event_intersection) },
+      { ALT: () => this.CONSUME(Event_every) },
+      { ALT: () => this.CONSUME(Identifier) }
+      // Custom event name
+    ]);
+  });
+  eventModifiers = this.RULE("eventModifiers", () => {
+    this.MANY(() => {
+      this.CONSUME(Dot);
+      this.CONSUME(Identifier);
+      this.OPTION(() => {
+        this.CONSUME(LParen);
+        this.SUBRULE(this.expression);
+        this.CONSUME(RParen);
+      });
+    });
+  });
+  // -------------------------------------------------------------------------
+  // Command chain (commands connected by 'then')
+  // -------------------------------------------------------------------------
+  commandChain = this.RULE("commandChain", () => {
+    this.SUBRULE(this.command);
+    this.MANY(() => {
+      this.CONSUME(Kw_then);
+      this.SUBRULE2(this.command);
+    });
+  });
+  // -------------------------------------------------------------------------
+  // Commands (grouped by category for error messages)
+  // -------------------------------------------------------------------------
+  command = this.RULE("command", () => {
+    this.OR([
+      // DOM class/attribute
+      { ALT: () => this.SUBRULE(this.toggleCommand) },
+      { ALT: () => this.SUBRULE(this.addCommand) },
+      { ALT: () => this.SUBRULE(this.removeCommand) },
+      // DOM content
+      { ALT: () => this.SUBRULE(this.putCommand) },
+      { ALT: () => this.SUBRULE(this.setCommand) },
+      { ALT: () => this.SUBRULE(this.appendCommand) },
+      { ALT: () => this.SUBRULE(this.prependCommand) },
+      // DOM visibility
+      { ALT: () => this.SUBRULE(this.showCommand) },
+      { ALT: () => this.SUBRULE(this.hideCommand) },
+      { ALT: () => this.SUBRULE(this.transitionCommand) },
+      // Variable
+      { ALT: () => this.SUBRULE(this.logCommand) },
+      { ALT: () => this.SUBRULE(this.incrementCommand) },
+      { ALT: () => this.SUBRULE(this.decrementCommand) },
+      // Async
+      { ALT: () => this.SUBRULE(this.fetchCommand) },
+      { ALT: () => this.SUBRULE(this.waitCommand) },
+      // Event
+      { ALT: () => this.SUBRULE(this.sendCommand) },
+      { ALT: () => this.SUBRULE(this.triggerCommand) },
+      // Navigation
+      { ALT: () => this.SUBRULE(this.goCommand) },
+      // Control flow
+      { ALT: () => this.SUBRULE(this.ifCommand) },
+      { ALT: () => this.SUBRULE(this.repeatCommand) },
+      // Execution
+      { ALT: () => this.SUBRULE(this.callCommand) },
+      { ALT: () => this.SUBRULE(this.jsCommand) },
+      { ALT: () => this.SUBRULE(this.returnCommand) },
+      { ALT: () => this.SUBRULE(this.throwCommand) },
+      { ALT: () => this.SUBRULE(this.haltCommand) }
+    ]);
+  });
+  // --- DOM class/attribute ---
+  toggleCommand = this.RULE("toggleCommand", () => {
+    this.CONSUME(Cmd_toggle);
+    this.SUBRULE(this.selectorOrExpression);
+    this.OPTION(() => {
+      this.CONSUME(Kw_on);
+      this.SUBRULE2(this.selectorOrExpression);
+    });
+  });
+  addCommand = this.RULE("addCommand", () => {
+    this.CONSUME(Cmd_add);
+    this.SUBRULE(this.selectorOrExpression);
+    this.OPTION(() => {
+      this.CONSUME(Kw_to);
+      this.SUBRULE2(this.selectorOrExpression);
+    });
+  });
+  removeCommand = this.RULE("removeCommand", () => {
+    this.CONSUME(Cmd_remove);
+    this.SUBRULE(this.selectorOrExpression);
+    this.OPTION(() => {
+      this.CONSUME(Kw_from);
+      this.SUBRULE2(this.selectorOrExpression);
+    });
+  });
+  // --- DOM content ---
+  putCommand = this.RULE("putCommand", () => {
+    this.CONSUME(Cmd_put);
+    this.SUBRULE(this.expression);
+    this.OPTION(() => {
+      this.OR([
+        { ALT: () => this.CONSUME(Kw_into) },
+        { ALT: () => this.CONSUME(Identifier, { LABEL: "putMarker" }) }
+        // before/after
+      ]);
+      this.SUBRULE2(this.selectorOrExpression);
+    });
+  });
+  setCommand = this.RULE("setCommand", () => {
+    this.CONSUME(Cmd_set);
+    this.SUBRULE(this.selectorOrExpression);
+    this.CONSUME(Kw_to);
+    this.SUBRULE2(this.expression);
+  });
+  appendCommand = this.RULE("appendCommand", () => {
+    this.CONSUME(Cmd_append);
+    this.SUBRULE(this.expression);
+    this.CONSUME(Kw_to);
+    this.SUBRULE2(this.selectorOrExpression);
+  });
+  prependCommand = this.RULE("prependCommand", () => {
+    this.CONSUME(Cmd_prepend);
+    this.SUBRULE(this.expression);
+    this.CONSUME(Kw_to);
+    this.SUBRULE2(this.selectorOrExpression);
+  });
+  // --- DOM visibility ---
+  showCommand = this.RULE("showCommand", () => {
+    this.CONSUME(Cmd_show);
+    this.OPTION(() => this.SUBRULE(this.selectorOrExpression));
+  });
+  hideCommand = this.RULE("hideCommand", () => {
+    this.CONSUME(Cmd_hide);
+    this.OPTION(() => this.SUBRULE(this.selectorOrExpression));
+  });
+  transitionCommand = this.RULE("transitionCommand", () => {
+    this.CONSUME(Cmd_transition);
+    this.SUBRULE(this.selectorOrExpression);
+  });
+  // --- Variable ---
+  logCommand = this.RULE("logCommand", () => {
+    this.CONSUME(Cmd_log);
+    this.SUBRULE(this.expression);
+  });
+  incrementCommand = this.RULE("incrementCommand", () => {
+    this.CONSUME(Cmd_increment);
+    this.SUBRULE(this.selectorOrExpression);
+    this.OPTION(() => {
+      this.CONSUME(Kw_by);
+      this.SUBRULE2(this.expression);
+    });
+  });
+  decrementCommand = this.RULE("decrementCommand", () => {
+    this.CONSUME(Cmd_decrement);
+    this.SUBRULE(this.selectorOrExpression);
+    this.OPTION(() => {
+      this.CONSUME(Kw_by);
+      this.SUBRULE2(this.expression);
+    });
+  });
+  // --- Async ---
+  fetchCommand = this.RULE("fetchCommand", () => {
+    this.CONSUME(Cmd_fetch);
+    this.SUBRULE(this.expression);
+    this.OPTION(() => {
+      this.CONSUME(Kw_as);
+      this.CONSUME(Identifier, { LABEL: "responseType" });
+    });
+  });
+  waitCommand = this.RULE("waitCommand", () => {
+    this.CONSUME(Cmd_wait);
+    this.OPTION(() => this.SUBRULE(this.expression));
+  });
+  // --- Event ---
+  sendCommand = this.RULE("sendCommand", () => {
+    this.CONSUME(Cmd_send);
+    this.CONSUME(Identifier, { LABEL: "eventName" });
+    this.OPTION(() => {
+      this.CONSUME(Kw_to);
+      this.SUBRULE(this.selectorOrExpression);
+    });
+  });
+  triggerCommand = this.RULE("triggerCommand", () => {
+    this.CONSUME(Cmd_trigger);
+    this.CONSUME(Identifier, { LABEL: "eventName" });
+    this.OPTION(() => {
+      this.CONSUME(Kw_on);
+      this.SUBRULE(this.selectorOrExpression);
+    });
+  });
+  // --- Navigation ---
+  goCommand = this.RULE("goCommand", () => {
+    this.CONSUME(Cmd_go);
+    this.OPTION(() => this.CONSUME(Kw_to));
+    this.SUBRULE(this.expression);
+  });
+  // --- Control flow ---
+  ifCommand = this.RULE("ifCommand", () => {
+    this.CONSUME(Kw_if);
+    this.SUBRULE(this.expression);
+    this.OPTION(() => this.SUBRULE(this.commandChain));
+    this.OPTION2(() => {
+      this.CONSUME(Kw_else);
+      this.OPTION3(() => this.SUBRULE2(this.commandChain));
+    });
+    this.OPTION4(() => this.CONSUME(Kw_end));
+  });
+  repeatCommand = this.RULE("repeatCommand", () => {
+    this.CONSUME(Cmd_repeat);
+    this.OR([
+      {
+        ALT: () => {
+          this.SUBRULE(this.expression);
+          this.CONSUME(Kw_times);
+        }
+      },
+      {
+        ALT: () => {
+          this.CONSUME(Kw_for);
+          this.CONSUME(Identifier, { LABEL: "loopVar" });
+          this.CONSUME(Kw_in);
+          this.SUBRULE2(this.expression);
+        }
+      },
+      {
+        ALT: () => {
+          this.CONSUME(Kw_while);
+          this.SUBRULE3(this.expression);
+        }
+      },
+      {
+        ALT: () => {
+          this.CONSUME(Kw_until);
+          this.SUBRULE4(this.expression);
+        }
+      },
+      {
+        ALT: () => {
+        }
+      }
+    ]);
+    this.OPTION(() => this.SUBRULE(this.commandChain));
+    this.OPTION2(() => this.CONSUME(Kw_end));
+  });
+  // --- Execution ---
+  callCommand = this.RULE("callCommand", () => {
+    this.CONSUME(Cmd_call);
+    this.SUBRULE(this.expression);
+  });
+  jsCommand = this.RULE("jsCommand", () => {
+    this.CONSUME(Cmd_js);
+    this.MANY(() => {
+      this.OR([
+        { ALT: () => this.CONSUME(Identifier) },
+        { ALT: () => this.CONSUME(StringLiteral) },
+        { ALT: () => this.CONSUME(NumberLiteral) },
+        { ALT: () => this.CONSUME(CSSSelector) },
+        { ALT: () => this.CONSUME(LocalVariable) },
+        { ALT: () => this.CONSUME(LParen) },
+        { ALT: () => this.CONSUME(RParen) },
+        { ALT: () => this.CONSUME(Comma) },
+        { ALT: () => this.CONSUME(Dot) }
+      ]);
+    });
+    this.CONSUME(Kw_end);
+  });
+  returnCommand = this.RULE("returnCommand", () => {
+    this.CONSUME(Cmd_return);
+    this.OPTION(() => this.SUBRULE(this.expression));
+  });
+  throwCommand = this.RULE("throwCommand", () => {
+    this.CONSUME(Cmd_throw);
+    this.SUBRULE(this.expression);
+  });
+  haltCommand = this.RULE("haltCommand", () => {
+    this.CONSUME(Cmd_halt);
+  });
+  // -------------------------------------------------------------------------
+  // Behavior definitions
+  // -------------------------------------------------------------------------
+  behaviorDef = this.RULE("behaviorDef", () => {
+    this.CONSUME(Cmd_behavior);
+    this.CONSUME(Identifier, { LABEL: "behaviorName" });
+    this.OPTION(() => {
+      this.CONSUME(LParen);
+      this.AT_LEAST_ONE_SEP({
+        SEP: Comma,
+        DEF: () => this.CONSUME2(Identifier, { LABEL: "param" })
+      });
+      this.CONSUME(RParen);
+    });
+    this.MANY(() => this.SUBRULE(this.statement));
+    this.CONSUME(Kw_end);
+  });
+  // -------------------------------------------------------------------------
+  // Expressions (simplified for LSP — full expression parsing is in core)
+  // -------------------------------------------------------------------------
+  expression = this.RULE("expression", () => {
+    this.SUBRULE(this.primaryExpression);
+    this.MANY(() => {
+      this.OR([
+        {
+          ALT: () => {
+            this.OR2([
+              { ALT: () => this.CONSUME(Kw_is) },
+              { ALT: () => this.CONSUME(Kw_and) },
+              { ALT: () => this.CONSUME(Kw_or) }
+            ]);
+            this.SUBRULE2(this.primaryExpression);
+          }
+        },
+        {
+          ALT: () => {
+            this.CONSUME(Dot);
+            this.CONSUME(Identifier);
+          }
+        }
+      ]);
+    });
+  });
+  primaryExpression = this.RULE("primaryExpression", () => {
+    this.OPTION(() => {
+      this.OR([
+        { ALT: () => this.CONSUME(Kw_not) },
+        { ALT: () => this.CONSUME(Kw_the) },
+        { ALT: () => this.CONSUME(Kw_no) }
+      ]);
+    });
+    this.OR2([
+      { ALT: () => this.CONSUME(StringLiteral) },
+      { ALT: () => this.CONSUME(NumberLiteral) },
+      { ALT: () => this.CONSUME(CSSSelector) },
+      { ALT: () => this.CONSUME(AttributeSelector) },
+      { ALT: () => this.CONSUME(HTMLSelector) },
+      { ALT: () => this.CONSUME(LocalVariable) },
+      { ALT: () => this.CONSUME(GlobalVariable) },
+      { ALT: () => this.CONSUME(Kw_me) },
+      { ALT: () => this.CONSUME(Kw_it) },
+      { ALT: () => this.CONSUME(Kw_true) },
+      { ALT: () => this.CONSUME(Kw_false) },
+      { ALT: () => this.CONSUME(Identifier) },
+      {
+        ALT: () => {
+          this.CONSUME(LParen);
+          this.SUBRULE(this.expression);
+          this.CONSUME(RParen);
+        }
+      }
+    ]);
+  });
+  // -------------------------------------------------------------------------
+  // Selectors or expressions
+  // -------------------------------------------------------------------------
+  selectorOrExpression = this.RULE("selectorOrExpression", () => {
+    this.OR([
+      { ALT: () => this.CONSUME(CSSSelector) },
+      { ALT: () => this.CONSUME(AttributeSelector) },
+      { ALT: () => this.CONSUME(HTMLSelector) },
+      { ALT: () => this.CONSUME(Kw_me) },
+      { ALT: () => this.CONSUME(Kw_it) },
+      { ALT: () => this.CONSUME(LocalVariable) },
+      { ALT: () => this.CONSUME(GlobalVariable) },
+      { ALT: () => this.CONSUME(Identifier) }
+    ]);
+  });
+};
+var parserInstance = new HyperscriptParser();
+function parseWithRecovery(code) {
+  const lexResult = hyperscriptLexer.tokenize(code);
+  const diagnostics = lexResult.errors.map((err) => ({
+    message: err.message,
+    severity: "error",
+    startOffset: err.offset,
+    endOffset: err.offset + (err.length || 1),
+    startLine: err.line ?? 1,
+    startColumn: err.column ?? 1,
+    code: "lex-error"
+  }));
+  const nonWS = lexResult.tokens.filter((t) => t.tokenType !== WhiteSpace);
+  parserInstance.input = nonWS;
+  const cst = parserInstance.program();
+  for (const err of parserInstance.errors) {
+    diagnostics.push(recognitionExceptionToDiagnostic(err));
+  }
+  return {
+    cst,
+    diagnostics,
+    tokens: lexResult.tokens
+  };
+}
+function getContentAssist(code, offset) {
+  const lexResult = hyperscriptLexer.tokenize(code);
+  const nonWS = lexResult.tokens.filter((t) => t.tokenType !== WhiteSpace);
+  const suggestions = [];
+  const tokenBefore = findTokenBefore(nonWS, offset);
+  const context = inferContextFromTokens(nonWS, tokenBefore);
+  switch (context) {
+    case "start":
+    case "after-then":
+      suggestions.push(...getCommandSuggestions());
+      suggestions.push({
+        label: "on",
+        kind: "keyword",
+        detail: "Event handler",
+        insertText: "on "
+      });
+      break;
+    case "after-on":
+      suggestions.push(...getEventSuggestions());
+      break;
+    case "after-command":
+      if (tokenBefore) {
+        suggestions.push(...getRoleMarkerSuggestions(tokenBefore));
+      }
+      break;
+    case "after-marker":
+      suggestions.push(...getSelectorSuggestions());
+      break;
+    default:
+      suggestions.push(...getCommandSuggestions());
+      suggestions.push(...getSelectorSuggestions());
+      break;
+  }
+  return suggestions;
+}
+function recognitionExceptionToDiagnostic(err) {
+  const token = err.token;
+  const startOffset = token.startOffset ?? 0;
+  const endOffset = token.endOffset ?? startOffset + 1;
+  let message = err.message;
+  const match = message.match(/Expecting (.*?) but found/);
+  if (match) {
+    const expected = match[1].replace(/token of type --> /g, "").replace(/ <--/g, "").replace(/one of these possible Token Types:\s*/g, "").replace(/\[.*?\]/g, (m) => {
+      const names = m.slice(1, -1).split(",").map((n) => n.trim());
+      return names.slice(0, 5).join(", ") + (names.length > 5 ? "..." : "");
+    });
+    message = `Expected ${expected}`;
+    if (token.image) {
+      message += ` but found '${token.image}'`;
+    }
+  }
+  return {
+    message,
+    severity: "error",
+    startOffset,
+    endOffset,
+    startLine: token.startLine ?? 1,
+    startColumn: token.startColumn ?? 1,
+    code: "parse-error"
+  };
+}
+function findTokenBefore(tokens, offset) {
+  let best = null;
+  for (const t of tokens) {
+    if (t.startOffset <= offset) {
+      best = t;
+    } else {
+      break;
+    }
+  }
+  return best;
+}
+function inferContextFromTokens(tokens, tokenBefore) {
+  if (!tokenBefore || tokens.length === 0) return "start";
+  const type = tokenBefore.tokenType;
+  if (type === Kw_on) return "after-on";
+  if (type === Kw_then) return "after-then";
+  if (type.name.startsWith("Cmd_")) return "after-command";
+  const markers = [Kw_to, Kw_from, Kw_into, Kw_in, Kw_of, Kw_on, Kw_as, Kw_with];
+  if (markers.includes(type)) return "after-marker";
+  return "general";
+}
+function getCommandSuggestions() {
+  return COMMAND_SCHEMAS.map((schema) => ({
+    label: schema.action,
+    kind: "command",
+    detail: getCategoryLabel(schema.category),
+    insertText: schema.action + " ",
+    category: schema.category
+  }));
+}
+function getEventSuggestions() {
+  const events = [
+    "click",
+    "dblclick",
+    "mousedown",
+    "mouseup",
+    "mousemove",
+    "mouseenter",
+    "mouseleave",
+    "keydown",
+    "keyup",
+    "keypress",
+    "input",
+    "change",
+    "submit",
+    "focus",
+    "blur",
+    "load",
+    "scroll",
+    "resize",
+    "mutation",
+    "intersection",
+    "every"
+  ];
+  return events.map((e) => ({
+    label: e,
+    kind: "event",
+    detail: `${e} event`,
+    insertText: e + " "
+  }));
+}
+function getRoleMarkerSuggestions(commandToken) {
+  const cmdName = commandToken.tokenType.name.replace("Cmd_", "");
+  const schema = COMMAND_SCHEMAS.find((s) => s.action === cmdName);
+  if (!schema) return [];
+  const suggestions = [];
+  for (const role of schema.roles) {
+    if (role.role === schema.primaryRole) continue;
+    const markers = getRoleMarkers(role.role);
+    for (const marker of markers) {
+      suggestions.push({
+        label: marker,
+        kind: "keyword",
+        detail: `${role.role} marker`,
+        insertText: marker + " "
+      });
+    }
+  }
+  return suggestions;
+}
+function getSelectorSuggestions() {
+  return [
+    { label: "me", kind: "keyword", detail: "Current element" },
+    { label: "it", kind: "keyword", detail: "Last result" },
+    { label: ".", kind: "selector", detail: "CSS class selector", insertText: "." },
+    { label: "#", kind: "selector", detail: "CSS ID selector", insertText: "#" },
+    { label: "@", kind: "selector", detail: "Attribute selector", insertText: "@" },
+    { label: ":", kind: "variable", detail: "Local variable", insertText: ":" },
+    { label: "$", kind: "variable", detail: "Global variable", insertText: "$" }
+  ];
+}
+function getRoleMarkers(role) {
+  switch (role) {
+    case "destination":
+      return ["to", "into"];
+    case "source":
+      return ["from"];
+    case "target":
+      return ["on"];
+    case "container":
+      return ["in"];
+    case "instrument":
+      return ["with"];
+    case "beneficiary":
+      return ["for"];
+    default:
+      return [];
+  }
+}
+function getCategoryLabel(category) {
+  const labels = {
+    "dom-class": "DOM Class/Attribute",
+    "dom-content": "DOM Content",
+    "dom-visibility": "DOM Visibility",
+    variable: "Variable",
+    event: "Event",
+    async: "Async",
+    navigation: "Navigation",
+    "control-flow": "Control Flow"
+  };
+  return labels[category] || category;
+}
+
+// src/localized-descriptions.ts
+var DESCRIPTIONS = {
+  en: {
+    toggle: {
+      detail: "Toggle class/visibility",
+      documentation: "Toggles a CSS class or attribute on an element. If the class exists, it is removed; otherwise, it is added."
+    },
+    add: {
+      detail: "Add class/attribute",
+      documentation: "Adds a CSS class or attribute to an element."
+    },
+    remove: {
+      detail: "Remove class/element",
+      documentation: "Removes a CSS class, attribute, or element from the DOM."
+    },
+    show: {
+      detail: "Show element",
+      documentation: "Makes an element visible by removing display:none."
+    },
+    hide: { detail: "Hide element", documentation: "Hides an element by setting display:none." },
+    put: {
+      detail: "Set content",
+      documentation: "Sets the content of an element (innerHTML, textContent, or value)."
+    },
+    set: { detail: "Set variable", documentation: "Assigns a value to a variable or property." },
+    get: {
+      detail: "Get value",
+      documentation: "Retrieves a value from an expression and stores it in the result variable."
+    },
+    fetch: {
+      detail: "HTTP request",
+      documentation: "Makes an HTTP request (GET, POST, etc.) and stores the response."
+    },
+    call: { detail: "Call function", documentation: "Calls a JavaScript function or method." },
+    send: { detail: "Send event", documentation: "Dispatches a custom event on an element." },
+    trigger: { detail: "Trigger event", documentation: "Triggers an event on an element." },
+    wait: {
+      detail: "Delay execution",
+      documentation: "Pauses execution for a specified duration."
+    },
+    log: { detail: "Log to console", documentation: "Outputs a value to the browser console." },
+    increment: {
+      detail: "Increment value",
+      documentation: "Increases a numeric value by 1 or a specified amount."
+    },
+    decrement: {
+      detail: "Decrement value",
+      documentation: "Decreases a numeric value by 1 or a specified amount."
+    },
+    append: { detail: "Append content", documentation: "Appends content to an element or array." },
+    settle: {
+      detail: "Wait for transitions",
+      documentation: "Waits for CSS transitions/animations to complete."
+    },
+    go: { detail: "Navigate", documentation: "Navigates to a URL or page location." },
+    throw: { detail: "Throw error", documentation: "Throws an error with a specified message." }
+  },
+  ja: {
+    toggle: {
+      detail: "\u30AF\u30E9\u30B9/\u8868\u793A\u5207\u66FF",
+      documentation: "\u8981\u7D20\u306ECSS\u30AF\u30E9\u30B9\u307E\u305F\u306F\u5C5E\u6027\u3092\u5207\u308A\u66FF\u3048\u307E\u3059\u3002\u30AF\u30E9\u30B9\u304C\u5B58\u5728\u3059\u308B\u5834\u5408\u306F\u524A\u9664\u3057\u3001\u5B58\u5728\u3057\u306A\u3044\u5834\u5408\u306F\u8FFD\u52A0\u3057\u307E\u3059\u3002"
+    },
+    add: { detail: "\u30AF\u30E9\u30B9/\u5C5E\u6027\u8FFD\u52A0", documentation: "\u8981\u7D20\u306BCSS\u30AF\u30E9\u30B9\u307E\u305F\u306F\u5C5E\u6027\u3092\u8FFD\u52A0\u3057\u307E\u3059\u3002" },
+    remove: {
+      detail: "\u30AF\u30E9\u30B9/\u8981\u7D20\u524A\u9664",
+      documentation: "CSS\u30AF\u30E9\u30B9\u3001\u5C5E\u6027\u3001\u307E\u305F\u306FDOM\u8981\u7D20\u3092\u524A\u9664\u3057\u307E\u3059\u3002"
+    },
+    show: { detail: "\u8981\u7D20\u8868\u793A", documentation: "display:none\u3092\u524A\u9664\u3057\u3066\u8981\u7D20\u3092\u8868\u793A\u3057\u307E\u3059\u3002" },
+    hide: { detail: "\u8981\u7D20\u975E\u8868\u793A", documentation: "display:none\u3092\u8A2D\u5B9A\u3057\u3066\u8981\u7D20\u3092\u975E\u8868\u793A\u306B\u3057\u307E\u3059\u3002" },
+    put: {
+      detail: "\u30B3\u30F3\u30C6\u30F3\u30C4\u8A2D\u5B9A",
+      documentation: "\u8981\u7D20\u306E\u30B3\u30F3\u30C6\u30F3\u30C4\uFF08innerHTML\u3001textContent\u3001\u307E\u305F\u306Fvalue\uFF09\u3092\u8A2D\u5B9A\u3057\u307E\u3059\u3002"
+    },
+    set: { detail: "\u5909\u6570\u8A2D\u5B9A", documentation: "\u5909\u6570\u307E\u305F\u306F\u30D7\u30ED\u30D1\u30C6\u30A3\u306B\u5024\u3092\u4EE3\u5165\u3057\u307E\u3059\u3002" },
+    get: { detail: "\u5024\u53D6\u5F97", documentation: "\u5F0F\u304B\u3089\u5024\u3092\u53D6\u5F97\u3057\u3001result\u5909\u6570\u306B\u683C\u7D0D\u3057\u307E\u3059\u3002" },
+    fetch: {
+      detail: "HTTP\u30EA\u30AF\u30A8\u30B9\u30C8",
+      documentation: "HTTP\u30EA\u30AF\u30A8\u30B9\u30C8\uFF08GET\u3001POST\u306A\u3069\uFF09\u3092\u5B9F\u884C\u3057\u3001\u30EC\u30B9\u30DD\u30F3\u30B9\u3092\u683C\u7D0D\u3057\u307E\u3059\u3002"
+    },
+    call: { detail: "\u95A2\u6570\u547C\u3073\u51FA\u3057", documentation: "JavaScript\u95A2\u6570\u307E\u305F\u306F\u30E1\u30BD\u30C3\u30C9\u3092\u547C\u3073\u51FA\u3057\u307E\u3059\u3002" },
+    send: { detail: "\u30A4\u30D9\u30F3\u30C8\u9001\u4FE1", documentation: "\u8981\u7D20\u306B\u30AB\u30B9\u30BF\u30E0\u30A4\u30D9\u30F3\u30C8\u3092\u30C7\u30A3\u30B9\u30D1\u30C3\u30C1\u3057\u307E\u3059\u3002" },
+    trigger: { detail: "\u30A4\u30D9\u30F3\u30C8\u30C8\u30EA\u30AC\u30FC", documentation: "\u8981\u7D20\u3067\u30A4\u30D9\u30F3\u30C8\u3092\u30C8\u30EA\u30AC\u30FC\u3057\u307E\u3059\u3002" },
+    wait: { detail: "\u5B9F\u884C\u9045\u5EF6", documentation: "\u6307\u5B9A\u3055\u308C\u305F\u6642\u9593\u3060\u3051\u5B9F\u884C\u3092\u4E00\u6642\u505C\u6B62\u3057\u307E\u3059\u3002" },
+    log: { detail: "\u30B3\u30F3\u30BD\u30FC\u30EB\u51FA\u529B", documentation: "\u30D6\u30E9\u30A6\u30B6\u30B3\u30F3\u30BD\u30FC\u30EB\u306B\u5024\u3092\u51FA\u529B\u3057\u307E\u3059\u3002" },
+    increment: { detail: "\u5024\u5897\u52A0", documentation: "\u6570\u5024\u30921\u307E\u305F\u306F\u6307\u5B9A\u91CF\u3060\u3051\u5897\u52A0\u3055\u305B\u307E\u3059\u3002" },
+    decrement: { detail: "\u5024\u6E1B\u5C11", documentation: "\u6570\u5024\u30921\u307E\u305F\u306F\u6307\u5B9A\u91CF\u3060\u3051\u6E1B\u5C11\u3055\u305B\u307E\u3059\u3002" },
+    append: { detail: "\u30B3\u30F3\u30C6\u30F3\u30C4\u8FFD\u52A0", documentation: "\u8981\u7D20\u307E\u305F\u306F\u914D\u5217\u306B\u30B3\u30F3\u30C6\u30F3\u30C4\u3092\u8FFD\u52A0\u3057\u307E\u3059\u3002" },
+    settle: {
+      detail: "\u30C8\u30E9\u30F3\u30B8\u30B7\u30E7\u30F3\u5F85\u6A5F",
+      documentation: "CSS\u30C8\u30E9\u30F3\u30B8\u30B7\u30E7\u30F3/\u30A2\u30CB\u30E1\u30FC\u30B7\u30E7\u30F3\u306E\u5B8C\u4E86\u3092\u5F85\u3061\u307E\u3059\u3002"
+    },
+    go: { detail: "\u30CA\u30D3\u30B2\u30FC\u30B7\u30E7\u30F3", documentation: "URL\u307E\u305F\u306F\u30DA\u30FC\u30B8\u4F4D\u7F6E\u306B\u79FB\u52D5\u3057\u307E\u3059\u3002" },
+    throw: { detail: "\u30A8\u30E9\u30FC\u9001\u51FA", documentation: "\u6307\u5B9A\u3055\u308C\u305F\u30E1\u30C3\u30BB\u30FC\u30B8\u3067\u30A8\u30E9\u30FC\u3092\u9001\u51FA\u3057\u307E\u3059\u3002" }
+  },
+  es: {
+    toggle: {
+      detail: "Alternar clase/visibilidad",
+      documentation: "Alterna una clase CSS o atributo en un elemento. Si la clase existe, se elimina; de lo contrario, se agrega."
+    },
+    add: {
+      detail: "Agregar clase/atributo",
+      documentation: "Agrega una clase CSS o atributo a un elemento."
+    },
+    remove: {
+      detail: "Eliminar clase/elemento",
+      documentation: "Elimina una clase CSS, atributo o elemento del DOM."
+    },
+    show: {
+      detail: "Mostrar elemento",
+      documentation: "Hace visible un elemento eliminando display:none."
+    },
+    hide: {
+      detail: "Ocultar elemento",
+      documentation: "Oculta un elemento estableciendo display:none."
+    },
+    put: {
+      detail: "Establecer contenido",
+      documentation: "Establece el contenido de un elemento (innerHTML, textContent o value)."
+    },
+    set: {
+      detail: "Establecer variable",
+      documentation: "Asigna un valor a una variable o propiedad."
+    },
+    get: {
+      detail: "Obtener valor",
+      documentation: "Recupera un valor de una expresion y lo almacena en la variable result."
+    },
+    fetch: {
+      detail: "Solicitud HTTP",
+      documentation: "Realiza una solicitud HTTP (GET, POST, etc.) y almacena la respuesta."
+    },
+    call: {
+      detail: "Llamar funcion",
+      documentation: "Llama a una funcion o metodo de JavaScript."
+    },
+    send: {
+      detail: "Enviar evento",
+      documentation: "Despacha un evento personalizado en un elemento."
+    },
+    trigger: { detail: "Activar evento", documentation: "Activa un evento en un elemento." },
+    wait: {
+      detail: "Retrasar ejecucion",
+      documentation: "Pausa la ejecucion durante un tiempo especificado."
+    },
+    log: {
+      detail: "Registrar en consola",
+      documentation: "Muestra un valor en la consola del navegador."
+    },
+    increment: {
+      detail: "Incrementar valor",
+      documentation: "Aumenta un valor numerico en 1 o una cantidad especificada."
+    },
+    decrement: {
+      detail: "Decrementar valor",
+      documentation: "Disminuye un valor numerico en 1 o una cantidad especificada."
+    },
+    append: {
+      detail: "Agregar contenido",
+      documentation: "Agrega contenido a un elemento o arreglo."
+    },
+    settle: {
+      detail: "Esperar transiciones",
+      documentation: "Espera a que las transiciones/animaciones CSS se completen."
+    },
+    go: { detail: "Navegar", documentation: "Navega a una URL o ubicacion de pagina." },
+    throw: { detail: "Lanzar error", documentation: "Lanza un error con un mensaje especificado." }
+  },
+  zh: {
+    toggle: {
+      detail: "\u5207\u6362\u7C7B/\u53EF\u89C1\u6027",
+      documentation: "\u5207\u6362\u5143\u7D20\u4E0A\u7684CSS\u7C7B\u6216\u5C5E\u6027\u3002\u5982\u679C\u7C7B\u5B58\u5728\u5219\u5220\u9664\uFF0C\u5426\u5219\u6DFB\u52A0\u3002"
+    },
+    add: { detail: "\u6DFB\u52A0\u7C7B/\u5C5E\u6027", documentation: "\u5411\u5143\u7D20\u6DFB\u52A0CSS\u7C7B\u6216\u5C5E\u6027\u3002" },
+    remove: { detail: "\u5220\u9664\u7C7B/\u5143\u7D20", documentation: "\u4ECEDOM\u4E2D\u5220\u9664CSS\u7C7B\u3001\u5C5E\u6027\u6216\u5143\u7D20\u3002" },
+    show: { detail: "\u663E\u793A\u5143\u7D20", documentation: "\u901A\u8FC7\u79FB\u9664display:none\u4F7F\u5143\u7D20\u53EF\u89C1\u3002" },
+    hide: { detail: "\u9690\u85CF\u5143\u7D20", documentation: "\u901A\u8FC7\u8BBE\u7F6Edisplay:none\u9690\u85CF\u5143\u7D20\u3002" },
+    put: { detail: "\u8BBE\u7F6E\u5185\u5BB9", documentation: "\u8BBE\u7F6E\u5143\u7D20\u7684\u5185\u5BB9\uFF08innerHTML\u3001textContent\u6216value\uFF09\u3002" },
+    set: { detail: "\u8BBE\u7F6E\u53D8\u91CF", documentation: "\u5C06\u503C\u8D4B\u7ED9\u53D8\u91CF\u6216\u5C5E\u6027\u3002" },
+    get: { detail: "\u83B7\u53D6\u503C", documentation: "\u4ECE\u8868\u8FBE\u5F0F\u83B7\u53D6\u503C\u5E76\u5B58\u50A8\u5728result\u53D8\u91CF\u4E2D\u3002" },
+    fetch: { detail: "HTTP\u8BF7\u6C42", documentation: "\u53D1\u8D77HTTP\u8BF7\u6C42\uFF08GET\u3001POST\u7B49\uFF09\u5E76\u5B58\u50A8\u54CD\u5E94\u3002" },
+    call: { detail: "\u8C03\u7528\u51FD\u6570", documentation: "\u8C03\u7528JavaScript\u51FD\u6570\u6216\u65B9\u6CD5\u3002" },
+    send: { detail: "\u53D1\u9001\u4E8B\u4EF6", documentation: "\u5728\u5143\u7D20\u4E0A\u6D3E\u53D1\u81EA\u5B9A\u4E49\u4E8B\u4EF6\u3002" },
+    trigger: { detail: "\u89E6\u53D1\u4E8B\u4EF6", documentation: "\u5728\u5143\u7D20\u4E0A\u89E6\u53D1\u4E8B\u4EF6\u3002" },
+    wait: { detail: "\u5EF6\u8FDF\u6267\u884C", documentation: "\u6682\u505C\u6267\u884C\u6307\u5B9A\u7684\u65F6\u95F4\u3002" },
+    log: { detail: "\u63A7\u5236\u53F0\u8F93\u51FA", documentation: "\u5C06\u503C\u8F93\u51FA\u5230\u6D4F\u89C8\u5668\u63A7\u5236\u53F0\u3002" },
+    increment: { detail: "\u9012\u589E\u503C", documentation: "\u5C06\u6570\u503C\u589E\u52A01\u6216\u6307\u5B9A\u91CF\u3002" },
+    decrement: { detail: "\u9012\u51CF\u503C", documentation: "\u5C06\u6570\u503C\u51CF\u5C111\u6216\u6307\u5B9A\u91CF\u3002" },
+    append: { detail: "\u8FFD\u52A0\u5185\u5BB9", documentation: "\u5411\u5143\u7D20\u6216\u6570\u7EC4\u8FFD\u52A0\u5185\u5BB9\u3002" },
+    settle: { detail: "\u7B49\u5F85\u8FC7\u6E21", documentation: "\u7B49\u5F85CSS\u8FC7\u6E21/\u52A8\u753B\u5B8C\u6210\u3002" },
+    go: { detail: "\u5BFC\u822A", documentation: "\u5BFC\u822A\u5230URL\u6216\u9875\u9762\u4F4D\u7F6E\u3002" },
+    throw: { detail: "\u629B\u51FA\u9519\u8BEF", documentation: "\u4F7F\u7528\u6307\u5B9A\u6D88\u606F\u629B\u51FA\u9519\u8BEF\u3002" }
+  },
+  ko: {
+    toggle: {
+      detail: "\uD074\uB798\uC2A4/\uD45C\uC2DC \uC804\uD658",
+      documentation: "\uC694\uC18C\uC758 CSS \uD074\uB798\uC2A4 \uB610\uB294 \uC18D\uC131\uC744 \uC804\uD658\uD569\uB2C8\uB2E4. \uD074\uB798\uC2A4\uAC00 \uC788\uC73C\uBA74 \uC81C\uAC70\uD558\uACE0, \uC5C6\uC73C\uBA74 \uCD94\uAC00\uD569\uB2C8\uB2E4."
+    },
+    add: { detail: "\uD074\uB798\uC2A4/\uC18D\uC131 \uCD94\uAC00", documentation: "\uC694\uC18C\uC5D0 CSS \uD074\uB798\uC2A4 \uB610\uB294 \uC18D\uC131\uC744 \uCD94\uAC00\uD569\uB2C8\uB2E4." },
+    remove: {
+      detail: "\uD074\uB798\uC2A4/\uC694\uC18C \uC81C\uAC70",
+      documentation: "DOM\uC5D0\uC11C CSS \uD074\uB798\uC2A4, \uC18D\uC131 \uB610\uB294 \uC694\uC18C\uB97C \uC81C\uAC70\uD569\uB2C8\uB2E4."
+    },
+    show: { detail: "\uC694\uC18C \uD45C\uC2DC", documentation: "display:none\uC744 \uC81C\uAC70\uD558\uC5EC \uC694\uC18C\uB97C \uD45C\uC2DC\uD569\uB2C8\uB2E4." },
+    hide: { detail: "\uC694\uC18C \uC228\uAE30\uAE30", documentation: "display:none\uC744 \uC124\uC815\uD558\uC5EC \uC694\uC18C\uB97C \uC228\uAE41\uB2C8\uB2E4." },
+    put: {
+      detail: "\uCF58\uD150\uCE20 \uC124\uC815",
+      documentation: "\uC694\uC18C\uC758 \uCF58\uD150\uCE20(innerHTML, textContent \uB610\uB294 value)\uB97C \uC124\uC815\uD569\uB2C8\uB2E4."
+    },
+    set: { detail: "\uBCC0\uC218 \uC124\uC815", documentation: "\uBCC0\uC218 \uB610\uB294 \uC18D\uC131\uC5D0 \uAC12\uC744 \uD560\uB2F9\uD569\uB2C8\uB2E4." },
+    get: {
+      detail: "\uAC12 \uAC00\uC838\uC624\uAE30",
+      documentation: "\uD45C\uD604\uC2DD\uC5D0\uC11C \uAC12\uC744 \uAC00\uC838\uC640 result \uBCC0\uC218\uC5D0 \uC800\uC7A5\uD569\uB2C8\uB2E4."
+    },
+    fetch: {
+      detail: "HTTP \uC694\uCCAD",
+      documentation: "HTTP \uC694\uCCAD(GET, POST \uB4F1)\uC744 \uC2E4\uD589\uD558\uACE0 \uC751\uB2F5\uC744 \uC800\uC7A5\uD569\uB2C8\uB2E4."
+    },
+    call: { detail: "\uD568\uC218 \uD638\uCD9C", documentation: "JavaScript \uD568\uC218 \uB610\uB294 \uBA54\uC11C\uB4DC\uB97C \uD638\uCD9C\uD569\uB2C8\uB2E4." },
+    send: { detail: "\uC774\uBCA4\uD2B8 \uC804\uC1A1", documentation: "\uC694\uC18C\uC5D0 \uCEE4\uC2A4\uD140 \uC774\uBCA4\uD2B8\uB97C \uB514\uC2A4\uD328\uCE58\uD569\uB2C8\uB2E4." },
+    trigger: { detail: "\uC774\uBCA4\uD2B8 \uD2B8\uB9AC\uAC70", documentation: "\uC694\uC18C\uC5D0\uC11C \uC774\uBCA4\uD2B8\uB97C \uD2B8\uB9AC\uAC70\uD569\uB2C8\uB2E4." },
+    wait: { detail: "\uC2E4\uD589 \uC9C0\uC5F0", documentation: "\uC9C0\uC815\uB41C \uC2DC\uAC04 \uB3D9\uC548 \uC2E4\uD589\uC744 \uC77C\uC2DC \uC911\uC9C0\uD569\uB2C8\uB2E4." },
+    log: { detail: "\uCF58\uC194 \uCD9C\uB825", documentation: "\uBE0C\uB77C\uC6B0\uC800 \uCF58\uC194\uC5D0 \uAC12\uC744 \uCD9C\uB825\uD569\uB2C8\uB2E4." },
+    increment: { detail: "\uAC12 \uC99D\uAC00", documentation: "\uC22B\uC790 \uAC12\uC744 1 \uB610\uB294 \uC9C0\uC815\uB41C \uC591\uB9CC\uD07C \uC99D\uAC00\uC2DC\uD0B5\uB2C8\uB2E4." },
+    decrement: { detail: "\uAC12 \uAC10\uC18C", documentation: "\uC22B\uC790 \uAC12\uC744 1 \uB610\uB294 \uC9C0\uC815\uB41C \uC591\uB9CC\uD07C \uAC10\uC18C\uC2DC\uD0B5\uB2C8\uB2E4." },
+    append: { detail: "\uCF58\uD150\uCE20 \uCD94\uAC00", documentation: "\uC694\uC18C \uB610\uB294 \uBC30\uC5F4\uC5D0 \uCF58\uD150\uCE20\uB97C \uCD94\uAC00\uD569\uB2C8\uB2E4." },
+    settle: {
+      detail: "\uD2B8\uB79C\uC9C0\uC158 \uB300\uAE30",
+      documentation: "CSS \uD2B8\uB79C\uC9C0\uC158/\uC560\uB2C8\uBA54\uC774\uC158\uC774 \uC644\uB8CC\uB420 \uB54C\uAE4C\uC9C0 \uB300\uAE30\uD569\uB2C8\uB2E4."
+    },
+    go: { detail: "\uB0B4\uBE44\uAC8C\uC774\uC158", documentation: "URL \uB610\uB294 \uD398\uC774\uC9C0 \uC704\uCE58\uB85C \uC774\uB3D9\uD569\uB2C8\uB2E4." },
+    throw: { detail: "\uC624\uB958 \uBC1C\uC0DD", documentation: "\uC9C0\uC815\uB41C \uBA54\uC2DC\uC9C0\uB85C \uC624\uB958\uB97C \uBC1C\uC0DD\uC2DC\uD0B5\uB2C8\uB2E4." }
+  },
+  ar: {
+    toggle: {
+      detail: "\u062A\u0628\u062F\u064A\u0644 \u0627\u0644\u0641\u0626\u0629/\u0627\u0644\u0631\u0624\u064A\u0629",
+      documentation: "\u064A\u0628\u062F\u0644 \u0641\u0626\u0629 CSS \u0623\u0648 \u0633\u0645\u0629 \u0639\u0644\u0649 \u0639\u0646\u0635\u0631. \u0625\u0630\u0627 \u0643\u0627\u0646\u062A \u0627\u0644\u0641\u0626\u0629 \u0645\u0648\u062C\u0648\u062F\u0629\u060C \u064A\u062A\u0645 \u0625\u0632\u0627\u0644\u062A\u0647\u0627\u061B \u0648\u0625\u0644\u0627\u060C \u064A\u062A\u0645 \u0625\u0636\u0627\u0641\u062A\u0647\u0627."
+    },
+    add: { detail: "\u0625\u0636\u0627\u0641\u0629 \u0641\u0626\u0629/\u0633\u0645\u0629", documentation: "\u064A\u0636\u064A\u0641 \u0641\u0626\u0629 CSS \u0623\u0648 \u0633\u0645\u0629 \u0625\u0644\u0649 \u0639\u0646\u0635\u0631." },
+    remove: { detail: "\u0625\u0632\u0627\u0644\u0629 \u0641\u0626\u0629/\u0639\u0646\u0635\u0631", documentation: "\u064A\u0632\u064A\u0644 \u0641\u0626\u0629 CSS \u0623\u0648 \u0633\u0645\u0629 \u0623\u0648 \u0639\u0646\u0635\u0631 \u0645\u0646 DOM." },
+    show: {
+      detail: "\u0625\u0638\u0647\u0627\u0631 \u0627\u0644\u0639\u0646\u0635\u0631",
+      documentation: "\u064A\u062C\u0639\u0644 \u0627\u0644\u0639\u0646\u0635\u0631 \u0645\u0631\u0626\u064A\u064B\u0627 \u0639\u0646 \u0637\u0631\u064A\u0642 \u0625\u0632\u0627\u0644\u0629 display:none."
+    },
+    hide: { detail: "\u0625\u062E\u0641\u0627\u0621 \u0627\u0644\u0639\u0646\u0635\u0631", documentation: "\u064A\u062E\u0641\u064A \u0627\u0644\u0639\u0646\u0635\u0631 \u0639\u0646 \u0637\u0631\u064A\u0642 \u062A\u0639\u064A\u064A\u0646 display:none." },
+    put: {
+      detail: "\u062A\u0639\u064A\u064A\u0646 \u0627\u0644\u0645\u062D\u062A\u0648\u0649",
+      documentation: "\u064A\u0639\u064A\u0651\u0646 \u0645\u062D\u062A\u0648\u0649 \u0627\u0644\u0639\u0646\u0635\u0631 (innerHTML \u0623\u0648 textContent \u0623\u0648 value)."
+    },
+    set: { detail: "\u062A\u0639\u064A\u064A\u0646 \u0627\u0644\u0645\u062A\u063A\u064A\u0631", documentation: "\u064A\u0639\u064A\u0651\u0646 \u0642\u064A\u0645\u0629 \u0644\u0645\u062A\u063A\u064A\u0631 \u0623\u0648 \u062E\u0627\u0635\u064A\u0629." },
+    get: {
+      detail: "\u0627\u0644\u062D\u0635\u0648\u0644 \u0639\u0644\u0649 \u0642\u064A\u0645\u0629",
+      documentation: "\u064A\u0633\u062A\u0631\u062C\u0639 \u0642\u064A\u0645\u0629 \u0645\u0646 \u062A\u0639\u0628\u064A\u0631 \u0648\u064A\u062E\u0632\u0646\u0647\u0627 \u0641\u064A \u0645\u062A\u063A\u064A\u0631 result."
+    },
+    fetch: { detail: "\u0637\u0644\u0628 HTTP", documentation: "\u064A\u0646\u0641\u0630 \u0637\u0644\u0628 HTTP (GET\u060C POST\u060C \u0625\u0644\u062E) \u0648\u064A\u062E\u0632\u0646 \u0627\u0644\u0627\u0633\u062A\u062C\u0627\u0628\u0629." },
+    call: { detail: "\u0627\u0633\u062A\u062F\u0639\u0627\u0621 \u062F\u0627\u0644\u0629", documentation: "\u064A\u0633\u062A\u062F\u0639\u064A \u062F\u0627\u0644\u0629 \u0623\u0648 \u0637\u0631\u064A\u0642\u0629 JavaScript." },
+    send: { detail: "\u0625\u0631\u0633\u0627\u0644 \u062D\u062F\u062B", documentation: "\u064A\u0631\u0633\u0644 \u062D\u062F\u062B\u064B\u0627 \u0645\u062E\u0635\u0635\u064B\u0627 \u0639\u0644\u0649 \u0639\u0646\u0635\u0631." },
+    trigger: { detail: "\u062A\u0634\u063A\u064A\u0644 \u062D\u062F\u062B", documentation: "\u064A\u0634\u063A\u0644 \u062D\u062F\u062B\u064B\u0627 \u0639\u0644\u0649 \u0639\u0646\u0635\u0631." },
+    wait: { detail: "\u062A\u0623\u062E\u064A\u0631 \u0627\u0644\u062A\u0646\u0641\u064A\u0630", documentation: "\u064A\u0648\u0642\u0641 \u0627\u0644\u062A\u0646\u0641\u064A\u0630 \u0645\u0624\u0642\u062A\u064B\u0627 \u0644\u0645\u062F\u0629 \u0645\u062D\u062F\u062F\u0629." },
+    log: { detail: "\u062A\u0633\u062C\u064A\u0644 \u0641\u064A \u0648\u062D\u062F\u0629 \u0627\u0644\u062A\u062D\u0643\u0645", documentation: "\u064A\u062E\u0631\u062C \u0642\u064A\u0645\u0629 \u0625\u0644\u0649 \u0648\u062D\u062F\u0629 \u062A\u062D\u0643\u0645 \u0627\u0644\u0645\u062A\u0635\u0641\u062D." },
+    increment: { detail: "\u0632\u064A\u0627\u062F\u0629 \u0627\u0644\u0642\u064A\u0645\u0629", documentation: "\u064A\u0632\u064A\u062F \u0642\u064A\u0645\u0629 \u0631\u0642\u0645\u064A\u0629 \u0628\u0645\u0642\u062F\u0627\u0631 1 \u0623\u0648 \u0645\u0642\u062F\u0627\u0631 \u0645\u062D\u062F\u062F." },
+    decrement: { detail: "\u0625\u0646\u0642\u0627\u0635 \u0627\u0644\u0642\u064A\u0645\u0629", documentation: "\u064A\u0646\u0642\u0635 \u0642\u064A\u0645\u0629 \u0631\u0642\u0645\u064A\u0629 \u0628\u0645\u0642\u062F\u0627\u0631 1 \u0623\u0648 \u0645\u0642\u062F\u0627\u0631 \u0645\u062D\u062F\u062F." },
+    append: { detail: "\u0625\u0644\u062D\u0627\u0642 \u0645\u062D\u062A\u0648\u0649", documentation: "\u064A\u0644\u062D\u0642 \u0645\u062D\u062A\u0648\u0649 \u0628\u0639\u0646\u0635\u0631 \u0623\u0648 \u0645\u0635\u0641\u0648\u0641\u0629." },
+    settle: { detail: "\u0627\u0646\u062A\u0638\u0627\u0631 \u0627\u0644\u062A\u062D\u0648\u0644\u0627\u062A", documentation: "\u064A\u0646\u062A\u0638\u0631 \u0627\u0643\u062A\u0645\u0627\u0644 \u062A\u062D\u0648\u0644\u0627\u062A/\u0631\u0633\u0648\u0645 CSS \u0627\u0644\u0645\u062A\u062D\u0631\u0643\u0629." },
+    go: { detail: "\u0627\u0644\u062A\u0646\u0642\u0644", documentation: "\u064A\u0646\u062A\u0642\u0644 \u0625\u0644\u0649 \u0639\u0646\u0648\u0627\u0646 URL \u0623\u0648 \u0645\u0648\u0642\u0639 \u0635\u0641\u062D\u0629." },
+    throw: { detail: "\u0631\u0645\u064A \u062E\u0637\u0623", documentation: "\u064A\u0631\u0645\u064A \u062E\u0637\u0623 \u0628\u0631\u0633\u0627\u0644\u0629 \u0645\u062D\u062F\u062F\u0629." }
+  }
+};
+function getCommandDescription(command, language) {
+  return DESCRIPTIONS[language]?.[command] ?? DESCRIPTIONS.en?.[command];
+}
+
 // src/server.ts
 import * as semanticImport from "@lokascript/semantic";
 var semanticPackage = semanticImport;
@@ -338,8 +1558,9 @@ try {
   parseFunction = core.parse;
   fromCoreASTFn = core.fromCoreAST;
   interchangeLSP = await import("@hyperfixi/core/ast-utils");
+  console.error("[lokascript-ls] @hyperfixi/core loaded \u2014 AST parsing + interchange LSP enabled");
 } catch {
-  console.error("[lokascript-ls] @hyperfixi/core not available");
+  console.error("[lokascript-ls] @hyperfixi/core not available \u2014 diagnostics and hover degraded");
 }
 try {
   lspMetadata = await import("@hyperfixi/core/lsp-metadata");
@@ -348,6 +1569,21 @@ try {
     "[lokascript-ls] @hyperfixi/core/lsp-metadata not available - using fallback keywords"
   );
 }
+var frameworkIR = null;
+try {
+  const fw = await import("./dist-V7SKUZF5.js");
+  frameworkIR = { fromInterchangeNode: fw.fromInterchangeNode, renderExplicit: fw.renderExplicit };
+  console.error(
+    "[lokascript-ls] @lokascript/framework loaded \u2014 LSE bracket notation in hover enabled"
+  );
+} catch {
+  console.error(
+    "[lokascript-ls] @lokascript/framework not available \u2014 hover will omit LSE bracket notation"
+  );
+}
+console.error(
+  `[lokascript-ls] capabilities: core=${!!parseFunction}, interchange=${!!interchangeLSP}, metadata=${!!lspMetadata}, framework=${!!frameworkIR}`
+);
 var FALLBACK_KEYWORDS = [
   "toggle",
   "add",
@@ -717,12 +1953,47 @@ async function getDiagnostics(code, language) {
       });
     }
   }
+  if (diagnostics.length === 0) {
+    try {
+      const chevrotainResult = parseWithRecovery(code);
+      for (const diag of chevrotainResult.diagnostics) {
+        const lines = code.split("\n");
+        const { line: startLine, character: startChar } = offsetToLineChar(code, diag.startOffset);
+        const { line: endLine, character: endChar } = offsetToLineChar(code, diag.endOffset);
+        diagnostics.push({
+          range: {
+            start: { line: startLine, character: startChar },
+            end: { line: endLine, character: endChar }
+          },
+          severity: diag.severity === "error" ? DiagnosticSeverity.Error : diag.severity === "warning" ? DiagnosticSeverity.Warning : DiagnosticSeverity.Information,
+          code: diag.code,
+          source: brand,
+          message: diag.message
+        });
+      }
+    } catch (e) {
+      connection.console.log(`[${brand}-ls] Chevrotain parsing failed: ${e}`);
+    }
+  }
   if (diagnostics.length === 0) {
     const simpleDiagnostics = runSimpleDiagnostics(code, language);
     diagnostics.push(...simpleDiagnostics.map((d) => ({ ...d, source: brand })));
   }
   return diagnostics.slice(0, globalSettings.maxDiagnostics);
 }
+function offsetToLineChar(text, offset) {
+  let line = 0;
+  let col = 0;
+  for (let i = 0; i < offset && i < text.length; i++) {
+    if (text[i] === "\n") {
+      line++;
+      col = 0;
+    } else {
+      col++;
+    }
+  }
+  return { line, character: col };
+}
 function runSimpleDiagnostics(code, _language) {
   const diagnostics = [];
   const lines = code.split("\n");
@@ -790,7 +2061,22 @@ connection.onCompletion((params) => {
     const offset = document.offsetAt(position);
     const beforeCursor = text.slice(0, offset);
     const context = inferContext(beforeCursor);
-    return getContextualCompletions(context, language);
+    const completions = getContextualCompletions(context, language);
+    try {
+      const chevrotainSuggestions = getContentAssist(beforeCursor, offset);
+      const existingLabels = new Set(completions.map((c) => c.label));
+      for (const s of chevrotainSuggestions) {
+        if (existingLabels.has(s.label)) continue;
+        completions.push({
+          label: s.label,
+          kind: s.kind === "command" ? CompletionItemKind.Method : s.kind === "event" ? CompletionItemKind.Event : s.kind === "selector" ? CompletionItemKind.Field : s.kind === "variable" ? CompletionItemKind.Variable : CompletionItemKind.Keyword,
+          detail: s.detail,
+          insertText: s.insertText
+        });
+      }
+    } catch {
+    }
+    return completions;
   }
 });
 function inferContext(beforeCursor) {
@@ -824,6 +2110,10 @@ function getContextualCompletions(context, language) {
   const commandMode = isHyperscriptCompatMode(resolvedMode) ? "hyperscript" : "lokascript";
   const availableCommands = getCommandsForMode(commandMode);
   const isCommandAvailable = (cmd) => availableCommands.includes(cmd);
+  const getDetail = (command, fallback) => {
+    const desc = getCommandDescription(command, effectiveLanguage);
+    return desc?.detail ?? fallback;
+  };
   switch (context) {
     case "event":
       const eventNames = lspMetadata?.EVENT_NAMES ?? FALLBACK_EVENT_NAMES;
@@ -840,55 +2130,71 @@ function getContextualCompletions(context, language) {
         {
           label: getKeyword("toggle"),
           kind: CompletionItemKind.Method,
-          detail: "Toggle class/visibility",
+          detail: getDetail("toggle", "Toggle class/visibility"),
           insertText: `${getKeyword("toggle")} .\${1:class}`
         },
         {
           label: getKeyword("add"),
           kind: CompletionItemKind.Method,
-          detail: "Add class/attribute",
+          detail: getDetail("add", "Add class/attribute"),
           insertText: `${getKeyword("add")} .\${1:class} to \${2:me}`
         },
         {
           label: getKeyword("remove"),
           kind: CompletionItemKind.Method,
-          detail: "Remove class/element",
+          detail: getDetail("remove", "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("show"),
+          kind: CompletionItemKind.Method,
+          detail: getDetail("show", "Show element")
+        },
+        {
+          label: getKeyword("hide"),
+          kind: CompletionItemKind.Method,
+          detail: getDetail("hide", "Hide element")
+        },
         {
           label: getKeyword("put"),
           kind: CompletionItemKind.Method,
-          detail: "Set content",
+          detail: getDetail("put", "Set content"),
           insertText: `${getKeyword("put")} \${1:value} into \${2:target}`
         },
         {
           label: getKeyword("set"),
           kind: CompletionItemKind.Method,
-          detail: "Set variable",
+          detail: getDetail("set", "Set variable"),
           insertText: `${getKeyword("set")} \${1:variable} to \${2:value}`
         },
         {
           label: getKeyword("fetch"),
           kind: CompletionItemKind.Method,
-          detail: "HTTP request",
+          detail: getDetail("fetch", "HTTP request"),
           insertText: `${getKeyword("fetch")} \${1:/api/endpoint}`
         },
         {
           label: getKeyword("wait"),
           kind: CompletionItemKind.Method,
-          detail: "Pause execution",
+          detail: getDetail("wait", "Pause execution"),
           insertText: `${getKeyword("wait")} \${1:1s}`
         },
         {
           label: getKeyword("send"),
           kind: CompletionItemKind.Method,
-          detail: "Dispatch event",
+          detail: getDetail("send", "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("trigger"),
+          kind: CompletionItemKind.Method,
+          detail: getDetail("trigger", "Trigger event")
+        },
+        {
+          label: getKeyword("log"),
+          kind: CompletionItemKind.Method,
+          detail: getDetail("log", "Console log")
+        },
         { label: getKeyword("if"), kind: CompletionItemKind.Keyword, detail: "Conditional" },
         { label: getKeyword("repeat"), kind: CompletionItemKind.Keyword, detail: "Loop" }
       );
@@ -999,8 +2305,14 @@ connection.onHover((params) => {
       if (!currentLine2) return null;
       const word2 = getWordAtPosition(currentLine2, found.localChar);
       if (!word2) return null;
-      const doc2 = getHoverDocumentation(word2.text, globalSettings.language);
+      let doc2 = getHoverDocumentation(word2.text, globalSettings.language);
       if (!doc2) return null;
+      const lse2 = tryGetLSE(found.region.code);
+      if (lse2) {
+        doc2 += `
+
+**LSE:** \`${lse2}\``;
+      }
       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 {
@@ -1016,8 +2328,14 @@ connection.onHover((params) => {
     if (!currentLine) return null;
     const word = getWordAtPosition(currentLine, position.character);
     if (!word) return null;
-    const doc = getHoverDocumentation(word.text, globalSettings.language);
+    let doc = getHoverDocumentation(word.text, globalSettings.language);
     if (!doc) return null;
+    const lse = tryGetLSE(text);
+    if (lse) {
+      doc += `
+
+**LSE:** \`${lse}\``;
+    }
     return {
       contents: { kind: MarkupKind.Markdown, value: doc },
       range: {
@@ -1030,19 +2348,34 @@ connection.onHover((params) => {
     return null;
   }
 });
+function tryGetLSE(code) {
+  if (!interchangeLSP || !parseFunction || !fromCoreASTFn || !frameworkIR) return null;
+  try {
+    const ast = parseFunction(code);
+    if (!ast) return null;
+    const interchange = fromCoreASTFn(ast);
+    if (!interchange) return null;
+    const semanticNode = frameworkIR.fromInterchangeNode(interchange);
+    return frameworkIR.renderExplicit(semanticNode);
+  } catch {
+    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;
+  const localizedDesc = getCommandDescription(canonicalKey, language);
   let content = `**${doc.title}**`;
   if (isMultilingualEnabled(resolvedMode) && wordLower !== canonicalKey) {
     content = `**${word}** (${canonicalKey})`;
   }
+  const description = localizedDesc?.documentation ?? doc.description;
   content += `
 
-${doc.description}`;
+${description}`;
   content += `
 
 \`\`\`hyperscript