@astrojs/language-server 2.11.1 → 2.12.0

package/dist/core/astro2tsx.d.ts

@@ -1,10 +1,11 @@
-import type { ConvertToTSXOptions, TSXResult } from '@astrojs/compiler/types';
+import type { ConvertToTSXOptions, TSXExtractedScript, TSXExtractedStyle, TSXResult } from '@astrojs/compiler/types';
 import type { VirtualCode } from '@volar/language-core';
 import { Range } from '@volar/language-server';
-import { HTMLDocument } from 'vscode-html-languageservice';
 export interface LSPTSXRanges {
     frontmatter: Range;
     body: Range;
+    scripts: TSXExtractedScript[];
+    styles: TSXExtractedStyle[];
 }
 export declare function safeConvertToTSX(content: string, options: ConvertToTSXOptions): TSXResult | {
     code: string;
@@ -36,10 +37,12 @@ export declare function safeConvertToTSX(content: string, options: ConvertToTSXO
             start: number;
             end: number;
         };
+        scripts: never[];
+        styles: never[];
     };
 };
 export declare function getTSXRangesAsLSPRanges(tsx: TSXResult): LSPTSXRanges;
-export declare function astro2tsx(input: string, fileName: string, htmlDocument: HTMLDocument): {
+export declare function astro2tsx(input: string, fileName: string): {
     virtualCode: VirtualCode;
     diagnostics: import("@astrojs/compiler").DiagnosticMessage[] | {
         code: 1000;

package/dist/core/astro2tsx.js

@@ -40,6 +40,8 @@ function safeConvertToTSX(content, options) {
                     start: 0,
                     end: 0,
                 },
+                scripts: [],
+                styles: [],
             },
         };
     }
@@ -50,19 +52,21 @@ function getTSXRangesAsLSPRanges(tsx) {
     return {
         frontmatter: language_server_1.Range.create(textDocument.positionAt(tsx.metaRanges.frontmatter.start), textDocument.positionAt(tsx.metaRanges.frontmatter.end)),
         body: language_server_1.Range.create(textDocument.positionAt(tsx.metaRanges.body.start), textDocument.positionAt(tsx.metaRanges.body.end)),
+        scripts: tsx.metaRanges.scripts ?? [],
+        styles: tsx.metaRanges.styles ?? [],
     };
 }
 exports.getTSXRangesAsLSPRanges = getTSXRangesAsLSPRanges;
