@vue/typescript-plugin 3.0.7 → 3.0.9

package/index.js

@@ -11,7 +11,6 @@ const getComponentSlots_1 = require("./lib/requests/getComponentSlots");
 const getElementAttrs_1 = require("./lib/requests/getElementAttrs");
 const getElementNames_1 = require("./lib/requests/getElementNames");
 const getImportPathForFile_1 = require("./lib/requests/getImportPathForFile");
-const getReactiveReferences_1 = require("./lib/requests/getReactiveReferences");
 const isRefAtPosition_1 = require("./lib/requests/isRefAtPosition");
 const windowsPathReg = /\\/g;
 const project2Service = new WeakMap();
@@ -125,12 +124,6 @@ module.exports = (0, createLanguageServicePlugin_1.createLanguageServicePlugin)(
             const { languageService } = getLanguageService(fileName);
             return createResponse((0, getElementNames_1.getElementNames)(ts, languageService.getProgram(), fileName));
         });
-        session.addProtocolHandler('_vue:getReactiveReferences', request => {
-            const [fileName, position] = request.arguments;
-            const { languageService, language } = getLanguageService(fileName);
-            const sourceScript = language.scripts.get(fileName);
-            return createResponse((0, getReactiveReferences_1.getReactiveReferences)(ts, language, languageService, sourceScript, fileName, position, sourceScript?.generated ? sourceScript.snapshot.getLength() : 0));
-        });
         projectService.logger.info('Vue specific commands are successfully added.');
         function createResponse(res) {
             return {

package/lib/common.js

@@ -125,8 +125,8 @@ function getCompletionEntryDetails(language, getCompletionEntryDetails) {
             const { fileName } = args[6].__isAutoImport;
             const sourceScript = language.scripts.get(fileName);
             if (sourceScript?.generated?.root instanceof language_core_1.VueVirtualCode) {
-                const sfc = sourceScript.generated.root.vueSfc;
-                if (!sfc?.descriptor.script && !sfc?.descriptor.scriptSetup) {
+                const { vueSfc } = sourceScript.generated.root;
+                if (!vueSfc?.descriptor.script && !vueSfc?.descriptor.scriptSetup) {
                     for (const codeAction of details?.codeActions ?? []) {
                         for (const change of codeAction.changes) {
                             for (const textChange of change.textChanges) {

package/lib/requests/index.d.ts

@@ -11,7 +11,6 @@ export interface Requests {
     getComponentSlots(fileName: string): Response<ReturnType<typeof import('./getComponentSlots.js')['getComponentSlots']>>;
     getElementAttrs(fileName: string, tag: string): Response<ReturnType<typeof import('./getElementAttrs.js')['getElementAttrs']>>;
     getElementNames(fileName: string): Response<ReturnType<typeof import('./getElementNames.js')['getElementNames']>>;
-    getReactiveReferences(fileName: string, position: number): Response<ReturnType<typeof import('./getReactiveReferences.js')['getReactiveReferences']>>;
     getDocumentHighlights(fileName: string, position: number): Response<ts.DocumentHighlights[]>;
     getEncodedSemanticClassifications(fileName: string, span: ts.TextSpan): Response<ts.Classifications>;
     getQuickInfoAtPosition(fileName: string, position: ts.LineAndCharacter): Response<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/typescript-plugin",
-	"version": "3.0.7",
+	"version": "3.0.9",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -14,7 +14,7 @@
 	},
 	"dependencies": {
 		"@volar/typescript": "2.4.23",
-		"@vue/language-core": "3.0.7",
+		"@vue/language-core": "3.0.9",
 		"@vue/shared": "^3.5.0",
 		"path-browserify": "^1.0.1"
 	},
@@ -22,5 +22,5 @@
 		"@types/node": "^22.10.4",
 		"@types/path-browserify": "^1.0.1"
 	},
-	"gitHead": "6022b75534487f8a031dfc61a7879f900b64d414"
+	"gitHead": "f4e06e14c70650256bf875a579e8ceaf093dd60b"
 }

package/lib/proxy.d.ts

@@ -1,3 +0,0 @@
-import { type Language, type VueCompilerOptions } from '@vue/language-core';
-import type * as ts from 'typescript';
-export declare function createVueLanguageServiceProxy(ts: typeof import('typescript'), language: Language<string>, languageService: ts.LanguageService, vueOptions: VueCompilerOptions): ts.LanguageService;

package/lib/proxy.js

@@ -1,227 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createVueLanguageServiceProxy = createVueLanguageServiceProxy;
-const language_core_1 = require("@vue/language-core");
-const shared_1 = require("@vue/shared");
-const windowsPathReg = /\\/g;
-function createVueLanguageServiceProxy(ts, language, languageService, vueOptions) {
-    const proxyCache = new Map();
-    const getProxyMethod = (target, p) => {
-        switch (p) {
-            case 'getCompletionsAtPosition':
-                return getCompletionsAtPosition(ts, language, vueOptions, target[p]);
-            case 'getCompletionEntryDetails':
-                return getCompletionEntryDetails(language, target[p]);
-            case 'getCodeFixesAtPosition':
-                return getCodeFixesAtPosition(target[p]);
-            case 'getDefinitionAndBoundSpan':
-                return getDefinitionAndBoundSpan(ts, language, languageService, vueOptions, target[p]);
-        }
-    };
-    return new Proxy(languageService, {
-        get(target, p, receiver) {
-            if (!proxyCache.has(p)) {
-                proxyCache.set(p, getProxyMethod(target, p));
-            }
-            return proxyCache.get(p) ?? Reflect.get(target, p, receiver);
-        },
-    });
-}
-function getCompletionsAtPosition(ts, language, vueOptions, getCompletionsAtPosition) {
-    return (filePath, position, options, formattingSettings) => {
-        const fileName = filePath.replace(windowsPathReg, '/');
-        const result = getCompletionsAtPosition(fileName, position, options, formattingSettings);
-        if (result) {
-            // filter __VLS_
-            result.entries = result.entries.filter(entry => !entry.name.includes('__VLS_')
-                && !entry.labelDetails?.description?.includes('__VLS_'));
-            // filter global variables in template and styles
-            const sourceScript = language.scripts.get(fileName);
-            const root = sourceScript?.generated?.root;
-            if (root instanceof language_core_1.VueVirtualCode) {
-                const blocks = [
-                    root.sfc.template,
-                    ...root.sfc.styles,
-                ];
-                const ranges = blocks.filter(Boolean).map(block => [
-                    block.startTagEnd,
-                    block.endTagStart,
-                ]);
-                if (ranges.some(([start, end]) => position >= start && position <= end)) {
-                    const globalKinds = new Set(['var', 'function', 'module']);
-                    const globalsOrKeywords = ts.Completions.SortText.GlobalsOrKeywords;
-                    const sortTexts = new Set([
-                        globalsOrKeywords,
-                        'z' + globalsOrKeywords,
-                        globalsOrKeywords + '1',
-                    ]);
-                    result.entries = result.entries.filter(entry => !(entry.kind === 'const' && entry.name in vueOptions.macros) && (!globalKinds.has(entry.kind)
-                        || !sortTexts.has(entry.sortText)
-                        || (0, shared_1.isGloballyAllowed)(entry.name)));
-                }
-            }
-            // modify label
-            for (const item of result.entries) {
-                if (item.source) {
-                    const originalName = item.name;
-                    for (const vueExt of vueOptions.extensions) {
-                        const suffix = (0, shared_1.capitalize)(vueExt.slice(1)); // .vue -> Vue
-                        if (item.source.endsWith(vueExt) && item.name.endsWith(suffix)) {
-                            item.name = (0, shared_1.capitalize)(item.name.slice(0, -suffix.length));
-                            if (item.insertText) {
-                                // #2286
-                                item.insertText = item.insertText.replace(`${suffix}$1`, '$1');
-                            }
-                            if (item.data) {
-                                // @ts-expect-error
-                                item.data.__isComponentAutoImport = {
-                                    ext: vueExt,
-                                    suffix,
-                                    originalName,
-                                    newName: item.insertText,
-                                };
-                            }
-                            break;
-                        }
-                    }
-                    if (item.data) {
-                        // @ts-expect-error
-                        item.data.__isAutoImport = {
-                            fileName,
-                        };
-                    }
-                }
-            }
-        }
-        return result;
-    };
-}
-function getCompletionEntryDetails(language, getCompletionEntryDetails) {
-    return (...args) => {
-        const details = getCompletionEntryDetails(...args);
-        // modify import statement
-        // @ts-expect-error
-        if (args[6]?.__isComponentAutoImport) {
-            // @ts-expect-error
-            const { originalName, newName } = args[6].__isComponentAutoImport;
-            for (const codeAction of details?.codeActions ?? []) {
-                for (const change of codeAction.changes) {
-                    for (const textChange of change.textChanges) {
-                        textChange.newText = textChange.newText.replace('import ' + originalName + ' from ', 'import ' + newName + ' from ');
-                    }
-                }
-            }
-        }
-        // @ts-expect-error
-        if (args[6]?.__isAutoImport) {
-            // @ts-expect-error
-            const { fileName } = args[6].__isAutoImport;
-            const sourceScript = language.scripts.get(fileName);
-            if (sourceScript?.generated?.root instanceof language_core_1.VueVirtualCode) {
-                const { sfc } = sourceScript.generated.root;
-                if (!sfc.script && !sfc.scriptSetup) {
-                    for (const codeAction of details?.codeActions ?? []) {
-                        for (const change of codeAction.changes) {
-                            for (const textChange of change.textChanges) {
-                                textChange.newText = `<script setup lang="ts">${textChange.newText}</script>\n\n`;
-                                break;
-                            }
-                            break;
-                        }
-                        break;
-                    }
-                }
-            }
-        }
-        return details;
-    };
-}
-function getCodeFixesAtPosition(getCodeFixesAtPosition) {
-    return (...args) => {
-        let result = getCodeFixesAtPosition(...args);
-        // filter __VLS_
-        result = result.filter(entry => !entry.description.includes('__VLS_'));
-        return result;
-    };
-}
-function getDefinitionAndBoundSpan(ts, language, languageService, vueOptions, getDefinitionAndBoundSpan) {
-    return (fileName, position) => {
-        const result = getDefinitionAndBoundSpan(fileName, position);
-        if (!result?.definitions?.length) {
-            return result;
-        }
-        const program = languageService.getProgram();
-        const sourceScript = language.scripts.get(fileName);
-        if (!sourceScript?.generated) {
-            return result;
-        }
-        const root = sourceScript.generated.root;
-        if (!(root instanceof language_core_1.VueVirtualCode)) {
-            return result;
-        }
-        if (!root.sfc.template
-            || position < root.sfc.template.startTagEnd
-            || position > root.sfc.template.endTagStart) {
-            return result;
-        }
-        const definitions = new Set(result.definitions);
-        const skippedDefinitions = [];
-        // #5275
-        if (result.definitions.length >= 2) {
-            for (const definition of result.definitions) {
-                if (root.sfc.content[definition.textSpan.start - 1] === '@'
-                    || root.sfc.content.slice(definition.textSpan.start - 5, definition.textSpan.start) === 'v-on:') {
-                    skippedDefinitions.push(definition);
-                }
-            }
-        }
-        for (const definition of result.definitions) {
-            if (vueOptions.extensions.some(ext => definition.fileName.endsWith(ext))) {
-                continue;
-            }
-            const sourceFile = program.getSourceFile(definition.fileName);
-            if (!sourceFile) {
-                continue;
-            }
-            visit(sourceFile, definition, sourceFile);
-        }
-        for (const definition of skippedDefinitions) {
-            definitions.delete(definition);
-        }
-        return {
-            definitions: [...definitions],
-            textSpan: result.textSpan,
-        };
-        function visit(node, definition, sourceFile) {
-            if (ts.isPropertySignature(node) && node.type) {
-                proxy(node.name, node.type, definition, sourceFile);
-            }
-            else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.type && !node.initializer) {
-                proxy(node.name, node.type, definition, sourceFile);
-            }
-            else {
-                ts.forEachChild(node, child => visit(child, definition, sourceFile));
-            }
-        }
-        function proxy(name, type, definition, sourceFile) {
-            const { textSpan, fileName } = definition;
-            const start = name.getStart(sourceFile);
-            const end = name.getEnd();
-            if (start !== textSpan.start || end - start !== textSpan.length) {
-                return;
-            }
-            if (!ts.isIndexedAccessTypeNode(type)) {
-                return;
-            }
-            const pos = type.indexType.getStart(sourceFile);
-            const res = getDefinitionAndBoundSpan(fileName, pos);
-            if (res?.definitions?.length) {
-                for (const definition of res.definitions) {
-                    definitions.add(definition);
-                }
-                skippedDefinitions.push(definition);
-            }
-        }
-    };
-}
-//# sourceMappingURL=proxy.js.map

package/lib/requests/getComponentHighlights.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/requests/getComponentHighlights.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=getComponentHighlights.js.map

package/lib/requests/getCurrentComponentSlots.d.ts

@@ -1 +0,0 @@
-export { };

package/lib/requests/getCurrentComponentSlots.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=getCurrentComponentSlots.js.map

package/lib/requests/getDefineSlotNames.d.ts

@@ -1 +0,0 @@
-export { };

package/lib/requests/getDefineSlotNames.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=getDefineSlotNames.js.map

package/lib/requests/getDefineSlots.d.ts

@@ -1,2 +0,0 @@
-import type { RequestContext } from './types';
-export declare function getDefineSlots(this: RequestContext, fileName: string): string[] | undefined;

package/lib/requests/getDefineSlots.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefineSlots = getDefineSlots;
-const language_core_1 = require("@vue/language-core");
-const utils_1 = require("./utils");
-function getDefineSlots(fileName) {
-    const { typescript: ts, language, languageService, getFileId } = this;
-    const volarFile = language.scripts.get(getFileId(fileName));
-    if (!(volarFile?.generated?.root instanceof language_core_1.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    const slots = (0, utils_1.getTypeAliasType)(ts, languageService, vueCode, '__VLS_Slots');
-    return slots?.type.getProperties().map(prop => prop.getName());
-}
-//# sourceMappingURL=getDefineSlots.js.map

package/lib/requests/getMissingPropsDiagnostics.d.ts

@@ -1,10 +0,0 @@
-import type { RequestContext } from './types';
-export interface ComponentPropInfo {
-    name: string;
-    required?: boolean;
-    deprecated?: boolean;
-    isAttribute?: boolean;
-    commentMarkdown?: string;
-    values?: string[];
-}
-export declare function getMissingPropsDiagnostics(this: RequestContext, fileName: string): undefined;

package/lib/requests/getMissingPropsDiagnostics.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMissingPropsDiagnostics = getMissingPropsDiagnostics;
-const language_core_1 = require("@vue/language-core");
-function getMissingPropsDiagnostics(fileName) {
-    const { typescript: ts, language, languageService, asScriptId } = this;
-    const volarFile = language.scripts.get(asScriptId(fileName));
-    if (!(volarFile?.generated?.root instanceof language_core_1.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    const program = languageService.getProgram();
-    const sourceFile = program.getSourceFile(vueCode.fileName);
-    if (!sourceFile) {
-        return;
-    }
-    const checker = program.getTypeChecker();
-    ts.forEachChild(sourceFile, function visit(node) {
-        if (ts.isVariableDeclaration(node)
-            && node.initializer
-            && ts.isCallExpression(node.initializer)
-            && ts.isIdentifier(node.initializer.expression)
-            && /^__VLS_\d+$/.test(node.initializer.expression.text)) {
-            const firstArg = node.initializer.arguments[0];
-            const type = checker.getTypeAtLocation(firstArg);
-            const contextualType = checker.getContextualType(firstArg);
-            if (contextualType) {
-                const subtype = contextualType.isUnion()
-                    ? contextualType.types.find(subtype => checker.isTypeAssignableTo(subtype, type))
-                    : contextualType;
-                void subtype;
-            }
-        }
-        else {
-            ts.forEachChild(node, visit);
-        }
-    });
-    return undefined;
-}
-//# sourceMappingURL=getMissingPropsDiagnostics.js.map

package/lib/requests/getPropertiesAtLocation.d.ts

@@ -1,2 +0,0 @@
-import type { RequestContext } from './types';
-export declare function getPropertiesAtLocation(this: RequestContext, fileName: string, position: number): string[];

package/lib/requests/getPropertiesAtLocation.js

@@ -1,63 +0,0 @@
-"use strict";
-/// <reference types="@volar/typescript" />
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPropertiesAtLocation = getPropertiesAtLocation;
-const language_core_1 = require("@vue/language-core");
-function getPropertiesAtLocation(fileName, position) {
-    const { languageService, language, typescript: ts } = this;
-    // mapping
-    const sourceScript = language.scripts.get(fileName);
-    const root = sourceScript?.generated?.root;
-    if (!sourceScript?.generated || !(root instanceof language_core_1.VueVirtualCode)) {
-        return [];
-    }
-    const virtualScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(root);
-    if (!virtualScript) {
-        return [];
-    }
-    let mapped = false;
-    for (const [_sourceScript, map] of language.maps.forEach(virtualScript.code)) {
-        for (const [position2, mapping] of map.toGeneratedLocation(position)) {
-            if ((0, language_core_1.isCompletionEnabled)(mapping.data)) {
-                position = position2;
-                mapped = true;
-                break;
-            }
-        }
-        if (mapped) {
-            break;
-        }
-    }
-    if (!mapped) {
-        return [];
-    }
-    position += sourceScript.snapshot.getLength();
-    const program = languageService.getProgram();
-    const sourceFile = program.getSourceFile(fileName);
-    if (!sourceFile) {
-        return [];
-    }
-    const node = findPositionIdentifier(sourceFile, sourceFile, position);
-    if (!node) {
-        return [];
-    }
-    const checker = program.getTypeChecker();
-    const type = checker.getTypeAtLocation(node);
-    const props = type.getProperties();
-    return props.map(prop => prop.name);
-    function findPositionIdentifier(sourceFile, node, offset) {
-        let result;
-        node.forEachChild(child => {
-            if (!result) {
-                if (child.end === offset && ts.isIdentifier(child)) {
-                    result = child;
-                }
-                else if (child.end >= offset && child.getStart(sourceFile) < offset) {
-                    result = findPositionIdentifier(sourceFile, child, offset);
-                }
-            }
-        });
-        return result;
-    }
-}
-//# sourceMappingURL=getPropertiesAtLocation.js.map

package/lib/requests/getReactiveReferences.d.ts

@@ -1,12 +0,0 @@
-import { type Language, type SourceScript } from '@vue/language-core';
-import type * as ts from 'typescript';
-export declare function getReactiveReferences(ts: typeof import('typescript'), language: Language, languageService: ts.LanguageService, sourceScript: SourceScript | undefined, fileName: string, position: number, leadingOffset?: number): {
-    dependencyRanges: {
-        start: number;
-        end: number;
-    }[];
-    dependentRanges: {
-        start: number;
-        end: number;
-    }[];
-} | undefined;

package/lib/requests/getReactiveReferences.js

@@ -1,605 +0,0 @@
-"use strict";
-/// <reference types="@volar/typescript" />
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getReactiveReferences = getReactiveReferences;
-const language_core_1 = require("@vue/language-core");
-const analyzeCache = new WeakMap();
-function getReactiveReferences(ts, language, languageService, sourceScript, fileName, position, leadingOffset = 0) {
-    const serviceScript = sourceScript?.generated?.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
-    const map = serviceScript ? language.maps.get(serviceScript.code, sourceScript) : undefined;
-    const toSourceRange = map
-        ? (start, end) => {
-            for (const [mappedStart, mappedEnd] of map.toSourceRange(start - leadingOffset, end - leadingOffset, false)) {
-                return { start: mappedStart, end: mappedEnd };
-            }
-        }
-        : (start, end) => ({ start, end });
-    const sourceFile = languageService.getProgram().getSourceFile(fileName);
-    if (!analyzeCache.has(sourceFile)) {
-        analyzeCache.set(sourceFile, analyze(ts, sourceFile, toSourceRange));
-    }
-    const { signals, allValuePropertyAccess, allPropertyAccess, allFunctionCalls, } = analyzeCache.get(sourceFile);
-    const info = findSignalByBindingRange(position) ?? findSignalByCallbackRange(position);
-    if (!info) {
-        return;
-    }
-    const dependents = info.binding ? findDependents(info.binding.ast, info.binding.accessTypes) : [];
-    const dependencies = findDependencies(info);
-    if ((!info.isDependent && !dependents.length) || (!info.isDependency && !dependencies.length)) {
-        return;
-    }
-    const dependencyRanges = [];
-    const dependentRanges = [];
-    for (const dependency of dependencies) {
-        let { ast } = dependency;
-        if (ts.isBlock(ast) && ast.statements.length) {
-            const sourceRange = toSourceRange(ast.statements[0].getStart(sourceFile), ast.statements[ast.statements.length - 1].end);
-            if (sourceRange) {
-                dependencyRanges.push({ start: sourceRange.start, end: sourceRange.end });
-            }
-        }
-        else {
-            dependencyRanges.push({ start: dependency.start, end: dependency.end });
-        }
-    }
-    for (const { callback } of dependents) {
-        if (!callback) {
-            continue;
-        }
-        if (ts.isBlock(callback.ast) && callback.ast.statements.length) {
-            const { statements } = callback.ast;
-            const sourceRange = toSourceRange(statements[0].getStart(sourceFile), statements[statements.length - 1].end);
-            if (sourceRange) {
-                dependencyRanges.push({ start: sourceRange.start, end: sourceRange.end });
-            }
-        }
-        else {
-            dependentRanges.push({ start: callback.start, end: callback.end });
-        }
-    }
-    return { dependencyRanges, dependentRanges };
-    function findDependencies(signal, visited = new Set()) {
-        if (visited.has(signal)) {
-            return [];
-        }
-        visited.add(signal);
-        const nodes = [];
-        let hasDependency = signal.isDependency;
-        if (signal.accessor) {
-            const { requiredAccess } = signal.accessor;
-            visit(signal.accessor, requiredAccess);
-            signal.accessor.ast.forEachChild(child => {
-                const childRange = toSourceRange(child.getStart(sourceFile), child.end);
-                if (childRange) {
-                    visit({
-                        ...childRange,
-                        ast: child,
-                    }, requiredAccess);
-                }
-            });
-        }
-        if (!hasDependency) {
-            return [];
-        }
-        return nodes;
-        function visit(node, requiredAccess, parentIsPropertyAccess = false) {
-            if (!requiredAccess) {
-                if (!parentIsPropertyAccess && ts.isIdentifier(node.ast)) {
-                    const definition = languageService.getDefinitionAtPosition(sourceFile.fileName, node.start);
-                    for (const info of definition ?? []) {
-                        if (info.fileName !== sourceFile.fileName) {
-                            continue;
-                        }
-                        const signal = findSignalByBindingRange(info.textSpan.start);
-                        if (!signal) {
-                            continue;
-                        }
-                        if (signal.binding) {
-                            nodes.push(signal.binding);
-                            hasDependency ||= signal.isDependency;
-                        }
-                        if (signal.callback) {
-                            nodes.push(signal.callback);
-                        }
-                        const deps = findDependencies(signal, visited);
-                        nodes.push(...deps);
-                        hasDependency ||= deps.length > 0;
-                    }
-                }
-            }
-            else if (ts.isPropertyAccessExpression(node.ast) || ts.isElementAccessExpression(node.ast)
-                || ts.isCallExpression(node.ast)) {
-                const definition = languageService.getDefinitionAtPosition(sourceFile.fileName, node.start);
-                for (const info of definition ?? []) {
-                    if (info.fileName !== sourceFile.fileName) {
-                        continue;
-                    }
-                    const signal = findSignalByBindingRange(info.textSpan.start);
-                    if (!signal) {
-                        continue;
-                    }
-                    const oldSize = nodes.length;
-                    if (signal.binding) {
-                        for (const accessType of signal.binding.accessTypes) {
-                            if (ts.isPropertyAccessExpression(node.ast)) {
-                                if (accessType === 0 /* ReactiveAccessType.ValueProperty */ && node.ast.name.text === 'value') {
-                                    nodes.push(signal.binding);
-                                    hasDependency ||= signal.isDependency;
-                                }
-                                if (accessType === 1 /* ReactiveAccessType.AnyProperty */ && node.ast.name.text !== '') {
-                                    nodes.push(signal.binding);
-                                    hasDependency ||= signal.isDependency;
-                                }
-                            }
-                            else if (ts.isElementAccessExpression(node.ast)) {
-                                if (accessType === 1 /* ReactiveAccessType.AnyProperty */) {
-                                    nodes.push(signal.binding);
-                                    hasDependency ||= signal.isDependency;
-                                }
-                            }
-                            else if (ts.isCallExpression(node.ast)) {
-                                if (accessType === 2 /* ReactiveAccessType.Call */) {
-                                    nodes.push(signal.binding);
-                                    hasDependency ||= signal.isDependency;
-                                }
-                            }
-                        }
-                    }
-                    const signalDetected = nodes.length > oldSize;
-                    if (signalDetected) {
-                        if (signal.callback) {
-                            nodes.push(signal.callback);
-                        }
-                        const deps = findDependencies(signal, visited);
-                        nodes.push(...deps);
-                        hasDependency ||= deps.length > 0;
-                    }
-                }
-            }
-            node.ast.forEachChild(child => {
-                const childRange = toSourceRange(child.getStart(sourceFile), child.end);
-                if (childRange) {
-                    visit({
-                        ...childRange,
-                        ast: child,
-                    }, requiredAccess, ts.isPropertyAccessExpression(node.ast) || ts.isElementAccessExpression(node.ast));
-                }
-            });
-        }
-    }
-    function findDependents(node, trackKinds, visited = new Set()) {
-        return (0, language_core_1.collectBindingRanges)(ts, node, sourceFile)
-            .map(range => {
-            const sourceRange = toSourceRange(range.start, range.end);
-            if (sourceRange) {
-                return findDependentsWorker(sourceRange.start, trackKinds, visited);
-            }
-            return [];
-        })
-            .flat();
-    }
-    function findDependentsWorker(pos, accessTypes, visited = new Set()) {
-        if (visited.has(pos)) {
-            return [];
-        }
-        visited.add(pos);
-        const references = languageService.findReferences(sourceFile.fileName, pos);
-        if (!references) {
-            return [];
-        }
-        const result = [];
-        for (const reference of references) {
-            for (const reference2 of reference.references) {
-                if (reference2.fileName !== sourceFile.fileName) {
-                    continue;
-                }
-                const effect = findSignalByAccessorRange(reference2.textSpan.start);
-                if (effect?.accessor) {
-                    let match = false;
-                    if (effect.accessor.requiredAccess) {
-                        for (const accessType of accessTypes) {
-                            if (accessType === 1 /* ReactiveAccessType.AnyProperty */) {
-                                match ||= allPropertyAccess.has(reference2.textSpan.start + reference2.textSpan.length);
-                            }
-                            else if (accessType === 0 /* ReactiveAccessType.ValueProperty */) {
-                                match ||= allValuePropertyAccess.has(reference2.textSpan.start + reference2.textSpan.length);
-                            }
-                            else {
-                                match ||= allFunctionCalls.has(reference2.textSpan.start + reference2.textSpan.length);
-                            }
-                        }
-                    }
-                    if (match) {
-                        let hasDependent = effect.isDependent;
-                        if (effect.binding) {
-                            const dependents = findDependents(effect.binding.ast, effect.binding.accessTypes, visited);
-                            result.push(...dependents);
-                            hasDependent ||= dependents.length > 0;
-                        }
-                        if (hasDependent) {
-                            result.push(effect);
-                        }
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    function findSignalByBindingRange(position) {
-        return signals.find(ref => ref.binding && ref.binding.start <= position
-            && ref.binding.end >= position);
-    }
-    function findSignalByCallbackRange(position) {
-        return signals.filter(ref => ref.callback && ref.callback.start <= position
-            && ref.callback.end >= position).sort((a, b) => (a.callback.end - a.callback.start) - (b.callback.end - b.callback.start))[0];
-    }
-    function findSignalByAccessorRange(position) {
-        return signals.filter(ref => ref.accessor && ref.accessor.start <= position
-            && ref.accessor.end >= position).sort((a, b) => (a.accessor.end - a.accessor.start) - (b.accessor.end - b.accessor.start))[0];
-    }
-}
-function analyze(ts, sourceFile, toSourceRange) {
-    const signals = [];
-    const allValuePropertyAccess = new Set();
-    const allPropertyAccess = new Set();
-    const allFunctionCalls = new Set();
-    sourceFile.forEachChild(function visit(node) {
-        if (ts.isVariableDeclaration(node)) {
-            if (node.initializer && ts.isCallExpression(node.initializer)) {
-                const call = node.initializer;
-                if (ts.isIdentifier(call.expression)) {
-                    const callName = call.expression.escapedText;
-                    if (callName === 'ref' || callName === 'shallowRef' || callName === 'toRef' || callName === 'useTemplateRef'
-                        || callName === 'defineModel') {
-                        const nameRange = toSourceRange(node.name.getStart(sourceFile), node.name.end);
-                        if (nameRange) {
-                            signals.push({
-                                isDependency: true,
-                                isDependent: false,
-                                binding: {
-                                    ...nameRange,
-                                    ast: node.name,
-                                    accessTypes: [0 /* ReactiveAccessType.ValueProperty */],
-                                },
-                            });
-                        }
-                    }
-                    else if (callName === 'reactive' || callName === 'shallowReactive' || callName === 'defineProps'
-                        || callName === 'withDefaults') {
-                        const nameRange = toSourceRange(node.name.getStart(sourceFile), node.name.end);
-                        if (nameRange) {
-                            signals.push({
-                                isDependency: true,
-                                isDependent: false,
-                                binding: {
-                                    ...nameRange,
-                                    ast: node.name,
-                                    accessTypes: [1 /* ReactiveAccessType.AnyProperty */],
-                                },
-                            });
-                        }
-                    }
-                    // TODO: toRefs
-                }
-            }
-        }
-        else if (ts.isFunctionDeclaration(node)) {
-            if (node.name && node.body) {
-                const nameRange = toSourceRange(node.name.getStart(sourceFile), node.name.end);
-                const bodyRange = toSourceRange(node.body.getStart(sourceFile), node.body.end);
-                if (nameRange && bodyRange) {
-                    signals.push({
-                        isDependency: false,
-                        isDependent: false,
-                        binding: {
-                            ...nameRange,
-                            ast: node.name,
-                            accessTypes: [2 /* ReactiveAccessType.Call */],
-                        },
-                        accessor: {
-                            ...bodyRange,
-                            ast: node.body,
-                            requiredAccess: true,
-                        },
-                        callback: {
-                            ...bodyRange,
-                            ast: node.body,
-                        },
-                    });
-                }
-            }
-        }
-        else if (ts.isVariableStatement(node)) {
-            for (const declaration of node.declarationList.declarations) {
-                const name = declaration.name;
-                const callback = declaration.initializer;
-                if (callback && ts.isIdentifier(name) && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback))) {
-                    const nameRange = toSourceRange(name.getStart(sourceFile), name.end);
-                    const callbackRange = toSourceRange(callback.getStart(sourceFile), callback.end);
-                    if (nameRange && callbackRange) {
-                        signals.push({
-                            isDependency: false,
-                            isDependent: false,
-                            binding: {
-                                ...nameRange,
-                                ast: name,
-                                accessTypes: [2 /* ReactiveAccessType.Call */],
-                            },
-                            accessor: {
-                                ...callbackRange,
-                                ast: callback,
-                                requiredAccess: true,
-                            },
-                            callback: {
-                                ...callbackRange,
-                                ast: callback,
-                            },
-                        });
-                    }
-                }
-            }
-        }
-        else if (ts.isParameter(node)) {
-            if (node.type && ts.isTypeReferenceNode(node.type)) {
-                const typeName = node.type.typeName.getText(sourceFile);
-                if (typeName.endsWith('Ref')) {
-                    const nameRange = toSourceRange(node.name.getStart(sourceFile), node.name.end);
-                    if (nameRange) {
-                        signals.push({
-                            isDependency: true,
-                            isDependent: false,
-                            binding: {
-                                ...nameRange,
-                                ast: node.name,
-                                accessTypes: [0 /* ReactiveAccessType.ValueProperty */],
-                            },
-                        });
-                    }
-                }
-            }
-        }
-        else if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
-            const call = node;
-            const callName = node.expression.escapedText;
-            if ((callName === 'effect' || callName === 'watchEffect') && call.arguments.length) {
-                const callback = call.arguments[0];
-                if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
-                    const callbackRange = toSourceRange(callback.getStart(sourceFile), callback.end);
-                    if (callbackRange) {
-                        signals.push({
-                            isDependency: false,
-                            isDependent: true,
-                            accessor: {
-                                ...callbackRange,
-                                ast: callback.body,
-                                requiredAccess: true,
-                            },
-                            callback: {
-                                ...callbackRange,
-                                ast: callback.body,
-                            },
-                        });
-                    }
-                }
-            }
-            if (callName === 'watch' && call.arguments.length >= 2) {
-                const depsCallback = call.arguments[0];
-                const effectCallback = call.arguments[1];
-                if (ts.isArrowFunction(effectCallback) || ts.isFunctionExpression(effectCallback)) {
-                    const depsRange = toSourceRange(depsCallback.getStart(sourceFile), depsCallback.end);
-                    const effectRange = toSourceRange(effectCallback.getStart(sourceFile), effectCallback.end);
-                    if (depsRange && effectRange) {
-                        if (ts.isArrowFunction(depsCallback) || ts.isFunctionExpression(depsCallback)) {
-                            signals.push({
-                                isDependency: false,
-                                isDependent: true,
-                                accessor: {
-                                    ...depsRange,
-                                    ast: depsCallback.body,
-                                    requiredAccess: true,
-                                },
-                                callback: {
-                                    ...effectRange,
-                                    ast: effectCallback.body,
-                                },
-                            });
-                        }
-                        else {
-                            signals.push({
-                                isDependency: false,
-                                isDependent: true,
-                                accessor: {
-                                    ...depsRange,
-                                    ast: depsCallback,
-                                    requiredAccess: false,
-                                },
-                                callback: {
-                                    ...effectRange,
-                                    ast: effectCallback.body,
-                                },
-                            });
-                        }
-                    }
-                }
-            }
-            else if ((0, language_core_1.hyphenateAttr)(callName).startsWith('use-')) {
-                let binding;
-                if (ts.isVariableDeclaration(call.parent)) {
-                    const nameRange = toSourceRange(call.parent.name.getStart(sourceFile), call.parent.name.end);
-                    if (nameRange) {
-                        binding = {
-                            ...nameRange,
-                            ast: call.parent.name,
-                            accessTypes: [1 /* ReactiveAccessType.AnyProperty */, 2 /* ReactiveAccessType.Call */],
-                        };
-                    }
-                }
-                const callRange = toSourceRange(call.getStart(sourceFile), call.end);
-                if (callRange) {
-                    signals.push({
-                        isDependency: true,
-                        isDependent: false,
-                        binding,
-                        accessor: {
-                            ...callRange,
-                            ast: call,
-                            requiredAccess: false,
-                        },
-                    });
-                }
-            }
-            else if ((callName === 'computed' || (0, language_core_1.hyphenateAttr)(callName).endsWith('-computed')) && call.arguments.length) {
-                const arg = call.arguments[0];
-                if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) {
-                    let binding;
-                    if (ts.isVariableDeclaration(call.parent)) {
-                        const nameRange = toSourceRange(call.parent.name.getStart(sourceFile), call.parent.name.end);
-                        if (nameRange) {
-                            binding = {
-                                ...nameRange,
-                                ast: call.parent.name,
-                                accessTypes: [0 /* ReactiveAccessType.ValueProperty */],
-                            };
-                        }
-                    }
-                    const argRange = toSourceRange(arg.getStart(sourceFile), arg.end);
-                    if (argRange) {
-                        signals.push({
-                            isDependency: true,
-                            isDependent: true,
-                            binding,
-                            accessor: {
-                                ...argRange,
-                                ast: arg.body,
-                                requiredAccess: true,
-                            },
-                            callback: {
-                                ...argRange,
-                                ast: arg.body,
-                            },
-                        });
-                    }
-                }
-                else if (ts.isIdentifier(arg)) {
-                    let binding;
-                    if (ts.isVariableDeclaration(call.parent)) {
-                        const nameRange = toSourceRange(call.parent.name.getStart(sourceFile), call.parent.name.end);
-                        if (nameRange) {
-                            binding = {
-                                ...nameRange,
-                                ast: call.parent.name,
-                                accessTypes: [0 /* ReactiveAccessType.ValueProperty */],
-                            };
-                        }
-                    }
-                    const argRange = toSourceRange(arg.getStart(sourceFile), arg.end);
-                    if (argRange) {
-                        signals.push({
-                            isDependency: true,
-                            isDependent: false,
-                            binding,
-                            accessor: {
-                                ...argRange,
-                                ast: arg,
-                                requiredAccess: false,
-                            },
-                        });
-                    }
-                }
-                else if (ts.isObjectLiteralExpression(arg)) {
-                    for (const prop of arg.properties) {
-                        if (prop.name?.getText(sourceFile) === 'get') {
-                            let binding;
-                            if (ts.isVariableDeclaration(call.parent)) {
-                                const nameRange = toSourceRange(call.parent.name.getStart(sourceFile), call.parent.name.end);
-                                if (nameRange) {
-                                    binding = {
-                                        ...nameRange,
-                                        ast: call.parent.name,
-                                        accessTypes: [0 /* ReactiveAccessType.ValueProperty */],
-                                    };
-                                }
-                            }
-                            if (ts.isPropertyAssignment(prop)) {
-                                const callback = prop.initializer;
-                                if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
-                                    const callbackRange = toSourceRange(callback.getStart(sourceFile), callback.end);
-                                    if (callbackRange) {
-                                        signals.push({
-                                            isDependency: true,
-                                            isDependent: true,
-                                            binding,
-                                            accessor: {
-                                                ...callbackRange,
-                                                ast: callback.body,
-                                                requiredAccess: true,
-                                            },
-                                            callback: {
-                                                ...callbackRange,
-                                                ast: callback.body,
-                                            },
-                                        });
-                                    }
-                                }
-                            }
-                            else if (ts.isMethodDeclaration(prop) && prop.body) {
-                                const bodyRange = toSourceRange(prop.body.getStart(sourceFile), prop.body.end);
-                                if (bodyRange) {
-                                    signals.push({
-                                        isDependency: true,
-                                        isDependent: true,
-                                        binding,
-                                        accessor: {
-                                            ...bodyRange,
-                                            ast: prop.body,
-                                            requiredAccess: true,
-                                        },
-                                        callback: {
-                                            ...bodyRange,
-                                            ast: prop.body,
-                                        },
-                                    });
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        node.forEachChild(visit);
-    });
-    sourceFile.forEachChild(function visit(node) {
-        if (ts.isPropertyAccessExpression(node)) {
-            const sourceRange = toSourceRange(node.expression.end, node.expression.end);
-            if (sourceRange) {
-                if (node.name.text === 'value') {
-                    allValuePropertyAccess.add(sourceRange.end);
-                    allPropertyAccess.add(sourceRange.end);
-                }
-                else if (node.name.text !== '') {
-                    allPropertyAccess.add(sourceRange.end);
-                }
-            }
-        }
-        else if (ts.isElementAccessExpression(node)) {
-            const sourceRange = toSourceRange(node.expression.end, node.expression.end);
-            if (sourceRange) {
-                allPropertyAccess.add(sourceRange.end);
-            }
-        }
-        else if (ts.isCallExpression(node)) {
-            const sourceRange = toSourceRange(node.expression.end, node.expression.end);
-            if (sourceRange) {
-                allFunctionCalls.add(sourceRange.end);
-            }
-        }
-        node.forEachChild(visit);
-    });
-    return {
-        signals,
-        allValuePropertyAccess,
-        allPropertyAccess,
-        allFunctionCalls,
-    };
-}
-//# sourceMappingURL=getReactiveReferences.js.map

package/lib/requests/getReactiveVariableSpans.d.ts

@@ -1,3 +0,0 @@
-import type { SourceScript } from '@vue/language-core';
-import type * as ts from 'typescript';
-export declare function getReactiveVariableSpans(ts: typeof import('typescript'), program: ts.Program, sourceScript: SourceScript, fileName: string, isTsPlugin: boolean): ts.TextSpan[];

package/lib/requests/getReactiveVariableSpans.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getReactiveVariableSpans = getReactiveVariableSpans;
-function getReactiveVariableSpans(ts, program, sourceScript, fileName, isTsPlugin) {
-    const sourceFile = program.getSourceFile(fileName);
-    if (!sourceFile) {
-        return [];
-    }
-    const checker = program.getTypeChecker();
-    const minusOffset = isTsPlugin ? sourceScript.snapshot.getLength() : 0;
-    const variableSpans = [];
-    ts.forEachChild(sourceFile, function visit(node) {
-        if (ts.isIdentifier(node)) {
-            const symbol = checker.getSymbolAtLocation(node);
-            if (symbol) {
-                const type = checker.getTypeOfSymbol(symbol);
-                const properties = type.getProperties();
-                if (properties.some(prop => prop.getName().startsWith('__@RefSymbol@'))) {
-                    variableSpans.push({
-                        start: node.getStart(sourceFile) - minusOffset,
-                        length: node.getWidth(),
-                    });
-                }
-            }
-        }
-        ts.forEachChild(node, visit);
-    });
-    return variableSpans;
-}
-//# sourceMappingURL=getReactiveVariableSpans.js.map

package/lib/requests/getSemanticClassfications.d.ts

@@ -1,3 +0,0 @@
-import type * as ts from 'typescript';
-import type { RequestContext } from './types';
-export declare function getSemanticClassifications(this: RequestContext, fileName: string, span: ts.TextSpan): ts.ClassifiedSpan[] | ts.ClassifiedSpan2020[];

package/lib/requests/getSemanticClassfications.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSemanticClassifications = getSemanticClassifications;
-function getSemanticClassifications(fileName, span) {
-    const { languageService, typescript: ts } = this;
-    return languageService.getSemanticClassifications(fileName, span, ts.SemanticClassificationFormat.TwentyTwenty);
-}
-//# sourceMappingURL=getSemanticClassfications.js.map

package/lib/requests/getVariableProperties.d.ts

@@ -1,10 +0,0 @@
-import type { RequestContext } from './types';
-export interface ComponentPropInfo {
-    name: string;
-    required?: boolean;
-    deprecated?: boolean;
-    isAttribute?: boolean;
-    commentMarkdown?: string;
-    values?: string[];
-}
-export declare function getVariableProperties(this: RequestContext, fileName: string, variableName: string): string[] | undefined;

package/lib/requests/getVariableProperties.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVariableProperties = getVariableProperties;
-const language_core_1 = require("@vue/language-core");
-const utils_1 = require("./utils");
-function getVariableProperties(fileName, variableName) {
-    const { typescript: ts, language, languageService, asScriptId } = this;
-    const volarFile = language.scripts.get(asScriptId(fileName));
-    if (!(volarFile?.generated?.root instanceof language_core_1.VueVirtualCode)) {
-        return;
-    }
-    const vueCode = volarFile.generated.root;
-    const variable = (0, utils_1.getVariableType)(ts, languageService, vueCode, variableName);
-    return variable?.type.getProperties().map(prop => prop.name);
-}
-//# sourceMappingURL=getVariableProperties.js.map

package/lib/requests/isRefAtLocation.d.ts

@@ -1,3 +0,0 @@
-import { type Language, type SourceScript, type VueVirtualCode } from '@vue/language-core';
-import type * as ts from 'typescript';
-export declare function isRefAtLocation(ts: typeof import('typescript'), language: Language, program: ts.Program, sourceScript: SourceScript, virtualCode: VueVirtualCode, position: number, isTsPlugin: boolean): boolean;

package/lib/requests/isRefAtLocation.js

@@ -1,55 +0,0 @@
-"use strict";
-/// <reference types="@volar/typescript" />
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRefAtLocation = isRefAtLocation;
-const language_core_1 = require("@vue/language-core");
-function isRefAtLocation(ts, language, program, sourceScript, virtualCode, position, isTsPlugin) {
-    const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(virtualCode);
-    if (!serviceScript) {
-        return false;
-    }
-    let mapped = false;
-    for (const [_sourceScript, map] of language.maps.forEach(serviceScript.code)) {
-        for (const [position2, mapping] of map.toGeneratedLocation(position)) {
-            if ((0, language_core_1.isCompletionEnabled)(mapping.data)) {
-                position = position2;
-                mapped = true;
-                break;
-            }
-        }
-        if (mapped) {
-            break;
-        }
-    }
-    if (!mapped) {
-        return false;
-    }
-    position += isTsPlugin ? sourceScript.snapshot.getLength() : 0;
-    const sourceFile = program.getSourceFile(virtualCode.fileName);
-    if (!sourceFile) {
-        return false;
-    }
-    const node = findPositionIdentifier(sourceFile, sourceFile, position);
-    if (!node) {
-        return false;
-    }
-    const checker = program.getTypeChecker();
-    const type = checker.getTypeAtLocation(node);
-    const props = type.getProperties();
-    return props.some(prop => prop.escapedName === 'value' && prop.flags & ts.SymbolFlags.Accessor);
-    function findPositionIdentifier(sourceFile, node, offset) {
-        let result;
-        node.forEachChild(child => {
-            if (!result) {
-                if (child.end === offset && ts.isIdentifier(child)) {
-                    result = child;
-                }
-                else if (child.end >= offset && child.getStart(sourceFile) < offset) {
-                    result = findPositionIdentifier(sourceFile, child, offset);
-                }
-            }
-        });
-        return result;
-    }
-}
-//# sourceMappingURL=isRefAtLocation.js.map

package/lib/requests/resolveModuleName.d.ts

@@ -1,4 +0,0 @@
-import type { RequestContext } from './types';
-export declare function resolveModuleName(this: RequestContext, fileName: string, moduleName: string): {
-    name?: string;
-};

package/lib/requests/resolveModuleName.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveModuleName = resolveModuleName;
-function resolveModuleName(fileName, moduleName) {
-    const { typescript: ts, languageServiceHost } = this;
-    const compilerOptions = languageServiceHost.getCompilationSettings();
-    const ext = moduleName.split('.').pop();
-    const result = ts.resolveModuleName(moduleName, fileName, {
-        ...compilerOptions,
-        allowArbitraryExtensions: true,
-    }, {
-        fileExists(fileName) {
-            fileName = transformFileName(fileName, ext);
-            return languageServiceHost.fileExists(fileName);
-        },
-    });
-    const resolveFileName = result.resolvedModule?.resolvedFileName;
-    return {
-        name: resolveFileName ? transformFileName(resolveFileName, ext) : undefined,
-    };
-}
-function transformFileName(fileName, ext) {
-    if (ext && fileName.endsWith(`.d.${ext}.ts`)) {
-        return fileName.slice(0, -`.d.${ext}.ts`.length) + `.${ext}`;
-    }
-    return fileName;
-}
-//# sourceMappingURL=resolveModuleName.js.map

package/lib/requests/types.d.ts

@@ -1,8 +0,0 @@
-import type { Language } from '@vue/language-core';
-import type * as ts from 'typescript';
-export interface RequestContext {
-    typescript: typeof ts;
-    languageService: ts.LanguageService;
-    languageServiceHost: ts.LanguageServiceHost;
-    language: Language<string>;
-}

package/lib/requests/types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map