@vue/language-service 1.9.0-alpha.3 → 2.0.1

package/scripts/update-html-data.js

@@ -0,0 +1,426 @@
+// @ts-check
+const fs = require('fs');
+const path = require('path');
+const langs = [
+	{
+		name: 'en',
+		url: 'https://vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs/docs/',
+		supported: true,
+	},
+	{
+		name: 'zh-cn',
+		url: 'https://cn.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-zh-cn/',
+		supported: true,
+	},
+	{
+		name: 'ja',
+		url: 'https://ja.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-ja/',
+		supported: true,
+	},
+	{
+		name: 'ua',
+		url: 'https://ua.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-ua/',
+		supported: false,
+	},
+	{
+		name: 'fr',
+		url: 'https://fr.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-fr/',
+		supported: true,
+	},
+	{
+		name: 'ko',
+		url: 'https://ko.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-ko/',
+		supported: true,
+	},
+	{
+		name: 'pt',
+		url: 'https://pt.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-pt/',
+		supported: true,
+	},
+	{
+		name: 'bn',
+		url: 'https://bn.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-bn/',
+		supported: false,
+	},
+	{
+		name: 'it',
+		url: 'https://it.vuejs.org/',
+		repoUrl: 'https://raw.githubusercontent.com/vuejs-translations/docs-it/',
+		supported: true,
+	},
+];
+
+for (const lang of langs) {
+	if (lang.supported) {
+		templateWorker(lang);
+		sfcWorker(lang);
+		modelWorker(lang);
+	}
+}
+
+async function sfcWorker(lang) {
+
+	const sfcDoc = await fetchText(lang.repoUrl + 'HEAD/src/api/sfc-spec.md', lang.url);
+	const cssFeaturesDoc = await fetchText(lang.repoUrl + 'HEAD/src/api/sfc-css-features.md', lang.url);
+
+	/**
+	 * @type {import('vscode-html-languageservice').IAttributeData}
+	 */
+	const langAttr = {
+		name: 'lang',
+		description: {
+			kind: 'markdown',
+			value: sfcDoc.split('\n## ')[4].split('\n').slice(1).join('\n'),
+		},
+		values: [
+			// // custom block
+			// { name: 'md' },
+			// { name: 'json' },
+			// { name: 'jsonc' },
+			// { name: 'json5' },
+			// { name: 'yaml' },
+			// { name: 'toml' },
+			// { name: 'gql' },
+			// { name: 'graphql' },
+		],
+		references: langs.map(lang => ({
+			name: lang.name,
+			url: `${lang.url}api/sfc-spec.html#pre-processors`,
+		})),
+	};
+	/**
+	 * @type {import('vscode-html-languageservice').IAttributeData}
+	 */
+	const srcAttr = {
+		name: 'src',
+		description: {
+			kind: 'markdown',
+			value: sfcDoc.split('\n## ')[5].split('\n').slice(1).join('\n'),
+		},
+		references: langs.map(lang => ({
+			name: lang.name,
+			url: `${lang.url}api/sfc-spec.html#src-imports`,
+		})),
+	};
+	const languageBlocks = sfcDoc
+		.split('\n## ')[2]
+		.split('\n### ')
+		.slice(1)
+		.map((section) => {
+			const lines = section.split('\n');
+			const name = normalizeTagName(lines[0]);
+			/**
+			 * @type {import('vscode-html-languageservice').ITagData}
+			 */
+			const data = {
+				name,
+				attributes: name === 'script setup' ? [] : [srcAttr],
+				description: {
+					kind: 'markdown',
+					value: lines.slice(1).join('\n'),
+				},
+				references: langs.map(lang => ({
+					name: lang.name,
+					url: `${lang.url}api/sfc-spec.html#${normalizeHash(name)}`,
+				})),
+			};
+			if (name === 'template') {
+				data.attributes.push({
+					...langAttr,
+					values: [
+						{ name: 'html' },
+						{ name: 'pug' },
+					],
+				});
+			}
+			if (name === 'script') {
+				data.attributes.push({
+					...langAttr,
+					values: [
+						{ name: 'ts' },
+						{ name: 'js' },
+						{ name: 'tsx' },
+						{ name: 'jsx' },
+					],
+				});
+				data.attributes.push({ name: 'generic' });
+			}
+			if (name === 'style') {
+				data.attributes.push({
+					...langAttr,
+					values: [
+						{ name: 'css' },
+						{ name: 'scss' },
+						{ name: 'less' },
+						{ name: 'stylus' },
+						{ name: 'postcss' },
+						{ name: 'sass' },
+					],
+				});
+				data.attributes.push({
+					name: 'scoped',
+					valueSet: 'v',
+					description: {
+						kind: 'markdown',
+						value: cssFeaturesDoc.split('\n## ')[1].split('\n').slice(1).join('\n'),
+					},
+					references: langs.map(lang => ({
+						name: lang.name,
+						url: `${lang.url}api/sfc-css-features.html#scoped-css`,
+					})),
+				});
+				data.attributes.push({
+					name: 'module',
+					valueSet: 'v',
+					description: {
+						kind: 'markdown',
+						value: cssFeaturesDoc.split('\n## ')[2].split('\n').slice(1).join('\n'),
+					},
+					references: langs.map(lang => ({
+						name: lang.name,
+						url: `${lang.url}api/sfc-css-features.html#css-modules`,
+					})),
+				});
+			}
+			return data;
+		});
+
+	const scriptBlock = languageBlocks.find(b => b.name === 'script');
+	const scriptSetupBlock = languageBlocks.find(b => b.name === 'script setup');
+
+	if (!scriptBlock || !scriptSetupBlock) {
+		throw new Error('script or script setup block not found');
+	}
+
+	scriptBlock.attributes.push({
+		name: 'setup',
+		valueSet: 'v',
+		description: scriptSetupBlock.description,
+		references: scriptSetupBlock.references,
+	});
+
+	/**
+	 * @type {import('vscode-html-languageservice').HTMLDataV1}
+	 */
+	const data = {
+		version: 1.1,
+		tags: languageBlocks,
+		globalAttributes: [langAttr, srcAttr],
+	};
+
+	const writePath = path.resolve(__dirname, '../data/language-blocks/' + lang.name + '.json');
+	fs.writeFileSync(writePath, JSON.stringify(data, null, 2));
+	console.log(writePath);
+}
+
+async function modelWorker(lang) {
+
+	const formsDoc = await fetchText(lang.repoUrl + 'HEAD/src/guide/essentials/forms.md', lang.url);
+	const modifiers = formsDoc
+		.split('\n## ')[3]
+		.split('\n### ')
+		.slice(1)
+		.map((section) => {
+			const lines = section.split('\n');
+			let name = normalizeAttrName(lines[0]);
+			name = name.split('.')[1];
+			/**
+			 * @type {import('vscode-html-languageservice').IAttributeData}
+			 */
+			const data = {
+				name,
+				description: {
+					kind: 'markdown',
+					value: lines.slice(1).join('\n'),
+				},
+				references: langs.map(lang => ({
+					name: lang.name,
+					url: `${lang.url}guide/essentials/forms.html#${normalizeHash(name)}`,
+				})),
+			};
+			return data;
+		});
+
+	/**
+	 * @type {import('vscode-html-languageservice').HTMLDataV1}
+	 */
+	const data = {
+		version: 1.1,
+		globalAttributes: modifiers,
+	};
+
+	const writePath = path.resolve(__dirname, '../data/model-modifiers/' + lang.name + '.json');
+	fs.writeFileSync(writePath, JSON.stringify(data, null, 2));
+	console.log(writePath);
+}
+
+async function templateWorker(lang) {
+
+	const directivesDoc = await fetchText(lang.repoUrl + 'HEAD/src/api/built-in-directives.md', lang.url);
+	const attributesDoc = await fetchText(lang.repoUrl + 'HEAD/src/api/built-in-special-attributes.md', lang.url);
+	const componentsDoc = await fetchText(lang.repoUrl + 'HEAD/src/api/built-in-components.md', lang.url);
+	const elementsDoc = await fetchText(lang.repoUrl + 'HEAD/src/api/built-in-special-elements.md', lang.url);
+
+	const directives = directivesDoc
+		.split('\n## ')
+		.slice(1)
+		.map((section) => {
+			const lines = section.split('\n');
+			const name = normalizeAttrName(lines[0]);
+			/**
+			 * @type {import('vscode-html-languageservice').IAttributeData}
+			 */
+			const data = {
+				name,
+				valueSet: name === 'v-else' ? 'v' : undefined,
+				description: {
+					kind: 'markdown',
+					value: lines.slice(1).join('\n'),
+				},
+				references: langs.map(lang => ({
+					name: lang.name,
+					url: `${lang.url}api/built-in-directives.html#${normalizeHash(name)}`,
+				})),
+			};
+			return data;
+		});
+	const attributes = attributesDoc
+		.split('\n## ')
+		.slice(1)
+		.map((section) => {
+			const lines = section.split('\n');
+			const name = normalizeAttrName(lines[0]);
+			/**
+			 * @type {import('vscode-html-languageservice').IAttributeData}
+			 */
+			const data = {
+				name,
+				description: {
+					kind: 'markdown',
+					value: lines.slice(1).join('\n'),
+				},
+				references: langs.map(lang => ({
+					name: lang.name,
+					url: `${lang.url}api/built-in-special-attributes.html#${normalizeHash(name)}`,
+				})),
+			};
+			return data;
+		});
+	const components = componentsDoc
+		.split('\n## ')
+		.slice(1)
+		.map((section) => {
+			const lines = section.split('\n');
+			const name = normalizeTagName(lines[0]);
+			/**
+			 * @type {import('vscode-html-languageservice').ITagData}
+			 */
+			const data = {
+				name,
+				description: {
+					kind: 'markdown',
+					value: lines.slice(1).join('\n'),
+				},
+				attributes: [],
+				references: langs.map(lang => ({
+					name: lang.name,
+					url: `${lang.url}api/built-in-components.html#${normalizeHash(name)}`,
+				})),
+			};
+			return data;
+		});
+	const elements = elementsDoc
+		.split('\n## ')
+		.slice(1)
+		.map((section) => {
+			const lines = section.split('\n');
+			const name = normalizeTagName(lines[0]);
+			/**
+			 * @type {import('vscode-html-languageservice').ITagData}
+			 */
+			const data = {
+				name,
+				description: {
+					kind: 'markdown',
+					value: lines.slice(1).join('\n'),
+				},
+				attributes: [],
+				references: langs.map(lang => ({
+					name: lang.name,
+					url: `${lang.url}api/built-in-special-elements.html#${normalizeHash(name)}`,
+				})),
+			};
+			return data;
+		});
+
+	/**
+	 * @type {import('vscode-html-languageservice').HTMLDataV1}
+	 */
+	const data = {
+		version: 1.1,
+		tags: [
+			...components,
+			...elements,
+		],
+		globalAttributes: [
+			...directives,
+			...attributes
+		],
+	};
+
+	const writePath = path.resolve(__dirname, '../data/template/' + lang.name + '.json');
+	fs.writeFileSync(writePath, JSON.stringify(data, null, 2));
+	console.log(writePath);
+}
+
+async function fetchText(url, baseUrl) {
+	let text = await (await fetch(url)).text();
+	text = text.replace(/```vue-html/g, '```html');
+	text = text.replace(/\{\#.*?\}/g, '')
+	text = resolveMarkdownLinks(text, baseUrl);
+	return text;
+}
+
+function resolveMarkdownLinks(text, url) {
+	return text.replace(/\[(.*?)\]\(\/(.*?)\)/g, (match, p1, p2) => {
+		const p2Parts = p2.split('#');
+		if (!p2Parts[0].endsWith('.html')) {
+			p2Parts[0] += '.html';
+		}
+		p2 = p2Parts.join('#');
+		return `[${p1}](${url}${p2})`;
+	});
+}
+
+function normalizeTagName(name) {
+	name = name.trim();
+	return _normalizeName(name);
+}
+
+function normalizeAttrName(name) {
+	name = name.trim();
+	name = name.split(' ')[0];
+	return _normalizeName(name);
+}
+
+function _normalizeName(name) {
+	if (name.startsWith('`')) {
+		name = name.split('`')[1].split('`')[0];
+	}
+	if (name.startsWith('<')) {
+		name = name.split('<')[1].split('>')[0];
+	}
+	return name;
+}
+
+function normalizeHash(str) {
+	return str.replace(/ /g, '-').toLowerCase();
+}

package/out/helpers.d.ts

@@ -1,17 +0,0 @@
-import * as vue from '@vue/language-core';
-import * as embedded from '@volar/language-core';
-import type * as ts from 'typescript/lib/tsserverlibrary';
-export declare function getPropsByTag(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, sourceFile: embedded.VirtualFile, tag: string, vueCompilerOptions: vue.VueCompilerOptions, requiredOnly?: boolean): string[];
-export declare function getEventsOfTag(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, sourceFile: embedded.VirtualFile, tag: string, vueCompilerOptions: vue.VueCompilerOptions): string[];
-export declare function getTemplateCtx(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, sourceFile: embedded.VirtualFile): string[] | undefined;
-export declare function getComponentNames(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, sourceFile: embedded.VirtualFile, vueCompilerOptions: vue.VueCompilerOptions): string[];
-export declare function getElementAttrs(ts: typeof import('typescript/lib/tsserverlibrary'), tsLs: ts.LanguageService, tsLsHost: ts.LanguageServiceHost, tagName: string): string[];
-type Tags = Map<string, {
-    offsets: number[];
-    attrs: Map<string, {
-        offsets: number[];
-    }>;
-}>;
-export declare function getTemplateTagsAndAttrs(sourceFile: embedded.VirtualFile): Tags;
-export {};
-//# sourceMappingURL=helpers.d.ts.map

package/out/helpers.js

@@ -1,235 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTemplateTagsAndAttrs = exports.getElementAttrs = exports.getComponentNames = exports.getTemplateCtx = exports.getEventsOfTag = exports.getPropsByTag = void 0;
-const vue = require("@vue/language-core");
-const embedded = require("@volar/language-core");
-const computeds_1 = require("computeds");
-const language_core_1 = require("@vue/language-core");
-const shared_1 = require("@vue/shared");
-function getPropsByTag(ts, tsLs, sourceFile, tag, vueCompilerOptions, requiredOnly = false) {
-    const checker = tsLs.getProgram().getTypeChecker();
-    const components = getVariableType(ts, tsLs, sourceFile, '__VLS_components');
-    if (!components)
-        return [];
-    const name = tag.split('.');
-    let componentSymbol = components.type.getProperty(name[0]);
-    if (!componentSymbol && !vueCompilerOptions.nativeTags.includes(name[0])) {
-        componentSymbol = components.type.getProperty((0, shared_1.camelize)(name[0]))
-            ?? components.type.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
-    }
-    if (!componentSymbol)
-        return [];
-    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-    for (let i = 1; i < name.length; i++) {
-        componentSymbol = componentType.getProperty(name[i]);
-        if (componentSymbol) {
-            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-        }
-        else {
-            return [];
-        }
-    }
-    const result = new Set();
-    for (const sig of componentType.getCallSignatures()) {
-        const propParam = sig.parameters[0];
-        if (propParam) {
-            const propsType = checker.getTypeOfSymbolAtLocation(propParam, components.node);
-            const props = propsType.getProperties();
-            for (const prop of props) {
-                if (!requiredOnly || !(prop.flags & ts.SymbolFlags.Optional)) {
-                    result.add(prop.name);
-                }
-            }
-        }
-    }
-    for (const sig of componentType.getConstructSignatures()) {
-        const instanceType = sig.getReturnType();
-        const propsSymbol = instanceType.getProperty('$props');
-        if (propsSymbol) {
-            const propsType = checker.getTypeOfSymbolAtLocation(propsSymbol, components.node);
-            const props = propsType.getProperties();
-            for (const prop of props) {
-                if (prop.flags & ts.SymbolFlags.Method) { // #2443
-                    continue;
-                }
-                if (!requiredOnly || !(prop.flags & ts.SymbolFlags.Optional)) {
-                    result.add(prop.name);
-                }
-            }
-        }
-    }
-    return [...result];
-}
-exports.getPropsByTag = getPropsByTag;
-function getEventsOfTag(ts, tsLs, sourceFile, tag, vueCompilerOptions) {
-    const checker = tsLs.getProgram().getTypeChecker();
-    const components = getVariableType(ts, tsLs, sourceFile, '__VLS_components');
-    if (!components)
-        return [];
-    const name = tag.split('.');
-    let componentSymbol = components.type.getProperty(name[0]);
-    if (!componentSymbol && !vueCompilerOptions.nativeTags.includes(name[0])) {
-        componentSymbol = components.type.getProperty((0, shared_1.camelize)(name[0]))
-            ?? components.type.getProperty((0, shared_1.capitalize)((0, shared_1.camelize)(name[0])));
-    }
-    if (!componentSymbol)
-        return [];
-    let componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-    for (let i = 1; i < name.length; i++) {
-        componentSymbol = componentType.getProperty(name[i]);
-        if (componentSymbol) {
-            componentType = checker.getTypeOfSymbolAtLocation(componentSymbol, components.node);
-        }
-        else {
-            return [];
-        }
-    }
-    const result = new Set();
-    // for (const sig of componentType.getCallSignatures()) {
-    // 	const emitParam = sig.parameters[1];
-    // 	if (emitParam) {
-    // 		// TODO
-    // 	}
-    // }
-    for (const sig of componentType.getConstructSignatures()) {
-        const instanceType = sig.getReturnType();
-        const emitSymbol = instanceType.getProperty('$emit');
-        if (emitSymbol) {
-            const emitType = checker.getTypeOfSymbolAtLocation(emitSymbol, components.node);
-            for (const call of emitType.getCallSignatures()) {
-                const eventNameParamSymbol = call.parameters[0];
-                if (eventNameParamSymbol) {
-                    const eventNameParamType = checker.getTypeOfSymbolAtLocation(eventNameParamSymbol, components.node);
-                    if (eventNameParamType.isStringLiteral()) {
-                        result.add(eventNameParamType.value);
-                    }
-                }
-            }
-        }
-    }
-    return [...result];
-}
-exports.getEventsOfTag = getEventsOfTag;
-function getTemplateCtx(ts, tsLs, sourceFile) {
-    return getVariableType(ts, tsLs, sourceFile, '__VLS_ctx')
-        ?.type
-        ?.getProperties()
-        .map(c => c.name);
-}
-exports.getTemplateCtx = getTemplateCtx;
-function getComponentNames(ts, tsLs, sourceFile, vueCompilerOptions) {
-    return getVariableType(ts, tsLs, sourceFile, '__VLS_components')
-        ?.type
-        ?.getProperties()
-        .map(c => c.name)
-        .filter(entry => entry.indexOf('$') === -1 && !entry.startsWith('_'))
-        .filter(entry => !vueCompilerOptions.nativeTags.includes(entry))
-        ?? [];
-}
-exports.getComponentNames = getComponentNames;
-function getElementAttrs(ts, tsLs, tsLsHost, tagName) {
-    const sharedTypesFileName = tsLsHost.getCurrentDirectory() + '/' + language_core_1.sharedTypes.baseName;
-    let tsSourceFile;
-    if (tsSourceFile = tsLs.getProgram()?.getSourceFile(sharedTypesFileName)) {
-        const typeNode = tsSourceFile.statements.find((node) => ts.isTypeAliasDeclaration(node) && node.name.getText() === '__VLS_IntrinsicElements');
-        const checker = tsLs.getProgram()?.getTypeChecker();
-        if (checker && typeNode) {
-            const type = checker.getTypeFromTypeNode(typeNode.type);
-            const el = type.getProperty(tagName);
-            if (el) {
-                const attrs = checker.getTypeOfSymbolAtLocation(el, typeNode).getProperties();
-                return attrs.map(c => c.name);
-            }
-        }
-    }
-    return [];
-}
-exports.getElementAttrs = getElementAttrs;
-function getVariableType(ts, tsLs, sourceFile, name) {
-    if (!(sourceFile instanceof vue.VueFile)) {
-        return;
-    }
-    let file;
-    let tsSourceFile;
-    embedded.forEachEmbeddedFile(sourceFile, embedded => {
-        if (embedded.fileName === sourceFile.mainScriptName) {
-            file = embedded;
-        }
-    });
-    if (file && (tsSourceFile = tsLs.getProgram()?.getSourceFile(file.fileName))) {
-        const node = searchVariableDeclarationNode(ts, tsSourceFile, name);
-        const checker = tsLs.getProgram()?.getTypeChecker();
-        if (checker && node) {
-            return {
-                node: node,
-                type: checker.getTypeAtLocation(node),
-            };
-        }
-    }
-}
-function searchVariableDeclarationNode(ts, sourceFile, name) {
-    let componentsNode;
-    walk(sourceFile);
-    return componentsNode;
-    function walk(node) {
-        if (componentsNode) {
-            return;
-        }
-        else if (ts.isVariableDeclaration(node) && node.name.getText() === name) {
-            componentsNode = node;
-        }
-        else {
-            node.forEachChild(walk);
-        }
-    }
-}
-const map = new WeakMap();
-function getTemplateTagsAndAttrs(sourceFile) {
-    if (!map.has(sourceFile)) {
-        const getter = (0, computeds_1.computed)(() => {
-            if (!(sourceFile instanceof vue.VueFile))
-                return;
-            const ast = sourceFile.sfc.template?.ast;
-            const tags = new Map();
-            if (ast) {
-                vue.walkElementNodes(ast, node => {
-                    if (!tags.has(node.tag)) {
-                        tags.set(node.tag, { offsets: [], attrs: new Map() });
-                    }
-                    const tag = tags.get(node.tag);
-                    const startTagHtmlOffset = node.loc.start.offset + node.loc.source.indexOf(node.tag);
-                    const endTagHtmlOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
-                    tag.offsets.push(startTagHtmlOffset);
-                    if (!node.isSelfClosing) {
-                        tag.offsets.push(endTagHtmlOffset);
-                    }
-                    for (const prop of node.props) {
-                        let name;
-                        let offset;
-                        if (prop.type === 7
-                            && prop.arg?.type === 4
-                            && prop.arg.isStatic) {
-                            name = prop.arg.content;
-                            offset = prop.arg.loc.start.offset;
-                        }
-                        else if (prop.type === 6) {
-                            name = prop.name;
-                            offset = prop.loc.start.offset;
-                        }
-                        if (name !== undefined && offset !== undefined) {
-                            if (!tag.attrs.has(name)) {
-                                tag.attrs.set(name, { offsets: [] });
-                            }
-                            tag.attrs.get(name).offsets.push(offset);
-                        }
-                    }
-                });
-            }
-            return tags;
-        });
-        map.set(sourceFile, getter);
-    }
-    return map.get(sourceFile)() ?? new Map();
-}
-exports.getTemplateTagsAndAttrs = getTemplateTagsAndAttrs;
-//# sourceMappingURL=helpers.js.map

package/out/ideFeatures/dragImport.d.ts

@@ -1,9 +0,0 @@
-import { ServiceContext } from '@volar/language-service';
-import type * as vscode from 'vscode-languageserver-protocol';
-import { TagNameCasing } from '../types';
-export declare function getDragImportEdits(ts: typeof import('typescript/lib/tsserverlibrary'), ctx: ServiceContext, uri: string, importUri: string, casing: TagNameCasing): {
-    insertText: string;
-    insertTextFormat: vscode.InsertTextFormat;
-    additionalEdits: vscode.TextEdit[];
-} | undefined;
-//# sourceMappingURL=dragImport.d.ts.map