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

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/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/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/types.js").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/compilerUtils.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TODO: Upstream this
+ */
+import type { AttributeNode, CommentNode, ComponentNode, CustomElementNode, DoctypeNode, ElementNode, ExpressionNode, FragmentNode, FrontmatterNode, LiteralNode, Node, ParentNode, Point, Position, RootNode, TagLikeNode, TextNode } from '@astrojs/compiler/types';
+export declare const is: {
+    parent(node: Node): node is ParentNode;
+    literal(node: Node): node is LiteralNode;
+    tag(node: Node): node is TagLikeNode;
+    whitespace(node: Node): node is TextNode;
+    root: (node: Node) => node is RootNode;
+    element: (node: Node) => node is ElementNode;
+    customElement: (node: Node) => node is CustomElementNode;
+    component: (node: Node) => node is ComponentNode;
+    fragment: (node: Node) => node is FragmentNode;
+    expression: (node: Node) => node is ExpressionNode;
+    text: (node: Node) => node is TextNode;
+    doctype: (node: Node) => node is DoctypeNode;
+    comment: (node: Node) => node is CommentNode;
+    frontmatter: (node: Node) => node is FrontmatterNode;
+};
+export declare function createCompilerPosition(start: Point, end: Point): Position;
+export declare function createCompilerPoint(line: number, column: number, offset: number): Point;
+type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type AttributeNodeWithPosition = WithRequired<AttributeNode, 'position'>;
+export {};

package/dist/core/compilerUtils.js

