luaut-language-server 1.0.0

package/dist/index.cjs

@@ -0,0 +1,774 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Analyzer: () => Analyzer,
+  bindingAt: () => bindingAt,
+  children: () => children,
+  completion: () => completion,
+  containsPosition: () => containsPosition,
+  createServer: () => createServer,
+  definition: () => definition,
+  diagnostics: () => diagnostics,
+  documentSymbols: () => documentSymbols,
+  enclosing: () => enclosing,
+  highlights: () => highlights,
+  hover: () => hover,
+  membersOf: () => membersOf,
+  nodeAt: () => nodeAt,
+  pathAt: () => pathAt,
+  prepareRename: () => prepareRename,
+  references: () => references,
+  rename: () => rename,
+  signatureHelp: () => signatureHelp,
+  signatureLabel: () => signatureLabel,
+  signaturesOf: () => signaturesOf,
+  startServer: () => startServer,
+  toPosition: () => toPosition,
+  toRange: () => toRange,
+  walk: () => walk
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server.ts
+var import_node = require("vscode-languageserver/node");
+var import_vscode_languageserver_textdocument = require("vscode-languageserver-textdocument");
+
+// src/analysis.ts
+var import_luaut_parser = require("luaut-parser");
+function globalsOf(libs) {
+  const names = /* @__PURE__ */ new Set();
+  for (const lib of libs) collect(lib.body.statements, names);
+  return [...names];
+}
+function collect(statements, into) {
+  for (const statement of statements) {
+    if (statement.type === "DeclareStatement") into.add(statement.name);
+  }
+}
+var Analyzer = class {
+  libs;
+  builtinGlobals;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.libs = options.libs ?? import_luaut_parser.defaultLibs;
+    this.builtinGlobals = globalsOf(this.libs);
+  }
+  /** Analyze `document`, reusing the previous result if its version is
+   *  unchanged. */
+  get(document) {
+    const cached = this.cache.get(document.uri);
+    const source = document.getText();
+    if (cached && cached.version === document.version && cached.source === source) return cached;
+    const analysis = this.analyze(document.uri, document.version, source);
+    this.cache.set(document.uri, analysis);
+    return analysis;
+  }
+  /** Analyze source text that is not a tracked document — used by
+   *  completion, which analyzes a speculatively edited copy of the file. */
+  analyze(uri, version, source) {
+    const { program, errors } = (0, import_luaut_parser.parseWithRecovery)(source);
+    const scopes = (0, import_luaut_parser.analyzeScopes)(program, { builtinGlobals: this.builtinGlobals });
+    const types = (0, import_luaut_parser.analyzeTypes)(program, scopes, { libs: this.libs });
+    return { uri, version, source, program, parseErrors: errors, scopes, types };
+  }
+  forget(uri) {
+    this.cache.delete(uri);
+  }
+};
+
+// src/features/diagnostics.ts
+var import_vscode_languageserver = require("vscode-languageserver");
+
+// src/ast-utils.ts
+function isSpanned(v) {
+  if (!v || typeof v !== "object") return false;
+  const n = v;
+  return typeof n.line === "object" && n.line !== null && typeof n.column === "object" && n.column !== null;
+}
+function toRange(node) {
+  return {
+    start: { line: node.line.start - 1, character: node.column.start - 1 },
+    end: { line: node.line.end - 1, character: node.column.end - 1 }
+  };
+}
+function toPosition(line, column) {
+  return { line: line - 1, character: column - 1 };
+}
+function containsPosition(node, pos, inclusive = false) {
+  const startLine = node.line.start - 1;
+  const endLine = node.line.end - 1;
+  if (pos.line < startLine || pos.line > endLine) return false;
+  if (pos.line === startLine && pos.character < node.column.start - 1) return false;
+  if (pos.line === endLine) {
+    const end = node.column.end - 1;
+    if (inclusive ? pos.character > end : pos.character >= end) return false;
+  }
+  return true;
+}
+function children(node) {
+  const out = [];
+  for (const key of Object.keys(node)) {
+    if (key === "line" || key === "column") continue;
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (isSpanned(item)) out.push(item);
+    } else if (isSpanned(value)) {
+      out.push(value);
+    }
+  }
+  return out;
+}
+function pathAt(root, pos, inclusive = false) {
+  let best;
+  const descend = (node, ancestors) => {
+    const here = [...ancestors, node];
+    if (containsPosition(node, pos, inclusive)) {
+      const incumbent = best?.[best.length - 1];
+      if (!incumbent || spanLength(node) < spanLength(incumbent) || spanLength(node) === spanLength(incumbent) && here.length > best.length) {
+        best = here;
+      }
+    }
+    for (const child of children(node)) descend(child, here);
+  };
+  descend(root, []);
+  return best ?? [];
+}
+function nodeAt(root, pos, inclusive = false) {
+  const path = pathAt(root, pos, inclusive);
+  return path[path.length - 1];
+}
+function enclosing(root, pos, types, inclusive = false) {
+  const path = pathAt(root, pos, inclusive);
+  for (let i = path.length - 1; i >= 0; i--) {
+    if (path[i].type && types.includes(path[i].type)) return path[i];
+  }
+  return void 0;
+}
+function spanLength(node) {
+  return (node.line.end - node.line.start) * 1e4 + (node.column.end - node.column.start);
+}
+function walk(root, visit, parent) {
+  visit(root, parent);
+  for (const child of children(root)) walk(child, visit, root);
+}
+
+// src/features/diagnostics.ts
+function diagnostics(analysis) {
+  const out = [];
+  for (const error of analysis.parseErrors) {
+    const start = toPosition(error.line, error.column);
+    out.push({
+      range: { start, end: { line: start.line, character: start.character + 1 } },
+      severity: import_vscode_languageserver.DiagnosticSeverity.Error,
+      source: "luaut",
+      code: "syntax",
+      // The parser appends `(line:column)`; the range already says that.
+      message: error.message.replace(/\s*\(\d+:\d+\)$/, "")
+    });
+  }
+  for (const d of analysis.scopes.diagnostics) {
+    out.push({
+      range: toRange(d.node),
+      severity: import_vscode_languageserver.DiagnosticSeverity.Error,
+      source: "luaut",
+      code: d.kind,
+      message: d.message
+    });
+  }
+  for (const d of analysis.types.diagnostics) {
+    out.push({
+      range: toRange(d.node),
+      severity: import_vscode_languageserver.DiagnosticSeverity.Error,
+      source: "luaut",
+      code: "type",
+      message: d.message
+    });
+  }
+  return out;
+}
+
+// src/features/hover.ts
+var import_luaut_parser2 = require("luaut-parser");
+function hover(analysis, position) {
+  const path = pathAt(analysis.program, position, true);
+  for (let i = path.length - 1; i >= 0; i--) {
+    const node = path[i];
+    const found = describe(analysis, node, path[i - 1]);
+    if (found) return { contents: { kind: "markdown", value: code(found) }, range: toRange(node) };
+  }
+  return null;
+}
+function describe(analysis, node, parent) {
+  const { types, scopes } = analysis;
+  if (node.type === "TypeAliasStatement" || node.type === "ExportTypeAliasStatement") {
+    const name = node.name;
+    const alias = types.aliases.get(name);
+    if (alias) return `type ${name} = ${(0, import_luaut_parser2.formatType)(alias)}`;
+  }
+  if (node.type === "Identifier") {
+    const identifier = node;
+    const narrowed = types.narrowedTypeOf.get(identifier);
+    if (narrowed) return `${identifier.name}: ${(0, import_luaut_parser2.formatType)(narrowed)}`;
+    const binding = (0, import_luaut_parser2.getBinding)(scopes, identifier);
+    if (binding) {
+      const type2 = types.bindingType.get(binding.id);
+      if (type2) return `${keyword(binding)} ${binding.name}: ${(0, import_luaut_parser2.formatType)(type2)}`;
+    }
+    if (parent && (parent.type === "MemberExpression" || parent.type === "MethodCallExpression")) {
+      const type2 = types.typeOf.get(parent);
+      if (type2) return `${identifier.name}: ${(0, import_luaut_parser2.formatType)(type2)}`;
+    }
+  }
+  if (node.type === "IdentifierPattern") {
+    const binding = (0, import_luaut_parser2.getBinding)(scopes, node);
+    if (binding) {
+      const type2 = types.bindingType.get(binding.id);
+      if (type2) return `${keyword(binding)} ${binding.name}: ${(0, import_luaut_parser2.formatType)(type2)}`;
+    }
+  }
+  const type = types.typeOf.get(node);
+  return type ? (0, import_luaut_parser2.formatType)(type) : void 0;
+}
+function keyword(binding) {
+  if (binding.kind === "param" || binding.kind === "self") return "(parameter)";
+  if (binding.kind === "global") return "(global)";
+  if (binding.kind.startsWith("for-")) return "(loop variable)";
+  return binding.isConst ? "const" : "let";
+}
+function code(text) {
+  return "```luaut\n" + text + "\n```";
+}
+
+// src/features/navigation.ts
+var import_vscode_languageserver2 = require("vscode-languageserver");
+var import_luaut_parser3 = require("luaut-parser");
+function bindingAt(analysis, position) {
+  const path = pathAt(analysis.program, position, true);
+  for (let i = path.length - 1; i >= 0; i--) {
+    const node = path[i];
+    if (node.type !== "Identifier" && node.type !== "IdentifierPattern") continue;
+    const binding = (0, import_luaut_parser3.getBinding)(analysis.scopes, node);
+    if (binding) return binding;
+  }
+  return void 0;
+}
+function sites(binding) {
+  const out = [];
+  if (binding.declarationNode) out.push(binding.declarationNode);
+  out.push(...binding.references);
+  return out;
+}
+function definition(analysis, position) {
+  const binding = bindingAt(analysis, position);
+  if (!binding?.declarationNode) return null;
+  return { uri: analysis.uri, range: toRange(binding.declarationNode) };
+}
+function references(analysis, position, includeDeclaration) {
+  const binding = bindingAt(analysis, position);
+  if (!binding) return [];
+  const nodes = includeDeclaration ? sites(binding) : binding.references;
+  return nodes.map((node) => ({ uri: analysis.uri, range: toRange(node) }));
+}
+function highlights(analysis, position) {
+  const binding = bindingAt(analysis, position);
+  if (!binding) return [];
+  return sites(binding).map((node) => ({
+    range: toRange(node),
+    kind: node === binding.declarationNode ? import_vscode_languageserver2.DocumentHighlightKind.Write : import_vscode_languageserver2.DocumentHighlightKind.Read
+  }));
+}
+function prepareRename(analysis, position) {
+  const binding = bindingAt(analysis, position);
+  if (!binding) return null;
+  if (binding.isBuiltin || !binding.declarationNode) return null;
+  const path = pathAt(analysis.program, position, true);
+  const identifier = [...path].reverse().find((n) => n.type === "Identifier" || n.type === "IdentifierPattern");
+  if (!identifier) return null;
+  return { range: toRange(identifier), placeholder: binding.name };
+}
+function rename(analysis, position, newName) {
+  if (!isIdentifier(newName)) return null;
+  const binding = bindingAt(analysis, position);
+  if (!binding || binding.isBuiltin || !binding.declarationNode) return null;
+  const edits = sites(binding).map((node) => ({ range: toRange(node), newText: newName }));
+  return { changes: { [analysis.uri]: edits } };
+}
+var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isIdentifier(name) {
+  return IDENTIFIER.test(name);
+}
+
+// src/features/completion.ts
+var import_vscode_languageserver3 = require("vscode-languageserver");
+var import_luaut_parser5 = require("luaut-parser");
+
+// src/features/members.ts
+var import_luaut_parser4 = require("luaut-parser");
+function membersOf(type, aliases, seen = /* @__PURE__ */ new Set()) {
+  if (!type || seen.has(type)) return [];
+  seen.add(type);
+  switch (type.kind) {
+    case "object": {
+      const out = [];
+      for (const [name, property] of type.properties) {
+        out.push({ name, property, isMethod: takesSelf(property.type) });
+      }
+      return out;
+    }
+    case "intersection": {
+      const merged = /* @__PURE__ */ new Map();
+      for (const part of type.types) {
+        for (const member of membersOf(part, aliases, seen)) merged.set(member.name, member);
+      }
+      return [...merged.values()];
+    }
+    case "union": {
+      const perBranch = type.types.map((part) => membersOf(part, aliases, seen));
+      if (!perBranch.length) return [];
+      const [first, ...rest] = perBranch;
+      return first.filter((member) => rest.every((other) => other.some((m) => m.name === member.name)));
+    }
+    case "genericRef": {
+      const alias = aliases.get(type.name);
+      return alias ? membersOf(alias, aliases, seen) : [];
+    }
+    case "typeParam":
+      return membersOf(type.constraint, aliases, seen);
+    default:
+      return [];
+  }
+}
+function takesSelf(type) {
+  for (const signature of signaturesOf(type)) {
+    if (signature.params[0]?.name === "self") return true;
+  }
+  return false;
+}
+function signaturesOf(type, aliases) {
+  if (!type) return [];
+  if (type.kind === "function") return [type];
+  if (type.kind === "intersection") return type.types.flatMap((t) => signaturesOf(t, aliases));
+  if (type.kind === "genericRef" && aliases) {
+    const alias = aliases.get(type.name);
+    return alias ? signaturesOf(alias, aliases) : [];
+  }
+  return [];
+}
+function signatureLabel(signature) {
+  const parameters = signature.params.map((p, i) => {
+    const name = p.name ?? `arg${i + 1}`;
+    return `${name}${p.optional ? "?" : ""}: ${(0, import_luaut_parser4.formatType)(p.type)}`;
+  });
+  const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
+  const varargs = signature.varargs ? [`...: ${(0, import_luaut_parser4.formatType)(signature.varargs)}`] : [];
+  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${(0, import_luaut_parser4.formatType)(signature.returns)}`;
+  return { label, parameters };
+}
+
+// src/features/completion.ts
+var PLACEHOLDER = "__luautCompletion__";
+var IDENTIFIER_CHAR = /[A-Za-z0-9_]/;
+function completion(analyzer, document, position) {
+  const source = document.getText();
+  const offset = document.offsetAt(position);
+  let start = offset;
+  while (start > 0 && IDENTIFIER_CHAR.test(source[start - 1])) start--;
+  let end = offset;
+  while (end < source.length && IDENTIFIER_CHAR.test(source[end])) end++;
+  const afterColon = source[start - 1] === ":";
+  const alreadyCalled = /^\s*\(/.test(source.slice(end));
+  const stand_in = afterColon && !alreadyCalled ? `${PLACEHOLDER}()` : PLACEHOLDER;
+  const patched = source.slice(0, start) + stand_in + source.slice(end);
+  const analysis = analyzer.analyze(document.uri, -1, patched);
+  const at = { line: position.line, character: position.character - (offset - start) };
+  const path = pathAt(analysis.program, at, true);
+  const placeholder = [...path].reverse().find(
+    (n) => n.type === "Identifier" && n.name === PLACEHOLDER
+  );
+  const parent = placeholder ? path[path.indexOf(placeholder) - 1] : path[path.length - 1];
+  if (parent && (parent.type === "MemberExpression" || parent.type === "MethodCallExpression")) {
+    const object = parent.object;
+    const type = analysis.types.typeOf.get(object);
+    const wantMethods = parent.type === "MethodCallExpression";
+    return membersOf(type, analysis.types.aliases).filter((member) => wantMethods ? member.isMethod : true).map((member) => memberItem(member.name, member.property.type, member.property.readonly));
+  }
+  if (inTypePosition(path)) {
+    const named = [...analysis.types.aliases.keys()].map((name) => ({
+      label: name,
+      kind: import_vscode_languageserver3.CompletionItemKind.Interface,
+      detail: "type"
+    }));
+    const primitives = PRIMITIVES.map((name) => ({
+      label: name,
+      kind: import_vscode_languageserver3.CompletionItemKind.Keyword,
+      detail: "type"
+    }));
+    return [...named, ...primitives];
+  }
+  return valueItems(analysis, at);
+}
+function valueItems(analysis, at) {
+  const items = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const binding of analysis.scopes.bindings.values()) {
+    if (binding.name === PLACEHOLDER || seen.has(binding.name)) continue;
+    const declaration = binding.declarationNode;
+    if (declaration && declaration.line.start - 1 > at.line) continue;
+    seen.add(binding.name);
+    const type = analysis.types.bindingType.get(binding.id);
+    items.push({
+      label: binding.name,
+      kind: kindOf(type, binding.kind),
+      detail: type ? (0, import_luaut_parser5.formatType)(type) : void 0,
+      // Locals before globals, and globals before library names.
+      sortText: `${binding.isBuiltin ? 2 : binding.kind === "global" ? 1 : 0}${binding.name}`
+    });
+  }
+  for (const keyword2 of KEYWORDS) {
+    items.push({ label: keyword2, kind: import_vscode_languageserver3.CompletionItemKind.Keyword, sortText: `3${keyword2}` });
+  }
+  return items;
+}
+function memberItem(name, type, readonly) {
+  const signatures = signaturesOf(type);
+  if (signatures.length) {
+    return {
+      label: name,
+      kind: import_vscode_languageserver3.CompletionItemKind.Method,
+      detail: signatureLabel(signatures[0]).label,
+      insertText: `${name}($0)`,
+      insertTextFormat: import_vscode_languageserver3.InsertTextFormat.Snippet
+    };
+  }
+  return {
+    label: name,
+    kind: import_vscode_languageserver3.CompletionItemKind.Field,
+    detail: `${readonly ? "readonly " : ""}${(0, import_luaut_parser5.formatType)(type)}`
+  };
+}
+function kindOf(type, bindingKind) {
+  if (type && signaturesOf(type).length) return import_vscode_languageserver3.CompletionItemKind.Function;
+  if (bindingKind === "param" || bindingKind === "self") return import_vscode_languageserver3.CompletionItemKind.Variable;
+  return import_vscode_languageserver3.CompletionItemKind.Variable;
+}
+function inTypePosition(path) {
+  return path.some(
+    (n) => !!n.type && (n.type.endsWith("TypeNode") || n.type === "TypeReference" || n.type === "TypeAliasStatement" || n.type === "ExportTypeAliasStatement")
+  );
+}
+var PRIMITIVES = [
+  "any",
+  "unknown",
+  "never",
+  "nil",
+  "boolean",
+  "number",
+  "string",
+  "thread",
+  "buffer"
+];
+var KEYWORDS = [
+  "const",
+  "let",
+  "function",
+  "return",
+  "if",
+  "then",
+  "elseif",
+  "else",
+  "end",
+  "for",
+  "in",
+  "while",
+  "do",
+  "repeat",
+  "until",
+  "break",
+  "continue",
+  "type",
+  "declare",
+  "export",
+  "import",
+  "and",
+  "or",
+  "not",
+  "true",
+  "false",
+  "nil"
+];
+
+// src/features/signatureHelp.ts
+function signatureHelp(analyzer, document, position) {
+  const source = document.getText();
+  const offset = document.offsetAt(position);
+  for (const repair of ["", "nil", "nil)", ")"]) {
+    const text = source.slice(0, offset) + repair + source.slice(offset);
+    const analysis = analyzer.analyze(document.uri, -1, text);
+    const found = helpAt(analysis, position);
+    if (found) return found;
+  }
+  return null;
+}
+function helpAt(analysis, position) {
+  const path = pathAt(analysis.program, position, true);
+  const call = [...path].reverse().find(
+    (n) => n.type === "CallExpression" || n.type === "MethodCallExpression"
+  );
+  if (!call) return null;
+  const callee = call.type === "CallExpression" ? call.callee : call;
+  const calleeType = call.type === "CallExpression" ? analysis.types.typeOf.get(callee) : methodType(analysis, call);
+  const signatures = signaturesOf(calleeType, analysis.types.aliases);
+  if (!signatures.length) return null;
+  const selfOffset = call.type === "MethodCallExpression" ? 1 : 0;
+  const written = activeArgument(call, position);
+  const infos = signatures.map((signature) => {
+    const { label, parameters } = signatureLabel(signature);
+    return { label, parameters: parameters.map((p) => ({ label: p })) };
+  });
+  const wanted = written + selfOffset + 1;
+  let active = signatures.findIndex((s) => s.params.length >= wanted || s.varargs);
+  if (active < 0) active = 0;
+  return {
+    signatures: infos,
+    activeSignature: active,
+    activeParameter: Math.min(
+      written + selfOffset,
+      Math.max(0, signatures[active].params.length - 1)
+    )
+  };
+}
+function methodType(analysis, call) {
+  const object = call.object;
+  const method = call.method;
+  const objectType = analysis.types.typeOf.get(object);
+  if (!objectType) return void 0;
+  return memberType(objectType, method.name, analysis);
+}
+function memberType(type, name, analysis) {
+  if (type.kind === "object") return type.properties.get(name)?.type;
+  if (type.kind === "intersection") {
+    for (const part of type.types) {
+      const found = memberType(part, name, analysis);
+      if (found) return found;
+    }
+  }
+  if (type.kind === "genericRef") {
+    const alias = analysis.types.aliases.get(type.name);
+    if (alias) return memberType(alias, name, analysis);
+  }
+  return void 0;
+}
+function activeArgument(call, position) {
+  const args = call.arguments;
+  for (let i = 0; i < args.length; i++) {
+    if (containsPosition(args[i], position, true)) return i;
+  }
+  let count = 0;
+  for (const arg of args) {
+    const before = arg.line.end - 1 < position.line || arg.line.end - 1 === position.line && arg.column.end - 1 <= position.character;
+    if (before) count++;
+  }
+  return count;
+}
+
+// src/features/symbols.ts
+var import_vscode_languageserver4 = require("vscode-languageserver");
+var import_luaut_parser6 = require("luaut-parser");
+function documentSymbols(analysis) {
+  const out = [];
+  walk(analysis.program, (node) => {
+    switch (node.type) {
+      case "FunctionDeclaration":
+      case "FunctionDeclarationStatement": {
+        const name = functionName(node);
+        if (name) out.push(symbol(name, import_vscode_languageserver4.SymbolKind.Function, node, detailOf(analysis, node)));
+        break;
+      }
+      case "TypeAliasStatement":
+      case "ExportTypeAliasStatement": {
+        const named = node.name;
+        const name = typeof named === "string" ? named : named?.name;
+        if (name) {
+          const alias = analysis.types.aliases.get(name);
+          out.push(symbol(name, import_vscode_languageserver4.SymbolKind.Interface, node, alias ? (0, import_luaut_parser6.formatType)(alias) : void 0));
+        }
+        break;
+      }
+      case "VariableDeclaration": {
+        for (const target of node.names ?? []) {
+          const name = target.name;
+          if (name) out.push(symbol(name, import_vscode_languageserver4.SymbolKind.Variable, target));
+        }
+        break;
+      }
+    }
+  });
+  return out;
+}
+function functionName(node) {
+  const named = node;
+  if (typeof named.name === "string") return named.name;
+  if (named.name && typeof named.name === "object") return named.name.name;
+  if (named.target?.base?.name) {
+    const path = (named.target.path ?? []).map((p) => p.name).filter(Boolean);
+    const dotted = [named.target.base.name, ...path].join(".");
+    return named.target.method ? `${dotted}:${named.target.method.name}` : dotted;
+  }
+  return void 0;
+}
+function detailOf(analysis, node) {
+  const name = node.name;
+  if (name && typeof name === "object") {
+    const binding = (0, import_luaut_parser6.getBinding)(analysis.scopes, name);
+    const type = binding && analysis.types.bindingType.get(binding.id);
+    if (type) return (0, import_luaut_parser6.formatType)(type);
+  }
+  return void 0;
+}
+function symbol(name, kind, node, detail) {
+  const range = toRange(node);
+  return { name, kind, detail, range, selectionRange: range };
+}
+
+// src/server.ts
+function createServer(connection, options = {}) {
+  const analyzer = new Analyzer(options);
+  const documents = new import_node.TextDocuments(import_vscode_languageserver_textdocument.TextDocument);
+  connection.onInitialize((_params) => ({
+    capabilities: {
+      textDocumentSync: import_node.TextDocumentSyncKind.Incremental,
+      hoverProvider: true,
+      definitionProvider: true,
+      referencesProvider: true,
+      documentHighlightProvider: true,
+      documentSymbolProvider: true,
+      renameProvider: { prepareProvider: true },
+      completionProvider: {
+        // `.` and `:` open a member list; the rest of the time
+        // completion is asked for as you type a word.
+        triggerCharacters: [".", ":"],
+        resolveProvider: false
+      },
+      signatureHelpProvider: { triggerCharacters: ["(", ","], retriggerCharacters: [","] }
+    },
+    serverInfo: { name: "luaut-language-server" }
+  }));
+  const publish = (document) => {
+    void connection.sendDiagnostics({
+      uri: document.uri,
+      version: document.version,
+      diagnostics: diagnostics(analyzer.get(document))
+    });
+  };
+  documents.onDidOpen((e) => publish(e.document));
+  documents.onDidChangeContent((e) => publish(e.document));
+  documents.onDidClose((e) => {
+    analyzer.forget(e.document.uri);
+    void connection.sendDiagnostics({ uri: e.document.uri, diagnostics: [] });
+  });
+  const withDocument = (uri, f, fallback) => {
+    const document = documents.get(uri);
+    return document ? f(document) : fallback;
+  };
+  connection.onHover((p) => withDocument(
+    p.textDocument.uri,
+    (d) => hover(analyzer.get(d), p.position),
+    null
+  ));
+  connection.onDefinition((p) => withDocument(
+    p.textDocument.uri,
+    (d) => definition(analyzer.get(d), p.position),
+    null
+  ));
+  connection.onReferences((p) => withDocument(
+    p.textDocument.uri,
+    (d) => references(analyzer.get(d), p.position, p.context.includeDeclaration),
+    []
+  ));
+  connection.onDocumentHighlight((p) => withDocument(
+    p.textDocument.uri,
+    (d) => highlights(analyzer.get(d), p.position),
+    []
+  ));
+  connection.onDocumentSymbol((p) => withDocument(
+    p.textDocument.uri,
+    (d) => documentSymbols(analyzer.get(d)),
+    []
+  ));
+  connection.onPrepareRename((p) => withDocument(
+    p.textDocument.uri,
+    (d) => {
+      const prepared = prepareRename(analyzer.get(d), p.position);
+      return prepared ? { range: prepared.range, placeholder: prepared.placeholder } : null;
+    },
+    null
+  ));
+  connection.onRenameRequest((p) => withDocument(
+    p.textDocument.uri,
+    (d) => rename(analyzer.get(d), p.position, p.newName),
+    null
+  ));
+  connection.onCompletion((p) => withDocument(
+    p.textDocument.uri,
+    (d) => completion(analyzer, d, p.position),
+    []
+  ));
+  connection.onSignatureHelp((p) => withDocument(
+    p.textDocument.uri,
+    (d) => signatureHelp(analyzer, d, p.position),
+    null
+  ));
+  documents.listen(connection);
+  connection.listen();
+}
+function startServer(options = {}) {
+  createServer((0, import_node.createConnection)(import_node.ProposedFeatures.all), options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Analyzer,
+  bindingAt,
+  children,
+  completion,
+  containsPosition,
+  createServer,
+  definition,
+  diagnostics,
+  documentSymbols,
+  enclosing,
+  highlights,
+  hover,
+  membersOf,
+  nodeAt,
+  pathAt,
+  prepareRename,
+  references,
+  rename,
+  signatureHelp,
+  signatureLabel,
+  signaturesOf,
+  startServer,
+  toPosition,
+  toRange,
+  walk
+});
+//# sourceMappingURL=index.cjs.map