-function astro2tsx(input, fileName, htmlDocument) {
+function astro2tsx(input, fileName) {
     const tsx = safeConvertToTSX(input, { filename: fileName });
     return {
-        virtualCode: getVirtualCodeTSX(input, tsx, fileName, htmlDocument),
+        virtualCode: getVirtualCodeTSX(input, tsx, fileName),
         diagnostics: tsx.diagnostics,
         ranges: getTSXRangesAsLSPRanges(tsx),
     };
 }
 exports.astro2tsx = astro2tsx;
-function getVirtualCodeTSX(input, tsx, fileName, htmlDocument) {
+function getVirtualCodeTSX(input, tsx, fileName) {
     tsx.code = (0, utils_js_1.patchTSX)(tsx.code, fileName);
     const v3Mappings = (0, sourcemap_codec_1.decode)(tsx.map.mappings);
     const sourcedDoc = vscode_html_languageservice_1.TextDocument.create('', 'astro', 0, input);
@@ -96,31 +100,18 @@ function getVirtualCodeTSX(input, tsx, fileName, htmlDocument) {
                         lastMapping.lengths[0] += 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'
-                            ? {
+                        mappings.push({
+                            sourceOffsets: [current.sourceOffset],
+                            generatedOffsets: [current.genOffset],
+                            lengths: [length],
+                            data: {
                                 verification: true,
                                 completion: true,
                                 semantic: true,
                                 navigation: true,
                                 structure: true,
                                 format: false,
-                            }
-                            : {
-                                verification: false,
-                                completion: false,
-                                semantic: false,
-                                navigation: false,
-                                structure: false,
-                                format: false,
-                            };
-                        mappings.push({
-                            sourceOffsets: [current.sourceOffset],
-                            generatedOffsets: [current.genOffset],
-                            lengths: [length],
-                            data: rangeCapabilities,
+                            },
                         });
                     }
                 }

package/dist/core/index.d.ts

@@ -16,7 +16,6 @@ export declare class AstroVirtualCode implements VirtualCode {
     astroMeta: AstroMetadata;
     compilerDiagnostics: DiagnosticMessage[];
     htmlDocument: HTMLDocument;
-    scriptCodeIds: string[];
     codegenStacks: never[];
     constructor(fileName: string, snapshot: ts.IScriptSnapshot);
     get hasCompilationErrors(): boolean;

package/dist/core/index.js

@@ -145,25 +145,19 @@ class AstroVirtualCode {
                 },
             },
         ];
-        this.compilerDiagnostics = [];
+        const tsx = (0, astro2tsx_1.astro2tsx)(this.snapshot.getText(0, this.snapshot.getLength()), this.fileName);
         const astroMetadata = (0, parseAstro_1.getAstroMetadata)(this.fileName, this.snapshot.getText(0, this.snapshot.getLength()));
-        if (astroMetadata.diagnostics.length > 0) {
-            this.compilerDiagnostics.push(...astroMetadata.diagnostics);
-        }
         const { htmlDocument, virtualCode: htmlVirtualCode } = (0, parseHTML_1.parseHTML)(this.snapshot, astroMetadata.frontmatter.status === 'closed'
             ? astroMetadata.frontmatter.position.end.offset
             : 0);
         this.htmlDocument = htmlDocument;
-        const scriptTags = (0, parseJS_js_1.extractScriptTags)(this.snapshot, htmlDocument, astroMetadata.ast);
-        this.scriptCodeIds = scriptTags.map((scriptTag) => scriptTag.id);
-        htmlVirtualCode.embeddedCodes = [];
-        htmlVirtualCode.embeddedCodes.push(...(0, parseCSS_1.extractStylesheets)(this.snapshot, htmlDocument, astroMetadata.ast), ...scriptTags);
-        this.embeddedCodes = [];
-        this.embeddedCodes.push(htmlVirtualCode);
-        const tsx = (0, astro2tsx_1.astro2tsx)(this.snapshot.getText(0, this.snapshot.getLength()), this.fileName, htmlDocument);
+        htmlVirtualCode.embeddedCodes = [
+            (0, parseCSS_1.extractStylesheets)(tsx.ranges.styles),
+            ...(0, parseJS_js_1.extractScriptTags)(tsx.ranges.scripts),
+        ];
         this.astroMeta = { ...astroMetadata, tsxRanges: tsx.ranges };
-        this.compilerDiagnostics.push(...tsx.diagnostics);
-        this.embeddedCodes.push(tsx.virtualCode);
+        this.compilerDiagnostics = [...tsx.diagnostics, ...astroMetadata.diagnostics];
+        this.embeddedCodes = [htmlVirtualCode, tsx.virtualCode];
     }
     get hasCompilationErrors() {
         return this.compilerDiagnostics.filter((diag) => diag.severity === 1).length > 0;

package/dist/core/parseCSS.d.ts

@@ -1,6 +1,3 @@
-import type { ParseResult } from '@astrojs/compiler/types';
+import type { TSXExtractedStyle } from '@astrojs/compiler/types';
 import type { VirtualCode } from '@volar/language-core';
-import type ts from 'typescript';
-import type { HTMLDocument } from 'vscode-html-languageservice';
-export declare function extractStylesheets(snapshot: ts.IScriptSnapshot, htmlDocument: HTMLDocument, ast: ParseResult['ast']): VirtualCode[];
-export declare function collectClassesAndIdsFromDocument(ast: ParseResult['ast']): string[];
+export declare function extractStylesheets(styles: TSXExtractedStyle[]): VirtualCode;

package/dist/core/parseCSS.js

@@ -1,142 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectClassesAndIdsFromDocument = exports.extractStylesheets = void 0;
-const utils_1 = require("@astrojs/compiler/utils");
+exports.extractStylesheets = void 0;
 const muggle_string_1 = require("muggle-string");
 const buildMappings_js_1 = require("../buildMappings.js");
-function extractStylesheets(snapshot, htmlDocument, ast) {
-    const embeddedCSSCodes = findEmbeddedStyles(snapshot, htmlDocument.roots);
-    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,
-                {
-                    completion: true,
-                    verification: false,
-                    semantic: true,
-                    navigation: true,
-                    structure: true,
-                    format: false,
-                },
-            ]);
-            codes.push(' }\n');
-        }
-        const mappings = (0, buildMappings_js_1.buildMappings)(codes);
-        const text = (0, muggle_string_1.toString)(codes);
-        embeddedCSSCodes.push({
-            id: 'inline.css',
-            languageId: 'css',
-            snapshot: {
-                getText: (start, end) => text.substring(start, end),
-                getLength: () => text.length,
-                getChangeRange: () => undefined,
-            },
-            embeddedCodes: [],
-            mappings,
-        });
-    }
-    return embeddedCSSCodes;
+function extractStylesheets(styles) {
+    return mergeCSSContexts(styles);
 }
 exports.extractStylesheets = extractStylesheets;
