@astrojs/language-server 1.0.4 → 2.0.0-next.0

package/dist/plugins/PluginHost.js

@@ -1,206 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginHost = void 0;
-const vscode_languageserver_1 = require("vscode-languageserver");
-const documents_1 = require("../core/documents");
-const utils_1 = require("../utils");
-var ExecuteMode;
-(function (ExecuteMode) {
-    ExecuteMode[ExecuteMode["None"] = 0] = "None";
-    ExecuteMode[ExecuteMode["FirstNonNull"] = 1] = "FirstNonNull";
-    ExecuteMode[ExecuteMode["Collect"] = 2] = "Collect";
-})(ExecuteMode || (ExecuteMode = {}));
-class PluginHost {
-    constructor(docManager) {
-        this.docManager = docManager;
-        this.plugins = [];
-        this.pluginHostConfig = {
-            filterIncompleteCompletions: true,
-            definitionLinkSupport: false,
-        };
-    }
-    initialize(pluginHostConfig) {
-        this.pluginHostConfig = pluginHostConfig;
-    }
-    registerPlugin(plugin) {
-        this.plugins.push(plugin);
-    }
-    async getCompletions(textDocument, position, completionContext, cancellationToken) {
-        const document = this.getDocument(textDocument.uri);
-        const completions = await Promise.all(this.plugins.map(async (plugin) => {
-            const result = await this.tryExecutePlugin(plugin, 'getCompletions', [document, position, completionContext, cancellationToken], null);
-            if (result) {
-                return { result: result, plugin: plugin.__name };
-            }
-        })).then((fullCompletions) => fullCompletions.filter(utils_1.isNotNullOrUndefined));
-        const html = completions.find((completion) => completion.plugin === 'html');
-        const ts = completions.find((completion) => completion.plugin === 'typescript');
-        const astro = completions.find((completion) => completion.plugin === 'astro');
-        if (html && ts) {
-            const inComponentStartTag = (0, documents_1.isInComponentStartTag)(document.html, document.offsetAt(position));
-            // If the HTML plugin returned completions, it's highly likely that TS ones are duplicate
-            if (html.result.items.length > 0) {
-                ts.result.items = [];
-            }
-            // Inside components, if the Astro plugin has completions we don't want the TS ones are they're duplicates
-            if (astro && astro.result.items.length > 0 && inComponentStartTag) {
-                ts.result.items = [];
-            }
-        }
-        let flattenedCompletions = completions.flatMap((completion) => completion.result.items);
-        const isIncomplete = completions.reduce((incomplete, completion) => incomplete || completion.result.isIncomplete, false);
-        // If the result is incomplete, we need to filter the results ourselves
-        // to throw out non-matching results. VSCode does filter client-side,
-        // but other IDEs might not.
-        if (isIncomplete && this.pluginHostConfig.filterIncompleteCompletions) {
-            const offset = document.offsetAt(position);
-            // Assumption for performance reasons:
-            // Noone types import names longer than 20 characters and still expects perfect autocompletion.
-            const text = document.getText().substring(Math.max(0, offset - 20), offset);
-            const start = (0, utils_1.regexLastIndexOf)(text, /[\W\s]/g) + 1;
-            const filterValue = text.substring(start).toLowerCase();
-            flattenedCompletions = flattenedCompletions.filter((comp) => comp.label.toLowerCase().includes(filterValue));
-        }
-        return vscode_languageserver_1.CompletionList.create(flattenedCompletions, isIncomplete);
-    }
-    async resolveCompletion(textDocument, completionItem) {
-        const document = this.getDocument(textDocument.uri);
-        const result = await this.execute('resolveCompletion', [document, completionItem], ExecuteMode.FirstNonNull);
-        return result ?? completionItem;
-    }
-    async getDiagnostics(textDocument) {
-        const document = this.getDocument(textDocument.uri);
-        const diagnostics = await this.execute('getDiagnostics', [document], ExecuteMode.Collect);
-        return diagnostics;
-    }
-    async doHover(textDocument, position) {
-        const document = this.getDocument(textDocument.uri);
-        return this.execute('doHover', [document, position], ExecuteMode.FirstNonNull);
-    }
-    async formatDocument(textDocument, options) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('formatDocument', [document, options], ExecuteMode.Collect);
-    }
-    async getCodeActions(textDocument, range, context, cancellationToken) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getCodeActions', [document, range, context, cancellationToken], ExecuteMode.Collect);
-    }
-    async doTagComplete(textDocument, position) {
-        const document = this.getDocument(textDocument.uri);
-        return this.execute('doTagComplete', [document, position], ExecuteMode.FirstNonNull);
-    }
-    async getFoldingRanges(textDocument) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getFoldingRanges', [document], ExecuteMode.Collect);
-    }
-    async getDocumentSymbols(textDocument, cancellationToken) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getDocumentSymbols', [document, cancellationToken], ExecuteMode.Collect);
-    }
-    async getSemanticTokens(textDocument, range, cancellationToken) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getSemanticTokens', [document, range, cancellationToken], ExecuteMode.FirstNonNull);
-    }
-    async getLinkedEditingRanges(textDocument, position) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getLinkedEditingRanges', [document, position], ExecuteMode.FirstNonNull);
-    }
-    async fileReferences(textDocument) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('fileReferences', [document], ExecuteMode.FirstNonNull);
-    }
-    async getDefinitions(textDocument, position) {
-        const document = this.getDocument(textDocument.uri);
-        const definitions = await this.execute('getDefinitions', [document, position], ExecuteMode.Collect);
-        if (this.pluginHostConfig.definitionLinkSupport) {
-            return definitions;
-        }
-        else {
-            return definitions.map((def) => ({ range: def.targetSelectionRange, uri: def.targetUri }));
-        }
-    }
-    getTypeDefinitions(textDocument, position) {
-        const document = this.getDocument(textDocument.uri);
-        return this.execute('getTypeDefinitions', [document, position], ExecuteMode.FirstNonNull);
-    }
-    getImplementations(textDocument, position) {
-        const document = this.getDocument(textDocument.uri);
-        return this.execute('getImplementation', [document, position], ExecuteMode.FirstNonNull);
-    }
-    getReferences(textdocument, position, context) {
-        const document = this.getDocument(textdocument.uri);
-        return this.execute('findReferences', [document, position, context], ExecuteMode.FirstNonNull);
-    }
-    async prepareRename(textDocument, position) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('prepareRename', [document, position], ExecuteMode.FirstNonNull);
-    }
-    async rename(textDocument, position, newName) {
-        const document = this.getDocument(textDocument.uri);
-        return this.execute('rename', [document, position, newName], ExecuteMode.FirstNonNull);
-    }
-    async getDocumentColors(textDocument) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getDocumentColors', [document], ExecuteMode.Collect);
-    }
-    async getColorPresentations(textDocument, range, color) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getColorPresentations', [document, range, color], ExecuteMode.Collect);
-    }
-    async getInlayHints(textDocument, range, cancellationToken) {
-        const document = this.getDocument(textDocument.uri);
-        return (await this.execute('getInlayHints', [document, range], ExecuteMode.FirstNonNull)) ?? [];
-    }
-    async getSignatureHelp(textDocument, position, context, cancellationToken) {
-        const document = this.getDocument(textDocument.uri);
-        return await this.execute('getSignatureHelp', [document, position, context, cancellationToken], ExecuteMode.FirstNonNull);
-    }
-    async onWatchFileChanges(onWatchFileChangesParams) {
-        for (const support of this.plugins) {
-            await support.onWatchFileChanges?.(onWatchFileChangesParams);
-        }
-    }
-    updateNonAstroFile(fileName, changes, text) {
-        for (const support of this.plugins) {
-            support.updateNonAstroFile?.(fileName, changes, text);
-        }
-    }
-    getDocument(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');
-        switch (mode) {
-            case ExecuteMode.FirstNonNull:
-                for (const plugin of plugins) {
-                    const res = await this.tryExecutePlugin(plugin, name, args, null);
-                    if (res != null) {
-                        return res;
-                    }
-                }
-                return null;
-            case ExecuteMode.Collect:
-                return (await Promise.all(plugins.map((plugin) => {
-                    let ret = this.tryExecutePlugin(plugin, name, args, []);
-                    return ret;
-                }))).flat();
-            case ExecuteMode.None:
-                await Promise.all(plugins.map((plugin) => this.tryExecutePlugin(plugin, name, args, null)));
-                return;
-        }
-    }
-    async tryExecutePlugin(plugin, fnName, args, failValue) {
-        try {
-            return await plugin[fnName](...args);
-        }
-        catch (e) {
-            console.error(e);
-            return failValue;
-        }
-    }
-}
-exports.PluginHost = PluginHost;

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

