@astrojs/language-server 0.9.2 → 0.12.0

package/dist/core/documents/utils.js

@@ -1,10 +1,64 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractStyleTag = exports.walk = exports.offsetAt = exports.positionAt = exports.isInComponentStartTag = exports.isComponentTag = exports.isInTag = exports.isInsideFrontmatter = exports.isInsideExpression = exports.getFirstNonWhitespaceIndex = exports.getWordAt = exports.getWordRangeAt = void 0;
-const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+exports.getFirstNonWhitespaceIndex = exports.getLineOffsets = exports.offsetAt = exports.positionAt = exports.isInsideFrontmatter = exports.isInsideExpression = exports.isInTag = exports.isInComponentStartTag = exports.isComponentTag = exports.extractStyleTags = exports.walk = void 0;
 const vscode_languageserver_1 = require("vscode-languageserver");
 const utils_1 = require("../../utils");
 const parseHtml_1 = require("./parseHtml");
+function* walk(node) {
+    for (let child of node.children) {
+        yield* walk(child);
+    }
+    yield node;
+}
+exports.walk = walk;
+/**
+ * Extracts a tag (style or script) from the given text
+ * and returns its start, end and the attributes on that tag.
+ *
+ * @param source text content to extract tag from
+ * @param tag the tag to extract
+ */
+function extractTags(text, tag, html) {
+    const rootNodes = (html === null || html === void 0 ? void 0 : html.roots) || (0, parseHtml_1.parseHtml)(text).roots;
+    const matchedNodes = rootNodes.filter((node) => node.tag === tag);
+    if (tag === 'style' && !matchedNodes.length && rootNodes.length) {
+        for (let child of walk(rootNodes[0])) {
+            if (child.tag === 'style') {
+                matchedNodes.push(child);
+            }
+        }
+    }
+    return matchedNodes.map(transformToTagInfo);
+    function transformToTagInfo(matchedNode) {
+        var _a, _b;
+        const start = (_a = matchedNode.startTagEnd) !== null && _a !== void 0 ? _a : matchedNode.start;
+        const end = (_b = matchedNode.endTagStart) !== null && _b !== void 0 ? _b : matchedNode.end;
+        const startPos = positionAt(start, text);
+        const endPos = positionAt(end, text);
+        const container = {
+            start: matchedNode.start,
+            end: matchedNode.end,
+        };
+        const content = text.substring(start, end);
+        return {
+            content,
+            attributes: parseAttributes(matchedNode.attributes),
+            start,
+            end,
+            startPos,
+            endPos,
+            container,
+        };
+    }
+}
+function extractStyleTags(source, html) {
+    const styles = extractTags(source, 'style', html);
+    if (!styles.length) {
+        return [];
+    }
+    return styles;
+}
+exports.extractStyleTags = extractStyleTags;
 function parseAttributes(rawAttrs) {
     const attrs = {};
     if (!rawAttrs) {
@@ -16,48 +70,42 @@ function parseAttributes(rawAttrs) {
     });
     return attrs;
     function removeOuterQuotes(attrValue) {
-        if ((attrValue.startsWith('"') && attrValue.endsWith('"')) || (attrValue.startsWith("'") && attrValue.endsWith("'"))) {
+        if ((attrValue.startsWith('"') && attrValue.endsWith('"')) ||
+            (attrValue.startsWith("'") && attrValue.endsWith("'"))) {
             return attrValue.slice(1, attrValue.length - 1);
         }
         return attrValue;
     }
 }
 /**
- * Gets word range at position.
- * Delimiter is by default a whitespace, but can be adjusted.
+ * Return if a Node is a Component
  */
-function getWordRangeAt(str, pos, delimiterRegex = { left: /\S+$/, right: /\s/ }) {
-    let start = str.slice(0, pos).search(delimiterRegex.left);
-    if (start < 0) {
-        start = pos;
-    }
-    let end = str.slice(pos).search(delimiterRegex.right);
-    if (end < 0) {
-        end = str.length;
-    }
-    else {
-        end = end + pos;
+function isComponentTag(node) {
+    if (!node.tag) {
+        return false;
     }
-    return { start, end };
+    const firstChar = node.tag[0];
+    return /[A-Z]/.test(firstChar);
 }
-exports.getWordRangeAt = getWordRangeAt;
+exports.isComponentTag = isComponentTag;
 /**
- * Gets word at position.
- * Delimiter is by default a whitespace, but can be adjusted.
+ * Return if a given offset is inside the start tag of a component
  */
-function getWordAt(str, pos, delimiterRegex = { left: /\S+$/, right: /\s/ }) {
-    const { start, end } = getWordRangeAt(str, pos, delimiterRegex);
-    return str.slice(start, end);
+function isInComponentStartTag(html, offset) {
+    const node = html.findNodeAt(offset);
+    return isComponentTag(node) && (!node.startTagEnd || offset < node.startTagEnd);
 }
-exports.getWordAt = getWordAt;
+exports.isInComponentStartTag = isInComponentStartTag;
 /**
- * Gets index of first-non-whitespace character.
+ * Return if the current position is in a specific tag
  */
-function getFirstNonWhitespaceIndex(str) {
-    return str.length - str.trimStart().length;
+function isInTag(position, tagInfo) {
+    return !!tagInfo && (0, utils_1.isInRange)(vscode_languageserver_1.Range.create(tagInfo.startPos, tagInfo.endPos), position);
 }
-exports.getFirstNonWhitespaceIndex = getFirstNonWhitespaceIndex;
-/** checks if a position is currently inside of an expression */
+exports.isInTag = isInTag;
+/**
+ * Return if a given position is inside a JSX expression
+ */
 function isInsideExpression(html, tagStart, position) {
     const charactersInNode = html.substring(tagStart, position);
     return charactersInNode.lastIndexOf('{') > charactersInNode.lastIndexOf('}');
@@ -72,58 +120,45 @@ function isInsideFrontmatter(text, offset) {
     return start > 1 && start < 3 && end >= 1;
 }
 exports.isInsideFrontmatter = isInsideFrontmatter;
-function isInTag(position, tagInfo) {
-    return !!tagInfo && (0, utils_1.isInRange)(position, vscode_languageserver_1.Range.create(tagInfo.startPos, tagInfo.endPos));
-}
-exports.isInTag = isInTag;
-function isComponentTag(node) {
-    if (!node.tag) {
-        return false;
-    }
-    const firstChar = node.tag[0];
-    return /[A-Z]/.test(firstChar);
-}
-exports.isComponentTag = isComponentTag;
-function isInComponentStartTag(html, offset) {
-    const node = html.findNodeAt(offset);
-    return (isComponentTag(node) && (!node.startTagEnd || offset < node.startTagEnd));
-}
-exports.isInComponentStartTag = isInComponentStartTag;
 /**
  * Get the line and character based on the offset
  * @param offset The index of the position
  * @param text The text for which the position should be retrived
+ * @param lineOffsets number Array with offsets for each line. Computed if not given
  */
-function positionAt(offset, text) {
+function positionAt(offset, text, lineOffsets = getLineOffsets(text)) {
     offset = (0, utils_1.clamp)(offset, 0, text.length);
-    const lineOffsets = getLineOffsets(text);
     let low = 0;
     let high = lineOffsets.length;
     if (high === 0) {
-        return vscode_html_languageservice_1.Position.create(0, offset);
+        return vscode_languageserver_1.Position.create(0, offset);
     }
-    while (low < high) {
+    while (low <= high) {
         const mid = Math.floor((low + high) / 2);
-        if (lineOffsets[mid] > offset) {
-            high = mid;
+        const lineOffset = lineOffsets[mid];
+        if (lineOffset === offset) {
+            return vscode_languageserver_1.Position.create(mid, 0);
         }
-        else {
+        else if (offset > lineOffset) {
             low = mid + 1;
         }
+        else {
+            high = mid - 1;
+        }
     }
     // low is the least x for which the line offset is larger than the current offset
     // or array.length if no line offset is larger than the current offset
     const line = low - 1;
-    return vscode_html_languageservice_1.Position.create(line, offset - lineOffsets[line]);
+    return vscode_languageserver_1.Position.create(line, offset - lineOffsets[line]);
 }
 exports.positionAt = positionAt;
 /**
  * Get the offset of the line and character position
  * @param position Line and character position
  * @param text The text for which the offset should be retrived
+ * @param lineOffsets number Array with offsets for each line. Computed if not given
  */
-function offsetAt(position, text) {
-    const lineOffsets = getLineOffsets(text);
+function offsetAt(position, text, lineOffsets = getLineOffsets(text)) {
     if (position.line >= lineOffsets.length) {
         return text.length;
     }
@@ -154,84 +189,11 @@ function getLineOffsets(text) {
     }
     return lineOffsets;
 }
-function* walk(node) {
-    for (let child of node.children) {
-        yield* walk(child);
-    }
-    yield node;
-}
-exports.walk = walk;
-/*
-export function* walk(node: Node, startIndex = 0) {
-    let skip, tmp;
-    let depth = 0;
-    let index = startIndex;
-
-    // Always start with the initial element.
-    do {
-        if ( !skip && (tmp = node.firstChild) ) {
-            depth++;
-            callback('child', node, tmp, index);
-            index++;
-        } else if ( tmp = node.nextSibling ) {
-            skip = false;
-            callback('sibling', node, tmp, index);
-            index++;
-        } else {
-            tmp = node.parentNode;
-            depth--;
-            skip = true;
-        }
-        node = tmp;
-    } while ( depth > 0 );
-};
-*/
+exports.getLineOffsets = getLineOffsets;
 /**
- * Extracts a tag (style or script) from the given text
- * and returns its start, end and the attributes on that tag.
- *
- * @param source text content to extract tag from
- * @param tag the tag to extract
+ * Gets index of first-non-whitespace character.
  */
-function extractTags(text, tag, html) {
-    const rootNodes = (html === null || html === void 0 ? void 0 : html.roots) || (0, parseHtml_1.parseHtml)(text).roots;
-    const matchedNodes = rootNodes.filter((node) => node.tag === tag);
-    if (tag === 'style' && !matchedNodes.length && rootNodes.length && rootNodes[0].tag === 'html') {
-        for (let child of walk(rootNodes[0])) {
-            if (child.tag === 'style') {
-                matchedNodes.push(child);
-            }
-        }
-    }
-    return matchedNodes.map(transformToTagInfo);
-    function transformToTagInfo(matchedNode) {
-        var _a, _b;
-        const start = (_a = matchedNode.startTagEnd) !== null && _a !== void 0 ? _a : matchedNode.start;
-        const end = (_b = matchedNode.endTagStart) !== null && _b !== void 0 ? _b : matchedNode.end;
-        const startPos = positionAt(start, text);
-        const endPos = positionAt(end, text);
-        const container = {
-            start: matchedNode.start,
-            end: matchedNode.end,
-        };
-        const content = text.substring(start, end);
-        return {
-            content,
-            attributes: parseAttributes(matchedNode.attributes),
-            start,
-            end,
-            startPos,
-            endPos,
-            container,
-        };
-    }
-}
-function extractStyleTag(source, html) {
-    const styles = extractTags(source, 'style', html);
-    if (!styles.length) {
-        return null;
-    }
-    // There can only be one style tag
-    return styles[0];
+function getFirstNonWhitespaceIndex(str) {
+    return str.length - str.trimStart().length;
 }
-exports.extractStyleTag = extractStyleTag;
+exports.getFirstNonWhitespaceIndex = getFirstNonWhitespaceIndex;

package/dist/index.d.ts

@@ -1,2 +1 @@
 export { AstroCheck, DiagnosticSeverity } from './check';
-export { startServer } from './server';

package/dist/index.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startServer = exports.DiagnosticSeverity = exports.AstroCheck = void 0;
+exports.DiagnosticSeverity = exports.AstroCheck = void 0;
 var check_1 = require("./check");
 Object.defineProperty(exports, "AstroCheck", { enumerable: true, get: function () { return check_1.AstroCheck; } });
 Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return check_1.DiagnosticSeverity; } });
-var server_1 = require("./server");
-Object.defineProperty(exports, "startServer", { enumerable: true, get: function () { return server_1.startServer; } });

package/dist/node.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vscode = __importStar(require("vscode-languageserver/node"));
+const server_1 = require("./server");
+const connection = vscode.createConnection(vscode.ProposedFeatures.all);
+(0, server_1.startLanguageServer)(connection);

package/dist/plugins/PluginHost.d.ts

@@ -1,22 +1,20 @@
-import type { CancellationToken, CompletionContext, CompletionItem, DefinitionLink, Diagnostic, Location, Position, SignatureHelp, SignatureHelpContext, TextDocumentIdentifier, WorkspaceEdit } from 'vscode-languageserver';
-import type { DocumentManager } from '../core/documents';
-import type * as d from './interfaces';
-import { CompletionList } from 'vscode-languageserver';
-import { Hover, FoldingRange } from 'vscode-languageserver-types';
+import { CancellationToken, CompletionContext, CompletionItem, CompletionList, DefinitionLink, Diagnostic, FoldingRange, Hover, Position, Location, SignatureHelp, SignatureHelpContext, TextDocumentContentChangeEvent, TextDocumentIdentifier, WorkspaceEdit } from 'vscode-languageserver';
+import type { AppCompletionItem, Plugin } from './interfaces';
+import { DocumentManager } from '../core/documents/DocumentManager';
 interface PluginHostConfig {
     filterIncompleteCompletions: boolean;
     definitionLinkSupport: boolean;
 }
 export declare class PluginHost {
-    private documentsManager;
+    private docManager;
     private plugins;
     private pluginHostConfig;
-    constructor(documentsManager: DocumentManager);
+    constructor(docManager: DocumentManager);
     initialize(pluginHostConfig: PluginHostConfig): void;
-    register(plugin: d.Plugin): void;
+    registerPlugin(plugin: Plugin): void;
     getCompletions(textDocument: TextDocumentIdentifier, position: Position, completionContext?: CompletionContext): Promise<CompletionList>;
+    resolveCompletion(textDocument: TextDocumentIdentifier, completionItem: AppCompletionItem): Promise<CompletionItem>;
     getDiagnostics(textDocument: TextDocumentIdentifier): Promise<Diagnostic[]>;
-    resolveCompletion(textDocument: TextDocumentIdentifier, completionItem: d.AppCompletionItem): Promise<CompletionItem>;
     doHover(textDocument: TextDocumentIdentifier, position: Position): Promise<Hover | null>;
     doTagComplete(textDocument: TextDocumentIdentifier, position: Position): Promise<string | null>;
     getFoldingRanges(textDocument: TextDocumentIdentifier): Promise<FoldingRange[] | null>;
@@ -24,6 +22,7 @@ export declare class PluginHost {
     rename(textDocument: TextDocumentIdentifier, position: Position, newName: string): Promise<WorkspaceEdit | null>;
     getSignatureHelp(textDocument: TextDocumentIdentifier, position: Position, context: SignatureHelpContext | undefined, cancellationToken: CancellationToken): Promise<SignatureHelp | null>;
     onWatchFileChanges(onWatchFileChangesParams: any[]): void;
+    updateNonAstroFile(fileName: string, changes: TextDocumentContentChangeEvent[]): void;
     private getDocument;
     private execute;
     private tryExecutePlugin;

package/dist/plugins/PluginHost.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginHost = void 0;
-const utils_1 = require("../utils");
 const vscode_languageserver_1 = require("vscode-languageserver");
+const lodash_1 = require("lodash");
 var ExecuteMode;
 (function (ExecuteMode) {
     ExecuteMode[ExecuteMode["None"] = 0] = "None";
@@ -10,8 +10,8 @@ var ExecuteMode;
     ExecuteMode[ExecuteMode["Collect"] = 2] = "Collect";
 })(ExecuteMode || (ExecuteMode = {}));
 class PluginHost {
-    constructor(documentsManager) {
-        this.documentsManager = documentsManager;
+    constructor(docManager) {
+        this.docManager = docManager;
         this.plugins = [];
         this.pluginHostConfig = {
             filterIncompleteCompletions: true,
@@ -21,62 +21,41 @@ class PluginHost {
     initialize(pluginHostConfig) {
         this.pluginHostConfig = pluginHostConfig;
     }
-    register(plugin) {
+    registerPlugin(plugin) {
         this.plugins.push(plugin);
     }
     async getCompletions(textDocument, position, completionContext) {
         const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
         const completions = (await this.execute('getCompletions', [document, position, completionContext], ExecuteMode.Collect)).filter((completion) => completion != null);
-        let flattenedCompletions = (0, utils_1.flatten)(completions.map((completion) => completion.items));
+        let flattenedCompletions = (0, lodash_1.flatten)(completions.map((completion) => completion.items));
         const isIncomplete = completions.reduce((incomplete, completion) => incomplete || completion.isIncomplete, false);
         return vscode_languageserver_1.CompletionList.create(flattenedCompletions, isIncomplete);
     }
-    async getDiagnostics(textDocument) {
-        const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
-        return (0, utils_1.flatten)(await this.execute('getDiagnostics', [document], ExecuteMode.Collect));
-    }
     async resolveCompletion(textDocument, completionItem) {
         const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
         const result = await this.execute('resolveCompletion', [document, completionItem], ExecuteMode.FirstNonNull);
         return result !== null && result !== void 0 ? result : completionItem;
     }
+    async getDiagnostics(textDocument) {
+        const document = this.getDocument(textDocument.uri);
+        return (0, lodash_1.flatten)(await this.execute('getDiagnostics', [document], ExecuteMode.Collect));
+    }
     async doHover(textDocument, position) {
         const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
         return this.execute('doHover', [document, position], ExecuteMode.FirstNonNull);
     }
     async doTagComplete(textDocument, position) {
         const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
         return this.execute('doTagComplete', [document, position], ExecuteMode.FirstNonNull);
     }
     async getFoldingRanges(textDocument) {
         const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
-        const foldingRanges = (0, utils_1.flatten)(await this.execute('getFoldingRanges', [document], ExecuteMode.Collect)).filter((completion) => completion != null);
+        const foldingRanges = (0, lodash_1.flatten)(await this.execute('getFoldingRanges', [document], ExecuteMode.Collect)).filter((completion) => completion != null);
         return foldingRanges;
     }
     async getDefinitions(textDocument, position) {
         const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
-        const definitions = (0, utils_1.flatten)(await this.execute('getDefinitions', [document, position], ExecuteMode.Collect));
+        const definitions = (0, lodash_1.flatten)(await this.execute('getDefinitions', [document, position], ExecuteMode.Collect));
         if (this.pluginHostConfig.definitionLinkSupport) {
             return definitions;
         }
@@ -86,9 +65,6 @@ class PluginHost {
     }
     async rename(textDocument, position, newName) {
         const document = this.getDocument(textDocument.uri);
-        if (!document) {
-            throw new Error('Cannot call methods on an unopened document');
-        }
         return this.execute('rename', [document, position, newName], ExecuteMode.FirstNonNull);
     }
     async getSignatureHelp(textDocument, position, context, cancellationToken) {
@@ -104,8 +80,18 @@ class PluginHost {
             (_a = support.onWatchFileChanges) === null || _a === void 0 ? void 0 : _a.call(support, onWatchFileChangesParams);
         }
     }
+    updateNonAstroFile(fileName, changes) {
+        var _a;
+        for (const support of this.plugins) {
+            (_a = support.updateNonAstroFile) === null || _a === void 0 ? void 0 : _a.call(support, fileName, changes);
+        }
+    }
     getDocument(uri) {
-        return this.documentsManager.get(uri);
+        const document = this.docManager.get(uri);
+        if (!document) {
+            throw new Error('Cannot call methods on an unopened document');
+        }
+        return document;
     }
     async execute(name, args, mode) {
         const plugins = this.plugins.filter((plugin) => typeof plugin[name] === 'function');

package/dist/plugins/astro/AstroPlugin.d.ts

@@ -1,17 +1,16 @@
-import { DefinitionLink } from 'vscode-languageserver';
-import type { Document, DocumentManager } from '../../core/documents';
-import type { ConfigManager } from '../../core/config';
-import type { CompletionsProvider, AppCompletionList, FoldingRangeProvider } from '../interfaces';
-import { CompletionContext, Position, FoldingRange } from 'vscode-languageserver';
-export declare class AstroPlugin implements CompletionsProvider, FoldingRangeProvider {
-    private readonly configManager;
-    private readonly tsLanguageServiceManager;
+import { CompletionContext, DefinitionLink, FoldingRange, Position } from 'vscode-languageserver';
+import { ConfigManager } from '../../core/config';
+import { AstroDocument, DocumentManager } from '../../core/documents';
+import { AppCompletionList, Plugin } from '../interfaces';
+export declare class AstroPlugin implements Plugin {
+    __name: string;
+    private configManager;
+    private readonly languageServiceManager;
     private readonly completionProvider;
-    pluginName: string;
     constructor(docManager: DocumentManager, configManager: ConfigManager, workspaceUris: string[]);
-    getCompletions(document: Document, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
-    getFoldingRanges(document: Document): Promise<FoldingRange[]>;
-    getDefinitions(document: Document, position: Position): Promise<DefinitionLink[]>;
+    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
+    getFoldingRanges(document: AstroDocument): Promise<FoldingRange[]>;
+    getDefinitions(document: AstroDocument, position: Position): Promise<DefinitionLink[]>;
     private isInsideFrontmatter;
     private isComponentTag;
     private getDefinitionsForComponentName;

package/dist/plugins/astro/AstroPlugin.js

@@ -1,40 +1,22 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstroPlugin = void 0;
+const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
+const documents_1 = require("../../core/documents");
 const utils_1 = require("../../utils");
-const utils_2 = require("../typescript/utils");
-const utils_3 = require("../../core/documents/utils");
-const ts = __importStar(require("typescript"));
 const LanguageServiceManager_1 = require("../typescript/LanguageServiceManager");
-const utils_4 = require("../typescript/utils");
-const vscode_languageserver_types_1 = require("vscode-languageserver-types");
-const CompletionProvider_1 = require("./features/CompletionProvider");
+const utils_2 = require("../typescript/utils");
+const CompletionsProvider_1 = require("./features/CompletionsProvider");
 class AstroPlugin {
     constructor(docManager, configManager, workspaceUris) {
-        this.pluginName = 'Astro';
+        this.__name = 'astro';
         this.configManager = configManager;
-        this.tsLanguageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, configManager, workspaceUris);
-        this.completionProvider = new CompletionProvider_1.CompletionProvider(docManager, this.tsLanguageServiceManager);
+        this.languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(docManager, workspaceUris, configManager);
+        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(docManager, this.languageServiceManager);
     }
     async getCompletions(document, position, completionContext) {
         const completions = this.completionProvider.getCompletions(document, position, completionContext);
@@ -42,7 +24,7 @@ class AstroPlugin {
     }
     async getFoldingRanges(document) {
         const foldingRanges = [];
-        const { frontmatter } = document.astro;
+        const { frontmatter } = document.astroMeta;
         // Currently editing frontmatter, don't fold
         if (frontmatter.state !== 'closed')
             return foldingRanges;
@@ -54,7 +36,7 @@ class AstroPlugin {
                 startCharacter: start.character,
                 endLine: end.line,
                 endCharacter: end.character,
-                kind: vscode_languageserver_types_1.FoldingRangeKind.Imports,
+                kind: vscode_languageserver_1.FoldingRangeKind.Imports,
             },
         ];
     }
@@ -69,20 +51,20 @@ class AstroPlugin {
             return [];
         }
         const [componentName] = node.tag.split(':');
-        const { lang } = await this.tsLanguageServiceManager.getTypeScriptDoc(document);
+        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
         const defs = this.getDefinitionsForComponentName(document, lang, componentName);
         if (!defs || !defs.length) {
             return [];
         }
         const startRange = vscode_languageserver_1.Range.create(vscode_languageserver_1.Position.create(0, 0), vscode_languageserver_1.Position.create(0, 0));
         const links = defs.map((def) => {
-            const defFilePath = (0, utils_4.ensureRealFilePath)(def.fileName);
+            const defFilePath = (0, utils_2.ensureRealFilePath)(def.fileName);
             return vscode_languageserver_1.LocationLink.create((0, utils_1.pathToUrl)(defFilePath), startRange, startRange);
         });
         return links;
     }
     isInsideFrontmatter(document, position) {
-        return (0, utils_3.isInsideFrontmatter)(document.getText(), document.offsetAt(position));
+        return (0, documents_1.isInsideFrontmatter)(document.getText(), document.offsetAt(position));
     }
     isComponentTag(node) {
         if (!node.tag) {
@@ -111,15 +93,15 @@ class AstroPlugin {
     }
     getImportSpecifierForIdentifier(sourceFile, identifier) {
         let importSpecifier = undefined;
-        ts.forEachChild(sourceFile, (tsNode) => {
-            if (ts.isImportDeclaration(tsNode)) {
+        typescript_1.default.forEachChild(sourceFile, (tsNode) => {
+            if (typescript_1.default.isImportDeclaration(tsNode)) {
                 if (tsNode.importClause) {
                     const { name, namedBindings } = tsNode.importClause;
                     if (name && name.getText() === identifier) {
                         importSpecifier = tsNode.moduleSpecifier;
                         return true;
                     }
-                    else if (namedBindings && namedBindings.kind === ts.SyntaxKind.NamedImports) {
+                    else if (namedBindings && namedBindings.kind === typescript_1.default.SyntaxKind.NamedImports) {
                         const elements = namedBindings.elements;
                         for (let elem of elements) {
                             if (elem.name.getText() === identifier) {
@@ -135,6 +117,3 @@ class AstroPlugin {
     }
 }
 exports.AstroPlugin = AstroPlugin;
-function isNodeExported(node) {
-    return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 || (!!node.parent && node.parent.kind === ts.SyntaxKind.SourceFile);
-}