-/**
- * Find all embedded styles in a document.
- * Embedded styles are styles that are defined in `<style>` tags.
- */
-function findEmbeddedStyles(snapshot, roots) {
-    const embeddedCSSCodes = [];
-    let cssIndex = 0;
-    getEmbeddedCSSInNodes(roots);
-    function getEmbeddedCSSInNodes(nodes) {
-        for (const [_, node] of nodes.entries()) {
-            if (node.tag === 'style' &&
-                node.startTagEnd !== undefined &&
-                node.endTagStart !== undefined) {
-                const styleText = snapshot.getText(node.startTagEnd, node.endTagStart);
-                embeddedCSSCodes.push({
-                    id: `${cssIndex}.css`,
-                    languageId: 'css',
-                    snapshot: {
-                        getText: (start, end) => styleText.substring(start, end),
-                        getLength: () => styleText.length,
-                        getChangeRange: () => undefined,
-                    },
-                    mappings: [
-                        {
-                            sourceOffsets: [node.startTagEnd],
-                            generatedOffsets: [0],
-                            lengths: [styleText.length],
-                            data: {
-                                verification: false,
-                                completion: true,
-                                semantic: true,
-                                navigation: true,
-                                structure: true,
-                                format: false,
-                            },
-                        },
-                    ],
-                    embeddedCodes: [],
-                });
-                cssIndex++;
-            }
-            if (node.children)
-                getEmbeddedCSSInNodes(node.children);
-        }
-    }
-    return embeddedCSSCodes;
-}
-/**
- * Find all inline styles using the Astro AST
- * Inline styles are styles that are defined in the `style` attribute of an element.
- * TODO: Merge this with `findEmbeddedCSS`? Unlike scripts, there's no scoping being done here, so merging all of it in
- * the same virtual file is possible, though it might make mapping more tricky.
- */
-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 (utils_1.is.element(child)) {
-                const styleAttribute = child.attributes.find((attr) => attr.name === 'style' && attr.kind === 'quoted');
-                if (styleAttribute && styleAttribute.position) {
-                    styleAttrs.push(styleAttribute);
-                }
-            }
-            if (utils_1.is.parent(child)) {
-                walkDown(child);
-            }
-        });
-    }
-    walkDown(ast);
-    return styleAttrs;
-}
-// TODO: Provide completion for classes and IDs
-function collectClassesAndIdsFromDocument(ast) {
-    const classesAndIds = [];
-    function walkDown(parent) {
-        if (!parent.children)
-            return;
-        parent.children.forEach((child) => {
-            if (utils_1.is.element(child)) {
-                const classOrIDAttributes = child.attributes
-                    .filter((attr) => attr.kind === 'quoted' && (attr.name === 'class' || attr.name === 'id'))
-                    .flatMap((attr) => attr.value.split(' '));
-                classesAndIds.push(...classOrIDAttributes);
-            }
-            if (utils_1.is.parent(child)) {
-                walkDown(child);
-            }
-        });
+function mergeCSSContexts(inlineStyles) {
+    const codes = [];
+    for (const javascriptContext of inlineStyles) {
+        if (javascriptContext.type === 'style-attribute')
+            codes.push('__ { ');
+        codes.push([
+            javascriptContext.content,
+            undefined,
+            javascriptContext.position.start,
+            {
+                verification: true,
+                completion: true,
+                semantic: true,
+                navigation: true,
+                structure: true,
+                format: false,
+            },
+        ]);
+        if (javascriptContext.type === 'style-attribute')
+            codes.push(' }\n');
     }
-    walkDown(ast);
-    return classesAndIds;
+    const mappings = (0, buildMappings_js_1.buildMappings)(codes);
+    const text = (0, muggle_string_1.toString)(codes);
+    return {
+        id: 'style.css',
+        languageId: 'css',
+        snapshot: {
+            getText: (start, end) => text.substring(start, end),
+            getLength: () => text.length,
+            getChangeRange: () => undefined,
+        },
+        embeddedCodes: [],
+        mappings,
+    };
 }
-exports.collectClassesAndIdsFromDocument = collectClassesAndIdsFromDocument;
 //# sourceMappingURL=parseCSS.js.map

package/dist/core/parseJS.d.ts

@@ -1,5 +1,3 @@
-import type { ParseResult } from '@astrojs/compiler/types';
+import type { TSXExtractedScript } from '@astrojs/compiler/types';
 import type { VirtualCode } from '@volar/language-core';
-import type ts from 'typescript';
-import type { HTMLDocument } from 'vscode-html-languageservice';
-export declare function extractScriptTags(snapshot: ts.IScriptSnapshot, htmlDocument: HTMLDocument, ast: ParseResult['ast']): VirtualCode[];
+export declare function extractScriptTags(scripts: TSXExtractedScript[]): VirtualCode[];

package/dist/core/parseJS.js

@@ -1,164 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractScriptTags = void 0;
-const utils_1 = require("@astrojs/compiler/utils");
 const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../buildMappings");
-function extractScriptTags(snapshot, htmlDocument, ast) {
-    const embeddedJSCodes = findModuleScripts(snapshot, htmlDocument.roots);
-    const javascriptContexts = [
-        ...findClassicScripts(htmlDocument, snapshot),
-        ...findEventAttributes(ast),
-    ].sort((a, b) => a.startOffset - b.startOffset);
-    if (javascriptContexts.length > 0) {
-        // classic scripts share the same scope
-        // merging them brings about redeclaration errors
-        embeddedJSCodes.push(mergeJSContexts(javascriptContexts));
+function extractScriptTags(scripts) {
+    const embeddedJSCodes = [];
+    const moduleScripts = scripts
+        .filter((script) => script.type === 'module' || script.type === 'processed-module')
+        .map(moduleScriptToVirtualCode);
+    const inlineScripts = scripts
+        .filter((script) => script.type === 'event-attribute' || script.type === 'inline')
+        .sort((a, b) => a.position.start - b.position.start);
+    embeddedJSCodes.push(...moduleScripts);
+    const mergedJSContext = mergeJSContexts(inlineScripts);
+    if (mergedJSContext) {
+        embeddedJSCodes.push(mergedJSContext);
     }
     return embeddedJSCodes;
 }
 exports.extractScriptTags = extractScriptTags;
-function getScriptType(scriptTag) {
-    // script tags without attributes are processed and converted into module scripts
-    if (!scriptTag.attributes || Object.entries(scriptTag.attributes).length === 0)
-        return 'processed module';
-    // even when it is not processed by vite, scripts with type=module remain modules
-    if (scriptTag.attributes['type']?.includes('module') === true)
-        return 'module';
-    // whenever there are attributes, is:inline is implied and in the absence of type=module, the script is classic
-    return 'classic';
-}
-/**
- * Get all the isolated scripts in the HTML document
- * Isolated scripts are scripts that are hoisted by Astro and as such, are isolated from the rest of the code because of the implicit `type="module"`
- * All the isolated scripts are passed to the TypeScript language server as separate `.mts` files.
- */
-function findModuleScripts(snapshot, roots) {
-    const embeddedScripts = [];
-    let scriptIndex = 0;
-    getEmbeddedScriptsInNodes(roots);
-    function getEmbeddedScriptsInNodes(nodes) {
-        for (const [_, node] of nodes.entries()) {
-            if (node.tag === 'script' &&
-                node.startTagEnd !== undefined &&
-                node.endTagStart !== undefined &&
-                getScriptType(node) !== 'classic') {
-                const scriptText = snapshot.getText(node.startTagEnd, node.endTagStart);
-                const extension = getScriptType(node) === 'processed module' ? 'mts' : 'mjs';
-                const languageId = getScriptType(node) === 'processed module' ? 'typescript' : 'javascript';
-                embeddedScripts.push({
-                    id: `${scriptIndex}.${extension}`,
-                    languageId: languageId,
-                    snapshot: {
-                        getText: (start, end) => scriptText.substring(start, end),
-                        getLength: () => scriptText.length,
-                        getChangeRange: () => undefined,
-                    },
-                    mappings: [
-                        {
-                            sourceOffsets: [node.startTagEnd],
-                            generatedOffsets: [0],
-                            lengths: [scriptText.length],
-                            data: {
-                                verification: true,
-                                completion: true,
-                                semantic: true,
-                                navigation: true,
-                                structure: true,
-                                format: false,
-                            },
-                        },
-                    ],
-                    embeddedCodes: [],
-                });
-                scriptIndex++;
-            }
-            if (node.children)
-                getEmbeddedScriptsInNodes(node.children);
-        }
-    }
-    return embeddedScripts;
-}
-/**
- * Get all the inline scripts in the HTML document
- * Inline scripts are scripts that are not hoisted by Astro and as such, are not isolated from the rest of the code.
- * All the inline scripts are concatenated into a single `.mjs` file and passed to the TypeScript language server.
- */
-function findClassicScripts(htmlDocument, snapshot) {
-    const inlineScripts = [];
-    getInlineScriptsInNodes(htmlDocument.roots);
-    function getInlineScriptsInNodes(nodes) {
-        for (const [_, node] of nodes.entries()) {
-            if (node.tag === 'script' &&
-                node.startTagEnd !== undefined &&
-                node.endTagStart !== undefined &&
-                !isJSON(node.attributes?.type) &&
-                getScriptType(node) === 'classic') {
-                const scriptText = snapshot.getText(node.startTagEnd, node.endTagStart);
-                inlineScripts.push({
-                    startOffset: node.startTagEnd,
-                    content: scriptText,
-                });
-            }
-            if (node.children)
-                getInlineScriptsInNodes(node.children);
-        }
+function moduleScriptToVirtualCode(script, index) {
+    let extension = 'mts';
+    let languageId = 'typescript';
+    if (script.type === 'module') {
+        extension = 'mjs';
+        languageId = 'javascript';
     }
-    return inlineScripts;
-}
-/**
- * Include both MIME JSON types and `importmap` and `speculationrules` script types
- * See MIME Types -> https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
- * See Script Types -> https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script/type
- */
-const JSON_TYPES = ['application/json', 'application/ld+json', 'importmap', 'speculationrules'];
-/**
- * Check if the script has a type, and if it's included in JSON_TYPES above.
- * @param type Found in the `type` attribute of the script tag
- */
-function isJSON(type) {
-    if (!type)
-        return false;
-    // HTML attributes are quoted, slice " and ' at the start and end of the string
-    return JSON_TYPES.includes(type.slice(1, -1));
-}
-function findEventAttributes(ast) {
-    const eventAttrs = [];
-    // `@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 (utils_1.is.element(child)) {
-                const eventAttribute = child.attributes.find((attr) => htmlEventAttributes.includes(attr.name) && attr.kind === 'quoted');
-                if (eventAttribute && eventAttribute.position) {
-                    eventAttrs.push({
-                        // Add a semicolon to the end of the event attribute to attempt to prevent errors from spreading to the rest of the document
-                        // This is not perfect, but it's better than nothing
-                        // See: https://github.com/microsoft/vscode/blob/e8e04769ec817a3374c3eaa26a08d3ae491820d5/extensions/html-language-features/server/src/modes/embeddedSupport.ts#L192
-                        content: eventAttribute.value + ';',
-                        startOffset: eventAttribute.position.start.offset + `${eventAttribute.name}="`.length,
-                    });
-                }
-            }
-            if (utils_1.is.parent(child)) {
-                walkDown(child);
-            }
-        });
-    }
-    walkDown(ast);
-    return eventAttrs;
+    return {
+        id: `${index}.${extension}`,
+        languageId,
+        snapshot: {
+            getText: (start, end) => script.content.substring(start, end),
+            getLength: () => script.content.length,
+            getChangeRange: () => undefined,
+        },
+        mappings: [
+            {
+                sourceOffsets: [script.position.start],
+                generatedOffsets: [0],
+                lengths: [script.content.length],
+                data: {
+                    verification: true,
+                    completion: true,
+                    semantic: true,
+                    navigation: true,
+                    structure: true,
+                    format: false,
+                },
+            },
+        ],
+        embeddedCodes: [],
+    };
 }
 /**
  * Merge all the inline and non-hoisted scripts into a single `.mjs` file
  */
-function mergeJSContexts(javascriptContexts) {
+function mergeJSContexts(inlineScripts) {
+    if (inlineScripts.length === 0) {
+        return undefined;
+    }
     const codes = [];
-    for (const javascriptContext of javascriptContexts) {
+    for (const javascriptContext of inlineScripts) {
         codes.push([
-            javascriptContext.content,
+            // Add a semicolon to the end of the event attribute to attempt to prevent errors from spreading to the rest of the document
+            // This is not perfect, but it's better than nothing
+            // See: https://github.com/microsoft/vscode/blob/e8e04769ec817a3374c3eaa26a08d3ae491820d5/extensions/html-language-features/server/src/modes/embeddedSupport.ts#L192
+            javascriptContext.content + ';',
             undefined,
-            javascriptContext.startOffset,
+            javascriptContext.position.start,
             {
                 verification: true,
                 completion: true,
@@ -183,91 +92,4 @@ function mergeJSContexts(javascriptContexts) {
         mappings,
     };
 }
-const htmlEventAttributes = [
-    'onabort',
-    'onafterprint',
-    'onauxclick',
-    'onbeforematch',
-    'onbeforeprint',
-    'onbeforeunload',
-    'onblur',
-    'oncancel',
-    'oncanplay',
-    'oncanplaythrough',
-    'onchange',
-    'onclick',
-    'onclose',
-    'oncontextlost',
-    'oncontextmenu',
-    'oncontextrestored',
-    'oncopy',
-    'oncuechange',
-    'oncut',
-    'ondblclick',
-    'ondrag',
-    'ondragend',
-    'ondragenter',
-    'ondragleave',
-    'ondragover',
-    'ondragstart',
-    'ondrop',
-    'ondurationchange',
-    'onemptied',
-    'onended',
-    'onerror',
-    'onfocus',
-    'onformdata',
-    'onhashchange',
-    'oninput',
-    'oninvalid',
-    'onkeydown',
-    'onkeypress',
-    'onkeyup',
-    'onlanguagechange',
-    'onload',
-    'onloadeddata',
-    'onloadedmetadata',
-    'onloadstart',
-    'onmessage',
-    'onmessageerror',
-    'onmousedown',
-    'onmouseenter',
-    'onmouseleave',
-    'onmousemove',
-    'onmouseout',
-    'onmouseover',
-    'onmouseup',
-    'onoffline',
-    'ononline',
-    'onpagehide',
-    'onpageshow',
-    'onpaste',
-    'onpause',
-    'onplay',
-    'onplaying',
-    'onpopstate',
-    'onprogress',
-    'onratechange',
-    'onrejectionhandled',
-    'onreset',
-    'onresize',
-    'onscroll',
-    'onscrollend',
-    'onsecuritypolicyviolation',
-    'onseeked',
-    'onseeking',
-    'onselect',
-    'onslotchange',
-    'onstalled',
-    'onstorage',
-    'onsubmit',
-    'onsuspend',
-    'ontimeupdate',
-    'ontoggle',
-    'onunhandledrejection',
-    'onunload',
-    'onvolumechange',
-    'onwaiting',
-    'onwheel',
-];
 //# sourceMappingURL=parseJS.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrojs/language-server",
-  "version": "2.11.1",
+  "version": "2.12.0",
   "author": "withastro",
   "license": "MIT",
   "repository": {
@@ -20,7 +20,7 @@
     "astro-ls": "./bin/nodeServer.js"
   },
   "dependencies": {
-    "@astrojs/compiler": "^2.7.0",
+    "@astrojs/compiler": "^2.9.1",
     "@jridgewell/sourcemap-codec": "^1.4.15",
     "@volar/kit": "~2.4.0-alpha.15",
     "@volar/language-core": "~2.4.0-alpha.15",