@vue/language-service 1.7.0

package/out/languageService.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = void 0;
+const volar_service_css_1 = require("volar-service-css");
+const volar_service_emmet_1 = require("volar-service-emmet");
+const volar_service_html_1 = require("volar-service-html");
+const volar_service_json_1 = require("volar-service-json");
+const volar_service_pug_1 = require("volar-service-pug");
+const volar_service_typescript_1 = require("volar-service-typescript");
+const volar_service_typescript_twoslash_queries_1 = require("volar-service-typescript-twoslash-queries");
+const vue = require("@vue/language-core");
+const vscode = require("vscode-languageserver-protocol");
+const vue_1 = require("./plugins/vue");
+const vue_autoinsert_dotvalue_1 = require("./plugins/vue-autoinsert-dotvalue");
+const vue_codelens_references_1 = require("./plugins/vue-codelens-references");
+const vue_twoslash_queries_1 = require("./plugins/vue-twoslash-queries");
+const vue_template_1 = require("./plugins/vue-template");
+const vue_visualize_hidden_callback_param_1 = require("./plugins/vue-visualize-hidden-callback-param");
+const shared_1 = require("@vue/shared");
+const volar_service_pug_beautify_1 = require("volar-service-pug-beautify");
+const vue_autoinsert_parentheses_1 = require("./plugins/vue-autoinsert-parentheses");
+const vue_autoinsert_space_1 = require("./plugins/vue-autoinsert-space");
+const types_1 = require("./types");
+const nameCasing_1 = require("./ideFeatures/nameCasing");
+function resolveConfig(config, // volar.config.js
+compilerOptions = {}, vueCompilerOptions = vue.resolveVueCompilerOptions({}), settings, ts = require('typescript')) {
+    const vueLanguageModules = vue.createLanguages(compilerOptions, vueCompilerOptions, ts);
+    config.languages = Object.assign({}, vueLanguageModules, config.languages);
+    config.services = resolvePlugins(config.services, vueCompilerOptions, settings);
+    return config;
+}
+exports.resolveConfig = resolveConfig;
+function resolvePlugins(services, vueCompilerOptions, settings) {
+    const originalTsPlugin = services?.typescript ?? (0, volar_service_typescript_1.default)();
+    services ??= {};
+    services.typescript = (_context, modules) => {
+        const base = typeof originalTsPlugin === 'function' ? originalTsPlugin(_context, modules) : originalTsPlugin;
+        if (!_context || !modules?.typescript)
+            return base;
+        const ts = modules.typescript;
+        const autoImportPositions = new WeakSet();
+        return {
+            ...base,
+            resolveEmbeddedRange(range) {
+                if (autoImportPositions.has(range.start) && autoImportPositions.has(range.end))
+                    return range;
+            },
+            async provideCompletionItems(document, position, context, item) {
+                const result = await base.provideCompletionItems?.(document, position, context, item);
+                if (result) {
+                    // filter __VLS_
+                    result.items = result.items.filter(item => item.label.indexOf('__VLS_') === -1
+                        && (!item.labelDetails?.description || item.labelDetails.description.indexOf('__VLS_') === -1));
+                    // handle component auto-import patch
+                    for (const [_, map] of _context.documents.getMapsByVirtualFileUri(document.uri)) {
+                        const virtualFile = _context.documents.getSourceByUri(map.sourceFileDocument.uri)?.root;
+                        if (virtualFile instanceof vue.VueFile) {
+                            const isAutoImport = !!map.toSourcePosition(position, data => typeof data.completion === 'object' && !!data.completion.autoImportOnly);
+                            if (isAutoImport) {
+                                result.items.forEach(item => {
+                                    item.data.__isComponentAutoImport = true;
+                                });
+                                // fix #2458
+                                const source = _context.documents.getVirtualFileByUri(document.uri)[1];
+                                if (source && _context.typescript) {
+                                    const casing = await (0, nameCasing_1.getNameCasing)(ts, _context, _context.env.fileNameToUri(source.fileName));
+                                    if (casing.tag === types_1.TagNameCasing.Kebab) {
+                                        result.items.forEach(item => {
+                                            item.filterText = (0, shared_1.hyphenate)(item.filterText ?? item.label);
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return result;
+            },
+            async resolveCompletionItem(item, token) {
+                item = await base.resolveCompletionItem?.(item, token) ?? item;
+                const itemData = item.data;
+                let newName;
+                if (itemData?.uri && item.additionalTextEdits) {
+                    patchAdditionalTextEdits(itemData.uri, item.additionalTextEdits);
+                }
+                for (const ext of vueCompilerOptions.extensions) {
+                    const suffix = (0, shared_1.capitalize)(ext.substring('.'.length)); // .vue -> Vue
+                    if (itemData?.uri
+                        && _context.typescript
+                        && item.textEdit?.newText.endsWith(suffix)
+                        && item.additionalTextEdits?.length === 1 && item.additionalTextEdits[0].newText.indexOf('import ' + item.textEdit.newText + ' from ') >= 0
+                        && (await _context.env.getConfiguration?.('vue.complete.normalizeComponentImportName') ?? true)) {
+                        newName = item.textEdit.newText.slice(0, -suffix.length);
+                        newName = newName[0].toUpperCase() + newName.substring(1);
+                        if (newName === 'Index') {
+                            const tsItem = item.data.originalItem;
+                            if (tsItem.source) {
+                                const dirs = tsItem.source.split('/');
+                                if (dirs.length >= 3) {
+                                    newName = dirs[dirs.length - 2];
+                                    newName = newName[0].toUpperCase() + newName.substring(1);
+                                }
+                            }
+                        }
+                        item.additionalTextEdits[0].newText = item.additionalTextEdits[0].newText.replace('import ' + item.textEdit.newText + ' from ', 'import ' + newName + ' from ');
+                        item.textEdit.newText = newName;
+                        const source = _context.documents.getVirtualFileByUri(itemData.uri)[1];
+                        if (source) {
+                            const casing = await (0, nameCasing_1.getNameCasing)(ts, _context, _context.env.fileNameToUri(source.fileName));
+                            if (casing.tag === types_1.TagNameCasing.Kebab) {
+                                item.textEdit.newText = (0, shared_1.hyphenate)(item.textEdit.newText);
+                            }
+                        }
+                    }
+                    else if (item.textEdit?.newText && new RegExp(`import \\w*${suffix}\\$1 from [\\S\\s]*`).test(item.textEdit.newText)) {
+                        // https://github.com/vuejs/language-tools/issues/2286
+                        item.textEdit.newText = item.textEdit.newText.replace(`${suffix}$1`, '$1');
+                    }
+                }
+                const data = item.data;
+                if (item.data?.__isComponentAutoImport && data && item.additionalTextEdits?.length && item.textEdit) {
+                    for (const [_, map] of _context.documents.getMapsByVirtualFileUri(data.uri)) {
+                        const virtualFile = _context.documents.getSourceByUri(map.sourceFileDocument.uri)?.root;
+                        if (virtualFile instanceof vue.VueFile) {
+                            const sfc = virtualFile.sfc;
+                            const componentName = newName ?? item.textEdit.newText;
+                            const textDoc = _context.documents.getDocumentByFileName(virtualFile.snapshot, virtualFile.fileName);
+                            if (sfc.scriptAst && sfc.script) {
+                                const _scriptRanges = vue.scriptRanges.parseScriptRanges(ts, sfc.scriptAst, !!sfc.scriptSetup, true);
+                                const exportDefault = _scriptRanges.exportDefault;
+                                if (exportDefault) {
+                                    // https://github.com/microsoft/TypeScript/issues/36174
+                                    const printer = ts.createPrinter();
+                                    if (exportDefault.componentsOption && exportDefault.componentsOptionNode) {
+                                        const newNode = {
+                                            ...exportDefault.componentsOptionNode,
+                                            properties: [
+                                                ...exportDefault.componentsOptionNode.properties,
+                                                ts.factory.createShorthandPropertyAssignment(componentName),
+                                            ],
+                                        };
+                                        const printText = printer.printNode(ts.EmitHint.Expression, newNode, sfc.scriptAst);
+                                        const editRange = vscode.Range.create(textDoc.positionAt(sfc.script.startTagEnd + exportDefault.componentsOption.start), textDoc.positionAt(sfc.script.startTagEnd + exportDefault.componentsOption.end));
+                                        autoImportPositions.add(editRange.start);
+                                        autoImportPositions.add(editRange.end);
+                                        item.additionalTextEdits.push(vscode.TextEdit.replace(editRange, unescape(printText.replace(/\\u/g, '%u'))));
+                                    }
+                                    else if (exportDefault.args && exportDefault.argsNode) {
+                                        const newNode = {
+                                            ...exportDefault.argsNode,
+                                            properties: [
+                                                ...exportDefault.argsNode.properties,
+                                                ts.factory.createShorthandPropertyAssignment(`components: { ${componentName} }`),
+                                            ],
+                                        };
+                                        const printText = printer.printNode(ts.EmitHint.Expression, newNode, sfc.scriptAst);
+                                        const editRange = vscode.Range.create(textDoc.positionAt(sfc.script.startTagEnd + exportDefault.args.start), textDoc.positionAt(sfc.script.startTagEnd + exportDefault.args.end));
+                                        autoImportPositions.add(editRange.start);
+                                        autoImportPositions.add(editRange.end);
+                                        item.additionalTextEdits.push(vscode.TextEdit.replace(editRange, unescape(printText.replace(/\\u/g, '%u'))));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return item;
+            },
+            async provideCodeActions(document, range, context, token) {
+                const result = await base.provideCodeActions?.(document, range, context, token);
+                return result?.filter(codeAction => codeAction.title.indexOf('__VLS_') === -1);
+            },
+            async resolveCodeAction(item, token) {
+                const result = await base.resolveCodeAction?.(item, token) ?? item;
+                if (result?.edit?.changes) {
+                    for (const uri in result.edit.changes) {
+                        const edits = result.edit.changes[uri];
+                        if (edits) {
+                            patchAdditionalTextEdits(uri, edits);
+                        }
+                    }
+                }
+                if (result?.edit?.documentChanges) {
+                    for (const documentChange of result.edit.documentChanges) {
+                        if (vscode.TextDocumentEdit.is(documentChange)) {
+                            patchAdditionalTextEdits(documentChange.textDocument.uri, documentChange.edits);
+                        }
+                    }
+                }
+                return result;
+            },
+        };
+    };
+    services.html ??= (0, vue_template_1.default)({
+        templateLanguagePlugin: (0, volar_service_html_1.default)(),
+        getScanner: (document, htmlPlugin) => {
+            return htmlPlugin.getHtmlLs().createScanner(document.getText());
+        },
+        isSupportedDocument: (document) => document.languageId === 'html',
+        vueCompilerOptions,
+    });
+    services.pug ??= (0, vue_template_1.default)({
+        templateLanguagePlugin: (0, volar_service_pug_1.default)(),
+        getScanner: (document, pugPlugin) => {
+            const pugDocument = pugPlugin.getPugDocument(document);
+            if (pugDocument) {
+                return pugPlugin.getPugLs().createScanner(pugDocument);
+            }
+        },
+        isSupportedDocument: (document) => document.languageId === 'jade',
+        vueCompilerOptions,
+    });
+    services.vue ??= (0, vue_1.default)();
+    services.css ??= (0, volar_service_css_1.default)();
+    services['pug-beautify'] ??= (0, volar_service_pug_beautify_1.default)();
+    services.json ??= (0, volar_service_json_1.default)(settings?.json);
+    services['typescript/twoslash-queries'] ??= (0, volar_service_typescript_twoslash_queries_1.default)();
+    services['vue/referencesCodeLens'] ??= (0, vue_codelens_references_1.default)();
+    services['vue/autoInsertDotValue'] ??= (0, vue_autoinsert_dotvalue_1.default)();
+    services['vue/twoslash-queries'] ??= (0, vue_twoslash_queries_1.default)();
+    services['vue/autoInsertParentheses'] ??= (0, vue_autoinsert_parentheses_1.default)();
+    services['vue/autoInsertSpaces'] ??= (0, vue_autoinsert_space_1.default)();
+    services['vue/visualizeHiddenCallbackParam'] ??= (0, vue_visualize_hidden_callback_param_1.default)();
+    services.emmet ??= (0, volar_service_emmet_1.default)();
+    return services;
+}
+// fix https://github.com/vuejs/language-tools/issues/916
+function patchAdditionalTextEdits(uri, edits) {
+    if (uri.endsWith('.vue.js')
+        || uri.endsWith('.vue.ts')
+        || uri.endsWith('.vue.jsx')
+        || uri.endsWith('.vue.tsx')) {
+        for (const edit of edits) {
+            if (edit.range.start.line === 0
+                && edit.range.start.character === 0
+                && edit.range.end.line === 0
+                && edit.range.end.character === 0) {
+                edit.newText = '\n' + edit.newText;
+            }
+        }
+    }
+}
+//# sourceMappingURL=languageService.js.map

package/out/plugins/data.d.ts

@@ -0,0 +1,4 @@
+import * as html from 'vscode-html-languageservice';
+export declare function loadTemplateData(lang: string): html.HTMLDataV1;
+export declare function loadLanguageBlocks(lang: string): html.HTMLDataV1;
+export declare function loadModelModifiersData(lang: string): html.HTMLDataV1;

package/out/plugins/data.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModelModifiersData = exports.loadLanguageBlocks = exports.loadTemplateData = void 0;
+function loadTemplateData(lang) {
+    lang = lang.toLowerCase();
+    let data;
+    if (lang === 'ja') {
+        data = require('../../data/template/ja.json');
+    }
+    else if (lang === 'fr') {
+        data = require('../../data/template/fr.json');
+    }
+    else if (lang === 'ko') {
+        data = require('../../data/template/ko.json');
+    }
+    else if (lang === 'zh-cn') {
+        data = require('../../data/template/zh-cn.json');
+    }
+    else if (lang === 'zh-tw') {
+        data = require('../../data/template/zh-tw.json');
+    }
+    else {
+        data = require('../../data/template/en.json');
+    }
+    for (const attr of [...data.globalAttributes ?? []]) {
+        if (!attr.name.startsWith('v-')) {
+            data.globalAttributes?.push({ ...attr, name: `:${attr.name}` });
+        }
+    }
+    const vOn = data.globalAttributes?.find(d => d.name === 'v-on');
+    const vSlot = data.globalAttributes?.find(d => d.name === 'v-slot');
+    const vBind = data.globalAttributes?.find(d => d.name === 'v-bind');
+    if (vOn)
+        data.globalAttributes?.push({ ...vOn, name: '@' });
+    if (vSlot)
+        data.globalAttributes?.push({ ...vSlot, name: '#' });
+    if (vBind)
+        data.globalAttributes?.push({ ...vBind, name: ':' });
+    return data;
+}
+exports.loadTemplateData = loadTemplateData;
+function loadLanguageBlocks(lang) {
+    lang = lang.toLowerCase();
+    let data;
+    if (lang === 'ja') {
+        data = require('../../data/language-blocks/ja.json');
+    }
+    else if (lang === 'fr') {
+        data = require('../../data/language-blocks/fr.json');
+    }
+    else if (lang === 'ko') {
+        data = require('../../data/language-blocks/ko.json');
+    }
+    else if (lang === 'zh-cn') {
+        data = require('../../data/language-blocks/zh-cn.json');
+    }
+    else if (lang === 'zh-tw') {
+        data = require('../../data/language-blocks/zh-tw.json');
+    }
+    else {
+        data = require('../../data/language-blocks/en.json');
+    }
+    return data;
+}
+exports.loadLanguageBlocks = loadLanguageBlocks;
+function loadModelModifiersData(lang) {
+    lang = lang.toLowerCase();
+    let data;
+    if (lang === 'ja') {
+        data = require('../../data/model-modifiers/ja.json');
+    }
+    else if (lang === 'fr') {
+        data = require('../../data/model-modifiers/fr.json');
+    }
+    else if (lang === 'ko') {
+        data = require('../../data/model-modifiers/ko.json');
+    }
+    else if (lang === 'zh-cn') {
+        data = require('../../data/model-modifiers/zh-cn.json');
+    }
+    else if (lang === 'zh-tw') {
+        data = require('../../data/model-modifiers/zh-tw.json');
+    }
+    else {
+        data = require('../../data/model-modifiers/en.json');
+    }
+    return data;
+}
+exports.loadModelModifiersData = loadModelModifiersData;
+//# sourceMappingURL=data.js.map

package/out/plugins/vue-autoinsert-dotvalue.d.ts

@@ -0,0 +1,7 @@
+import { AutoInsertionContext, Service } from '@volar/language-service';
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+declare const _default: () => Service;
+export default _default;
+export declare function isCharacterTyping(document: TextDocument, options: AutoInsertionContext): boolean;
+export declare function isBlacklistNode(ts: typeof import('typescript/lib/tsserverlibrary'), node: ts.Node, pos: number, allowAccessDotValue: boolean): boolean;

package/out/plugins/vue-autoinsert-dotvalue.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBlacklistNode = exports.isCharacterTyping = void 0;
+const shared_1 = require("@vue/shared");
+const vscode = require("vscode-languageserver-protocol");
+const plugin = (context, modules) => {
+    if (!modules?.typescript)
+        return {};
+    if (!context?.typescript)
+        return {};
+    const ts = modules.typescript;
+    const _ts = context.typescript;
+    return {
+        async provideAutoInsertionEdit(document, position, insertContext) {
+            if (!isTsDocument(document))
+                return;
+            if (!isCharacterTyping(document, insertContext))
+                return;
+            const enabled = await context.env.getConfiguration?.('vue.autoInsert.dotValue') ?? true;
+            if (!enabled)
+                return;
+            const program = _ts.languageService.getProgram();
+            if (!program)
+                return;
+            const sourceFile = program.getSourceFile(context.env.uriToFileName(document.uri));
+            if (!sourceFile)
+                return;
+            if (isBlacklistNode(ts, sourceFile, document.offsetAt(position), false))
+                return;
+            const node = findPositionIdentifier(sourceFile, sourceFile, document.offsetAt(position));
+            if (!node)
+                return;
+            const token = _ts.languageServiceHost.getCancellationToken?.();
+            if (token) {
+                _ts.languageService.getQuickInfoAtPosition(context.env.uriToFileName(document.uri), node.end);
+                if (token?.isCancellationRequested()) {
+                    return; // check cancel here because type checker do not use cancel token
+                }
+            }
+            const checker = program.getTypeChecker();
+            const type = checker.getTypeAtLocation(node);
+            const props = type.getProperties();
+            if (props.some(prop => prop.name === 'value')) {
+                return '${1:.value}';
+            }
+            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;
+            }
+        },
+    };
+};
+exports.default = () => plugin;
+function isTsDocument(document) {
+    return document.languageId === 'javascript' ||
+        document.languageId === 'typescript' ||
+        document.languageId === 'javascriptreact' ||
+        document.languageId === 'typescriptreact';
+}
+function isCharacterTyping(document, options) {
+    const lastCharacter = options.lastChange.text[options.lastChange.text.length - 1];
+    const rangeStart = options.lastChange.range.start;
+    const position = vscode.Position.create(rangeStart.line, rangeStart.character + options.lastChange.text.length);
+    const nextCharacter = document.getText(vscode.Range.create(position, document.positionAt(document.offsetAt(position) + 1)));
+    if (lastCharacter === undefined) { // delete text
+        return false;
+    }
+    if (options.lastChange.text.indexOf('\n') >= 0) { // multi-line change
+        return false;
+    }
+    return /\w/.test(lastCharacter) && !/\w/.test(nextCharacter);
+}
+exports.isCharacterTyping = isCharacterTyping;
+function isBlacklistNode(ts, node, pos, allowAccessDotValue) {
+    if (ts.isVariableDeclaration(node) && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isFunctionDeclaration(node) && node.name && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isParameter(node) && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isPropertyAssignment(node) && pos >= node.name.getFullStart() && pos <= node.name.getEnd()) {
+        return true;
+    }
+    else if (ts.isShorthandPropertyAssignment(node)) {
+        return true;
+    }
+    else if (ts.isImportDeclaration(node)) {
+        return true;
+    }
+    else if (ts.isLiteralTypeNode(node)) {
+        return true;
+    }
+    else if (ts.isTypeReferenceNode(node)) {
+        return true;
+    }
+    else if (!allowAccessDotValue && ts.isPropertyAccessExpression(node) && node.expression.end === pos && node.name.text === 'value') {
+        return true;
+    }
+    else if (ts.isCallExpression(node)
+        && ts.isIdentifier(node.expression)
+        && isWatchOrUseFunction(node.expression.text)
+        && isTopLevelArgOrArrayTopLevelItemItem(node)) {
+        return true;
+    }
+    else {
+        let _isBlacklistNode = false;
+        node.forEachChild(node => {
+            if (_isBlacklistNode)
+                return;
+            if (pos >= node.getFullStart() && pos <= node.getEnd()) {
+                if (isBlacklistNode(ts, node, pos, allowAccessDotValue)) {
+                    _isBlacklistNode = true;
+                }
+            }
+        });
+        return _isBlacklistNode;
+    }
+    function isWatchOrUseFunction(fnName) {
+        return fnName === 'watch'
+            || fnName === 'unref'
+            || fnName === 'triggerRef'
+            || fnName === 'isRef'
+            || (0, shared_1.hyphenate)(fnName).startsWith('use-');
+    }
+    function isTopLevelArgOrArrayTopLevelItemItem(node) {
+        for (const arg of node.arguments) {
+            if (pos >= arg.getFullStart() && pos <= arg.getEnd()) {
+                if (ts.isIdentifier(arg)) {
+                    return true;
+                }
+                if (ts.isArrayLiteralExpression(arg)) {
+                    for (const el of arg.elements) {
+                        if (pos >= el.getFullStart() && pos <= el.getEnd()) {
+                            return ts.isIdentifier(el);
+                        }
+                    }
+                }
+                return false;
+            }
+        }
+    }
+}
+exports.isBlacklistNode = isBlacklistNode;
+//# sourceMappingURL=vue-autoinsert-dotvalue.js.map

package/out/plugins/vue-autoinsert-parentheses.d.ts

@@ -0,0 +1,3 @@
+import { Service } from '@volar/language-service';
+declare const _default: () => Service;
+export default _default;

package/out/plugins/vue-autoinsert-parentheses.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const embedded = require("@volar/language-core");
+const language_core_1 = require("@vue/language-core");
+const vscode = require("vscode-languageserver-protocol");
+const vue_autoinsert_dotvalue_1 = require("./vue-autoinsert-dotvalue");
+const plugin = (context, modules) => {
+    if (!context) {
+        return {};
+    }
+    if (!modules?.typescript) {
+        return {};
+    }
+    const ts = modules.typescript;
+    return {
+        async provideAutoInsertionEdit(document, position, options_2) {
+            const enabled = await context.env.getConfiguration?.('vue.autoInsert.parentheses') ?? false;
+            if (!enabled)
+                return;
+            if (!(0, vue_autoinsert_dotvalue_1.isCharacterTyping)(document, options_2))
+                return;
+            const [vueFile] = context.documents.getVirtualFileByUri(document.uri);
+            if (!(vueFile instanceof language_core_1.VueFile))
+                return;
+            let templateFormatScript;
+            embedded.forEachEmbeddedFile(vueFile, embedded => {
+                if (embedded.fileName.endsWith('.template_format.ts')) {
+                    templateFormatScript = embedded;
+                }
+            });
+            if (!templateFormatScript)
+                return;
+            const offset = document.offsetAt(position);
+            for (const mappedRange of templateFormatScript.mappings) {
+                if (mappedRange.sourceRange[1] === offset) {
+                    const text = document.getText().substring(mappedRange.sourceRange[0], mappedRange.sourceRange[1]);
+                    const ast = ts.createSourceFile(templateFormatScript.fileName, text, ts.ScriptTarget.Latest);
+                    if (ast.statements.length === 1) {
+                        const statement = ast.statements[0];
+                        if (ts.isExpressionStatement(statement)
+                            && ((ts.isAsExpression(statement.expression)
+                                && ts.isTypeReferenceNode(statement.expression.type)
+                                && ts.isIdentifier(statement.expression.type.typeName)
+                                && statement.expression.type.typeName.text)
+                                || (ts.isBinaryExpression(statement.expression)
+                                    && statement.expression.right.getText(ast)
+                                    && statement.expression.operatorToken.kind === ts.SyntaxKind.InstanceOfKeyword)
+                                || (ts.isTypeOfExpression(statement.expression)
+                                    && statement.expression.expression.getText(ast)))) {
+                            // https://code.visualstudio.com/docs/editor/userdefinedsnippets#_grammar
+                            const escapedText = text
+                                .replaceAll('\\', '\\\\')
+                                .replaceAll('$', '\\$')
+                                .replaceAll('}', '\\}');
+                            return vscode.TextEdit.replace({
+                                start: document.positionAt(mappedRange.sourceRange[0]),
+                                end: document.positionAt(mappedRange.sourceRange[1]),
+                            }, '(' + escapedText + '$0' + ')');
+                        }
+                    }
+                }
+            }
+        },
+    };
+};
+exports.default = () => plugin;
+//# sourceMappingURL=vue-autoinsert-parentheses.js.map

package/out/plugins/vue-autoinsert-space.d.ts

@@ -0,0 +1,3 @@
+import { Service } from '@volar/language-service';
+declare const _default: () => Service;
+export default _default;

package/out/plugins/vue-autoinsert-space.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin = (context) => {
+    if (!context)
+        return {};
+    return {
+        async provideAutoInsertionEdit(document, _, { lastChange }) {
+            if (document.languageId === 'html' || document.languageId === 'jade') {
+                const enabled = await context.env.getConfiguration?.('vue.autoInsert.bracketSpacing') ?? true;
+                if (!enabled)
+                    return;
+                if (lastChange.text === '{}'
+                    && document.getText({
+                        start: { line: lastChange.range.start.line, character: lastChange.range.start.character - 1 },
+                        end: { line: lastChange.range.start.line, character: lastChange.range.start.character + 3 }
+                    }) === '{{}}') {
+                    return {
+                        newText: ` $0 `,
+                        range: {
+                            start: { line: lastChange.range.start.line, character: lastChange.range.start.character + 1 },
+                            end: { line: lastChange.range.start.line, character: lastChange.range.start.character + 1 }
+                        },
+                    };
+                }
+            }
+        },
+    };
+};
+exports.default = () => plugin;
+//# sourceMappingURL=vue-autoinsert-space.js.map

package/out/plugins/vue-codelens-references.d.ts

@@ -0,0 +1,2 @@
+import { Service } from '@volar/language-service';
+export default function (): Service;