@astrojs/language-server 0.23.2 → 0.24.1

package/dist/plugins/typescript/features/SemanticTokenProvider.d.ts

@@ -1,9 +1,10 @@
 import { CancellationToken, Range, SemanticTokens } from 'vscode-languageserver';
 import { AstroDocument } from '../../../core/documents';
-import { SemanticTokensProvider } from '../../interfaces';
-import { LanguageServiceManager } from '../LanguageServiceManager';
+import type { SemanticTokensProvider } from '../../interfaces';
+import type { LanguageServiceManager } from '../LanguageServiceManager';
 export declare class SemanticTokensProviderImpl implements SemanticTokensProvider {
     private languageServiceManager;
+    private ts;
     constructor(languageServiceManager: LanguageServiceManager);
     getSemanticTokens(document: AstroDocument, range?: Range, cancellationToken?: CancellationToken): Promise<SemanticTokens | null>;
     private mapToOrigin;

package/dist/plugins/typescript/features/SemanticTokenProvider.js

@@ -1,16 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SemanticTokensProviderImpl = void 0;
-const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
 const documents_1 = require("../../../core/documents");
 const utils_1 = require("../utils");
 class SemanticTokensProviderImpl {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;
+        this.ts = languageServiceManager.docContext.ts;
     }
     async getSemanticTokens(document, range, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
@@ -26,7 +23,7 @@ class SemanticTokensProviderImpl {
                 ? fragment.offsetAt(fragment.getGeneratedPosition(range.end)) - start
                 : // We don't want tokens for things added by astro2tsx
                     fragment.text.lastIndexOf('export default function ') || fragment.text.length,
-        }, typescript_1.default.SemanticClassificationFormat.TwentyTwenty);
+        }, this.ts.SemanticClassificationFormat.TwentyTwenty);
         const tokens = [];
         let i = 0;
         while (i < spans.length) {
@@ -72,10 +69,10 @@ class SemanticTokensProviderImpl {
      *  TSClassification = (TokenType + 1) << TokenEncodingConsts.typeOffset + TokenModifier
      */
     getTokenTypeFromClassification(tsClassification) {
-        return (tsClassification >> 8 /* typeOffset */) - 1;
+        return (tsClassification >> 8 /* TokenEncodingConsts.typeOffset */) - 1;
     }
     getTokenModifierFromClassification(tsClassification) {
-        return tsClassification & 255 /* modifierMask */;
+        return tsClassification & 255 /* TokenEncodingConsts.modifierMask */;
     }
 }
 exports.SemanticTokensProviderImpl = SemanticTokensProviderImpl;

package/dist/plugins/typescript/features/SignatureHelpProvider.d.ts

@@ -1,9 +1,10 @@
-import type { LanguageServiceManager } from '../LanguageServiceManager';
+import { CancellationToken, Position, SignatureHelp, SignatureHelpContext } from 'vscode-languageserver';
+import type { AstroDocument } from '../../../core/documents';
 import type { SignatureHelpProvider } from '../../interfaces';
-import { Position, SignatureHelpContext, SignatureHelp, CancellationToken } from 'vscode-languageserver';
-import { AstroDocument } from '../../../core/documents';
+import type { LanguageServiceManager } from '../LanguageServiceManager';
 export declare class SignatureHelpProviderImpl implements SignatureHelpProvider {
-    private readonly languageServiceManager;
+    private languageServiceManager;
+    private ts;
     constructor(languageServiceManager: LanguageServiceManager);
     private static readonly triggerCharacters;
     private static readonly retriggerCharacters;

package/dist/plugins/typescript/features/SignatureHelpProvider.js

@@ -1,16 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SignatureHelpProviderImpl = void 0;
-const typescript_1 = __importDefault(require("typescript"));
 const vscode_languageserver_1 = require("vscode-languageserver");
 const previewer_1 = require("../previewer");
 const utils_1 = require("../utils");
 class SignatureHelpProviderImpl {
     constructor(languageServiceManager) {
         this.languageServiceManager = languageServiceManager;
+        this.ts = languageServiceManager.docContext.ts;
     }
     async getSignatureHelp(document, position, context, cancellationToken) {
         const { lang, tsDoc } = await this.languageServiceManager.getLSAndTSDoc(document);
@@ -33,7 +30,7 @@ class SignatureHelpProviderImpl {
         if (!info) {
             return null;
         }
-        const signatures = info.items.map(this.toSignatureHelpInformation);
+        const signatures = info.items.map((item) => this.toSignatureHelpInformation(item, this.ts));
         return {
             signatures,
             activeSignature: info.selectedItemIndex,
@@ -76,21 +73,21 @@ class SignatureHelpProviderImpl {
     /**
      * adopted from https://github.com/microsoft/vscode/blob/265a2f6424dfbd3a9788652c7d376a7991d049a3/extensions/typescript-language-features/src/languageFeatures/signatureHelp.ts#L73
      */
-    toSignatureHelpInformation(item) {
+    toSignatureHelpInformation(item, ts) {
         const [prefixLabel, separatorLabel, suffixLabel] = [
             item.prefixDisplayParts,
             item.separatorDisplayParts,
             item.suffixDisplayParts,
-        ].map(typescript_1.default.displayPartsToString);
+        ].map(this.ts.displayPartsToString);
         let textIndex = prefixLabel.length;
         let signatureLabel = '';
         const parameters = [];
         const lastIndex = item.parameters.length - 1;
         item.parameters.forEach((parameter, index) => {
-            const label = typescript_1.default.displayPartsToString(parameter.displayParts);
+            const label = ts.displayPartsToString(parameter.displayParts);
             const startIndex = textIndex;
             const endIndex = textIndex + label.length;
-            const doc = typescript_1.default.displayPartsToString(parameter.documentation);
+            const doc = ts.displayPartsToString(parameter.documentation);
             signatureLabel += label;
             parameters.push(vscode_languageserver_1.ParameterInformation.create([startIndex, endIndex], doc));
             if (index < lastIndex) {
@@ -98,7 +95,7 @@ class SignatureHelpProviderImpl {
                 signatureLabel += separatorLabel;
             }
         });
-        const signatureDocumentation = (0, previewer_1.getMarkdownDocumentation)(item.documentation, item.tags.filter((tag) => tag.name !== 'param'));
+        const signatureDocumentation = (0, previewer_1.getMarkdownDocumentation)(item.documentation, item.tags.filter((tag) => tag.name !== 'param'), ts);
         return {
             label: prefixLabel + signatureLabel + suffixLabel,
             documentation: signatureDocumentation

package/dist/plugins/typescript/features/TypeDefinitionsProvider.d.ts

@@ -1,7 +1,7 @@
-import { Position, Location } from 'vscode-languageserver-protocol';
+import { Location, Position } from 'vscode-languageserver-protocol';
 import { AstroDocument } from '../../../core/documents';
-import { TypeDefinitionProvider } from '../../interfaces';
-import { LanguageServiceManager } from '../LanguageServiceManager';
+import type { TypeDefinitionProvider } from '../../interfaces';
+import type { LanguageServiceManager } from '../LanguageServiceManager';
 export declare class TypeDefinitionsProviderImpl implements TypeDefinitionProvider {
     private languageServiceManager;
     constructor(languageServiceManager: LanguageServiceManager);

package/dist/plugins/typescript/features/utils.d.ts

@@ -1,7 +1,7 @@
-import type { SnapshotFragment, DocumentSnapshot } from '../snapshots/DocumentSnapshot';
+import type ts from 'typescript';
+import type { Position } from 'vscode-languageserver';
 import type { LanguageServiceManager } from '../LanguageServiceManager';
-import { Position } from 'vscode-languageserver';
-import ts from 'typescript';
+import type { DocumentSnapshot, SnapshotFragment } from '../snapshots/DocumentSnapshot';
 export declare function isPartOfImportStatement(text: string, position: Position): boolean;
 export declare class SnapshotFragmentMap {
     private languageServiceManager;

package/dist/plugins/typescript/language-service.d.ts

@@ -1,9 +1,8 @@
-import { AstroDocument } from '../../core/documents';
-import ts from 'typescript';
-import { TextDocumentContentChangeEvent } from 'vscode-languageserver';
-import { GlobalSnapshotManager, SnapshotManager } from './snapshots/SnapshotManager';
+import type { TextDocumentContentChangeEvent } from 'vscode-languageserver';
+import type { ConfigManager } from '../../core/config';
+import type { AstroDocument } from '../../core/documents';
 import { DocumentSnapshot } from './snapshots/DocumentSnapshot';
-import { ConfigManager } from '../../core/config';
+import { GlobalSnapshotManager, SnapshotManager } from './snapshots/SnapshotManager';
 export interface LanguageServiceContainer {
     readonly tsconfigPath: string;
     readonly compilerOptions: ts.CompilerOptions;
@@ -12,7 +11,7 @@ export interface LanguageServiceContainer {
      */
     readonly snapshotManager: SnapshotManager;
     getService(): ts.LanguageService;
-    updateSnapshot(documentOrFilePath: AstroDocument | string): DocumentSnapshot;
+    updateSnapshot(documentOrFilePath: AstroDocument | string, ts: typeof import('typescript/lib/tsserverlibrary')): DocumentSnapshot;
     deleteSnapshot(filePath: string): void;
     updateProjectFiles(): void;
     updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): void;
@@ -30,6 +29,8 @@ export interface LanguageServiceDocumentContext {
     createDocument: (fileName: string, content: string) => AstroDocument;
     globalSnapshotManager: GlobalSnapshotManager;
     configManager: ConfigManager;
+    ts: typeof import('typescript/lib/tsserverlibrary');
+    tsLocalized: Record<string, string> | undefined;
 }
 export declare function getLanguageService(path: string, workspaceUris: string[], docContext: LanguageServiceDocumentContext): Promise<LanguageServiceContainer>;
 export declare function forAllLanguageServices(cb: (service: LanguageServiceContainer) => any): Promise<void>;

package/dist/plugins/typescript/language-service.js

@@ -22,22 +22,18 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __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.getLanguageServiceForTsconfig = exports.forAllLanguageServices = exports.getLanguageService = void 0;
 const path_1 = require("path");
-const typescript_1 = __importDefault(require("typescript"));
 const utils_1 = require("../../utils");
 const module_loader_1 = require("./module-loader");
-const SnapshotManager_1 = require("./snapshots/SnapshotManager");
-const utils_2 = require("./utils");
 const DocumentSnapshot_1 = require("./snapshots/DocumentSnapshot");
+const SnapshotManager_1 = require("./snapshots/SnapshotManager");
 const DocumentSnapshotUtils = __importStar(require("./snapshots/utils"));
+const utils_2 = require("./utils");
 const services = new Map();
 async function getLanguageService(path, workspaceUris, docContext) {
-    const tsconfigPath = (0, utils_2.findTsConfigPath)(path, workspaceUris);
+    const tsconfigPath = (0, utils_2.findTsConfigPath)(path, workspaceUris, docContext.ts);
     return getLanguageServiceForTsconfig(tsconfigPath, docContext, workspaceUris);
 }
 exports.getLanguageService = getLanguageService;
@@ -78,11 +74,11 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
     // `raw` here represent the tsconfig merged with any extended config
     const { compilerOptions, fileNames: files, raw: fullConfig } = getParsedTSConfig();
     let projectVersion = 0;
-    const snapshotManager = new SnapshotManager_1.SnapshotManager(docContext.globalSnapshotManager, files, fullConfig, tsconfigRoot || process.cwd());
-    const astroModuleLoader = (0, module_loader_1.createAstroModuleLoader)(getScriptSnapshot, compilerOptions);
+    const snapshotManager = new SnapshotManager_1.SnapshotManager(docContext.globalSnapshotManager, files, fullConfig, tsconfigRoot || process.cwd(), docContext.ts);
+    const astroModuleLoader = (0, module_loader_1.createAstroModuleLoader)(getScriptSnapshot, compilerOptions, docContext.ts);
     const scriptFileNames = [];
     if (astroInstall) {
-        scriptFileNames.push(...['./env.d.ts', './astro-jsx.d.ts'].map((f) => typescript_1.default.sys.resolvePath((0, path_1.resolve)(astroInstall.path, f))));
+        scriptFileNames.push(...['./env.d.ts', './astro-jsx.d.ts'].map((f) => docContext.ts.sys.resolvePath((0, path_1.resolve)(astroInstall.path, f))));
     }
     let languageServerDirectory;
     try {
@@ -96,30 +92,33 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         ((astroInstall.version.major === 0 || astroInstall.version.full === '1.0.0-beta.0') &&
             !astroInstall.version.full.startsWith('0.0.0-rc-')) // 1.0.0's RC is considered to be 0.0.0, so we have to check for it
     ) {
-        scriptFileNames.push(...['../types/astro-jsx.d.ts', '../types/env.d.ts'].map((f) => typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, f))));
+        scriptFileNames.push(...['../types/astro-jsx.d.ts', '../types/env.d.ts'].map((f) => docContext.ts.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, f))));
         console.warn("Couldn't load types from Astro, using internal types instead");
     }
     if (allowArbitraryAttrs) {
-        const arbitraryAttrsDTS = typescript_1.default.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, '../types/arbitrary-attrs.d.ts'));
+        const arbitraryAttrsDTS = docContext.ts.sys.resolvePath((0, path_1.resolve)(languageServerDirectory, '../types/arbitrary-attrs.d.ts'));
         scriptFileNames.push(arbitraryAttrsDTS);
     }
     const host = {
-        getNewLine: () => typescript_1.default.sys.newLine,
-        useCaseSensitiveFileNames: () => typescript_1.default.sys.useCaseSensitiveFileNames,
-        getDirectories: typescript_1.default.sys.getDirectories,
+        getNewLine: () => docContext.ts.sys.newLine,
+        useCaseSensitiveFileNames: () => docContext.ts.sys.useCaseSensitiveFileNames,
+        getDirectories: docContext.ts.sys.getDirectories,
         resolveModuleNames: astroModuleLoader.resolveModuleNames,
         readFile: astroModuleLoader.readFile,
         fileExists: astroModuleLoader.fileExists,
         readDirectory: astroModuleLoader.readDirectory,
         getCompilationSettings: () => compilerOptions,
         getCurrentDirectory: () => tsconfigRoot,
-        getDefaultLibFileName: typescript_1.default.getDefaultLibFilePath,
+        getDefaultLibFileName: docContext.ts.getDefaultLibFilePath,
         getProjectVersion: () => projectVersion.toString(),
         getScriptFileNames: () => Array.from(new Set([...snapshotManager.getProjectFileNames(), ...snapshotManager.getFileNames(), ...scriptFileNames])),
         getScriptSnapshot,
         getScriptVersion: (fileName) => getScriptSnapshot(fileName).version.toString(),
     };
-    let languageService = typescript_1.default.createLanguageService(host);
+    if (docContext.tsLocalized) {
+        host.getLocalizedDiagnosticMessages = () => docContext.tsLocalized;
+    }
+    let languageService = docContext.ts.createLanguageService(host);
     docContext.globalSnapshotManager.onChange(() => {
         projectVersion++;
     });
@@ -153,7 +152,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         if (!prevSnapshot) {
             astroModuleLoader.deleteUnresolvedResolutionsFromCache(filePath);
         }
-        const newSnapshot = DocumentSnapshotUtils.createFromDocument(document);
+        const newSnapshot = DocumentSnapshotUtils.createFromDocument(document, docContext.ts);
         snapshotManager.set(filePath, newSnapshot);
         const scriptTagSnapshots = createScriptTagsSnapshots(filePath, document);
         scriptTagSnapshots.forEach((snapshot) => {
@@ -163,7 +162,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         if (prevSnapshot && prevSnapshot.scriptKind !== newSnapshot.scriptKind) {
             // Restart language service as it doesn't handle script kind changes.
             languageService.dispose();
-            languageService = typescript_1.default.createLanguageService(host);
+            languageService = docContext.ts.createLanguageService(host);
         }
         return newSnapshot;
     }
@@ -173,7 +172,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
             return prevSnapshot;
         }
         astroModuleLoader.deleteUnresolvedResolutionsFromCache(filePath);
-        const newSnapshot = DocumentSnapshotUtils.createFromFilePath(filePath, docContext.createDocument);
+        const newSnapshot = DocumentSnapshotUtils.createFromFilePath(filePath, docContext.createDocument, docContext.ts);
         snapshotManager.set(filePath, newSnapshot);
         return newSnapshot;
     }
@@ -184,7 +183,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
             return doc;
         }
         astroModuleLoader.deleteUnresolvedResolutionsFromCache(fileName);
-        doc = DocumentSnapshotUtils.createFromFilePath(fileName, docContext.createDocument);
+        doc = DocumentSnapshotUtils.createFromFilePath(fileName, docContext.createDocument, docContext.ts);
         snapshotManager.set(fileName, doc);
         // If we needed to create an Astro snapshot, also create its script tags snapshots
         if ((0, utils_2.isAstroFilePath)(fileName)) {
@@ -223,7 +222,7 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
         });
     }
     function getParsedTSConfig() {
-        let configJson = (tsconfigPath && typescript_1.default.readConfigFile(tsconfigPath, typescript_1.default.sys.readFile).config) || {};
+        let configJson = (tsconfigPath && docContext.ts.readConfigFile(tsconfigPath, docContext.ts.sys.readFile).config) || {};
         // Delete include so that .astro files don't get mistakenly excluded by the user
         delete configJson.include;
         // If the user supplied exclude, let's use theirs otherwise, use ours
@@ -236,18 +235,18 @@ async function createLanguageService(tsconfigPath, docContext, workspaceUris) {
             allowSyntheticDefaultImports: true,
             allowNonTsExtensions: true,
             allowJs: true,
-            jsx: typescript_1.default.JsxEmit.Preserve,
+            jsx: docContext.ts.JsxEmit.Preserve,
             jsxImportSource: undefined,
             jsxFactory: 'astroHTML',
-            module: typescript_1.default.ModuleKind.ESNext,
-            target: typescript_1.default.ScriptTarget.ESNext,
+            module: docContext.ts.ModuleKind.ESNext,
+            target: docContext.ts.ScriptTarget.ESNext,
             isolatedModules: true,
-            moduleResolution: typescript_1.default.ModuleResolutionKind.NodeJs,
+            moduleResolution: docContext.ts.ModuleResolutionKind.NodeJs,
         };
-        const project = typescript_1.default.parseJsonConfigFileContent(configJson, typescript_1.default.sys, tsconfigRoot, forcedCompilerOptions, tsconfigPath, undefined, [
-            { extension: '.vue', isMixedContent: true, scriptKind: typescript_1.default.ScriptKind.Deferred },
-            { extension: '.svelte', isMixedContent: true, scriptKind: typescript_1.default.ScriptKind.Deferred },
-            { extension: '.astro', isMixedContent: true, scriptKind: typescript_1.default.ScriptKind.Deferred },
+        const project = docContext.ts.parseJsonConfigFileContent(configJson, docContext.ts.sys, tsconfigRoot, forcedCompilerOptions, tsconfigPath, undefined, [
+            { extension: '.vue', isMixedContent: true, scriptKind: docContext.ts.ScriptKind.Deferred },
+            { extension: '.svelte', isMixedContent: true, scriptKind: docContext.ts.ScriptKind.Deferred },
+            { extension: '.astro', isMixedContent: true, scriptKind: docContext.ts.ScriptKind.Deferred },
         ]);
         return {
             ...project,

package/dist/plugins/typescript/module-loader.d.ts

@@ -1,4 +1,4 @@
-import ts from 'typescript';
+import type { ResolvedModule } from 'typescript';
 import type { DocumentSnapshot } from './snapshots/DocumentSnapshot';
 /**
  * Creates a module loader specifically for `.astro` and other frameworks files.
@@ -12,7 +12,7 @@ import type { DocumentSnapshot } from './snapshots/DocumentSnapshot';
  * @param getSnapshot A function which returns a (in case of astro file fully preprocessed) typescript/javascript snapshot
  * @param compilerOptions The typescript compiler options
  */
-export declare function createAstroModuleLoader(getSnapshot: (fileName: string) => DocumentSnapshot, compilerOptions: ts.CompilerOptions): {
+export declare function createAstroModuleLoader(getSnapshot: (fileName: string) => DocumentSnapshot, compilerOptions: ts.CompilerOptions, ts: typeof import('typescript/lib/tsserverlibrary')): {
     fileExists: (path: string) => boolean;
     readFile: (path: string, encoding?: string | undefined) => string | undefined;
     readDirectory: (path: string, extensions?: readonly string[] | undefined, exclude?: readonly string[] | undefined, include?: readonly string[] | undefined, depth?: number | undefined) => string[];

package/dist/plugins/typescript/module-loader.js

@@ -1,13 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAstroModuleLoader = void 0;
-const typescript_1 = __importDefault(require("typescript"));
-const utils_1 = require("./utils");
+const utils_1 = require("../../utils");
 const astro_sys_1 = require("./astro-sys");
-const utils_2 = require("../../utils");
+const utils_2 = require("./utils");
 /**
  * Caches resolved modules.
  */
@@ -49,7 +45,7 @@ class ModuleResolutionCache {
      * and which might match the path.
      */
     deleteUnresolvedResolutionsFromCache(path) {
-        const fileNameWithoutEnding = (0, utils_2.getLastPartOfPath)(path).split('.').shift() || '';
+        const fileNameWithoutEnding = (0, utils_1.getLastPartOfPath)(path).split('.').shift() || '';
         this.cache.forEach((val, key) => {
             const moduleName = key.split(':::').pop() || '';
             if (!val && moduleName.includes(fileNameWithoutEnding)) {
@@ -58,7 +54,7 @@ class ModuleResolutionCache {
         });
     }
     getKey(moduleName, containingFile) {
-        return containingFile + ':::' + (0, utils_1.ensureRealFilePath)(moduleName);
+        return containingFile + ':::' + (0, utils_2.ensureRealFilePath)(moduleName);
     }
 }
 /**
@@ -73,8 +69,8 @@ class ModuleResolutionCache {
  * @param getSnapshot A function which returns a (in case of astro file fully preprocessed) typescript/javascript snapshot
  * @param compilerOptions The typescript compiler options
  */
-function createAstroModuleLoader(getSnapshot, compilerOptions) {
-    const astroSys = (0, astro_sys_1.createAstroSys)(getSnapshot);
+function createAstroModuleLoader(getSnapshot, compilerOptions, ts) {
+    const astroSys = (0, astro_sys_1.createAstroSys)(getSnapshot, ts);
     const moduleCache = new ModuleResolutionCache();
     return {
         fileExists: astroSys.fileExists,
@@ -104,18 +100,18 @@ function createAstroModuleLoader(getSnapshot, compilerOptions) {
         // Delegate to the TS resolver first.
         // If that does not bring up anything, try the Astro Module loader
         // which is able to deal with .astro and other frameworks files.
-        const tsResolvedModule = typescript_1.default.resolveModuleName(name, containingFile, compilerOptions, typescript_1.default.sys).resolvedModule;
-        if (tsResolvedModule && !(0, utils_1.isVirtualFilePath)(tsResolvedModule.resolvedFileName)) {
+        const tsResolvedModule = ts.resolveModuleName(name, containingFile, compilerOptions, ts.sys).resolvedModule;
+        if (tsResolvedModule && !(0, utils_2.isVirtualFilePath)(tsResolvedModule.resolvedFileName)) {
             return tsResolvedModule;
         }
-        const astroResolvedModule = typescript_1.default.resolveModuleName(name, containingFile, compilerOptions, astroSys).resolvedModule;
-        if (!astroResolvedModule || !(0, utils_1.isVirtualFilePath)(astroResolvedModule.resolvedFileName)) {
+        const astroResolvedModule = ts.resolveModuleName(name, containingFile, compilerOptions, astroSys).resolvedModule;
+        if (!astroResolvedModule || !(0, utils_2.isVirtualFilePath)(astroResolvedModule.resolvedFileName)) {
             return astroResolvedModule;
         }
-        const resolvedFileName = (0, utils_1.ensureRealFilePath)(astroResolvedModule.resolvedFileName);
+        const resolvedFileName = (0, utils_2.ensureRealFilePath)(astroResolvedModule.resolvedFileName);
         const snapshot = getSnapshot(resolvedFileName);
         const resolvedAstroModule = {
-            extension: (0, utils_1.getExtensionFromScriptKind)(snapshot && snapshot.scriptKind),
+            extension: (0, utils_2.getExtensionFromScriptKind)(snapshot && snapshot.scriptKind, ts),
             resolvedFileName,
             isExternalLibraryImport: astroResolvedModule.isExternalLibraryImport,
         };

package/dist/plugins/typescript/previewer.d.ts

@@ -1,7 +1,3 @@
-/**
- * adopted from https://github.com/microsoft/vscode/blob/10722887b8629f90cc38ee7d90d54e8246dc895f/extensions/typescript-language-features/src/utils/previewer.ts
- */
-import ts from 'typescript';
-export declare function getTagDocumentation(tag: ts.JSDocTagInfo): string | undefined;
-export declare function plain(parts: ts.SymbolDisplayPart[] | string): string;
-export declare function getMarkdownDocumentation(documentation: ts.SymbolDisplayPart[] | undefined, tags: ts.JSDocTagInfo[] | undefined): string;
+export declare function getTagDocumentation(tag: ts.JSDocTagInfo, ts: typeof import('typescript/lib/tsserverlibrary')): string | undefined;
+export declare function plain(parts: ts.SymbolDisplayPart[] | string, ts: typeof import('typescript/lib/tsserverlibrary')): string;
+export declare function getMarkdownDocumentation(documentation: ts.SymbolDisplayPart[] | undefined, tags: ts.JSDocTagInfo[] | undefined, ts: typeof import('typescript/lib/tsserverlibrary')): string;

package/dist/plugins/typescript/previewer.js

@@ -3,15 +3,11 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getMarkdownDocumentation = exports.plain = exports.getTagDocumentation = void 0;
 /**
  * adopted from https://github.com/microsoft/vscode/blob/10722887b8629f90cc38ee7d90d54e8246dc895f/extensions/typescript-language-features/src/utils/previewer.ts
  */
-const typescript_1 = __importDefault(require("typescript"));
 const utils_1 = require("../../utils");
 function replaceLinks(text) {
     return (text
@@ -28,7 +24,7 @@ function replaceLinks(text) {
 function processInlineTags(text) {
     return replaceLinks(text);
 }
-function getTagBodyText(tag) {
+function getTagBodyText(tag, ts) {
     if (!tag.text) {
         return undefined;
     }
@@ -61,17 +57,17 @@ function getTagBodyText(tag) {
     }
     switch (tag.name) {
         case 'example':
-            return makeExampleTag(typescript_1.default.displayPartsToString(tag.text));
+            return makeExampleTag(ts.displayPartsToString(tag.text));
         case 'author':
-            return makeEmailTag(typescript_1.default.displayPartsToString(tag.text));
+            return makeEmailTag(ts.displayPartsToString(tag.text));
         case 'default':
-            return makeCodeblock(typescript_1.default.displayPartsToString(tag.text));
+            return makeCodeblock(ts.displayPartsToString(tag.text));
     }
-    return processInlineTags(typescript_1.default.displayPartsToString(tag.text));
+    return processInlineTags(ts.displayPartsToString(tag.text));
 }
-function getTagDocumentation(tag) {
+function getTagDocumentation(tag, ts) {
     function getWithType() {
-        const body = (typescript_1.default.displayPartsToString(tag.text) || '').split(/^(\S+)\s*-?\s*/);
+        const body = (ts.displayPartsToString(tag.text) || '').split(/^(\S+)\s*-?\s*/);
         if (body?.length === 3) {
             const param = body[1];
             const doc = body[2];
@@ -91,24 +87,24 @@ function getTagDocumentation(tag) {
     }
     // Generic tag
     const label = `*@${tag.name}*`;
-    const text = getTagBodyText(tag);
+    const text = getTagBodyText(tag, ts);
     if (!text) {
         return label;
     }
     return label + (text.match(/\r\n|\n/g) ? '  \n' + text : ` — ${text}`);
 }
 exports.getTagDocumentation = getTagDocumentation;
-function plain(parts) {
-    return processInlineTags(typeof parts === 'string' ? parts : typescript_1.default.displayPartsToString(parts));
+function plain(parts, ts) {
+    return processInlineTags(typeof parts === 'string' ? parts : ts.displayPartsToString(parts));
 }
 exports.plain = plain;
-function getMarkdownDocumentation(documentation, tags) {
+function getMarkdownDocumentation(documentation, tags, ts) {
     let result = [];
     if (documentation) {
-        result.push(plain(documentation));
+        result.push(plain(documentation, ts));
     }
     if (tags) {
-        result = result.concat(tags.map(getTagDocumentation));
+        result = result.concat(tags.map((tag) => getTagDocumentation(tag, ts)));
     }
     return result.filter(utils_1.isNotNullOrUndefined).join('\n\n');
 }

package/dist/plugins/typescript/snapshots/DocumentSnapshot.d.ts

@@ -1,7 +1,6 @@
-import ts from 'typescript';
-import { Position, TextDocumentContentChangeEvent } from 'vscode-languageserver';
-import { AstroDocument, DocumentMapper, IdentityMapper, FragmentMapper, TagInformation } from '../../../core/documents';
-import { FrameworkExt } from '../utils';
+import type { Position, TextDocumentContentChangeEvent } from 'vscode-languageserver';
+import { AstroDocument, DocumentMapper, FragmentMapper, IdentityMapper, TagInformation } from '../../../core/documents';
+import type { FrameworkExt } from '../utils';
 export interface DocumentSnapshot extends ts.IScriptSnapshot {
     version: number;
     filePath: string;
@@ -96,7 +95,7 @@ export declare class TypeScriptDocumentSnapshot extends IdentityMapper implement
     readonly framework?: FrameworkExt | undefined;
     scriptKind: ts.ScriptKind;
     private lineOffsets?;
-    constructor(version: number, filePath: string, text: string, scriptKind?: ts.ScriptKind, framework?: FrameworkExt | undefined);
+    constructor(version: number, filePath: string, text: string, scriptKind: ts.ScriptKind, framework?: FrameworkExt | undefined);
     getText(start: number, end: number): string;
     getLength(): number;
     getFullText(): string;

package/dist/plugins/typescript/snapshots/DocumentSnapshot.js

@@ -1,13 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptDocumentSnapshot = exports.ScriptTagDocumentSnapshot = exports.AstroSnapshotFragment = exports.AstroSnapshot = void 0;
-const typescript_1 = __importDefault(require("typescript"));
 const documents_1 = require("../../../core/documents");
 const utils_1 = require("../../../utils");
-const utils_2 = require("../utils");
 /**
  * Snapshots used for Astro files
  */
@@ -85,7 +80,7 @@ class ScriptTagDocumentSnapshot extends documents_1.FragmentMapper {
         this.filePath = filePath;
         this.version = this.parent.version;
         this.text = this.parent.getText().slice(this.scriptTag.start, this.scriptTag.end) + '\nexport {}';
-        this.scriptKind = typescript_1.default.ScriptKind.JS;
+        this.scriptKind = 1;
     }
     positionAt(offset) {
         return (0, documents_1.positionAt)(offset, this.text, this.getLineOffsets());
@@ -130,7 +125,7 @@ class TypeScriptDocumentSnapshot extends documents_1.IdentityMapper {
         this.filePath = filePath;
         this.text = text;
         this.framework = framework;
-        scriptKind ? (this.scriptKind = scriptKind) : (this.scriptKind = (0, utils_2.getScriptKindFromFileName)(filePath));
+        this.scriptKind = scriptKind;
     }
     getText(start, end) {
         return this.text.substring(start, end);

package/dist/plugins/typescript/snapshots/SnapshotManager.d.ts

@@ -1,13 +1,15 @@
+import type { TextDocumentContentChangeEvent } from 'vscode-languageserver';
 import { DocumentSnapshot, TypeScriptDocumentSnapshot } from './DocumentSnapshot';
-import { TextDocumentContentChangeEvent } from 'vscode-languageserver';
 /**
  * Every snapshot corresponds to a unique file on disk.
  * A snapshot can be part of multiple projects, but for a given file path
  * there can be only one snapshot.
  */
 export declare class GlobalSnapshotManager {
+    private readonly ts;
     private emitter;
     private documents;
+    constructor(ts: typeof import('typescript/lib/tsserverlibrary'));
     get(fileName: string): DocumentSnapshot | undefined;
     set(fileName: string, document: DocumentSnapshot): void;
     delete(fileName: string): void;
@@ -26,10 +28,11 @@ export declare class SnapshotManager {
     private projectFiles;
     private fileSpec;
     private workspaceRoot;
+    private ts;
     private documents;
     private lastLogged;
     private readonly watchExtensions;
-    constructor(globalSnapshotsManager: GlobalSnapshotManager, projectFiles: string[], fileSpec: TsFilesSpec, workspaceRoot: string);
+    constructor(globalSnapshotsManager: GlobalSnapshotManager, projectFiles: string[], fileSpec: TsFilesSpec, workspaceRoot: string, ts: typeof import('typescript/lib/tsserverlibrary'));
     updateProjectFiles(): void;
     updateNonAstroFile(fileName: string, changes?: TextDocumentContentChangeEvent[]): void;
     has(fileName: string): boolean;