@astrojs/language-server 1.0.8 → 2.0.0-next.10

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Nate Moore
+Copyright (c) 2023 The Astro Technology Company
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -20,13 +20,11 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 
-
 """
 
-This license applies to code originating from the https://github.com/sveltejs/language-tools repository,
-which has provided an extremely solid foundation for us to build upon:
+This license applies to code originating from the https://github.com/sveltejs/language-tools repository:
 
-Copyright (c) 2020-Present [these people](https://github.com/sveltejs/language-tools/graphs/contributors) 
+Copyright (c) 2020-Present [these people](https://github.com/sveltejs/language-tools/graphs/contributors)
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -13,3 +13,13 @@ The Astro language server, implement the [language server protocol](https://micr
 ├── test            # Tests
 └── types           # Types injected into Astro files by the language server under certain conditions
 ```
+
+## Troubleshooting
+
+### Formatting does not work
+
+> Using VS Code? This section does not apply to you, the VS Code extension includes both Prettier and the Astro plugin by default.
+
+The Astro language server uses Prettier to format Astro files, but does not include `prettier` or `prettier-plugin-astro` by itself as dependencies in order to keep the dependency count low and allow users to better control the version of Prettier they want to use.
+
+As such, if you want to use formatting, you'll need to install `prettier` and `prettier-plugin-astro` as dependencies in your project.

package/bin/nodeServer.js

@@ -1,3 +1,7 @@
-#! /usr/bin/env node
-
-require('../dist/node.js');
+#!/usr/bin/env node
+if (process.argv.includes('--version')) {
+	const pkgJSON = require('../package.json');
+	console.log(`${pkgJSON['version']}`);
+} else {
+	require('../dist/nodeServer.js');
+}

package/dist/check.d.ts

@@ -1,23 +1,24 @@
-import type { Diagnostic } from 'vscode-languageserver-types';
-import { LSConfig } from './core/config';
-export { DiagnosticSeverity } from 'vscode-languageserver-types';
-export { Diagnostic };
-export interface GetDiagnosticsResult {
-    fileUri: string;
-    text: string;
-    diagnostics: Diagnostic[];
+import * as kit from '@volar/kit';
+export { DiagnosticSeverity, type Diagnostic } from '@volar/language-server';
+export interface CheckResult {
+    errors: kit.Diagnostic[];
+    fileUrl: URL;
+    fileContent: string;
 }
 export declare class AstroCheck {
-    private docManager;
-    private configManager;
-    private pluginHost;
-    constructor(workspacePath: string, typescriptPath: string, options?: LSConfig);
-    upsertDocument(doc: {
-        text: string;
-        uri: string;
-    }): void;
-    removeDocument(uri: string): void;
-    getDiagnostics(): Promise<GetDiagnosticsResult[]>;
+    private readonly workspacePath;
+    private readonly typescriptPath;
+    private ts;
+    private project;
+    private linter;
+    constructor(workspacePath: string, typescriptPath: string | undefined);
+    /**
+     * Lint a list of files or the entire project and optionally log the errors found
+     * @param fileNames List of files to lint, if undefined, all files included in the project will be linted
+     * @param logErrors Whether to log errors by itself. This is disabled by default.
+     * @return {CheckResult} The result of the lint, including a list of errors, the file's content and its file path.
+     */
+    lint(fileNames?: string[] | undefined, logErrors?: boolean): Promise<CheckResult[]>;
     private initialize;
-    private getDiagnosticsForFile;
+    private getTsconfig;
 }

package/dist/check.js

@@ -1,60 +1,117 @@
 "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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AstroCheck = exports.DiagnosticSeverity = void 0;
-const config_1 = require("./core/config");
-const documents_1 = require("./core/documents");
-const plugins_1 = require("./plugins");
-const LanguageServiceManager_1 = require("./plugins/typescript/LanguageServiceManager");
-const utils_1 = require("./utils");
-var vscode_languageserver_types_1 = require("vscode-languageserver-types");
-Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return vscode_languageserver_types_1.DiagnosticSeverity; } });
+const kit = __importStar(require("@volar/kit"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const node_url_1 = require("node:url");
+const index_js_1 = require("./core/index.js");
+const svelte_js_1 = require("./core/svelte.js");
+const utils_js_1 = require("./core/utils.js");
+const vue_js_1 = require("./core/vue.js");
+const astro_js_1 = __importDefault(require("./plugins/astro.js"));
+const index_js_2 = __importDefault(require("./plugins/typescript/index.js"));
+// Export those for downstream consumers
+var language_server_1 = require("@volar/language-server");
+Object.defineProperty(exports, "DiagnosticSeverity", { enumerable: true, get: function () { return language_server_1.DiagnosticSeverity; } });
 class AstroCheck {
-    constructor(workspacePath, typescriptPath, options) {
-        this.docManager = documents_1.DocumentManager.newInstance();
-        this.configManager = new config_1.ConfigManager();
-        this.pluginHost = new plugins_1.PluginHost(this.docManager);
-        try {
-            const ts = require(typescriptPath);
-            this.initialize(workspacePath, ts);
-        }
-        catch (e) {
-            throw new Error(`Couldn't load TypeScript from path ${typescriptPath}`);
-        }
-        if (options) {
-            this.configManager.updateGlobalConfig(options);
-        }
-    }
-    upsertDocument(doc) {
-        this.docManager.openDocument({
-            text: doc.text,
-            uri: doc.uri,
-        });
-        this.docManager.markAsOpenedInClient(doc.uri);
+    constructor(workspacePath, typescriptPath) {
+        this.workspacePath = workspacePath;
+        this.typescriptPath = typescriptPath;
+        this.initialize();
     }
-    removeDocument(uri) {
-        if (!this.docManager.get(uri)) {
-            return;
+    /**
+     * Lint a list of files or the entire project and optionally log the errors found
+     * @param fileNames List of files to lint, if undefined, all files included in the project will be linted
+     * @param logErrors Whether to log errors by itself. This is disabled by default.
+     * @return {CheckResult} The result of the lint, including a list of errors, the file's content and its file path.
+     */
+    async lint(fileNames = undefined, logErrors = false) {
+        const files = fileNames !== undefined
+            ? fileNames
+            : this.project.languageServiceHost
+                .getScriptFileNames()
+                .filter((file) => file.endsWith('.astro'));
+        const errors = [];
+        for (const file of files) {
+            const fileErrors = await this.linter.check(file);
+            if (logErrors) {
+                this.linter.logErrors(file, fileErrors);
+            }
+            if (fileErrors.length > 0) {
+                const fileSnapshot = this.project.languageServiceHost.getScriptSnapshot(file);
+                const fileContent = fileSnapshot?.getText(0, fileSnapshot.getLength());
+                errors.push({
+                    errors: fileErrors,
+                    fileContent: fileContent ?? '',
+                    fileUrl: (0, node_url_1.pathToFileURL)(file),
+                });
+            }
         }
-        this.docManager.closeDocument(uri);
-        this.docManager.releaseDocument(uri);
+        return errors;
     }
-    async getDiagnostics() {
-        return await Promise.all(this.docManager.getAllOpenedByClient().map(async (doc) => {
-            const uri = doc[1].uri;
-            return await this.getDiagnosticsForFile(uri);
-        }));
-    }
-    initialize(workspacePath, ts) {
-        const languageServiceManager = new LanguageServiceManager_1.LanguageServiceManager(this.docManager, [(0, utils_1.normalizeUri)(workspacePath)], this.configManager, ts);
-        this.pluginHost.registerPlugin(new plugins_1.TypeScriptPlugin(this.configManager, languageServiceManager));
-    }
-    async getDiagnosticsForFile(uri) {
-        const diagnostics = await this.pluginHost.getDiagnostics({ uri });
-        return {
-            fileUri: uri || '',
-            text: this.docManager.get(uri)?.getText() || '',
-            diagnostics,
+    initialize() {
+        this.ts = this.typescriptPath ? require(this.typescriptPath) : require('typescript');
+        const tsconfigPath = this.getTsconfig();
+        const config = {
+            languages: {
+                astro: (0, index_js_1.getLanguageModule)((0, utils_js_1.getAstroInstall)([this.workspacePath]), this.ts),
+                svelte: (0, svelte_js_1.getSvelteLanguageModule)(),
+                vue: (0, vue_js_1.getVueLanguageModule)(),
+            },
+            services: {
+                typescript: (0, index_js_2.default)(),
+                astro: (0, astro_js_1.default)(),
+            },
         };
+        if (tsconfigPath) {
+            this.project = kit.createProject(tsconfigPath, [
+                { extension: 'astro', isMixedContent: true, scriptKind: 7 },
+                { extension: 'vue', isMixedContent: true, scriptKind: 7 },
+                { extension: 'svelte', isMixedContent: true, scriptKind: 7 },
+            ]);
+        }
+        else {
+            this.project = kit.createInferredProject(this.workspacePath, () => {
+                return fast_glob_1.default.sync('**/*.astro', {
+                    cwd: this.workspacePath,
+                    ignore: ['node_modules'],
+                    absolute: true,
+                });
+            });
+        }
+        this.linter = kit.createLinter(config, this.project.languageServiceHost);
+    }
+    getTsconfig() {
+        const tsconfig = this.ts.findConfigFile(this.workspacePath, this.ts.sys.fileExists) ||
+            this.ts.findConfigFile(this.workspacePath, this.ts.sys.fileExists, 'jsconfig.json');
+        return tsconfig;
     }
 }
 exports.AstroCheck = AstroCheck;
+//# sourceMappingURL=check.js.map

package/dist/core/astro2tsx.d.ts

@@ -0,0 +1,6 @@
+import { VirtualFile } from '@volar/language-core';
+import { HTMLDocument } from 'vscode-html-languageservice';
+export declare function astro2tsx(input: string, fileName: string, ts: typeof import('typescript/lib/tsserverlibrary.js'), htmlDocument: HTMLDocument): {
+    virtualFile: VirtualFile;
+    diagnostics: import("@astrojs/compiler").DiagnosticMessage[];
+};

package/dist/core/astro2tsx.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astro2tsx = void 0;
+const sync_1 = require("@astrojs/compiler/sync");
+const sourcemap_codec_1 = require("@jridgewell/sourcemap-codec");
+const language_core_1 = require("@volar/language-core");
+const vscode_html_languageservice_1 = require("vscode-html-languageservice");
+const utils_js_1 = require("./utils.js");
+function astro2tsx(input, fileName, ts, htmlDocument) {
+    const tsx = (0, sync_1.convertToTSX)(input, { filename: fileName });
+    return {
+        virtualFile: getVirtualFileTSX(input, tsx, fileName, ts, htmlDocument),
+        diagnostics: tsx.diagnostics,
+    };
+}
+exports.astro2tsx = astro2tsx;
+function getVirtualFileTSX(input, tsx, fileName, ts, htmlDocument) {
+    tsx.code = (0, utils_js_1.patchTSX)(tsx.code);
+    const v3Mappings = (0, sourcemap_codec_1.decode)(tsx.map.mappings);
+    const sourcedDoc = vscode_html_languageservice_1.TextDocument.create(fileName, 'astro', 0, input);
+    const genDoc = vscode_html_languageservice_1.TextDocument.create(fileName + '.tsx', 'typescriptreact', 0, tsx.code);
+    const mappings = [];
+    let current;
+    for (let genLine = 0; genLine < v3Mappings.length; genLine++) {
+        for (const segment of v3Mappings[genLine]) {
+            const genCharacter = segment[0];
+            const genOffset = genDoc.offsetAt({ line: genLine, character: genCharacter });
+            if (current) {
+                let length = genOffset - current.genOffset;
+                const sourceText = input.substring(current.sourceOffset, current.sourceOffset + length);
+                const genText = tsx.code.substring(current.genOffset, current.genOffset + length);
+                if (sourceText !== genText) {
+                    length = 0;
+                    for (let i = 0; i < genOffset - current.genOffset; i++) {
+                        if (sourceText[i] === genText[i]) {
+                            length = i + 1;
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                }
+                if (length > 0) {
+                    const lastMapping = mappings.length ? mappings[mappings.length - 1] : undefined;
+                    if (lastMapping &&
+                        lastMapping.generatedRange[1] === current.genOffset &&
+                        lastMapping.sourceRange[1] === current.sourceOffset) {
+                        lastMapping.generatedRange[1] = current.genOffset + length;
+                        lastMapping.sourceRange[1] = current.sourceOffset + length;
+                    }
+                    else {
+                        // Disable features inside script tags. This is a bit annoying to do, I wonder if maybe leaving script tags
+                        // unmapped would be better.
+                        const node = htmlDocument.findNodeAt(current.sourceOffset);
+                        const rangeCapabilities = node.tag !== 'script'
+                            ? language_core_1.FileRangeCapabilities.full
+                            : {
+                                completion: false,
+                                definition: false,
+                                diagnostic: false,
+                                displayWithLink: false,
+                                hover: false,
+                                references: false,
+                                referencesCodeLens: false,
+                                rename: false,
+                                semanticTokens: false,
+                            };
+                        mappings.push({
+                            sourceRange: [current.sourceOffset, current.sourceOffset + length],
+                            generatedRange: [current.genOffset, current.genOffset + length],
+                            data: rangeCapabilities,
+                        });
+                    }
+                }
+                current = undefined;
+            }
+            if (segment[2] !== undefined && segment[3] !== undefined) {
+                const sourceOffset = sourcedDoc.offsetAt({ line: segment[2], character: segment[3] });
+                current = {
+                    genOffset,
+                    sourceOffset,
+                };
+            }
+        }
+    }
+    // Ensure that `0:0` is mapped to `0:0` to make sure we properly handle "unmapped" lines
+    mappings.push({
+        sourceRange: [0, 0],
+        generatedRange: [0, 0],
+        data: {},
+    });
+    const ast = ts.createSourceFile('/a.tsx', tsx.code, ts.ScriptTarget.ESNext);
+    mappings.push({
+        sourceRange: [0, input.length],
+        generatedRange: [ast.statements[0].getStart(ast), tsx.code.length],
+        data: {},
+    });
+    return {
+        fileName: fileName + '.tsx',
+        kind: language_core_1.FileKind.TypeScriptHostFile,
+        capabilities: {
+            codeAction: true,
+            documentFormatting: false,
+            diagnostic: true,
+            documentSymbol: true,
+            inlayHint: true,
+            foldingRange: true,
+        },
+        codegenStacks: [],
+        snapshot: {
+            getText: (start, end) => tsx.code.substring(start, end),
+            getLength: () => tsx.code.length,
+            getChangeRange: () => undefined,
+        },
+        mappings: mappings,
+        embeddedFiles: [],
+    };
+}
+//# sourceMappingURL=astro2tsx.js.map

package/dist/core/index.d.ts

@@ -0,0 +1,28 @@
+import type { DiagnosticMessage, ParseResult } from '@astrojs/compiler/types';
+import { FileCapabilities, FileKind, type Language, type VirtualFile } from '@volar/language-core';
+import type ts from 'typescript/lib/tsserverlibrary';
+import type { HTMLDocument } from 'vscode-html-languageservice';
+import { FrontmatterStatus } from './parseAstro';
+import type { AstroInstall } from './utils';
+export declare function getLanguageModule(astroInstall: AstroInstall | undefined, ts: typeof import('typescript/lib/tsserverlibrary.js')): Language<AstroFile>;
+export declare class AstroFile implements VirtualFile {
+    sourceFileName: string;
+    snapshot: ts.IScriptSnapshot;
+    private readonly ts;
+    kind: FileKind;
+    capabilities: FileCapabilities;
+    fileName: string;
+    mappings: VirtualFile['mappings'];
+    embeddedFiles: VirtualFile['embeddedFiles'];
+    astroMeta: ParseResult & {
+        frontmatter: FrontmatterStatus;
+    };
+    compilerDiagnostics: DiagnosticMessage[];
+    htmlDocument: HTMLDocument;
+    scriptFiles: string[];
+    codegenStacks: never[];
+    constructor(sourceFileName: string, snapshot: ts.IScriptSnapshot, ts: typeof import('typescript/lib/tsserverlibrary.js'));
+    get hasCompilationErrors(): boolean;
+    update(newSnapshot: ts.IScriptSnapshot): void;
+    onSnapshotUpdated(): void;
+}

package/dist/core/index.js

@@ -0,0 +1,121 @@
+"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 });
+exports.AstroFile = exports.getLanguageModule = void 0;
+const language_core_1 = require("@volar/language-core");
+const path = __importStar(require("node:path"));
+const astro2tsx_1 = require("./astro2tsx");
+const parseAstro_1 = require("./parseAstro");
+const parseCSS_1 = require("./parseCSS");
+const parseHTML_1 = require("./parseHTML");
+const parseJS_js_1 = require("./parseJS.js");
+function getLanguageModule(astroInstall, ts) {
+    return {
+        createVirtualFile(fileName, snapshot) {
+            if (fileName.endsWith('.astro')) {
+                return new AstroFile(fileName, snapshot, ts);
+            }
+        },
+        updateVirtualFile(astroFile, snapshot) {
+            astroFile.update(snapshot);
+        },
+        resolveHost(host) {
+            return {
+                ...host,
+                getScriptFileNames() {
+                    const fileNames = host.getScriptFileNames();
+                    return [
+                        ...fileNames,
+                        ...(astroInstall
+                            ? ['./env.d.ts', './astro-jsx.d.ts'].map((filePath) => ts.sys.resolvePath(path.resolve(astroInstall.path, filePath)))
+                            : []),
+                    ];
+                },
+                getCompilationSettings() {
+                    const baseCompilationSettings = host.getCompilationSettings();
+                    return {
+                        ...baseCompilationSettings,
+                        module: ts.ModuleKind.ESNext ?? 99,
+                        target: ts.ScriptTarget.ESNext ?? 99,
+                        jsx: ts.JsxEmit.Preserve ?? 1,
+                        jsxImportSource: undefined,
+                        jsxFactory: 'astroHTML',
+                        resolveJsonModule: true,
+                        allowJs: true,
+                        isolatedModules: true,
+                        moduleResolution: baseCompilationSettings.moduleResolution === ts.ModuleResolutionKind.Classic ||
+                            !baseCompilationSettings.moduleResolution
+                            ? ts.ModuleResolutionKind.Node10
+                            : baseCompilationSettings.moduleResolution,
+                    };
+                },
+            };
+        },
+    };
+}
+exports.getLanguageModule = getLanguageModule;
+class AstroFile {
+    constructor(sourceFileName, snapshot, ts) {
+        this.sourceFileName = sourceFileName;
+        this.snapshot = snapshot;
+        this.ts = ts;
+        this.kind = language_core_1.FileKind.TextFile;
+        this.capabilities = language_core_1.FileCapabilities.full;
+        this.codegenStacks = [];
+        this.fileName = sourceFileName;
+        this.onSnapshotUpdated();
+    }
+    get hasCompilationErrors() {
+        return this.compilerDiagnostics.filter((diag) => diag.severity === 1).length > 0;
+    }
+    update(newSnapshot) {
+        this.snapshot = newSnapshot;
+        this.onSnapshotUpdated();
+    }
+    onSnapshotUpdated() {
+        this.mappings = [
+            {
+                sourceRange: [0, this.snapshot.getLength()],
+                generatedRange: [0, this.snapshot.getLength()],
+                data: language_core_1.FileRangeCapabilities.full,
+            },
+        ];
+        this.astroMeta = (0, parseAstro_1.getAstroMetadata)(this.snapshot.getText(0, this.snapshot.getLength()));
+        const { htmlDocument, virtualFile: htmlVirtualFile } = (0, parseHTML_1.parseHTML)(this.fileName, this.snapshot, this.astroMeta.frontmatter.status === 'closed'
+            ? this.astroMeta.frontmatter.position.end.offset
+            : 0);
+        this.htmlDocument = htmlDocument;
+        const scriptTags = (0, parseJS_js_1.extractScriptTags)(this.fileName, this.snapshot, htmlDocument, this.astroMeta.ast);
+        this.scriptFiles = scriptTags.map((scriptTag) => scriptTag.fileName);
+        htmlVirtualFile.embeddedFiles.push(...(0, parseCSS_1.extractStylesheets)(this.fileName, this.snapshot, htmlDocument, this.astroMeta.ast), ...scriptTags);
+        this.embeddedFiles = [];
+        this.embeddedFiles.push(htmlVirtualFile);
+        const tsx = (0, astro2tsx_1.astro2tsx)(this.snapshot.getText(0, this.snapshot.getLength()), this.fileName, this.ts, htmlDocument);
+        this.compilerDiagnostics = tsx.diagnostics;
+        this.embeddedFiles.push(tsx.virtualFile);
+    }
+}
+exports.AstroFile = AstroFile;
+//# sourceMappingURL=index.js.map

package/dist/core/parseAstro.d.ts

@@ -0,0 +1,26 @@
+import type { ParseResult, Point } from '@astrojs/compiler/types';
+type AstroMetadata = ParseResult & {
+    frontmatter: FrontmatterStatus;
+};
+export declare function getAstroMetadata(input: string, position?: boolean): AstroMetadata;
+interface FrontmatterOpen {
+    status: 'open';
+    position: {
+        start: Point;
+        end: undefined;
+    };
+}
+interface FrontmatterClosed {
+    status: 'closed';
+    position: {
+        start: Point;
+        end: Point;
+    };
+}
+interface FrontmatterNull {
+    status: 'doesnt-exist';
+    position: undefined;
+}
+export type FrontmatterStatus = FrontmatterOpen | FrontmatterClosed | FrontmatterNull;
+export declare function getFrontmatterStatus(ast: ParseResult['ast']): FrontmatterStatus;
+export {};

package/dist/core/parseAstro.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFrontmatterStatus = exports.getAstroMetadata = void 0;
+const sync_1 = require("@astrojs/compiler/sync");
+function getAstroMetadata(input, position = true) {
+    const parseResult = (0, sync_1.parse)(input, { position: position });
+    return {
+        ...parseResult,
+        frontmatter: getFrontmatterStatus(parseResult.ast),
+    };
+}
+exports.getAstroMetadata = getAstroMetadata;
+function getFrontmatterStatus(ast) {
+    if (!ast.children || (ast.children && ast.children.length === 0)) {
+        return {
+            status: 'doesnt-exist',
+            position: undefined,
+        };
+    }
+    if (ast.children[0].type === 'frontmatter') {
+        const frontmatter = ast.children[0];
+        if (frontmatter.position) {
+            if (frontmatter.position.end) {
+                return {
+                    status: 'closed',
+                    position: {
+                        start: frontmatter.position.start,
+                        end: frontmatter.position.end,
+                    },
+                };
+            }
+            return {
+                status: 'open',
+                position: {
+                    start: frontmatter.position.start,
+                    end: undefined,
+                },
+            };
+        }
+    }
+    return {
+        status: 'doesnt-exist',
+        position: undefined,
+    };
+}
+exports.getFrontmatterStatus = getFrontmatterStatus;
+//# sourceMappingURL=parseAstro.js.map

package/dist/core/parseCSS.d.ts

@@ -0,0 +1,8 @@
+import type { ParseResult } from '@astrojs/compiler/types';
+import { VirtualFile } from '@volar/language-core';
+import type ts from 'typescript/lib/tsserverlibrary';
+import type { HTMLDocument } from 'vscode-html-languageservice';
+import type { AttributeNodeWithPosition } from '../utils.js';
+export declare function extractStylesheets(fileName: string, snapshot: ts.IScriptSnapshot, htmlDocument: HTMLDocument, ast: ParseResult['ast']): VirtualFile[];
+export declare function collectClassesAndIdsFromDocument(ast: ParseResult['ast']): string[];
+export declare function findInlineStyles(ast: ParseResult['ast']): AttributeNodeWithPosition[];