@vue/language-core 1.7.0

package/out/plugins/file-md.js

@@ -0,0 +1,62 @@
+"use strict";
+const source_map_1 = require("@volar/source-map");
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = () => {
+    return {
+        version: 1,
+        parseSFC(fileName, content) {
+            if (fileName.endsWith('.md')) {
+                content = content
+                    // code block
+                    .replace(/```[\s\S]+?```/g, match => '```' + ' '.repeat(match.length - 6) + '```')
+                    // inline code block
+                    .replace(/`[^\n`]+?`/g, match => `\`${' '.repeat(match.length - 2)}\``)
+                    // # \<script setup>
+                    .replace(/\\\<[\s\S]+?\>\n?/g, match => ' '.repeat(match.length));
+                const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
+                const codes = [];
+                for (const match of content.matchAll(sfcBlockReg)) {
+                    if (match.index !== undefined) {
+                        const matchText = match[0];
+                        codes.push([matchText, undefined, match.index]);
+                        codes.push('\n\n');
+                        content = content.substring(0, match.index) + ' '.repeat(matchText.length) + content.substring(match.index + matchText.length);
+                    }
+                }
+                content = content
+                    // angle bracket: <http://foo.com>
+                    .replace(/\<\S*\:\S*\>/g, match => ' '.repeat(match.length))
+                    // [foo](http://foo.com)
+                    .replace(/\[[\s\S]*?\]\([\s\S]*?\)/g, match => ' '.repeat(match.length));
+                codes.push('<template>\n');
+                codes.push([content, undefined, 0]);
+                codes.push('\n</template>');
+                const file2VueSourceMap = new source_map_1.SourceMap((0, source_map_1.buildMappings)(codes));
+                const sfc = (0, parseSfc_1.parse)((0, source_map_1.toString)(codes));
+                if (sfc.descriptor.template) {
+                    transformRange(sfc.descriptor.template);
+                }
+                if (sfc.descriptor.script) {
+                    transformRange(sfc.descriptor.script);
+                }
+                if (sfc.descriptor.scriptSetup) {
+                    transformRange(sfc.descriptor.scriptSetup);
+                }
+                for (const style of sfc.descriptor.styles) {
+                    transformRange(style);
+                }
+                for (const customBlock of sfc.descriptor.customBlocks) {
+                    transformRange(customBlock);
+                }
+                return sfc;
+                function transformRange(block) {
+                    block.loc.start.offset = file2VueSourceMap.toSourceOffset(block.loc.start.offset)?.[0] ?? -1;
+                    block.loc.end.offset = file2VueSourceMap.toSourceOffset(block.loc.end.offset)?.[0] ?? -1;
+                }
+            }
+            ;
+        }
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=file-md.js.map

package/out/plugins/file-vue.d.ts

@@ -0,0 +1,3 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export = plugin;

package/out/plugins/file-vue.js

@@ -0,0 +1,39 @@
+"use strict";
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = (_ctx) => {
+    return {
+        version: 1,
+        parseSFC(_fileName, content) {
+            return (0, parseSfc_1.parse)(content);
+        },
+        updateSFC(sfc, change) {
+            const blocks = [
+                sfc.descriptor.template,
+                sfc.descriptor.script,
+                sfc.descriptor.scriptSetup,
+                ...sfc.descriptor.styles,
+                ...sfc.descriptor.customBlocks,
+            ].filter((block) => !!block);
+            const hitBlock = blocks.find(block => change.start >= block.loc.start.offset && change.end <= block.loc.end.offset);
+            if (!hitBlock) {
+                return;
+            }
+            hitBlock.content =
+                hitBlock.content.substring(0, change.start - hitBlock.loc.start.offset)
+                    + change.newText
+                    + hitBlock.content.substring(change.end - hitBlock.loc.start.offset);
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            for (const block of blocks) {
+                if (block.loc.start.offset > change.end) {
+                    block.loc.start.offset += lengthDiff;
+                }
+                if (block.loc.end.offset >= change.end) {
+                    block.loc.end.offset += lengthDiff;
+                }
+            }
+            return sfc;
+        },
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=file-vue.js.map

package/out/plugins/vue-sfc-customblocks.d.ts

@@ -0,0 +1,3 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export = plugin;

package/out/plugins/vue-sfc-customblocks.js

@@ -0,0 +1,31 @@
+"use strict";
+const language_core_1 = require("@volar/language-core");
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            const names = [];
+            for (let i = 0; i < sfc.customBlocks.length; i++) {
+                const customBlock = sfc.customBlocks[i];
+                names.push(fileName + '.customBlock_' + customBlock.type + '_' + i + '.' + customBlock.lang);
+            }
+            return names;
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const match = embeddedFile.fileName.match(/^(.*)\.customBlock_([^_]+)_(\d+)\.([^.]+)$/);
+            if (match) {
+                const index = parseInt(match[3]);
+                const customBlock = sfc.customBlocks[index];
+                embeddedFile.capabilities = language_core_1.FileCapabilities.full;
+                embeddedFile.content.push([
+                    customBlock.content,
+                    customBlock.name,
+                    0,
+                    language_core_1.FileRangeCapabilities.full,
+                ]);
+            }
+        },
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=vue-sfc-customblocks.js.map

package/out/plugins/vue-sfc-scripts.d.ts

@@ -0,0 +1,3 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export = plugin;

package/out/plugins/vue-sfc-scripts.js

@@ -0,0 +1,39 @@
+"use strict";
+const language_core_1 = require("@volar/language-core");
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            const names = [];
+            if (sfc.script) {
+                names.push(fileName + '.script_format.' + sfc.script.lang);
+            }
+            if (sfc.scriptSetup) {
+                names.push(fileName + '.scriptSetup_format.' + sfc.scriptSetup.lang);
+            }
+            return names;
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const scriptMatch = embeddedFile.fileName.match(/^(.*)\.script_format\.([^.]+)$/);
+            const scriptSetupMatch = embeddedFile.fileName.match(/^(.*)\.scriptSetup_format\.([^.]+)$/);
+            const script = scriptMatch ? sfc.script : scriptSetupMatch ? sfc.scriptSetup : undefined;
+            if (script) {
+                embeddedFile.kind = language_core_1.FileKind.TextFile;
+                embeddedFile.capabilities = {
+                    ...language_core_1.FileCapabilities.full,
+                    diagnostic: false,
+                    codeAction: false,
+                    inlayHint: false,
+                };
+                embeddedFile.content.push([
+                    script.content,
+                    script.name,
+                    0,
+                    {},
+                ]);
+            }
+        },
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=vue-sfc-scripts.js.map

package/out/plugins/vue-sfc-styles.d.ts

@@ -0,0 +1,3 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export = plugin;

package/out/plugins/vue-sfc-styles.js

@@ -0,0 +1,31 @@
+"use strict";
+const language_core_1 = require("@volar/language-core");
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            const names = [];
+            for (let i = 0; i < sfc.styles.length; i++) {
+                const style = sfc.styles[i];
+                names.push(fileName + '.style_' + i + '.' + style.lang);
+            }
+            return names;
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const match = embeddedFile.fileName.match(/^(.*)\.style_(\d+)\.([^.]+)$/);
+            if (match) {
+                const index = parseInt(match[2]);
+                const style = sfc.styles[index];
+                embeddedFile.capabilities = language_core_1.FileCapabilities.full;
+                embeddedFile.content.push([
+                    style.content,
+                    style.name,
+                    0,
+                    language_core_1.FileRangeCapabilities.full,
+                ]);
+            }
+        },
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=vue-sfc-styles.js.map

