luaut-language-server 1.0.0 → 1.1.0

package/dist/chunk-HK7PKBDB.js

@@ -0,0 +1,1535 @@
+// src/analysis.ts
+import { readFileSync, statSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import {
+  parseWithRecovery,
+  analyzeScopes,
+  analyzeTypes,
+  moduleExports,
+  defaultLibs,
+  getBinding
+} from "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);
+  }
+}
+function bindingOfNode(analysis, node) {
+  const used = getBinding(analysis.scopes, node);
+  if (used) return used;
+  return declarationIndex(analysis).get(node);
+}
+var declarationIndexes = /* @__PURE__ */ new WeakMap();
+function declarationIndex(analysis) {
+  let index = declarationIndexes.get(analysis);
+  if (!index) {
+    index = /* @__PURE__ */ new Map();
+    for (const binding of analysis.scopes.bindings.values()) {
+      if (binding.declarationNode) index.set(binding.declarationNode, binding);
+    }
+    declarationIndexes.set(analysis, index);
+  }
+  return index;
+}
+function pathOfUri(uri) {
+  if (!uri.startsWith("file:")) return void 0;
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return void 0;
+  }
+}
+function uriOfPath(path) {
+  return pathToFileURL(path).href;
+}
+function samePath(a, b) {
+  return pathKey(a) === pathKey(b);
+}
+function pathKey(path) {
+  const normalized = resolve(path);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+var CYCLE = { values: /* @__PURE__ */ new Map(), types: /* @__PURE__ */ new Map(), partial: true };
+var Analyzer = class {
+  libs;
+  builtinGlobals;
+  openDocument;
+  cache = /* @__PURE__ */ new Map();
+  /** Imported modules, by path key. */
+  modules = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.libs = options.libs ?? defaultLibs;
+    this.builtinGlobals = globalsOf(this.libs);
+    this.openDocument = options.openDocument;
+  }
+  /** Analyze `document`, reusing the previous result while neither it nor
+   *  anything it imports has changed. */
+  get(document) {
+    const cached = this.cache.get(document.uri);
+    const source = document.getText();
+    if (cached && cached.version === document.version && cached.source === source && this.isFresh(cached)) {
+      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 path = pathOfUri(uri);
+    return this.analyzeModule(uri, version, source, new Set(path ? [pathKey(path)] : []));
+  }
+  forget(uri) {
+    this.cache.delete(uri);
+  }
+  /** The file an import in `fromUri` names. Relative paths only (`./x`,
+   *  `../x`); the extension may be left off, and a folder means its
+   *  `index.luaut`. */
+  resolveModulePath(fromUri, specifier) {
+    return this.moduleCandidates(fromUri, specifier).find((candidate) => this.sourceOf(candidate) !== void 0);
+  }
+  /** Every file an import could mean, in the order they are tried. */
+  moduleCandidates(fromUri, specifier) {
+    const from = pathOfUri(fromUri);
+    if (!from || !(specifier.startsWith("./") || specifier.startsWith("../"))) return [];
+    const base = resolve(dirname(from), specifier);
+    return specifier.endsWith(".luaut") ? [base] : [`${base}.luaut`, `${base}.d.luaut`, join(base, "index.luaut")];
+  }
+  /** What the module at `path` exports, analyzing it if need be. */
+  exportsAt(path) {
+    return this.exportsOf(path, /* @__PURE__ */ new Set());
+  }
+  /** The analysis of the module at `path`, analyzing it if need be. */
+  moduleAt(path) {
+    this.exportsOf(path, /* @__PURE__ */ new Set());
+    return this.modules.get(pathKey(path))?.analysis;
+  }
+  sourceOf(path) {
+    const open = this.openDocument?.(path);
+    if (open) return open.getText();
+    try {
+      return statSync(path).isFile() ? readFileSync(path, "utf8") : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /** `importing` holds every module on the current import chain, so an
+   *  import back into one of them is recognized as a cycle. */
+  analyzeModule(uri, version, source, importing) {
+    const { program, errors } = parseWithRecovery(source);
+    const scopes = analyzeScopes(program, { builtinGlobals: this.builtinGlobals });
+    const dependencies = /* @__PURE__ */ new Map();
+    const types = analyzeTypes(program, scopes, {
+      libs: this.libs,
+      resolveModule: (specifier) => {
+        const target = this.resolveModulePath(uri, specifier);
+        if (!target) {
+          for (const candidate of this.moduleCandidates(uri, specifier)) dependencies.set(candidate, void 0);
+          return void 0;
+        }
+        const exports = this.exportsOf(target, importing);
+        dependencies.set(target, this.sourceOf(target));
+        return exports;
+      }
+    });
+    return { uri, version, source, program, parseErrors: errors, scopes, types, dependencies };
+  }
+  exportsOf(path, importing) {
+    const key = pathKey(path);
+    if (importing.has(key)) return CYCLE;
+    const source = this.sourceOf(path);
+    if (source === void 0) return void 0;
+    const cached = this.modules.get(key);
+    if (cached && cached.analysis.source === source && this.isFresh(cached.analysis)) return cached.exports;
+    importing.add(key);
+    try {
+      const analysis = this.analyzeModule(uriOfPath(path), -1, source, importing);
+      const exports = moduleExports(analysis.program, analysis.scopes, analysis.types, (specifier) => {
+        const next = this.resolveModulePath(analysis.uri, specifier);
+        return next ? this.exportsOf(next, importing) : void 0;
+      });
+      this.modules.set(key, { analysis, exports });
+      return exports;
+    } finally {
+      importing.delete(key);
+    }
+  }
+  /** Does every module `analysis` imported — and everything those import —
+   *  still have the text it was analyzed against? */
+  isFresh(analysis, seen = /* @__PURE__ */ new Set()) {
+    if (seen.has(analysis)) return true;
+    seen.add(analysis);
+    for (const [path, source] of analysis.dependencies) {
+      if (this.sourceOf(path) !== source) return false;
+      const module = this.modules.get(pathKey(path));
+      if (module && !this.isFresh(module.analysis, seen)) return false;
+    }
+    return true;
+  }
+};
+
+// 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 = [];
+  collect2(node, out);
+  return out;
+}
+function collect2(container, out) {
+  for (const key of Object.keys(container)) {
+    if (key === "line" || key === "column") continue;
+    const value = container[key];
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (isSpanned(item)) out.push(item);
+      else if (isSpanlessNode(item)) collect2(item, out);
+    }
+  }
+}
+function isSpanlessNode(v) {
+  return !!v && typeof v === "object" && typeof v.type === "string";
+}
+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/members.ts
+import { formatType } from "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 ? "?" : ""}: ${formatType(p.type)}`;
+  });
+  const generics = signature.typeParams?.length ? `<${signature.typeParams.join(", ")}>` : "";
+  const varargs = signature.varargs ? [`...: ${formatType(signature.varargs)}`] : [];
+  const label = `${generics}(${[...parameters, ...varargs].join(", ")}) -> ${formatType(signature.returns)}`;
+  return { label, parameters };
+}
+
+// src/features/imports.ts
+import { readdirSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import {
+  CompletionItemKind
+} from "vscode-languageserver";
+import {
+  formatType as formatType2
+} from "luaut-parser";
+var SUGGEST_AGAIN = { title: "Suggest", command: "editor.action.triggerSuggest" };
+function importCompletion(analyzer, document, position) {
+  const text = document.getText();
+  const cursor = document.offsetAt(position);
+  const lineStart = document.offsetAt({ line: position.line, character: 0 });
+  const lineEnd = document.offsetAt({ line: position.line + 1, character: 0 });
+  const before = text.slice(lineStart, cursor);
+  const after = text.slice(cursor, lineEnd);
+  if (!/^\s*(?:import|export)\b/.test(before)) return void 0;
+  const path = /\bfrom\s*(["'])([^"']*)$/.exec(before);
+  if (path) return pathItems(document.uri, position, path[2]);
+  const braces = /^\s*(import|export)\s+(?:[A-Za-z_][A-Za-z0-9_]*\s*,\s*)?\{[^}]*$/.exec(before);
+  if (braces) {
+    const module = /\}\s*from\s*(["'])([^"']+)\1/.exec(after);
+    if (module) return nameItems(analyzer, document.uri, module[2], before);
+    return braces[1] === "import" ? [] : void 0;
+  }
+  return void 0;
+}
+function pathItems(fromUri, position, typed) {
+  const from = pathOfUri(fromUri);
+  if (!from) return [];
+  if (!typed.startsWith("./") && !typed.startsWith("../")) {
+    const range2 = rangeBack(position, typed.length);
+    return ["./", "../"].map((label) => ({
+      label,
+      kind: CompletionItemKind.Folder,
+      textEdit: { range: range2, newText: label },
+      command: SUGGEST_AGAIN
+    }));
+  }
+  const slash = typed.lastIndexOf("/");
+  const directory = resolve2(dirname2(from), typed.slice(0, slash + 1));
+  const range = rangeBack(position, typed.length - slash - 1);
+  let entries;
+  try {
+    entries = readdirSync(directory, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const items = [];
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    if (entry.isDirectory()) {
+      items.push({
+        label: `${entry.name}/`,
+        kind: CompletionItemKind.Folder,
+        textEdit: { range, newText: `${entry.name}/` },
+        command: SUGGEST_AGAIN
+      });
+    } else if (entry.name.endsWith(".luaut")) {
+      if (samePath(resolve2(directory, entry.name), from)) continue;
+      const name = entry.name.replace(/(\.d)?\.luaut$/, "");
+      items.push({
+        label: name,
+        kind: CompletionItemKind.File,
+        detail: entry.name,
+        textEdit: { range, newText: name }
+      });
+    }
+  }
+  return items;
+}
+function nameItems(analyzer, fromUri, specifier, before) {
+  const target = analyzer.resolveModulePath(fromUri, specifier);
+  const exports = target ? analyzer.exportsAt(target) : void 0;
+  if (!exports) return [];
+  const braces = before.slice(before.indexOf("{") + 1);
+  const listed = new Set(braces.split(",").map((part) => part.trim().split(/\s+/)[0]).filter(Boolean));
+  const items = [];
+  for (const [name, type] of exports.values) {
+    if (listed.has(name)) continue;
+    items.push({
+      label: name,
+      kind: signaturesOf(type).length ? CompletionItemKind.Function : CompletionItemKind.Variable,
+      detail: formatType2(type)
+    });
+  }
+  for (const [name, exported] of exports.types) {
+    if (listed.has(name) || exports.values.has(name)) continue;
+    items.push({
+      label: name,
+      kind: CompletionItemKind.Interface,
+      detail: `type ${name} = ${formatType2(exported.type)}`
+    });
+  }
+  return items;
+}
+function rangeBack(position, length) {
+  return { start: { line: position.line, character: position.character - length }, end: position };
+}
+function importDefinition(analyzer, analysis, position) {
+  const path = pathAt(analysis.program, position, true);
+  const statement = path.find(isModuleReference);
+  if (!statement?.source) return void 0;
+  const target = analyzer.resolveModulePath(analysis.uri, statement.source.value);
+  if (!target) return null;
+  const fileStart = {
+    uri: uriOfPath(target),
+    range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }
+  };
+  const name = referencedName(statement, path[path.length - 1]);
+  if (!name) return fileStart;
+  const module = analyzer.moduleAt(target);
+  const found = module && exportDeclaration(analyzer, module, name);
+  return found ? { uri: found.uri, range: toRange(found.node) } : fileStart;
+}
+function isModuleReference(node) {
+  return node.type === "ImportStatement" || node.type === "ExportAllStatement" || node.type === "ExportNamedStatement" && !!node.source;
+}
+function referencedName(statement, node) {
+  switch (statement.type) {
+    case "ImportStatement":
+      if (node === statement.defaultImport) return "default";
+      return statement.specifiers.find((s) => node === s.imported || node === s.local)?.imported.name;
+    case "ExportNamedStatement":
+      return statement.specifiers.find((s) => node === s.local || node === s.exported)?.local.name;
+    case "ExportAllStatement":
+      return void 0;
+  }
+}
+function exportDeclaration(analyzer, module, name, seen = /* @__PURE__ */ new Set()) {
+  const key = `${module.uri}#${name}`;
+  if (seen.has(key)) return void 0;
+  seen.add(key);
+  const here = (node) => ({ uri: module.uri, node });
+  const stars = [];
+  for (const statement of module.program.body.statements) {
+    switch (statement.type) {
+      case "ExportDefaultStatement":
+        if (name === "default") return here(statement);
+        break;
+      case "ExportTypeAliasStatement":
+        if (statement.alias.name.name === name) return here(statement.alias.name);
+        break;
+      case "ExportStatement": {
+        const declaration = statement.declaration;
+        if (declaration.type === "FunctionDeclaration") {
+          if (declaration.name.name === name) return here(declaration.name);
+        } else {
+          for (const target of declaration.names) {
+            const found = patternNamed(target, name);
+            if (found) return here(found);
+          }
+        }
+        break;
+      }
+      case "ExportNamedStatement": {
+        const specifier = statement.specifiers.find((s) => s.exported.name === name);
+        if (!specifier) break;
+        if (statement.source) {
+          const next = moduleFrom(analyzer, module, statement.source.value);
+          return next && exportDeclaration(analyzer, next, specifier.local.name, seen);
+        }
+        return here(localDeclaration(module, specifier.local) ?? specifier.local);
+      }
+      case "ExportAllStatement":
+        stars.push(statement.source.value);
+        break;
+    }
+  }
+  if (name === "default") return void 0;
+  for (const specifier of stars) {
+    const next = moduleFrom(analyzer, module, specifier);
+    const found = next && exportDeclaration(analyzer, next, name, seen);
+    if (found) return found;
+  }
+  return void 0;
+}
+function moduleFrom(analyzer, module, specifier) {
+  const target = analyzer.resolveModulePath(module.uri, specifier);
+  return target ? analyzer.moduleAt(target) : void 0;
+}
+function localDeclaration(module, local) {
+  const binding = bindingOfNode(module, local);
+  if (binding?.declarationNode) return binding.declarationNode;
+  for (const statement of module.program.body.statements) {
+    const alias = statement.type === "TypeAliasStatement" ? statement : statement.type === "ExportTypeAliasStatement" ? statement.alias : void 0;
+    if (alias?.name.name === local.name) return alias.name;
+  }
+  return void 0;
+}
+function patternNamed(target, name) {
+  switch (target.type) {
+    case "IdentifierPattern":
+      return target.name === name ? target : void 0;
+    case "ObjectPattern":
+      for (const property of target.properties) {
+        const found = patternNamed(property.value, name);
+        if (found) return found;
+      }
+      return target.rest && patternNamed(target.rest, name);
+    case "ArrayPattern":
+      for (const element of target.elements) {
+        const found = element && patternNamed(element.value, name);
+        if (found) return found;
+      }
+      return target.rest && patternNamed(target.rest, name);
+  }
+}
+
+// src/features/diagnostics.ts
+import { DiagnosticSeverity } from "vscode-languageserver";
+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: 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: DiagnosticSeverity.Error,
+      source: "luaut",
+      code: d.kind,
+      message: d.message
+    });
+  }
+  for (const d of analysis.types.diagnostics) {
+    out.push({
+      range: toRange(d.node),
+      severity: DiagnosticSeverity.Error,
+      source: "luaut",
+      code: "type",
+      message: d.message
+    });
+  }
+  return out;
+}
+
+// src/features/hover.ts
+import {
+  formatType as formatType3
+} from "luaut-parser";
+function hover(analysis, position) {
+  const path = pathAt(analysis.program, position, true);
+  for (let i = path.length - 1; i >= 0; i--) {
+    const text = describe(analysis, path, i);
+    if (text) return { contents: { kind: "markdown", value: code(text) }, range: toRange(path[i]) };
+  }
+  return null;
+}
+var PRIMITIVES = /* @__PURE__ */ new Set(["any", "unknown", "never", "nil", "boolean", "number", "string", "thread", "buffer"]);
+function describe(analysis, path, index) {
+  const { types } = analysis;
+  const node = path[index];
+  const parent = path[index - 1];
+  const typeOfNode = (n) => types.typeOfTypeNode.get(n);
+  switch (node.type) {
+    case "Identifier": {
+      const identifier2 = node;
+      const name = identifier2.name;
+      switch (parent?.type) {
+        // `{ name: "n" }` — read the property off the object's type, so
+        // it widens the way the object did (`string`, not `"n"`).
+        case "TableExpression": {
+          const field = fieldWithKey(parent, node);
+          if (!field) break;
+          const objectType = types.typeOf.get(parent);
+          const property = objectType?.kind === "object" ? objectType.properties.get(name) : void 0;
+          const type2 = property?.type ?? types.typeOf.get(field.value);
+          return type2 && `(property) ${name}: ${pretty(type2)}`;
+        }
+        case "ImportSpecifier": {
+          const alias = types.aliases.get(name);
+          const binding2 = bindingOfNode(analysis, identifier2);
+          const value = binding2 && types.bindingType.get(binding2.id);
+          if (alias && (!value || value.kind === "any")) return `type ${name} = ${pretty(alias)}`;
+          break;
+        }
+        case "ExportSpecifier": {
+          if (bindingOfNode(analysis, identifier2)) break;
+          const alias = types.aliases.get(name);
+          if (alias) return `type ${name} = ${pretty(alias)}`;
+          break;
+        }
+        case "TypeAliasStatement":
+        case "ExportTypeAliasStatement":
+          if (parent.name === node) return aliasText(analysis, parent);
+          break;
+        case "DeclareStatement":
+          if (parent.id === node) return declareText(analysis, parent);
+          break;
+        case "TableTypeProperty":
+          if (parent.key === node) {
+            const type2 = typeOfNode(parent.valueType);
+            const readonly = parent.readonly ? "readonly " : "";
+            return type2 && `(property) ${readonly}${name}${parent.optional ? "?" : ""}: ${pretty(type2)}`;
+          }
+          break;
+        case "FunctionTypeParameter":
+          if (parent.id === node) {
+            const type2 = typeOfNode(parent.typeAnnotation);
+            return type2 && `(parameter) ${name}${parent.optional ? "?" : ""}: ${pretty(type2)}`;
+          }
+          break;
+        case "GenericTypeParameter":
+          if (parent.id === node) return typeParameterText(analysis, parent);
+          break;
+        case "InferTypeNode":
+          if (parent.id === node) return `(type parameter) infer ${name}`;
+          break;
+        case "MappedTypeNode":
+          if (parent.parameterId === node) {
+            const keys = typeOfNode(parent.constraint);
+            return `(type parameter) ${name}${keys ? ` in ${formatType3(keys)}` : ""}`;
+          }
+          break;
+      }
+      const narrowed = types.narrowedTypeOf.get(identifier2);
+      if (narrowed) return `${name}: ${pretty(narrowed)}`;
+      const binding = bindingOfNode(analysis, identifier2);
+      if (binding) {
+        const type2 = types.bindingType.get(binding.id);
+        if (type2) return `${keyword(binding)} ${binding.name}: ${pretty(type2)}`;
+      }
+      if (parent?.type === "MemberExpression" || parent?.type === "MethodCallExpression") {
+        const type2 = types.typeOf.get(parent);
+        if (type2) return `${name}: ${pretty(type2)}`;
+      }
+      return void 0;
+    }
+    // Declarations: `const x`, a parameter, `const function f`.
+    case "IdentifierPattern":
+    case "FunctionParameter":
+    case "TypedIdentifier": {
+      const binding = bindingOfNode(analysis, node);
+      const type2 = binding && types.bindingType.get(binding.id);
+      return type2 ? `${keyword(binding)} ${binding.name}: ${pretty(type2)}` : void 0;
+    }
+    // A type written by name: `number`, `Shape`, `Partial<User>`, or a type
+    // parameter in scope.
+    case "TypeReference": {
+      const base = node.base;
+      if (!node.namespace) {
+        const parameter = typeParameterInScope(path, index, base);
+        if (parameter) return typeParameterText(analysis, parameter);
+        if (PRIMITIVES.has(base)) return `type ${base}`;
+      }
+      if (!node.namespace && !node.typeArguments.length) {
+        const alias = types.aliases.get(base);
+        if (alias) return `type ${base} = ${pretty(alias)}`;
+      }
+      const type2 = typeOfNode(node);
+      return type2 && `type ${referenceText(analysis, node)} = ${pretty(type2)}`;
+    }
+  }
+  const annotated = typeOfNode(node);
+  if (annotated) return pretty(annotated);
+  const type = types.typeOf.get(node);
+  return type ? pretty(type) : void 0;
+}
+function aliasText(analysis, statement) {
+  const name = statement.name.name;
+  const alias = analysis.types.aliases.get(name);
+  if (!alias) return void 0;
+  const generics = statement.generics ?? [];
+  const parameters = generics.length ? `<${generics.map((g) => typeParameterSignature(analysis, g)).join(", ")}>` : "";
+  return `type ${name}${parameters} = ${pretty(alias)}`;
+}
+function declareText(analysis, statement) {
+  const name = statement.name;
+  const own = analysis.types.typeOfTypeNode.get(statement.valueType);
+  if (!own) return void 0;
+  if (own.kind !== "function") return `declare ${name}: ${pretty(own)}`;
+  const total = analysis.program.body.statements.filter((s) => s.type === "DeclareStatement" && s.name === name).reduce((n, s) => n + signaturesOf(analysis.types.typeOfTypeNode.get(s.valueType)).length, 0);
+  const others = total - 1;
+  const overloads = others > 0 ? `  (+${others} overload${others > 1 ? "s" : ""})` : "";
+  return `declare function ${name}${formatType3(own)}${overloads}`;
+}
+function typeParameterText(analysis, parameter) {
+  return `(type parameter) ${typeParameterSignature(analysis, parameter)}`;
+}
+function typeParameterSignature(analysis, parameter) {
+  const p = parameter;
+  if (p.infer) return `infer ${p.name}`;
+  const constraint = p.constraint ? analysis.types.typeOfTypeNode.get(p.constraint) : void 0;
+  return `${p.isConst ? "const " : ""}${p.name}${constraint ? ` extends ${formatType3(constraint)}` : ""}`;
+}
+function typeParameterInScope(path, index, name) {
+  for (let i = index - 1; i >= 0; i--) {
+    const a = path[i];
+    const generic = a.generics?.find((g) => g.name === name);
+    if (generic) return generic;
+    if (a.type === "MappedTypeNode" && a.parameter === name) return { name };
+    if (a.type === "ConditionalTypeNode" && bindsInfer(a.extendsType, name)) return { name, infer: true };
+  }
+  return void 0;
+}
+function bindsInfer(node, name) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some((n2) => bindsInfer(n2, name));
+  const n = node;
+  if (n.type === "InferTypeNode" && n.name === name) return true;
+  return Object.values(n).some((v) => bindsInfer(v, name));
+}
+function referenceText(analysis, reference) {
+  const name = reference.namespace ? `${reference.namespace}.${reference.base}` : reference.base;
+  const args = reference.typeArguments ?? [];
+  if (!args.length) return name;
+  const resolved = args.map((a) => {
+    const t = analysis.types.typeOfTypeNode.get(a);
+    return t ? formatType3(t) : "?";
+  });
+  return `${name}<${resolved.join(", ")}>`;
+}
+function fieldWithKey(table, key) {
+  const fields = table.fields;
+  return fields.find((f) => f.type === "TableFieldNamed" && f.key === key);
+}
+function pretty(type) {
+  const flat = formatType3(type);
+  if (flat.length <= 80) return flat;
+  if (type.kind === "object") {
+    const lines = [];
+    if (type.indexer) lines.push(`    [${formatType3(type.indexer.key)}]: ${formatType3(type.indexer.value)},`);
+    for (const [name, property] of type.properties) {
+      const readonly = property.readonly ? "readonly " : "";
+      lines.push(`    ${readonly}${name}${property.optional ? "?" : ""}: ${formatType3(property.type)},`);
+    }
+    return `{
+${lines.join("\n")}
+}`;
+  }
+  if (type.kind === "intersection" && type.types.every((t) => t.kind === "function")) {
+    return type.types.map(formatType3).join("\n& ");
+  }
+  return flat;
+}
+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-hover\n" + text + "\n```";
+}
+
+// src/features/navigation.ts
+import {
+  DocumentHighlightKind
+} from "vscode-languageserver";
+var NAMING = /* @__PURE__ */ new Set(["Identifier", "IdentifierPattern", "FunctionParameter", "TypedIdentifier"]);
+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 || !NAMING.has(node.type)) continue;
+    const binding = bindingOfNode(analysis, 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 ? DocumentHighlightKind.Write : 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 identifier2 = [...path].reverse().find((n) => !!n.type && NAMING.has(n.type));
+  if (!identifier2) return null;
+  return { range: toRange(identifier2), 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
+import {
+  CompletionItemKind as CompletionItemKind2,
+  InsertTextFormat
+} from "vscode-languageserver";
+import { formatType as formatType4 } from "luaut-parser";
+var PLACEHOLDER = "__luautCompletion__";
+var IDENTIFIER_CHAR = /[A-Za-z0-9_]/;
+function completion(analyzer, document, position) {
+  const inImport = importCompletion(analyzer, document, position);
+  if (inImport) return inImport;
+  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 operator = memberOperator(source, start);
+  const alreadyCalled = /^\s*\(/.test(source.slice(end));
+  const standIns = operator === ":" ? [alreadyCalled ? PLACEHOLDER : `${PLACEHOLDER}()`] : operator === "." && !alreadyCalled ? [PLACEHOLDER, `${PLACEHOLDER}()`] : [PLACEHOLDER];
+  const at = { line: position.line, character: position.character - (offset - start) };
+  let first;
+  for (const standIn of standIns) {
+    const patched = source.slice(0, start) + standIn + source.slice(end);
+    const analysis = analyzer.analyze(document.uri, -1, patched);
+    const path = pathAt(analysis.program, at, true);
+    const index = path.findLastIndex(
+      (n) => n.type === "Identifier" && n.name === PLACEHOLDER
+    );
+    const parent = index > 0 ? path[index - 1] : void 0;
+    if (parent && (parent.type === "MemberExpression" || parent.type === "MethodCallExpression")) {
+      return memberItems(analysis, parent);
+    }
+    first ??= { analysis, path };
+  }
+  if (operator || !first) return [];
+  if (inTypePosition(first.path)) {
+    const named = [...first.analysis.types.aliases.keys()].map((name) => ({
+      label: name,
+      kind: CompletionItemKind2.Interface,
+      detail: "type"
+    }));
+    const primitives = PRIMITIVES2.map((name) => ({
+      label: name,
+      kind: CompletionItemKind2.Keyword,
+      detail: "type"
+    }));
+    return [...named, ...primitives];
+  }
+  return valueItems(first.analysis, at);
+}
+function memberOperator(source, wordStart) {
+  const ch = source[wordStart - 1];
+  if (ch === ":") return source[wordStart - 2] === ":" ? void 0 : ":";
+  if (ch !== ".") return void 0;
+  if (source[wordStart - 2] === ".") return void 0;
+  let i = wordStart - 2;
+  while (i >= 0 && /[0-9]/.test(source[i])) i--;
+  const digits = wordStart - 2 - i;
+  if (digits > 0 && (i < 0 || !/[A-Za-z_]/.test(source[i]))) return void 0;
+  return ".";
+}
+function memberItems(analysis, access) {
+  const object = access.object;
+  const type = analysis.types.typeOf.get(object);
+  const colon = access.type === "MethodCallExpression";
+  if (isStringLike(type)) {
+    if (!colon) return [];
+    const id = analysis.scopes.globalsByName.get("string");
+    const library = id === void 0 ? void 0 : analysis.types.bindingType.get(id);
+    return membersOf(library, analysis.types.aliases).filter((member) => signaturesOf(member.property.type).length > 0).map((member) => memberItem(member.name, member.property.type, member.property.readonly));
+  }
+  return membersOf(type, analysis.types.aliases).filter((member) => colon ? member.isMethod : true).map((member) => memberItem(member.name, member.property.type, member.property.readonly));
+}
+function isStringLike(type) {
+  if (!type) return false;
+  switch (type.kind) {
+    case "primitive":
+      return type.name === "string";
+    case "literal":
+      return typeof type.value === "string";
+    case "templateLiteral":
+      return true;
+    case "union":
+      return type.types.length > 0 && type.types.every(isStringLike);
+    default:
+      return false;
+  }
+}
+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 ? formatType4(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: CompletionItemKind2.Keyword, sortText: `3${keyword2}` });
+  }
+  return items;
+}
+function memberItem(name, type, readonly) {
+  const signatures = signaturesOf(type);
+  if (signatures.length) {
+    return {
+      label: name,
+      kind: CompletionItemKind2.Method,
+      detail: signatureLabel(signatures[0]).label,
+      insertText: `${name}($0)`,
+      insertTextFormat: InsertTextFormat.Snippet
+    };
+  }
+  return {
+    label: name,
+    kind: CompletionItemKind2.Field,
+    detail: `${readonly ? "readonly " : ""}${formatType4(type)}`
+  };
+}
+function kindOf(type, bindingKind) {
+  if (type && signaturesOf(type).length) return CompletionItemKind2.Function;
+  if (bindingKind === "param" || bindingKind === "self") return CompletionItemKind2.Variable;
+  return CompletionItemKind2.Variable;
+}
+function inTypePosition(path) {
+  return path.some(
+    (n) => !!n.type && (n.type.endsWith("TypeNode") || n.type === "TypeReference" || n.type === "TypeAliasStatement" || n.type === "ExportTypeAliasStatement")
+  );
+}
+var PRIMITIVES2 = [
+  "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
+import { SymbolKind } from "vscode-languageserver";
+import { formatType as formatType5 } from "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, 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, SymbolKind.Interface, node, alias ? formatType5(alias) : void 0));
+        }
+        break;
+      }
+      case "VariableDeclaration": {
+        for (const target of node.names ?? []) {
+          const name = target.name;
+          if (name) out.push(symbol(name, 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 = bindingOfNode(analysis, name);
+    const type = binding && analysis.types.bindingType.get(binding.id);
+    if (type) return formatType5(type);
+  }
+  return void 0;
+}
+function symbol(name, kind, node, detail) {
+  const range = toRange(node);
+  return { name, kind, detail, range, selectionRange: range };
+}
+
+// src/features/semanticTokens.ts
+import { tokenize } from "luaut-parser";
+var TOKEN_TYPES = [
+  "namespace",
+  "type",
+  "typeParameter",
+  "parameter",
+  "variable",
+  "property",
+  "function",
+  "method",
+  "keyword"
+];
+var TOKEN_MODIFIERS = ["declaration", "readonly", "defaultLibrary"];
+var semanticTokensLegend = {
+  tokenTypes: [...TOKEN_TYPES],
+  tokenModifiers: [...TOKEN_MODIFIERS]
+};
+var SOFT_KEYWORDS = /* @__PURE__ */ new Set([
+  "type",
+  "declare",
+  "extends",
+  "keyof",
+  "infer",
+  "readonly",
+  "is",
+  "asserts",
+  "satisfies",
+  "typeof"
+]);
+var PRIMITIVES3 = /* @__PURE__ */ new Set(["any", "unknown", "never", "nil", "boolean", "number", "string", "thread", "buffer"]);
+function semanticTokens(analysis) {
+  const entries = /* @__PURE__ */ new Map();
+  const add = (at, length, type, modifiers = []) => {
+    const line = at.line.start - 1;
+    const character = at.column.start - 1;
+    const key = `${line}:${character}`;
+    if (!entries.has(key)) entries.set(key, { line, character, length, type, modifiers });
+  };
+  let tokens = [];
+  try {
+    tokens = tokenize(analysis.source);
+  } catch {
+  }
+  const identifiers = tokens.filter((t) => t.type === "Identifier");
+  const ancestors = [];
+  const walk2 = (node) => {
+    classify(analysis, node, ancestors, identifiers, add);
+    ancestors.push(node);
+    for (const child of children(node)) walk2(child);
+    ancestors.pop();
+  };
+  walk2(analysis.program);
+  for (const token of tokens) {
+    const value = token.value;
+    if (typeof value !== "string") continue;
+    if (token.type === "Keyword" && value !== "true" && value !== "false" && value !== "nil") {
+      add(token, value.length, "keyword");
+    } else if (token.type === "Identifier" && SOFT_KEYWORDS.has(value)) {
+      add(token, value.length, "keyword");
+    }
+  }
+  return { data: encode([...entries.values()]) };
+}
+function classify(analysis, spanned, ancestors, identifiers, add) {
+  const node = spanned;
+  switch (node.type) {
+    case "Identifier":
+      identifier(analysis, node, ancestors[ancestors.length - 1], add);
+      return;
+    // Declarations whose node starts at the name.
+    case "IdentifierPattern":
+    case "TypedIdentifier":
+    case "FunctionParameter": {
+      const name = node.name;
+      if (typeof name !== "string" || !name) return;
+      const binding = bindingOfNode(analysis, node);
+      add(node, name.length, valueKind(analysis, binding), modifiersOf(binding, true));
+      return;
+    }
+    case "TypeReference": {
+      const base = node.base;
+      const namespace = node.namespace;
+      const names = firstTokensWithin(identifiers, node, namespace ? 2 : 1);
+      if (namespace && names[0]) add(names[0], namespace.length, "namespace");
+      const baseToken = names[namespace ? 1 : 0];
+      if (!baseToken) return;
+      if (!namespace && typeParameterInScope2(ancestors, base)) {
+        add(baseToken, base.length, "typeParameter");
+      } else {
+        add(baseToken, base.length, "type", PRIMITIVES3.has(base) ? ["defaultLibrary"] : []);
+      }
+      return;
+    }
+  }
+}
+function identifier(analysis, node, parent, add) {
+  const name = node.name;
+  const as = (type, modifiers = []) => add(node, name.length, type, modifiers);
+  const typeOfNode = (n) => analysis.types.typeOfTypeNode.get(n);
+  switch (parent?.type) {
+    case "MemberExpression":
+      if (parent.property === node) {
+        return as(isFunction(analysis.types.typeOf.get(parent)) ? "method" : "property");
+      }
+      break;
+    case "MethodCallExpression":
+      if (parent.method === node) return as("method");
+      break;
+    case "TableExpression":
+      if (isFieldKey(parent, node)) return as("property", ["declaration"]);
+      break;
+    case "TypeAliasStatement":
+    case "ExportTypeAliasStatement":
+      if (parent.name === node) return as("type", ["declaration"]);
+      break;
+    case "DeclareStatement":
+      if (parent.id === node) return as(isFunction(typeOfNode(parent.valueType)) ? "function" : "variable", ["declaration"]);
+      break;
+    case "TableTypeProperty":
+      if (parent.key === node) {
+        return as(
+          isFunction(typeOfNode(parent.valueType)) ? "method" : "property",
+          parent.readonly ? ["declaration", "readonly"] : ["declaration"]
+        );
+      }
+      break;
+    case "FunctionTypeParameter":
+      if (parent.id === node) return as("parameter", ["declaration"]);
+      break;
+    case "GenericTypeParameter":
+    case "InferTypeNode":
+      if (parent.id === node) return as("typeParameter", ["declaration"]);
+      break;
+    case "MappedTypeNode":
+      if (parent.parameterId === node) return as("typeParameter", ["declaration"]);
+      break;
+    case "ImportSpecifier": {
+      const binding2 = bindingOfNode(analysis, node);
+      const value = binding2 && analysis.types.bindingType.get(binding2.id);
+      if (analysis.types.aliases.has(name) && (!value || value.kind === "any")) return as("type", ["declaration"]);
+      break;
+    }
+    case "ExportSpecifier":
+      if (!bindingOfNode(analysis, node) && analysis.types.aliases.has(name)) return as("type");
+      break;
+    case "FunctionName":
+      if (parent.path.includes(node)) return as("property");
+      if (parent.method === node) return as("method", ["declaration"]);
+      break;
+  }
+  const binding = bindingOfNode(analysis, node);
+  if (!binding) return;
+  as(valueKind(analysis, binding), modifiersOf(binding, binding.declarationNode === node));
+}
+function valueKind(analysis, binding) {
+  if (!binding) return "variable";
+  if (binding.kind === "param" || binding.kind === "self") return "parameter";
+  return isFunction(analysis.types.bindingType.get(binding.id)) ? "function" : "variable";
+}
+function modifiersOf(binding, isDeclaration) {
+  const modifiers = [];
+  if (isDeclaration) modifiers.push("declaration");
+  if (binding?.isConst) modifiers.push("readonly");
+  if (binding?.isBuiltin) modifiers.push("defaultLibrary");
+  return modifiers;
+}
+function isFunction(type) {
+  return signaturesOf(type).length > 0;
+}
+function isFieldKey(table, key) {
+  const fields = table.fields;
+  return fields.some((f) => f.type === "TableFieldNamed" && f.key === key);
+}
+function typeParameterInScope2(ancestors, name) {
+  for (let i = ancestors.length - 1; i >= 0; i--) {
+    const a = ancestors[i];
+    if (a.generics?.some((g) => g.name === name)) return true;
+    if (a.type === "MappedTypeNode" && a.parameter === name) return true;
+    if (a.type === "ConditionalTypeNode" && bindsInfer2(a.extendsType, name)) return true;
+  }
+  return false;
+}
+function bindsInfer2(node, name) {
+  if (!node || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some((n2) => bindsInfer2(n2, name));
+  const n = node;
+  if (n.type === "InferTypeNode" && n.name === name) return true;
+  return Object.values(n).some((v) => bindsInfer2(v, name));
+}
+function firstTokensWithin(tokens, node, count) {
+  let lo = 0;
+  let hi = tokens.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    const t = tokens[mid];
+    const before = t.line.start < node.line.start || t.line.start === node.line.start && t.column.start < node.column.start;
+    if (before) lo = mid + 1;
+    else hi = mid;
+  }
+  const out = [];
+  for (let i = lo; i < tokens.length && out.length < count; i++) {
+    const t = tokens[i];
+    const after = t.line.start > node.line.end || t.line.start === node.line.end && t.column.start >= node.column.end;
+    if (after) break;
+    out.push(t);
+  }
+  return out;
+}
+function encode(entries) {
+  entries.sort((a, b) => a.line - b.line || a.character - b.character);
+  const data = [];
+  let line = 0;
+  let character = 0;
+  for (const e of entries) {
+    const deltaLine = e.line - line;
+    data.push(
+      deltaLine,
+      deltaLine === 0 ? e.character - character : e.character,
+      e.length,
+      TOKEN_TYPES.indexOf(e.type),
+      e.modifiers.reduce((bits, m) => bits | 1 << TOKEN_MODIFIERS.indexOf(m), 0)
+    );
+    line = e.line;
+    character = e.character;
+  }
+  return data;
+}
+
+// src/server.ts
+import {
+  createConnection,
+  ProposedFeatures,
+  TextDocuments,
+  TextDocumentSyncKind
+} from "vscode-languageserver/node";
+import { TextDocument } from "vscode-languageserver-textdocument";
+function createServer(connection, options = {}) {
+  const documents = new TextDocuments(TextDocument);
+  const analyzer = new Analyzer({
+    ...options,
+    openDocument: (path) => documents.all().find((document) => {
+      const documentPath = pathOfUri(document.uri);
+      return documentPath !== void 0 && samePath(documentPath, path);
+    })
+  });
+  connection.onInitialize((_params) => ({
+    capabilities: {
+      textDocumentSync: 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.
+        // plus the characters that start or extend an import path.
+        triggerCharacters: [".", ":", '"', "'", "/"],
+        resolveProvider: false
+      },
+      signatureHelpProvider: { triggerCharacters: ["(", ","], retriggerCharacters: [","] },
+      // Colours from the parser, not from patterns: whether a word is a
+      // keyword, a type or a name depends on where it stands.
+      semanticTokensProvider: { legend: semanticTokensLegend, full: true }
+    },
+    serverInfo: { name: "luaut-language-server" }
+  }));
+  connection.languages.semanticTokens.on((p) => {
+    const document = documents.get(p.textDocument.uri);
+    return document ? semanticTokens(analyzer.get(document)) : { data: [] };
+  });
+  const publish = (document) => {
+    void connection.sendDiagnostics({
+      uri: document.uri,
+      version: document.version,
+      diagnostics: diagnostics(analyzer.get(document))
+    });
+  };
+  documents.onDidOpen((e) => publish(e.document));
+  const publishAll = () => {
+    for (const document of documents.all()) publish(document);
+  };
+  documents.onDidChangeContent(publishAll);
+  connection.onDidChangeWatchedFiles(publishAll);
+  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) => {
+      const analysis = analyzer.get(d);
+      const across = importDefinition(analyzer, analysis, p.position);
+      return across !== void 0 ? across : definition(analysis, 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(createConnection(ProposedFeatures.all), options);
+}
+
+export {
+  pathOfUri,
+  uriOfPath,
+  samePath,
+  Analyzer,
+  toRange,
+  toPosition,
+  containsPosition,
+  children,
+  pathAt,
+  nodeAt,
+  enclosing,
+  walk,
+  membersOf,
+  signaturesOf,
+  signatureLabel,
+  importCompletion,
+  importDefinition,
+  exportDeclaration,
+  diagnostics,
+  hover,
+  bindingAt,
+  definition,
+  references,
+  highlights,
+  prepareRename,
+  rename,
+  completion,
+  signatureHelp,
+  documentSymbols,
+  semanticTokensLegend,
+  semanticTokens,
+  createServer,
+  startServer
+};
+//# sourceMappingURL=chunk-HK7PKBDB.js.map