@@ -1,17 +0,0 @@
-import { CompletionContext, Diagnostic, FoldingRange, FormattingOptions, Position, TextEdit } from 'vscode-languageserver';
-import type { ConfigManager } from '../../core/config';
-import type { AstroDocument } from '../../core/documents';
-import type { AppCompletionList, Plugin } from '../interfaces';
-import type { LanguageServiceManager } from '../typescript/LanguageServiceManager';
-export declare class AstroPlugin implements Plugin {
-    __name: string;
-    private configManager;
-    private readonly languageServiceManager;
-    private readonly completionProvider;
-    private readonly diagnosticsProvider;
-    constructor(configManager: ConfigManager, languageServiceManager: LanguageServiceManager);
-    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
-    getDiagnostics(document: AstroDocument): Promise<Diagnostic[]>;
-    formatDocument(document: AstroDocument, options: FormattingOptions): Promise<TextEdit[]>;
-    getFoldingRanges(document: AstroDocument): FoldingRange[];
-}

package/dist/plugins/astro/AstroPlugin.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AstroPlugin = void 0;
-const vscode_languageserver_1 = require("vscode-languageserver");
-const importPackage_1 = require("../../importPackage");
-const CompletionsProvider_1 = require("./features/CompletionsProvider");
-const DiagnosticsProvider_1 = require("./features/DiagnosticsProvider");
-class AstroPlugin {
-    constructor(configManager, languageServiceManager) {
-        this.__name = 'astro';
-        this.configManager = configManager;
-        this.languageServiceManager = languageServiceManager;
-        this.completionProvider = new CompletionsProvider_1.CompletionsProviderImpl(this.languageServiceManager);
-        this.diagnosticsProvider = new DiagnosticsProvider_1.DiagnosticsProviderImpl(this.languageServiceManager);
-    }
-    async getCompletions(document, position, completionContext) {
-        const completions = this.completionProvider.getCompletions(document, position, completionContext);
-        return completions;
-    }
-    async getDiagnostics(document) {
-        return await this.diagnosticsProvider.getDiagnostics(document);
-    }
-    async formatDocument(document, options) {
-        const filePath = document.getFilePath();
-        if (!filePath) {
-            return [];
-        }
-        const prettier = (0, importPackage_1.importPrettier)(filePath);
-        const prettierConfig = (await prettier.resolveConfig(filePath, { editorconfig: true, useCache: false })) ?? {};
-        const prettierVSConfig = await this.configManager.getPrettierVSConfig(document);
-        const editorFormatConfig = options !== undefined // We need to check for options existing here because some editors might not have it
-            ? {
-                tabWidth: options.tabSize,
-                useTabs: !options.insertSpaces,
-            }
-            : {};
-        // Return a config with the following cascade:
-        // - Prettier config file should always win if it exists, if it doesn't:
-        // - Prettier config from the VS Code extension is used, if it doesn't exist:
-        // - Use the editor's basic configuration settings
-        const resultConfig = returnObjectIfHasKeys(prettierConfig) || returnObjectIfHasKeys(prettierVSConfig) || editorFormatConfig;
-        const fileInfo = await prettier.getFileInfo(filePath, { ignorePath: '.prettierignore' });
-        if (fileInfo.ignored) {
-            return [];
-        }
-        const result = prettier.format(document.getText(), {
-            ...resultConfig,
-            plugins: [...getAstroPrettierPlugin(), ...(resultConfig.plugins ?? [])],
-            parser: 'astro',
-        });
-        return document.getText() === result
-            ? []
-            : [vscode_languageserver_1.TextEdit.replace(vscode_languageserver_1.Range.create(document.positionAt(0), document.positionAt(document.getTextLength())), result)];
-        function getAstroPrettierPlugin() {
-            const hasPluginLoadedAlready = prettier.getSupportInfo().languages.some((l) => l.name === 'astro');
-            return hasPluginLoadedAlready ? [] : [(0, importPackage_1.getPrettierPluginPath)(filePath)];
-        }
-    }
-    getFoldingRanges(document) {
-        const foldingRanges = [];
-        const { frontmatter } = document.astroMeta;
-        // Currently editing frontmatter, don't fold
-        if (frontmatter.state !== 'closed')
-            return foldingRanges;
-        // The way folding ranges work is by folding anything between the starting position and the ending one, as such
-        // the start in this case should be after the frontmatter start (after the starting ---) until the last character
-        // of the last line of the frontmatter before its ending (before the closing ---)
-        // ---
-        //		^ -- start
-        // console.log("Astro")
-        // ---								^ -- end
-        const start = document.positionAt(frontmatter.startOffset + 3);
-        const end = document.positionAt(frontmatter.endOffset - 1);
-        return [
-            {
-                startLine: start.line,
-                startCharacter: start.character,
-                endLine: end.line,
-                endCharacter: end.character,
-                kind: vscode_languageserver_1.FoldingRangeKind.Imports,
-            },
-        ];
-    }
-}
-exports.AstroPlugin = AstroPlugin;
-function returnObjectIfHasKeys(obj) {
-    if (Object.keys(obj || {}).length > 0) {
-        return obj;
-    }
-}