package/out/plugins/vue-sfc-template.d.ts

@@ -0,0 +1,3 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export = plugin;

package/out/plugins/vue-sfc-template.js

@@ -0,0 +1,27 @@
+"use strict";
+const language_core_1 = require("@volar/language-core");
+const plugin = () => {
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            if (sfc.template) {
+                return [fileName + '.template.' + sfc.template.lang];
+            }
+            return [];
+        },
+        resolveEmbeddedFile(_fileName, sfc, embeddedFile) {
+            const match = embeddedFile.fileName.match(/^(.*)\.template\.([^.]+)$/);
+            if (match && sfc.template) {
+                embeddedFile.capabilities = language_core_1.FileCapabilities.full;
+                embeddedFile.content.push([
+                    sfc.template.content,
+                    sfc.template.name,
+                    0,
+                    language_core_1.FileRangeCapabilities.full,
+                ]);
+            }
+        },
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=vue-sfc-template.js.map

package/out/plugins/vue-template-html.d.ts

@@ -0,0 +1,3 @@
+import { VueLanguagePlugin } from '../types';
+declare const plugin: VueLanguagePlugin;
+export = plugin;

package/out/plugins/vue-template-html.js

@@ -0,0 +1,165 @@
+"use strict";
+const plugin = ({ modules }) => {
+    return {
+        version: 1,
+        compileSFCTemplate(lang, template, options) {
+            if (lang === 'html') {
+                const compiler = modules['@vue/compiler-dom'];
+                return compiler.compile(template, options);
+            }
+        },
+        updateSFCTemplate(oldResult, change) {
+            const CompilerDOM = modules['@vue/compiler-dom'];
+            const lengthDiff = change.newText.length - (change.end - change.start);
+            let hitNodes = [];
+            if (tryUpdateNode(oldResult.ast) && hitNodes.length) {
+                hitNodes = hitNodes.sort((a, b) => a.loc.source.length - b.loc.source.length);
+                const hitNode = hitNodes[0];
+                if (hitNode.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
+                    return oldResult;
+                }
+            }
+            function tryUpdateNode(node) {
+                if (withinChangeRange(node.loc)) {
+                    hitNodes.push(node);
+                }
+                if (tryUpdateNodeLoc(node.loc)) {
+                    if (node.type === 0 /* CompilerDOM.NodeTypes.ROOT */) {
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === 1 /* CompilerDOM.NodeTypes.ELEMENT */) {
+                        if (withinChangeRange(node.loc)) {
+                            // if not self closing, should not hit tag name
+                            const start = node.loc.start.offset + 2;
+                            const end = node.loc.start.offset + node.loc.source.lastIndexOf('</');
+                            if (!withinChangeRange({ start: { offset: start }, end: { offset: end }, source: '' })) {
+                                return false;
+                            }
+                        }
+                        for (const prop of node.props) {
+                            if (!tryUpdateNode(prop)) {
+                                return false;
+                            }
+                        }
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === 6 /* CompilerDOM.NodeTypes.ATTRIBUTE */) {
+                        if (node.value && !tryUpdateNode(node.value)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 7 /* CompilerDOM.NodeTypes.DIRECTIVE */) {
+                        if (node.arg && withinChangeRange(node.arg.loc) && node.name === 'slot') {
+                            return false;
+                        }
+                        if (node.exp && withinChangeRange(node.exp.loc) && node.name === 'for') { // #2266
+                            return false;
+                        }
+                        if (node.arg && !tryUpdateNode(node.arg)) {
+                            return false;
+                        }
+                        if (node.exp && !tryUpdateNode(node.exp)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 12 /* CompilerDOM.NodeTypes.TEXT_CALL */) {
+                        if (!tryUpdateNode(node.content)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 8 /* CompilerDOM.NodeTypes.COMPOUND_EXPRESSION */) {
+                        for (const childNode of node.children) {
+                            if (typeof childNode === 'object') {
+                                if (!tryUpdateNode(childNode)) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                    else if (node.type === 9 /* CompilerDOM.NodeTypes.IF */) {
+                        for (const branch of node.branches) {
+                            if (branch.condition && !tryUpdateNode(branch.condition)) {
+                                return false;
+                            }
+                            for (const child of branch.children) {
+                                if (!tryUpdateNode(child)) {
+                                    return false;
+                                }
+                            }
+                        }
+                    }
+                    else if (node.type === 11 /* CompilerDOM.NodeTypes.FOR */) {
+                        for (const child of [
+                            node.parseResult.source,
+                            node.parseResult.value,
+                            node.parseResult.key,
+                            node.parseResult.index,
+                        ]) {
+                            if (child && !tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                        for (const child of node.children) {
+                            if (!tryUpdateNode(child)) {
+                                return false;
+                            }
+                        }
+                    }
+                    else if (node.type === 5 /* CompilerDOM.NodeTypes.INTERPOLATION */) {
+                        if (!tryUpdateNode(node.content)) {
+                            return false;
+                        }
+                    }
+                    else if (node.type === 4 /* CompilerDOM.NodeTypes.SIMPLE_EXPRESSION */) {
+                        if (withinChangeRange(node.loc)) { // TODO: review this (slot name?)
+                            if (node.isStatic) {
+                                return false;
+                            }
+                            else {
+                                node.content = node.loc.source;
+                            }
+                        }
+                    }
+                    return true;
+                }
+                return false;
+            }
+            function tryUpdateNodeLoc(loc) {
+                delete loc.__endOffset;
+                if (withinChangeRange(loc)) {
+                    loc.source =
+                        loc.source.substring(0, change.start - loc.start.offset)
+                            + change.newText
+                            + loc.source.substring(change.end - loc.start.offset);
+                    loc.__endOffset = loc.end.offset;
+                    loc.end.offset += lengthDiff;
+                    return true;
+                }
+                else if (change.end <= loc.start.offset) {
+                    loc.__endOffset = loc.end.offset;
+                    loc.start.offset += lengthDiff;
+                    loc.end.offset += lengthDiff;
+                    return true;
+                }
+                else if (change.start >= loc.end.offset) {
+                    return true; // no need update
+                }
+                return false;
+            }
+            function withinChangeRange(loc) {
+                const originalLocEnd = loc.__endOffset ?? loc.end.offset;
+                return change.start >= loc.start.offset && change.end <= originalLocEnd;
+            }
+        },
+    };
+};
+module.exports = plugin;
+//# sourceMappingURL=vue-template-html.js.map

package/out/plugins/vue-tsx.d.ts

@@ -0,0 +1,14 @@
+import { Sfc, VueLanguagePlugin } from '../types';
+import { TextRange } from '../types';
+declare const plugin: VueLanguagePlugin;
+export default plugin;
+export declare function collectStyleCssClasses(sfc: Sfc, condition: (style: Sfc['styles'][number]) => boolean): {
+    style: (typeof sfc.styles)[number];
+    index: number;
+    classNameRanges: TextRange[];
+    classNames: string[];
+}[];
+export declare function collectCssVars(sfc: Sfc): {
+    style: (typeof sfc.styles)[number];
+    ranges: TextRange[];
+}[];

package/out/plugins/vue-tsx.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectCssVars = exports.collectStyleCssClasses = void 0;
+const reactivity_1 = require("@vue/reactivity");
+const script_1 = require("../generators/script");
+const templateGen = require("../generators/template");
+const scriptRanges_1 = require("../parsers/scriptRanges");
+const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+const language_core_1 = require("@volar/language-core");
+const parseCssClassNames_1 = require("../utils/parseCssClassNames");
+const parseCssVars_1 = require("../utils/parseCssVars");
+const sharedTypes = require("../utils/directorySharedTypes");
+const plugin = ({ modules, vueCompilerOptions, compilerOptions }) => {
+    const ts = modules.typescript;
+    const instances = new WeakMap();
+    const sharedTypesImport = sharedTypes.getImportName(compilerOptions);
+    return {
+        version: 1,
+        getEmbeddedFileNames(fileName, sfc) {
+            const tsx = useTsx(fileName, sfc);
+            const fileNames = [];
+            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang.value)) {
+                fileNames.push(fileName + '.' + tsx.lang.value);
+            }
+            if (sfc.template) {
+                fileNames.push(fileName + '.template_format.ts');
+                fileNames.push(fileName + '.template_style.css');
+            }
+            return fileNames;
+        },
+        resolveEmbeddedFile(fileName, sfc, embeddedFile) {
+            const _tsx = useTsx(fileName, sfc);
+            const suffix = embeddedFile.fileName.replace(fileName, '');
+            if (suffix === '.' + _tsx.lang.value) {
+                embeddedFile.kind = language_core_1.FileKind.TypeScriptHostFile;
+                embeddedFile.capabilities = {
+                    ...language_core_1.FileCapabilities.full,
+                    foldingRange: false,
+                    documentFormatting: false,
+                    documentSymbol: false,
+                };
+                const tsx = _tsx.tsxGen.value;
+                if (tsx) {
+                    embeddedFile.content = [...tsx.codes];
+                    embeddedFile.mirrorBehaviorMappings = [...tsx.mirrorBehaviorMappings];
+                }
+            }
+            else if (suffix.match(/^\.template_format\.ts$/)) {
+                embeddedFile.parentFileName = fileName + '.template.' + sfc.template?.lang;
+                embeddedFile.kind = language_core_1.FileKind.TextFile;
+                embeddedFile.capabilities = {
+                    ...language_core_1.FileCapabilities.full,
+                    diagnostic: false,
+                    foldingRange: false,
+                    codeAction: false,
+                    inlayHint: false,
+                };
+                if (_tsx.htmlGen.value) {
+                    embeddedFile.content = [..._tsx.htmlGen.value.formatCodes];
+                }
+                for (const cssVar of _tsx.cssVars.value) {
+                    embeddedFile.content.push('\n\n');
+                    for (const range of cssVar.ranges) {
+                        embeddedFile.content.push('(');
+                        embeddedFile.content.push([
+                            cssVar.style.content.substring(range.start, range.end),
+                            cssVar.style.name,
+                            range.start,
+                            {},
+                        ]);
+                        embeddedFile.content.push(');\n');
+                    }
+                }
+            }
+            else if (suffix.match(/^\.template_style\.css$/)) {
+                embeddedFile.parentFileName = fileName + '.template.' + sfc.template?.lang;
+                if (_tsx.htmlGen.value) {
+                    embeddedFile.content = [..._tsx.htmlGen.value.cssCodes];
+                }
+                // for color pickers support
+                embeddedFile.capabilities.documentSymbol = true;
+            }
+        },
+    };
+    function useTsx(fileName, sfc) {
+        if (!instances.has(sfc)) {
+            instances.set(sfc, createTsx(fileName, sfc));
+        }
+        return instances.get(sfc);
+    }
+    function createTsx(fileName, _sfc) {
+        const lang = (0, reactivity_1.computed)(() => {
+            return !_sfc.script && !_sfc.scriptSetup ? 'ts'
+                : _sfc.scriptSetup && _sfc.scriptSetup.lang !== 'js' ? _sfc.scriptSetup.lang
+                    : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
+                        : 'js';
+        });
+        const cssVars = (0, reactivity_1.computed)(() => collectCssVars(_sfc));
+        const scriptRanges = (0, reactivity_1.computed)(() => _sfc.scriptAst
+            ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.scriptAst, !!_sfc.scriptSetup, false)
+            : undefined);
+        const scriptSetupRanges = (0, reactivity_1.computed)(() => _sfc.scriptSetupAst
+            ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetupAst, vueCompilerOptions)
+            : undefined);
+        const cssModuleClasses = (0, reactivity_1.computed)(() => collectStyleCssClasses(_sfc, style => !!style.module));
+        const cssScopedClasses = (0, reactivity_1.computed)(() => collectStyleCssClasses(_sfc, style => {
+            const setting = vueCompilerOptions.experimentalResolveStyleCssClasses;
+            return (setting === 'scoped' && style.scoped) || setting === 'always';
+        }));
+        const htmlGen = (0, reactivity_1.computed)(() => {
+            if (!_sfc.templateAst)
+                return;
+            return templateGen.generate(ts, compilerOptions, vueCompilerOptions, _sfc.template?.content ?? '', _sfc.template?.lang ?? 'html', _sfc.templateAst, hasScriptSetupSlots.value, sharedTypesImport, Object.values(cssScopedClasses.value).map(style => style.classNames).flat());
+        });
+        const hasScriptSetupSlots = (0, reactivity_1.shallowRef)(false); // remove when https://github.com/vuejs/core/pull/5912 merged
+        const tsxGen = (0, reactivity_1.computed)(() => {
+            hasScriptSetupSlots.value = !!scriptSetupRanges.value?.slotsTypeArg;
+            return (0, script_1.generate)(ts, fileName, _sfc, lang.value, scriptRanges.value, scriptSetupRanges.value, cssVars.value, cssModuleClasses.value, cssScopedClasses.value, htmlGen.value, compilerOptions, vueCompilerOptions, sharedTypesImport);
+        });
+        return {
+            lang,
+            tsxGen,
+            htmlGen,
+            cssVars,
+        };
+    }
+};
+exports.default = plugin;
+function collectStyleCssClasses(sfc, condition) {
+    const result = [];
+    for (let i = 0; i < sfc.styles.length; i++) {
+        const style = sfc.styles[i];
+        if (condition(style)) {
+            const classNameRanges = [...(0, parseCssClassNames_1.parseCssClassNames)(style.content)];
+            result.push({
+                style: style,
+                index: i,
+                classNameRanges: classNameRanges,
+                classNames: classNameRanges.map(range => style.content.substring(range.start + 1, range.end)),
+            });
+        }
+    }
+    return result;
+}
+exports.collectStyleCssClasses = collectStyleCssClasses;
+function collectCssVars(sfc) {
+    const result = [];
+    for (let i = 0; i < sfc.styles.length; i++) {
+        const style = sfc.styles[i];
+        result.push({
+            style,
+            ranges: [...(0, parseCssVars_1.parseCssVars)(style.content)],
+        });
+    }
+    return result;
+}
+exports.collectCssVars = collectCssVars;
+//# sourceMappingURL=vue-tsx.js.map

package/out/plugins.d.ts

@@ -0,0 +1,23 @@
+import type * as ts from 'typescript/lib/tsserverlibrary';
+import { VueCompilerOptions } from './types';
+import * as CompilerDOM from '@vue/compiler-dom';
+export declare function getDefaultVueLanguagePlugins(ts: typeof import('typescript/lib/tsserverlibrary'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): {
+    version: 1;
+    name?: string | undefined;
+    order?: number | undefined;
+    parseSFC?(fileName: string, content: string): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    updateSFC?(oldResult: import("@vue/compiler-sfc").SFCParseResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    resolveTemplateCompilerOptions?(options: CompilerDOM.CompilerOptions): CompilerDOM.CompilerOptions;
+    compileSFCTemplate?(lang: string, template: string, options: CompilerDOM.CompilerOptions): CompilerDOM.CodegenResult | undefined;
+    updateSFCTemplate?(oldResult: CompilerDOM.CodegenResult, textChange: {
+        start: number;
+        end: number;
+        newText: string;
+    }): CompilerDOM.CodegenResult | undefined;
+    getEmbeddedFileNames?(fileName: string, sfc: import("./types").Sfc): string[];
+    resolveEmbeddedFile?(fileName: string, sfc: import("./types").Sfc, embeddedFile: import("./sourceFile").VueEmbeddedFile): void;
+}[];