@@ -0,0 +1,52 @@
+"use strict";
+/**
+ * TODO: Upstream this
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompilerPoint = exports.createCompilerPosition = exports.is = void 0;
+function guard(type) {
+    return (node) => node.type === type;
+}
+exports.is = {
+    parent(node) {
+        return Array.isArray(node.children);
+    },
+    literal(node) {
+        return typeof node.value === 'string';
+    },
+    tag(node) {
+        return (node.type === 'element' ||
+            node.type === 'custom-element' ||
+            node.type === 'component' ||
+            node.type === 'fragment');
+    },
+    whitespace(node) {
+        return node.type === 'text' && node.value.trim().length === 0;
+    },
+    root: guard('root'),
+    element: guard('element'),
+    customElement: guard('custom-element'),
+    component: guard('component'),
+    fragment: guard('fragment'),
+    expression: guard('expression'),
+    text: guard('text'),
+    doctype: guard('doctype'),
+    comment: guard('comment'),
+    frontmatter: guard('frontmatter'),
+};
+function createCompilerPosition(start, end) {
+    return {
+        start,
+        end,
+    };
+}
+exports.createCompilerPosition = createCompilerPosition;
+function createCompilerPoint(line, column, offset) {
+    return {
+        line,
+        column,
+        offset,
+    };
+}
+exports.createCompilerPoint = createCompilerPoint;
+//# sourceMappingURL=compilerUtils.js.map

package/dist/core/index.d.ts

@@ -0,0 +1,27 @@
+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;
+    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,119 @@
+"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 [
+                        ...(astroInstall
+                            ? ['./env.d.ts', './astro-jsx.d.ts'].map((filePath) => ts.sys.resolvePath(path.resolve(astroInstall.path, filePath)))
+                            : []),
+                        ...fileNames,
+                    ];
+                },
+                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;
+        htmlVirtualFile.embeddedFiles.push(...(0, parseCSS_1.extractStylesheets)(this.fileName, this.snapshot, htmlDocument, this.astroMeta.ast), ...(0, parseJS_js_1.extractScriptTags)(this.fileName, this.snapshot, htmlDocument, this.astroMeta.ast));
+        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,27 @@
+import type { Point } from '@astrojs/compiler/shared/ast';
+import type { ParseResult } 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,7 @@
+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 { AttributeNodeWithPosition } from './compilerUtils.js';
+export declare function extractStylesheets(fileName: string, snapshot: ts.IScriptSnapshot, htmlDocument: HTMLDocument, ast: ParseResult['ast']): VirtualFile[];
+export declare function findInlineStyles(ast: ParseResult['ast']): AttributeNodeWithPosition[];

package/dist/core/parseCSS.js

@@ -0,0 +1,116 @@
+"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.findInlineStyles = exports.extractStylesheets = void 0;
+const language_core_1 = require("@volar/language-core");
+const SourceMap = __importStar(require("@volar/source-map"));
+const muggle = __importStar(require("muggle-string"));
+const compilerUtils_js_1 = require("./compilerUtils.js");
+function extractStylesheets(fileName, snapshot, htmlDocument, ast) {
+    const embeddedCSSFiles = [];
+    for (const [index, root] of htmlDocument.roots.entries()) {
+        if (root.tag === 'style' && root.startTagEnd !== undefined && root.endTagStart !== undefined) {
+            const styleText = snapshot.getText(root.startTagEnd, root.endTagStart);
+            embeddedCSSFiles.push({
+                fileName: fileName + `.${index}.css`,
+                kind: language_core_1.FileKind.TextFile,
+                snapshot: {
+                    getText: (start, end) => styleText.substring(start, end),
+                    getLength: () => styleText.length,
+                    getChangeRange: () => undefined,
+                },
+                codegenStacks: [],
+                mappings: [
+                    {
+                        sourceRange: [root.startTagEnd, root.endTagStart],
+                        generatedRange: [0, styleText.length],
+                        data: language_core_1.FileRangeCapabilities.full,
+                    },
+                ],
+                capabilities: {
+                    diagnostic: false,
+                    documentSymbol: true,
+                    foldingRange: true,
+                    documentFormatting: false,
+                },
+                embeddedFiles: [],
+            });
+        }
+    }
+    const inlineStyles = findInlineStyles(ast);
+    if (inlineStyles.length > 0) {
+        const codes = [];
+        for (const inlineStyle of inlineStyles) {
+            codes.push('x { ');
+            codes.push([
+                inlineStyle.value,
+                undefined,
+                inlineStyle.position.start.offset + 'style="'.length,
+                language_core_1.FileRangeCapabilities.full,
+            ]);
+            codes.push(' }\n');
+        }
+        const mappings = SourceMap.buildMappings(codes);
+        const text = muggle.toString(codes);
+        embeddedCSSFiles.push({
+            fileName: fileName + '.inline.css',
+            codegenStacks: [],
+            snapshot: {
+                getText: (start, end) => text.substring(start, end),
+                getLength: () => text.length,
+                getChangeRange: () => undefined,
+            },
+            capabilities: {},
+            embeddedFiles: [],
+            kind: language_core_1.FileKind.TextFile,
+            mappings,
+        });
+    }
+    return embeddedCSSFiles;
+}
+exports.extractStylesheets = extractStylesheets;
+function findInlineStyles(ast) {
+    const styleAttrs = [];
+    // `@astrojs/compiler`'s `walk` method is async, so we can't use it here. Arf
+    function walkDown(parent) {
+        if (!parent.children)
+            return;
+        parent.children.forEach((child) => {
+            if (compilerUtils_js_1.is.element(child)) {
+                const styleAttribute = child.attributes.find((attr) => attr.name === 'style' && attr.kind === 'quoted');
+                if (styleAttribute && styleAttribute.position) {
+                    styleAttrs.push(styleAttribute);
+                }
+            }
+            if (compilerUtils_js_1.is.parent(child)) {
+                walkDown(child);
+            }
+        });
+    }
+    walkDown(ast);
+    return styleAttrs;
+}
+exports.findInlineStyles = findInlineStyles;
+//# sourceMappingURL=parseCSS.js.map

package/dist/core/parseHTML.d.ts

@@ -0,0 +1,7 @@
+import { VirtualFile } from '@volar/language-core';
+import type ts from 'typescript/lib/tsserverlibrary';
+import * as html from 'vscode-html-languageservice';
+export declare function parseHTML(fileName: string, snapshot: ts.IScriptSnapshot, frontmatterEnd: number): {
+    virtualFile: VirtualFile;
+    htmlDocument: html.HTMLDocument;
+};