package/dist/plugins/astro/features/CompletionsProvider.d.ts

@@ -1,17 +0,0 @@
-import { CompletionContext, Position } from 'vscode-languageserver';
-import type { AstroDocument } from '../../../core/documents';
-import type { AppCompletionList, CompletionsProvider } from '../../interfaces';
-import type { LanguageServiceManager } from '../../typescript/LanguageServiceManager';
-export declare class CompletionsProviderImpl implements CompletionsProvider {
-    private readonly languageServiceManager;
-    private readonly ts;
-    private lastCompletion;
-    directivesHTMLLang: import("vscode-html-languageservice").LanguageService;
-    constructor(languageServiceManager: LanguageServiceManager);
-    getCompletions(document: AstroDocument, position: Position, completionContext?: CompletionContext): Promise<AppCompletionList | null>;
-    private getComponentScriptCompletion;
-    private getPropCompletionsAndFilePath;
-    private getImportedSymbol;
-    private getPropType;
-    private getCompletionItemForProperty;
-}

package/dist/plugins/astro/features/CompletionsProvider.js

@@ -1,242 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompletionsProviderImpl = void 0;
-const vscode_html_languageservice_1 = require("vscode-html-languageservice");
-const vscode_languageserver_1 = require("vscode-languageserver");
-const utils_1 = require("../../../core/documents/utils");
-const astro_attributes_1 = require("../../html/features/astro-attributes");
-const utils_2 = require("../../html/utils");
-const utils_3 = require("../../typescript/utils");
-class CompletionsProviderImpl {
-    constructor(languageServiceManager) {
-        this.lastCompletion = null;
-        this.directivesHTMLLang = (0, vscode_html_languageservice_1.getLanguageService)({
-            customDataProviders: [astro_attributes_1.astroDirectives],
-            useDefaultDataProvider: false,
-        });
-        this.languageServiceManager = languageServiceManager;
-        this.ts = languageServiceManager.docContext.ts;
-    }
-    async getCompletions(document, position, completionContext) {
-        let items = [];
-        const html = document.html;
-        const offset = document.offsetAt(position);
-        const node = html.findNodeAt(offset);
-        const insideExpression = (0, utils_1.isInsideExpression)(document.getText(), node.start, offset);
-        if (completionContext?.triggerCharacter === '-' && node.parent === undefined && !insideExpression) {
-            const frontmatter = this.getComponentScriptCompletion(document, position);
-            if (frontmatter)
-                items.push(frontmatter);
-        }
-        if ((0, utils_1.isInComponentStartTag)(html, offset) && !insideExpression) {
-            const { completions: props, componentFilePath } = await this.getPropCompletionsAndFilePath(document, position, completionContext);
-            if (props.length) {
-                items.push(...props);
-            }
-            const isAstro = componentFilePath?.endsWith('.astro');
-            if (!isAstro && node.tag !== 'Fragment') {
-                const directives = (0, utils_2.removeDataAttrCompletion)(this.directivesHTMLLang.doComplete(document, position, html).items);
-                items.push(...directives);
-            }
-        }
-        return vscode_languageserver_1.CompletionList.create(items, true);
-    }
-    getComponentScriptCompletion(document, position) {
-        const base = {
-            kind: vscode_languageserver_1.CompletionItemKind.Snippet,
-            label: '---',
-            sortText: '\0',
-            preselect: true,
-            detail: 'Create component script block',
-            insertTextFormat: vscode_languageserver_1.InsertTextFormat.Snippet,
-            commitCharacters: [],
-        };
-        const prefix = document.getLineUntilOffset(document.offsetAt(position));
-        if (document.astroMeta.frontmatter.state === null) {
-            return {
-                ...base,
-                insertText: '---\n$0\n---',
-                textEdit: prefix.match(/^\s*\-+/)
-                    ? vscode_languageserver_1.TextEdit.replace({ start: { ...position, character: 0 }, end: position }, '---\n$0\n---')
-                    : undefined,
-            };
-        }
-        if (document.astroMeta.frontmatter.state === 'open') {
-            let insertText = '---';
-            // If the current line is a full component script starter/ender, the user expects a full frontmatter
-            // completion and not just a completion for "---"  on the same line (which result in, well, nothing)
-            if (prefix === '---') {
-                insertText = '---\n$0\n---';
-            }
-            return {
-                ...base,
-                insertText,
-                detail: insertText === '---' ? 'Close component script block' : 'Create component script block',
-                textEdit: prefix.match(/^\s*\-+/)
-                    ? vscode_languageserver_1.TextEdit.replace({ start: { ...position, character: 0 }, end: position }, insertText)
-                    : undefined,
-            };
-        }
-        return null;
-    }
-    async getPropCompletionsAndFilePath(document, position, completionContext) {
-        const offset = document.offsetAt(position);
-        const html = document.html;
-        const node = html.findNodeAt(offset);
-        if (!(0, utils_1.isPossibleComponent)(node)) {
-            return { completions: [], componentFilePath: null };
-        }
-        const inAttribute = node.start + node.tag.length < offset;
-        if (!inAttribute) {
-            return { completions: [], componentFilePath: null };
-        }
-        if (completionContext?.triggerCharacter === '/' || completionContext?.triggerCharacter === '>') {
-            return { completions: [], componentFilePath: null };
-        }
-        // If inside of attribute value, skip.
-        if (completionContext &&
-            completionContext.triggerKind === vscode_languageserver_1.CompletionTriggerKind.TriggerCharacter &&
-            completionContext.triggerCharacter === '"') {
-            return { completions: [], componentFilePath: null };
-        }
-        const componentName = node.tag;
-        const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
-        // Get the source file
-        const tsFilePath = tsDoc.filePath;
-        const program = lang.getProgram();
-        const sourceFile = program?.getSourceFile(tsFilePath);
-        const typeChecker = program?.getTypeChecker();
-        if (!sourceFile || !typeChecker) {
-            return { completions: [], componentFilePath: null };
-        }
-        // Get the import statement
-        const imp = this.getImportedSymbol(sourceFile, componentName);
-        const importType = imp && typeChecker.getTypeAtLocation(imp);
-        if (!importType) {
-            return { completions: [], componentFilePath: null };
-        }
-        const symbol = importType.getSymbol();
-        if (!symbol) {
-            return { completions: [], componentFilePath: null };
-        }
-        const symbolDeclaration = symbol.declarations;
-        if (!symbolDeclaration) {
-            return { completions: [], componentFilePath: null };
-        }
-        const filePath = symbolDeclaration[0].getSourceFile().fileName;
-        const componentSnapshot = await this.languageServiceManager.getSnapshot(filePath);
-        if (this.lastCompletion) {
-            if (this.lastCompletion.tag === componentName &&
-                this.lastCompletion.documentVersion == componentSnapshot.version) {
-                return { completions: this.lastCompletion.completions, componentFilePath: filePath };
-            }
-        }
-        // Get the component's props type
-        const componentType = this.getPropType(symbolDeclaration, typeChecker);
-        if (!componentType) {
-            return { completions: [], componentFilePath: null };
-        }
-        let completionItems = [];
-        // Add completions for this component's props type properties
-        const properties = componentType.getProperties().filter((property) => property.name !== 'children') || [];
-        properties.forEach((property) => {
-            const type = typeChecker.getTypeOfSymbolAtLocation(property, imp);
-            let completionItem = this.getCompletionItemForProperty(property, typeChecker, type);
-            completionItems.push(completionItem);
-        });
-        this.lastCompletion = {
-            tag: componentName,
-            documentVersion: componentSnapshot.version,
-            completions: completionItems,
-        };
-        return { completions: completionItems, componentFilePath: filePath };
-    }
-    getImportedSymbol(sourceFile, identifier) {
-        for (let list of sourceFile.getChildren()) {
-            for (let node of list.getChildren()) {
-                if (this.ts.isImportDeclaration(node)) {
-                    let clauses = node.importClause;
-                    if (!clauses)
-                        continue;
-                    let namedImport = clauses.getChildAt(0);
-                    if (this.ts.isNamedImports(namedImport)) {
-                        for (let imp of namedImport.elements) {
-                            // Iterate the named imports
-                            if (imp.name.getText() === identifier) {
-                                return imp;
-                            }
-                        }
-                    }
-                    else if (this.ts.isIdentifier(namedImport)) {
-                        if (namedImport.getText() === identifier) {
-                            return namedImport;
-                        }
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    getPropType(declarations, typeChecker) {
-        for (const decl of declarations) {
-            const fileName = (0, utils_3.toVirtualFilePath)(decl.getSourceFile().fileName);
-            if (fileName.endsWith('.tsx') || fileName.endsWith('.jsx') || fileName.endsWith('.d.ts')) {
-                if (!this.ts.isFunctionDeclaration(decl) && !this.ts.isFunctionTypeNode(decl)) {
-                    console.error(`We only support functions declarations at the moment`);
-                    continue;
-                }
-                const fn = decl;
-                if (!fn.parameters.length)
-                    continue;
-                const param1 = fn.parameters[0];
-                const propType = typeChecker.getTypeAtLocation(param1);
-                return propType;
-            }
-        }
-        return null;
-    }
-    getCompletionItemForProperty(mem, typeChecker, type) {
-        const typeString = typeChecker.typeToString(type);
-        let insertText = mem.name;
-        switch (typeString) {
-            case 'string':
-                insertText = `${mem.name}="$1"`;
-                break;
-            case 'boolean':
-                insertText = mem.name;
-                break;
-            default:
-                insertText = `${mem.name}={$1}`;
-                break;
-        }
-        let item = {
-            label: mem.name,
-            detail: typeString,
-            insertText: insertText,
-            insertTextFormat: vscode_languageserver_1.InsertTextFormat.Snippet,
-            commitCharacters: [],
-            // Ensure that props shows up first as a completion, despite this plugin being ran after the HTML one
-            sortText: '\0',
-        };
-        if (mem.flags & this.ts.SymbolFlags.Optional) {
-            item.filterText = item.label;
-            item.label += '?';
-            // Put optional props at a lower priority
-            item.sortText = '_';
-        }
-        mem.getDocumentationComment(typeChecker);
-        let description = mem
-            .getDocumentationComment(typeChecker)
-            .map((val) => val.text)
-            .join('\n');
-        if (description) {
-            let docs = {
-                kind: vscode_languageserver_1.MarkupKind.Markdown,
-                value: description,
-            };
-            item.documentation = docs;
-        }
-        return item;
-    }
-}
-exports.CompletionsProviderImpl = CompletionsProviderImpl;

package/dist/plugins/astro/features/DiagnosticsProvider.d.ts

@@ -1,10 +0,0 @@
-import { Diagnostic } from 'vscode-languageserver-types';
-import { AstroDocument } from '../../../core/documents';
-import { DiagnosticsProvider } from '../../interfaces';
-import { LanguageServiceManager } from '../../typescript/LanguageServiceManager';
-export declare class DiagnosticsProviderImpl implements DiagnosticsProvider {
-    private languageServiceManager;
-    constructor(languageServiceManager: LanguageServiceManager);
-    getDiagnostics(document: AstroDocument): Promise<Diagnostic[]>;
-    private compilerMessageToDiagnostic;
-}

package/dist/plugins/astro/features/DiagnosticsProvider.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiagnosticsProviderImpl = void 0;
-const vscode_languageserver_types_1 = require("vscode-languageserver-types");
-class DiagnosticsProviderImpl {
-    constructor(languageServiceManager) {
-        this.languageServiceManager = languageServiceManager;
-    }
-    async getDiagnostics(document) {
-        const { tsDoc } = (await this.languageServiceManager.getLSAndTSDoc(document));
-        return tsDoc.compilerDiagnostics.map(this.compilerMessageToDiagnostic);
-    }
-    compilerMessageToDiagnostic(message) {
-        return {
-            message: message.text + '\n\n' + message.hint,
-            range: vscode_languageserver_types_1.Range.create(message.location.line - 1, message.location.column - 1, message.location.line, message.location.length),
-            code: message.code,
-            severity: message.severity,
-            source: 'astro',
-        };
-    }
-}
-exports.DiagnosticsProviderImpl = DiagnosticsProviderImpl;

package/dist/plugins/css/CSSDocument.d.ts

@@ -1,45 +0,0 @@
-import type { Stylesheet, TextDocument } from 'vscode-css-languageservice';
-import type { Position } from 'vscode-languageserver';
-import { AstroDocument, DocumentMapper, ReadableDocument, TagInformation } from '../../core/documents';
-export interface CSSDocumentBase extends DocumentMapper, TextDocument {
-    languageId: string;
-    stylesheet: Stylesheet;
-}
-export declare class CSSDocument extends ReadableDocument implements DocumentMapper {
-    private parent;
-    private styleInfo;
-    readonly version: number;
-    stylesheet: Stylesheet;
-    languageId: string;
-    constructor(parent: AstroDocument, styleInfo: Pick<TagInformation, 'attributes' | 'start' | 'end'>);
-    /**
-     * Get the fragment position relative to the parent
-     * @param pos Position in fragment
-     */
-    getOriginalPosition(pos: Position): Position;
-    /**
-     * Get the position relative to the start of the fragment
-     * @param pos Position in parent
-     */
-    getGeneratedPosition(pos: Position): Position;
-    /**
-     * Returns true if the given parent position is inside of this fragment
-     * @param pos Position in parent
-     */
-    isInGenerated(pos: Position): boolean;
-    /**
-     * Get the fragment text from the parent
-     */
-    getText(): string;
-    /**
-     * Returns the length of the fragment as calculated from the start and end position
-     */
-    getTextLength(): number;
-    /**
-     * Return the parent file path
-     */
-    getFilePath(): string | null;
-    getURL(): string;
-    getAttributes(): Record<string, string>;
-    private get language();
-}