luaut-language-server 1.0.1 → 1.1.0

package/dist/index.d.cts

@@ -1,16 +1,7 @@
 import { Connection } from 'vscode-languageserver/node';
-import { Program, ParseError, ScopeAnalysis, TypeAnalysis, Binding, ObjectProperty, Type, FunctionType } from 'luaut-parser';
+import { Program, ParseError, ScopeAnalysis, TypeAnalysis, ModuleExports, Binding, ObjectProperty, Type, FunctionType } from 'luaut-parser';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { Diagnostic, Position, Hover, Location, DocumentHighlight, Range, WorkspaceEdit, CompletionItem, SignatureHelp, DocumentSymbol } from 'vscode-languageserver';
-
-/**
- * Analysis cache.
- *
- * The three parser passes are cheap (single-digit milliseconds for a normal
- * file) but not free, and every LSP request wants the same result for the same
- * document version — so each document is analyzed once per version and the
- * result is reused by hover, definition, completion and the rest.
- */
+import { Position, Range, CompletionItem, Location, Diagnostic, Hover, DocumentHighlight, WorkspaceEdit, SignatureHelp, DocumentSymbol, SemanticTokens, SemanticTokensLegend } from 'vscode-languageserver';
 
 interface Analysis {
     readonly uri: string;
@@ -20,23 +11,56 @@ interface Analysis {
     readonly parseErrors: readonly ParseError[];
     readonly scopes: ScopeAnalysis;
     readonly types: TypeAnalysis;
+    /** Every file this analysis read for an import, with the text it read —
+     *  or `undefined` for a file it looked for and did not find. How a cached
+     *  result tells that an import changed, appeared or vanished under it. */
+    readonly dependencies: ReadonlyMap<string, string | undefined>;
 }
 interface AnalyzerOptions {
     /** Definitions to analyze against. Defaults to core Luau + Roblox. */
     libs?: readonly Program[];
+    /** The open document for a file path, if there is one. */
+    openDocument?: (path: string) => TextDocument | undefined;
 }
+/** A file URI's path, or `undefined` for anything that is not a file. */
+declare function pathOfUri(uri: string): string | undefined;
+declare function uriOfPath(path: string): string;
+/** Paths compare case-insensitively on Windows, where editors and the file
+ *  system disagree about drive-letter case. */
+declare function samePath(a: string, b: string): boolean;
 declare class Analyzer {
     private readonly libs;
     private readonly builtinGlobals;
+    private readonly openDocument?;
     private readonly cache;
+    /** Imported modules, by path key. */
+    private readonly modules;
     constructor(options?: AnalyzerOptions);
-    /** Analyze `document`, reusing the previous result if its version is
-     *  unchanged. */
+    /** Analyze `document`, reusing the previous result while neither it nor
+     *  anything it imports has changed. */
     get(document: TextDocument): Analysis;
     /** Analyze source text that is not a tracked document — used by
      *  completion, which analyzes a speculatively edited copy of the file. */
     analyze(uri: string, version: number, source: string): Analysis;
     forget(uri: string): void;
+    /** 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: string, specifier: string): string | undefined;
+    /** Every file an import could mean, in the order they are tried. */
+    private moduleCandidates;
+    /** What the module at `path` exports, analyzing it if need be. */
+    exportsAt(path: string): ModuleExports | undefined;
+    /** The analysis of the module at `path`, analyzing it if need be. */
+    moduleAt(path: string): Analysis | undefined;
+    private sourceOf;
+    /** `importing` holds every module on the current import chain, so an
+     *  import back into one of them is recognized as a cycle. */
+    private analyzeModule;
+    private exportsOf;
+    /** Does every module `analysis` imported — and everything those import —
+     *  still have the text it was analyzed against? */
+    private isFresh;
 }
 
 /**
@@ -56,11 +80,88 @@ declare function createServer(connection: Connection, options?: ServerOptions):
 /** Run the server over stdio — the transport editors launch it with. */
 declare function startServer(options?: ServerOptions): void;
 
+/**
+ * Position mapping and AST lookup.
+ *
+ * luaut spans are 1-based with an exclusive end column; LSP positions are
+ * 0-based. Every conversion between the two lives here so the features never
+ * do the arithmetic themselves.
+ */
+
+/** The shape every luaut AST node shares. */
+interface Spanned {
+    type?: string;
+    line: {
+        start: number;
+        end: number;
+    };
+    column: {
+        start: number;
+        end: number;
+    };
+}
+declare function toRange(node: Spanned): Range;
+/** A one-character range, for a diagnostic on a node with a collapsed span. */
+declare function toPosition(line: number, column: number): Position;
+/** Is `pos` inside `node`'s span? The end is exclusive, except that `inclusive`
+ *  admits a cursor sitting immediately after the node — which is where it is
+ *  while you are still typing the identifier under it. */
+declare function containsPosition(node: Spanned, pos: Position, inclusive?: boolean): boolean;
+/** Every child node of `node`, in source order-ish (declaration order of the
+ *  fields). Generic on purpose: it walks the object graph rather than knowing
+ *  the node types, so a new node kind in the parser needs no change here.
+ *
+ *  Some nodes carry no span — the field wrappers of object literals
+ *  (`TableFieldNamed`) and type literals (`TableTypeProperty`). They are
+ *  walked *through*: their own children are returned in their place. Skipping
+ *  them would hide everything inside, which is how hovering an object key used
+ *  to land on the whole object. */
+declare function children(node: Spanned): Spanned[];
+/** The chain of nodes containing `pos`, outermost first — the last entry is
+ *  the innermost node at the cursor and the ones before it are its ancestors.
+ *
+ *  It descends through every child rather than only children that contain
+ *  `pos`, because a parent's span does not always cover its child's: a
+ *  binding's span is the name alone, while its type annotation sits after it.
+ *  So an ancestor in this path is a real ancestor, but not necessarily one
+ *  whose own span contains the cursor. */
+declare function pathAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned[];
+/** The innermost node containing `pos`. */
+declare function nodeAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned | undefined;
+/** The innermost node of one of `types` containing `pos`. */
+declare function enclosing<T extends Spanned>(root: Spanned, pos: Position, types: readonly string[], inclusive?: boolean): T | undefined;
+/** Walk every node under `root`, depth first. */
+declare function walk(root: Spanned, visit: (node: Spanned, parent?: Spanned) => void, parent?: Spanned): void;
+
+/** Completion inside an `import` or `export ... from`, or `undefined` when the
+ *  cursor is not in one. */
+declare function importCompletion(analyzer: Analyzer, document: TextDocument, position: Position): CompletionItem[] | undefined;
+/** Go-to-definition inside a statement that names another module: the module
+ *  string opens the module, a name jumps to where it is really declared —
+ *  through any `export { } from` and `export *` in between. `undefined` when
+ *  the cursor is not in such a statement, so the caller can fall back to
+ *  ordinary definition. */
+declare function importDefinition(analyzer: Analyzer, analysis: Analysis, position: Position): Location | null | undefined;
+interface Declaration {
+    uri: string;
+    node: Spanned;
+}
+/** Where the export `name` (`"default"` for the default) of `module` is
+ *  declared — following re-exports into the module that declares it. */
+declare function exportDeclaration(analyzer: Analyzer, module: Analysis, name: string, seen?: Set<string>): Declaration | undefined;
+
 /** Syntax errors, scope errors and type errors, as one list. */
 
 declare function diagnostics(analysis: Analysis): Diagnostic[];
 
-/** Hover: the type of the thing under the cursor, as luaut would write it. */
+/**
+ * Hover: what the thing under the cursor is, as luaut would write it.
+ *
+ * Every answer comes from the parser's own tables — binding types, the type of
+ * each expression, the resolved type of each type annotation — and every name
+ * has a node of its own to point at. Nothing is recovered from the source
+ * text.
+ */
 
 declare function hover(analysis: Analysis, position: Position): Hover | null;
 
@@ -111,6 +212,24 @@ declare function signatureHelp(analyzer: Analyzer, document: TextDocument, posit
 
 declare function documentSymbols(analysis: Analysis): DocumentSymbol[];
 
+/**
+ * Semantic highlighting, from the parser rather than from patterns.
+ *
+ * A TextMate grammar only sees characters, and in luaut a word's role depends
+ * on where it stands: `extends` is a keyword inside a type and a plain name
+ * elsewhere, `type Foo = ...` declares an alias while `type(x)` calls a
+ * builtin, and `typeof x` in a type is a query while `typeof(v)` in code is a
+ * call. Guessing that with regexes is how `extends (` came out coloured as a
+ * function call. Here every token is classified from the same lexer and AST
+ * the analyzer uses, so the colours cannot disagree with what the file means.
+ *
+ * The grammar still colours what is unambiguous — comments, strings, numbers,
+ * reserved words — so the file looks right before the server answers.
+ */
+
+declare const semanticTokensLegend: SemanticTokensLegend;
+declare function semanticTokens(analysis: Analysis): SemanticTokens;
+
 /** What members a type has — shared by completion and signature help. */
 
 interface Member {
@@ -134,51 +253,4 @@ declare function signatureLabel(signature: FunctionType): {
     parameters: string[];
 };
 
-/**
- * Position mapping and AST lookup.
- *
- * luaut spans are 1-based with an exclusive end column; LSP positions are
- * 0-based. Every conversion between the two lives here so the features never
- * do the arithmetic themselves.
- */
-
-/** The shape every luaut AST node shares. */
-interface Spanned {
-    type?: string;
-    line: {
-        start: number;
-        end: number;
-    };
-    column: {
-        start: number;
-        end: number;
-    };
-}
-declare function toRange(node: Spanned): Range;
-/** A one-character range, for a diagnostic on a node with a collapsed span. */
-declare function toPosition(line: number, column: number): Position;
-/** Is `pos` inside `node`'s span? The end is exclusive, except that `inclusive`
- *  admits a cursor sitting immediately after the node — which is where it is
- *  while you are still typing the identifier under it. */
-declare function containsPosition(node: Spanned, pos: Position, inclusive?: boolean): boolean;
-/** Every child node of `node`, in source order-ish (declaration order of the
- *  fields). Generic on purpose: it walks the object graph rather than knowing
- *  the node types, so a new node kind in the parser needs no change here. */
-declare function children(node: Spanned): Spanned[];
-/** The chain of nodes containing `pos`, outermost first — the last entry is
- *  the innermost node at the cursor and the ones before it are its ancestors.
- *
- *  It descends through every child rather than only children that contain
- *  `pos`, because a parent's span does not always cover its child's: a
- *  binding's span is the name alone, while its type annotation sits after it.
- *  So an ancestor in this path is a real ancestor, but not necessarily one
- *  whose own span contains the cursor. */
-declare function pathAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned[];
-/** The innermost node containing `pos`. */
-declare function nodeAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned | undefined;
-/** The innermost node of one of `types` containing `pos`. */
-declare function enclosing<T extends Spanned>(root: Spanned, pos: Position, types: readonly string[], inclusive?: boolean): T | undefined;
-/** Walk every node under `root`, depth first. */
-declare function walk(root: Spanned, visit: (node: Spanned, parent?: Spanned) => void, parent?: Spanned): void;
-
-export { type Analysis, Analyzer, type AnalyzerOptions, type Member, type ServerOptions, type Spanned, bindingAt, children, completion, containsPosition, createServer, definition, diagnostics, documentSymbols, enclosing, highlights, hover, membersOf, nodeAt, pathAt, prepareRename, references, rename, signatureHelp, signatureLabel, signaturesOf, startServer, toPosition, toRange, walk };
+export { type Analysis, Analyzer, type AnalyzerOptions, type Member, type ServerOptions, type Spanned, bindingAt, children, completion, containsPosition, createServer, definition, diagnostics, documentSymbols, enclosing, exportDeclaration, highlights, hover, importCompletion, importDefinition, membersOf, nodeAt, pathAt, pathOfUri, prepareRename, references, rename, samePath, semanticTokens, semanticTokensLegend, signatureHelp, signatureLabel, signaturesOf, startServer, toPosition, toRange, uriOfPath, walk };

package/dist/index.d.ts

@@ -1,16 +1,7 @@
 import { Connection } from 'vscode-languageserver/node';
-import { Program, ParseError, ScopeAnalysis, TypeAnalysis, Binding, ObjectProperty, Type, FunctionType } from 'luaut-parser';
+import { Program, ParseError, ScopeAnalysis, TypeAnalysis, ModuleExports, Binding, ObjectProperty, Type, FunctionType } from 'luaut-parser';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { Diagnostic, Position, Hover, Location, DocumentHighlight, Range, WorkspaceEdit, CompletionItem, SignatureHelp, DocumentSymbol } from 'vscode-languageserver';
-
-/**
- * Analysis cache.
- *
- * The three parser passes are cheap (single-digit milliseconds for a normal
- * file) but not free, and every LSP request wants the same result for the same
- * document version — so each document is analyzed once per version and the
- * result is reused by hover, definition, completion and the rest.
- */
+import { Position, Range, CompletionItem, Location, Diagnostic, Hover, DocumentHighlight, WorkspaceEdit, SignatureHelp, DocumentSymbol, SemanticTokens, SemanticTokensLegend } from 'vscode-languageserver';
 
 interface Analysis {
     readonly uri: string;
@@ -20,23 +11,56 @@ interface Analysis {
     readonly parseErrors: readonly ParseError[];
     readonly scopes: ScopeAnalysis;
     readonly types: TypeAnalysis;
+    /** Every file this analysis read for an import, with the text it read —
+     *  or `undefined` for a file it looked for and did not find. How a cached
+     *  result tells that an import changed, appeared or vanished under it. */
+    readonly dependencies: ReadonlyMap<string, string | undefined>;
 }
 interface AnalyzerOptions {
     /** Definitions to analyze against. Defaults to core Luau + Roblox. */
     libs?: readonly Program[];
+    /** The open document for a file path, if there is one. */
+    openDocument?: (path: string) => TextDocument | undefined;
 }
+/** A file URI's path, or `undefined` for anything that is not a file. */
+declare function pathOfUri(uri: string): string | undefined;
+declare function uriOfPath(path: string): string;
+/** Paths compare case-insensitively on Windows, where editors and the file
+ *  system disagree about drive-letter case. */
+declare function samePath(a: string, b: string): boolean;
 declare class Analyzer {
     private readonly libs;
     private readonly builtinGlobals;
+    private readonly openDocument?;
     private readonly cache;
+    /** Imported modules, by path key. */
+    private readonly modules;
     constructor(options?: AnalyzerOptions);
-    /** Analyze `document`, reusing the previous result if its version is
-     *  unchanged. */
+    /** Analyze `document`, reusing the previous result while neither it nor
+     *  anything it imports has changed. */
     get(document: TextDocument): Analysis;
     /** Analyze source text that is not a tracked document — used by
      *  completion, which analyzes a speculatively edited copy of the file. */
     analyze(uri: string, version: number, source: string): Analysis;
     forget(uri: string): void;
+    /** 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: string, specifier: string): string | undefined;
+    /** Every file an import could mean, in the order they are tried. */
+    private moduleCandidates;
+    /** What the module at `path` exports, analyzing it if need be. */
+    exportsAt(path: string): ModuleExports | undefined;
+    /** The analysis of the module at `path`, analyzing it if need be. */
+    moduleAt(path: string): Analysis | undefined;
+    private sourceOf;
+    /** `importing` holds every module on the current import chain, so an
+     *  import back into one of them is recognized as a cycle. */
+    private analyzeModule;
+    private exportsOf;
+    /** Does every module `analysis` imported — and everything those import —
+     *  still have the text it was analyzed against? */
+    private isFresh;
 }
 
 /**
@@ -56,11 +80,88 @@ declare function createServer(connection: Connection, options?: ServerOptions):
 /** Run the server over stdio — the transport editors launch it with. */
 declare function startServer(options?: ServerOptions): void;
 
+/**
+ * Position mapping and AST lookup.
+ *
+ * luaut spans are 1-based with an exclusive end column; LSP positions are
+ * 0-based. Every conversion between the two lives here so the features never
+ * do the arithmetic themselves.
+ */
+
+/** The shape every luaut AST node shares. */
+interface Spanned {
+    type?: string;
+    line: {
+        start: number;
+        end: number;
+    };
+    column: {
+        start: number;
+        end: number;
+    };
+}
+declare function toRange(node: Spanned): Range;
+/** A one-character range, for a diagnostic on a node with a collapsed span. */
+declare function toPosition(line: number, column: number): Position;
+/** Is `pos` inside `node`'s span? The end is exclusive, except that `inclusive`
+ *  admits a cursor sitting immediately after the node — which is where it is
+ *  while you are still typing the identifier under it. */
+declare function containsPosition(node: Spanned, pos: Position, inclusive?: boolean): boolean;
+/** Every child node of `node`, in source order-ish (declaration order of the
+ *  fields). Generic on purpose: it walks the object graph rather than knowing
+ *  the node types, so a new node kind in the parser needs no change here.
+ *
+ *  Some nodes carry no span — the field wrappers of object literals
+ *  (`TableFieldNamed`) and type literals (`TableTypeProperty`). They are
+ *  walked *through*: their own children are returned in their place. Skipping
+ *  them would hide everything inside, which is how hovering an object key used
+ *  to land on the whole object. */
+declare function children(node: Spanned): Spanned[];
+/** The chain of nodes containing `pos`, outermost first — the last entry is
+ *  the innermost node at the cursor and the ones before it are its ancestors.
+ *
+ *  It descends through every child rather than only children that contain
+ *  `pos`, because a parent's span does not always cover its child's: a
+ *  binding's span is the name alone, while its type annotation sits after it.
+ *  So an ancestor in this path is a real ancestor, but not necessarily one
+ *  whose own span contains the cursor. */
+declare function pathAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned[];
+/** The innermost node containing `pos`. */
+declare function nodeAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned | undefined;
+/** The innermost node of one of `types` containing `pos`. */
+declare function enclosing<T extends Spanned>(root: Spanned, pos: Position, types: readonly string[], inclusive?: boolean): T | undefined;
+/** Walk every node under `root`, depth first. */
+declare function walk(root: Spanned, visit: (node: Spanned, parent?: Spanned) => void, parent?: Spanned): void;
+
+/** Completion inside an `import` or `export ... from`, or `undefined` when the
+ *  cursor is not in one. */
+declare function importCompletion(analyzer: Analyzer, document: TextDocument, position: Position): CompletionItem[] | undefined;
+/** Go-to-definition inside a statement that names another module: the module
+ *  string opens the module, a name jumps to where it is really declared —
+ *  through any `export { } from` and `export *` in between. `undefined` when
+ *  the cursor is not in such a statement, so the caller can fall back to
+ *  ordinary definition. */
+declare function importDefinition(analyzer: Analyzer, analysis: Analysis, position: Position): Location | null | undefined;
+interface Declaration {
+    uri: string;
+    node: Spanned;
+}
+/** Where the export `name` (`"default"` for the default) of `module` is
+ *  declared — following re-exports into the module that declares it. */
+declare function exportDeclaration(analyzer: Analyzer, module: Analysis, name: string, seen?: Set<string>): Declaration | undefined;
+
 /** Syntax errors, scope errors and type errors, as one list. */
 
 declare function diagnostics(analysis: Analysis): Diagnostic[];
 
-/** Hover: the type of the thing under the cursor, as luaut would write it. */
+/**
+ * Hover: what the thing under the cursor is, as luaut would write it.
+ *
+ * Every answer comes from the parser's own tables — binding types, the type of
+ * each expression, the resolved type of each type annotation — and every name
+ * has a node of its own to point at. Nothing is recovered from the source
+ * text.
+ */
 
 declare function hover(analysis: Analysis, position: Position): Hover | null;
 
@@ -111,6 +212,24 @@ declare function signatureHelp(analyzer: Analyzer, document: TextDocument, posit
 
 declare function documentSymbols(analysis: Analysis): DocumentSymbol[];
 
+/**
+ * Semantic highlighting, from the parser rather than from patterns.
+ *
+ * A TextMate grammar only sees characters, and in luaut a word's role depends
+ * on where it stands: `extends` is a keyword inside a type and a plain name
+ * elsewhere, `type Foo = ...` declares an alias while `type(x)` calls a
+ * builtin, and `typeof x` in a type is a query while `typeof(v)` in code is a
+ * call. Guessing that with regexes is how `extends (` came out coloured as a
+ * function call. Here every token is classified from the same lexer and AST
+ * the analyzer uses, so the colours cannot disagree with what the file means.
+ *
+ * The grammar still colours what is unambiguous — comments, strings, numbers,
+ * reserved words — so the file looks right before the server answers.
+ */
+
+declare const semanticTokensLegend: SemanticTokensLegend;
+declare function semanticTokens(analysis: Analysis): SemanticTokens;
+
 /** What members a type has — shared by completion and signature help. */
 
 interface Member {
@@ -134,51 +253,4 @@ declare function signatureLabel(signature: FunctionType): {
     parameters: string[];
 };
 
-/**
- * Position mapping and AST lookup.
- *
- * luaut spans are 1-based with an exclusive end column; LSP positions are
- * 0-based. Every conversion between the two lives here so the features never
- * do the arithmetic themselves.
- */
-
-/** The shape every luaut AST node shares. */
-interface Spanned {
-    type?: string;
-    line: {
-        start: number;
-        end: number;
-    };
-    column: {
-        start: number;
-        end: number;
-    };
-}
-declare function toRange(node: Spanned): Range;
-/** A one-character range, for a diagnostic on a node with a collapsed span. */
-declare function toPosition(line: number, column: number): Position;
-/** Is `pos` inside `node`'s span? The end is exclusive, except that `inclusive`
- *  admits a cursor sitting immediately after the node — which is where it is
- *  while you are still typing the identifier under it. */
-declare function containsPosition(node: Spanned, pos: Position, inclusive?: boolean): boolean;
-/** Every child node of `node`, in source order-ish (declaration order of the
- *  fields). Generic on purpose: it walks the object graph rather than knowing
- *  the node types, so a new node kind in the parser needs no change here. */
-declare function children(node: Spanned): Spanned[];
-/** The chain of nodes containing `pos`, outermost first — the last entry is
- *  the innermost node at the cursor and the ones before it are its ancestors.
- *
- *  It descends through every child rather than only children that contain
- *  `pos`, because a parent's span does not always cover its child's: a
- *  binding's span is the name alone, while its type annotation sits after it.
- *  So an ancestor in this path is a real ancestor, but not necessarily one
- *  whose own span contains the cursor. */
-declare function pathAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned[];
-/** The innermost node containing `pos`. */
-declare function nodeAt(root: Spanned, pos: Position, inclusive?: boolean): Spanned | undefined;
-/** The innermost node of one of `types` containing `pos`. */
-declare function enclosing<T extends Spanned>(root: Spanned, pos: Position, types: readonly string[], inclusive?: boolean): T | undefined;
-/** Walk every node under `root`, depth first. */
-declare function walk(root: Spanned, visit: (node: Spanned, parent?: Spanned) => void, parent?: Spanned): void;
-
-export { type Analysis, Analyzer, type AnalyzerOptions, type Member, type ServerOptions, type Spanned, bindingAt, children, completion, containsPosition, createServer, definition, diagnostics, documentSymbols, enclosing, highlights, hover, membersOf, nodeAt, pathAt, prepareRename, references, rename, signatureHelp, signatureLabel, signaturesOf, startServer, toPosition, toRange, walk };
+export { type Analysis, Analyzer, type AnalyzerOptions, type Member, type ServerOptions, type Spanned, bindingAt, children, completion, containsPosition, createServer, definition, diagnostics, documentSymbols, enclosing, exportDeclaration, highlights, hover, importCompletion, importDefinition, membersOf, nodeAt, pathAt, pathOfUri, prepareRename, references, rename, samePath, semanticTokens, semanticTokensLegend, signatureHelp, signatureLabel, signaturesOf, startServer, toPosition, toRange, uriOfPath, walk };

package/dist/index.js

@@ -9,22 +9,30 @@ import {
   diagnostics,
   documentSymbols,
   enclosing,
+  exportDeclaration,
   highlights,
   hover,
+  importCompletion,
+  importDefinition,
   membersOf,
   nodeAt,
   pathAt,
+  pathOfUri,
   prepareRename,
   references,
   rename,
+  samePath,
+  semanticTokens,
+  semanticTokensLegend,
   signatureHelp,
   signatureLabel,
   signaturesOf,
   startServer,
   toPosition,
   toRange,
+  uriOfPath,
   walk
-} from "./chunk-FMWNSXUC.js";
+} from "./chunk-HK7PKBDB.js";
 export {
   Analyzer,
   bindingAt,
@@ -36,20 +44,28 @@ export {
   diagnostics,
   documentSymbols,
   enclosing,
+  exportDeclaration,
   highlights,
   hover,
+  importCompletion,
+  importDefinition,
   membersOf,
   nodeAt,
   pathAt,
+  pathOfUri,
   prepareRename,
   references,
   rename,
+  samePath,
+  semanticTokens,
+  semanticTokensLegend,
   signatureHelp,
   signatureLabel,
   signaturesOf,
   startServer,
   toPosition,
   toRange,
+  uriOfPath,
   walk
 };
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "luaut-language-server",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Language server for luaut (LSP), built on luaut-parser",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -39,7 +39,7 @@
     "typescript": "^5.0.4"
   },
   "dependencies": {
-    "luaut-parser": "^1.0.0",
+    "luaut-parser": "^1.1.0",
     "vscode-languageserver": "^10.1.1",
     "vscode-languageserver-textdocument": "^1.0.14"
   },