@vue/language-core 2.1.10 → 2.2.2

package/lib/plugins/vue-tsx.js

@@ -1,11 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tsCodegen = void 0;
+const shared_1 = require("@vue/shared");
 const alien_signals_1 = require("alien-signals");
+const path = require("path-browserify");
 const script_1 = require("../codegen/script");
 const template_1 = require("../codegen/template");
 const scriptRanges_1 = require("../parsers/scriptRanges");
 const scriptSetupRanges_1 = require("../parsers/scriptSetupRanges");
+const vueCompilerOptions_1 = require("../parsers/vueCompilerOptions");
+const signals_1 = require("../utils/signals");
+const ts_1 = require("../utils/ts");
 exports.tsCodegen = new WeakMap();
 const fileEditTimes = new Map();
 const plugin = ctx => {
@@ -17,26 +22,25 @@ const plugin = ctx => {
             'exactOptionalPropertyTypes',
         ],
         getEmbeddedCodes(fileName, sfc) {
-            const tsx = useTsx(fileName, sfc);
+            const codegen = useCodegen(fileName, sfc);
             const files = [];
-            if (['js', 'ts', 'jsx', 'tsx'].includes(tsx.lang.get())) {
-                files.push({ id: 'script_' + tsx.lang.get(), lang: tsx.lang.get() });
+            if (['js', 'ts', 'jsx', 'tsx'].includes(codegen.getLang())) {
+                files.push({ id: 'script_' + codegen.getLang(), lang: codegen.getLang() });
             }
             return files;
         },
         resolveEmbeddedCode(fileName, sfc, embeddedFile) {
-            const _tsx = useTsx(fileName, sfc);
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
-                const tsx = _tsx.generatedScript.get();
+                const codegen = useCodegen(fileName, sfc);
+                const tsx = codegen.getGeneratedScript();
                 if (tsx) {
-                    const content = [...tsx.codes];
-                    embeddedFile.content = content;
+                    embeddedFile.content = [...tsx.codes];
                     embeddedFile.linkedCodeMappings = [...tsx.linkedCodeMappings];
                 }
             }
         },
     };
-    function useTsx(fileName, sfc) {
+    function useCodegen(fileName, sfc) {
         if (!exports.tsCodegen.has(sfc)) {
             let appendGlobalTypes = false;
             if (!ctx.vueCompilerOptions.__setupedGlobalTypes && !appendedGlobalTypes) {
@@ -51,37 +55,106 @@ const plugin = ctx => {
 exports.default = plugin;
 function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
-    const lang = (0, alien_signals_1.computed)(() => {
+    const getLang = (0, alien_signals_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 scriptRanges = (0, alien_signals_1.computed)(() => _sfc.script
+    const getResolvedOptions = (0, alien_signals_1.computed)(() => {
+        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(_sfc.comments);
+        if (options) {
+            const resolver = new ts_1.CompilerOptionsResolver();
+            resolver.addConfig(options, path.dirname(fileName));
+            return resolver.build(ctx.vueCompilerOptions);
+        }
+        return ctx.vueCompilerOptions;
+    });
+    const getScriptRanges = (0, alien_signals_1.computed)(() => _sfc.script
         ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
         : undefined);
-    const scriptSetupRanges = (0, alien_signals_1.computed)(() => _sfc.scriptSetup
-        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, ctx.vueCompilerOptions)
+    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => _sfc.scriptSetup
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, getResolvedOptions())
         : undefined);
-    const generatedTemplate = (0, alien_signals_1.computed)(() => {
-        if (ctx.vueCompilerOptions.skipTemplateCodegen || !_sfc.template) {
+    const getSetupBindingNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+        const newNames = new Set();
+        const bindings = getScriptSetupRanges()?.bindings;
+        if (_sfc.scriptSetup && bindings) {
+            for (const { range } of bindings) {
+                newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+            }
+        }
+        return newNames;
+    }));
+    const getSetupImportComponentNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+        const newNames = new Set();
+        const bindings = getScriptSetupRanges()?.bindings;
+        if (_sfc.scriptSetup && bindings) {
+            for (const { range, moduleName, isDefaultImport, isNamespace } of bindings) {
+                if (moduleName
+                    && isDefaultImport
+                    && !isNamespace
+                    && ctx.vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
+                    newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+                }
+            }
+        }
+        return newNames;
+    }));
+    const getSetupDestructuredPropNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+        const newNames = new Set(getScriptSetupRanges()?.defineProps?.destructured?.keys());
+        const rest = getScriptSetupRanges()?.defineProps?.destructuredRest;
+        if (rest) {
+            newNames.add(rest);
+        }
+        return newNames;
+    }));
+    const getSetupTemplateRefNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
+        const newNames = new Set(getScriptSetupRanges()?.useTemplateRef
+            .map(({ name }) => name)
+            .filter(name => name !== undefined));
+        return newNames;
+    }));
+    const setupHasDefineSlots = (0, alien_signals_1.computed)(() => !!getScriptSetupRanges()?.defineSlots);
+    const getSetupSlotsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineSlots?.name);
+    const getSetupPropsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineProps?.name);
+    const getSetupInheritAttrs = (0, alien_signals_1.computed)(() => {
+        const value = getScriptSetupRanges()?.defineOptions?.inheritAttrs ?? getScriptRanges()?.exportDefault?.inheritAttrsOption;
+        return value !== 'false';
+    });
+    const getComponentSelfName = (0, alien_signals_1.computed)(() => {
+        const { exportDefault } = getScriptRanges() ?? {};
+        if (_sfc.script && exportDefault?.nameOption) {
+            const { nameOption } = exportDefault;
+            return _sfc.script.content.slice(nameOption.start + 1, nameOption.end - 1);
+        }
+        const { defineOptions } = getScriptSetupRanges() ?? {};
+        if (_sfc.scriptSetup && defineOptions?.name) {
+            return defineOptions.name;
+        }
+        const baseName = path.basename(fileName);
+        return (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
+    });
+    const getGeneratedTemplate = (0, alien_signals_1.computed)(() => {
+        if (getResolvedOptions().skipTemplateCodegen || !_sfc.template) {
             return;
         }
         const codes = [];
         const codegen = (0, template_1.generateTemplate)({
             ts,
             compilerOptions: ctx.compilerOptions,
-            vueCompilerOptions: ctx.vueCompilerOptions,
+            vueCompilerOptions: getResolvedOptions(),
             template: _sfc.template,
-            edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
-            scriptSetupBindingNames: scriptSetupBindingNames.get(),
-            scriptSetupImportComponentNames: scriptSetupImportComponentNames.get(),
-            destructuredPropNames: destructuredPropNames.get(),
-            templateRefNames: templateRefNames.get(),
-            hasDefineSlots: hasDefineSlots.get(),
-            slotsAssignName: slotsAssignName.get(),
-            propsAssignName: propsAssignName.get(),
-            inheritAttrs: inheritAttrs.get(),
+            edited: getResolvedOptions().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            scriptSetupBindingNames: getSetupBindingNames(),
+            scriptSetupImportComponentNames: getSetupImportComponentNames(),
+            destructuredPropNames: getSetupDestructuredPropNames(),
+            templateRefNames: getSetupTemplateRefNames(),
+            hasDefineSlots: setupHasDefineSlots(),
+            slotsAssignName: getSetupSlotsAssignName(),
+            propsAssignName: getSetupPropsAssignName(),
+            inheritAttrs: getSetupInheritAttrs(),
+            selfComponentName: getComponentSelfName(),
         });
         let current = codegen.next();
         while (!current.done) {
@@ -91,71 +164,26 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         }
         return {
             ...current.value,
-            codes: codes,
+            codes,
         };
     });
-    const scriptSetupBindingNames = (0, alien_signals_1.computed)(oldNames => {
-        const newNames = new Set();
-        const bindings = scriptSetupRanges.get()?.bindings;
-        if (_sfc.scriptSetup && bindings) {
-            for (const binding of bindings) {
-                newNames.add(_sfc.scriptSetup?.content.substring(binding.start, binding.end));
-            }
-        }
-        if (newNames && oldNames && twoSetsEqual(newNames, oldNames)) {
-            return oldNames;
-        }
-        return newNames;
-    });
-    const scriptSetupImportComponentNames = (0, alien_signals_1.computed)(oldNames => {
-        const newNames = scriptSetupRanges.get()?.importComponentNames ?? new Set();
-        if (oldNames && twoSetsEqual(newNames, oldNames)) {
-            return oldNames;
-        }
-        return newNames;
-    });
-    const destructuredPropNames = (0, alien_signals_1.computed)(oldNames => {
-        const newNames = scriptSetupRanges.get()?.props.destructured ?? new Set();
-        const rest = scriptSetupRanges.get()?.props.destructuredRest;
-        if (rest) {
-            newNames.add(rest);
-        }
-        if (oldNames && twoSetsEqual(newNames, oldNames)) {
-            return oldNames;
-        }
-        return newNames;
-    });
-    const templateRefNames = (0, alien_signals_1.computed)(oldNames => {
-        const newNames = new Set(scriptSetupRanges.get()?.templateRefs
-            .map(({ name }) => name)
-            .filter(name => name !== undefined));
-        if (oldNames && twoSetsEqual(newNames, oldNames)) {
-            return oldNames;
-        }
-        return newNames;
-    });
-    const hasDefineSlots = (0, alien_signals_1.computed)(() => !!scriptSetupRanges.get()?.slots.define);
-    const slotsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.slots.name);
-    const propsAssignName = (0, alien_signals_1.computed)(() => scriptSetupRanges.get()?.props.name);
-    const inheritAttrs = (0, alien_signals_1.computed)(() => {
-        const value = scriptSetupRanges.get()?.options.inheritAttrs ?? scriptRanges.get()?.exportDefault?.inheritAttrsOption;
-        return value !== 'false';
-    });
-    const generatedScript = (0, alien_signals_1.computed)(() => {
+    const getGeneratedScript = (0, alien_signals_1.computed)(() => {
         const codes = [];
         const linkedCodeMappings = [];
         let generatedLength = 0;
         const codegen = (0, script_1.generateScript)({
             ts,
-            fileName,
-            sfc: _sfc,
-            lang: lang.get(),
-            scriptRanges: scriptRanges.get(),
-            scriptSetupRanges: scriptSetupRanges.get(),
-            templateCodegen: generatedTemplate.get(),
             compilerOptions: ctx.compilerOptions,
-            vueCompilerOptions: ctx.vueCompilerOptions,
-            edited: ctx.vueCompilerOptions.__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            vueCompilerOptions: getResolvedOptions(),
+            sfc: _sfc,
+            edited: getResolvedOptions().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
+            fileName,
+            lang: getLang(),
+            scriptRanges: getScriptRanges(),
+            scriptSetupRanges: getScriptSetupRanges(),
+            templateCodegen: getGeneratedTemplate(),
+            destructuredPropNames: getSetupDestructuredPropNames(),
+            templateRefNames: getSetupTemplateRefNames(),
             getGeneratedLength: () => generatedLength,
             linkedCodeMappings,
             appendGlobalTypes,
@@ -177,22 +205,11 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         };
     });
     return {
-        scriptRanges,
-        scriptSetupRanges,
-        lang,
-        generatedScript,
-        generatedTemplate,
+        getScriptRanges,
+        getScriptSetupRanges,
+        getLang,
+        getGeneratedScript,
+        getGeneratedTemplate,
     };
 }
-function twoSetsEqual(a, b) {
-    if (a.size !== b.size) {
-        return false;
-    }
-    for (const file of a) {
-        if (!b.has(file)) {
-            return false;
-        }
-    }
-    return true;
-}
 //# sourceMappingURL=vue-tsx.js.map

package/lib/plugins/vue-vine.d.ts

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

package/lib/plugins/vue-vine.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const shared_1 = require("./shared");
+const plugin = () => {
+    return {
+        version: 2.1,
+        getEmbeddedCodes(_fileName, sfc) {
+            const result = [];
+            for (let i = 0; i < sfc.customBlocks.length; i++) {
+                const block = sfc.customBlocks[i];
+                if (block.type === 'vine') {
+                    result.push({
+                        id: 'vine_' + i,
+                        lang: block.lang,
+                    });
+                }
+            }
+            return result;
+        },
+        resolveEmbeddedCode(_fileName, sfc, embeddedFile) {
+            if (embeddedFile.id.startsWith('vine_')) {
+                const index = parseInt(embeddedFile.id.slice('vine_'.length));
+                const block = sfc.customBlocks[index];
+                embeddedFile.content.push([
+                    block.content,
+                    block.name,
+                    0,
+                    shared_1.allCodeFeatures,
+                ]);
+            }
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=vue-vine.js.map

package/lib/types.d.ts

@@ -7,7 +7,8 @@ import type { VueEmbeddedCode } from './virtualFile/embeddedFile';
 export type { SFCParseResult } from '@vue/compiler-sfc';
 export { VueEmbeddedCode };
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'plugins'>> & {
-    target?: 'auto' | 2 | 2.7 | 3 | 3.3;
+    strictTemplates?: boolean;
+    target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 99 | number;
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
@@ -22,7 +23,10 @@ export interface VueCompilerOptions {
     vitePressExtensions: string[];
     petiteVueExtensions: string[];
     jsxSlots: boolean;
-    strictTemplates: boolean;
+    checkUnknownProps: boolean;
+    checkUnknownEvents: boolean;
+    checkUnknownDirectives: boolean;
+    checkUnknownComponents: boolean;
     skipTemplateCodegen: boolean;
     fallthroughAttributes: boolean;
     dataAttributes: string[];
@@ -37,8 +41,10 @@ export interface VueCompilerOptions {
         defineOptions: string[];
         withDefaults: string[];
     };
-    composibles: {
+    composables: {
+        useAttrs: string[];
         useCssModule: string[];
+        useSlots: string[];
         useTemplateRef: string[];
     };
     plugins: VueLanguagePlugin[];
@@ -81,8 +87,8 @@ export type VueLanguagePluginReturn = {
 };
 export type VueLanguagePlugin = (ctx: {
     modules: {
-        typescript: typeof import('typescript');
-        '@vue/compiler-dom': typeof import('@vue/compiler-dom');
+        typescript: typeof ts;
+        '@vue/compiler-dom': typeof CompilerDOM;
     };
     compilerOptions: ts.CompilerOptions;
     vueCompilerOptions: VueCompilerOptions;
@@ -97,14 +103,9 @@ export interface SfcBlock {
     content: string;
     attrs: Record<string, string | true>;
 }
-export interface SFCStyleOverride {
-    module?: {
-        name: string;
-        offset?: number;
-    };
-}
 export interface Sfc {
     content: string;
+    comments: string[];
     template: SfcBlock & {
         ast: CompilerDOM.RootNode | undefined;
         errors: CompilerDOM.CompilerError[];
@@ -120,8 +121,12 @@ export interface Sfc {
         genericOffset: number;
         ast: ts.SourceFile;
     } | undefined;
-    styles: readonly (SfcBlock & SFCStyleOverride & {
+    styles: readonly (SfcBlock & {
         scoped: boolean;
+        module?: {
+            name: string;
+            offset?: number;
+        };
         cssVars: {
             text: string;
             offset: number;
@@ -135,6 +140,14 @@ export interface Sfc {
         type: string;
     })[];
 }
+declare module '@vue/compiler-sfc' {
+    interface SFCStyleBlock {
+        __module?: {
+            name: string;
+            offset?: number;
+        };
+    }
+}
 export interface TextRange {
     start: number;
     end: number;

package/lib/utils/buildMappings.d.ts

@@ -1,3 +1,3 @@
-import type { Segment } from 'muggle-string';
 import type { Mapping } from '@volar/language-core';
+import type { Segment } from 'muggle-string';
 export declare function buildMappings<T>(chunks: Segment<T>[]): Mapping<T>[];

package/lib/utils/parseCssImports.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCssImports(css: string): Generator<{
+    text: string;
+    offset: number;
+}, void, unknown>;

package/lib/utils/parseCssImports.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssImports = parseCssImports;
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+function* parseCssImports(css) {
+    const matches = css.matchAll(cssImportReg);
+    for (const match of matches) {
+        let text = match[0];
+        let offset = match.index;
+        if (text.startsWith('\'') || text.startsWith('"')) {
+            text = text.slice(1, -1);
+            offset += 1;
+        }
+        if (text) {
+            yield { text, offset };
+        }
+    }
+}
+//# sourceMappingURL=parseCssImports.js.map

package/lib/utils/parseSfc.d.ts

@@ -1,2 +1,7 @@
 import type { SFCParseResult } from '@vue/compiler-sfc';
+declare module '@vue/compiler-sfc' {
+    interface SFCDescriptor {
+        comments: string[];
+    }
+}
 export declare function parse(source: string): SFCParseResult;

package/lib/utils/parseSfc.js

@@ -18,6 +18,7 @@ function parse(source) {
     const descriptor = {
         filename: 'anonymous.vue',
         source,
+        comments: [],
         template: null,
         script: null,
         scriptSetup: null,
@@ -28,7 +29,11 @@ function parse(source) {
         shouldForceReload: () => false,
     };
     ast.children.forEach(node => {
-        if (node.type !== compiler.NodeTypes.ELEMENT) {
+        if (node.type === compiler.NodeTypes.COMMENT) {
+            descriptor.comments.push(node.content);
+            return;
+        }
+        else if (node.type !== compiler.NodeTypes.ELEMENT) {
             return;
         }
         switch (node.tag) {
@@ -37,7 +42,7 @@ function parse(source) {
                 break;
             case 'script':
                 const scriptBlock = createBlock(node, source);
-                const isSetup = !!scriptBlock.attrs.setup;
+                const isSetup = !!scriptBlock.setup;
                 if (isSetup && !descriptor.scriptSetup) {
                     descriptor.scriptSetup = scriptBlock;
                     break;
@@ -107,14 +112,15 @@ function createBlock(node, source) {
                     block.scoped = true;
                 }
                 else if (p.name === 'module') {
-                    block.module = {
+                    block.__module = {
                         name: p.value?.content ?? '$style',
                         offset: p.value?.content ? p.value?.loc.start.offset - node.loc.start.offset : undefined
                     };
                 }
             }
-            else if (type === 'script' && p.name === 'setup') {
-                block.setup = attrs.setup;
+            else if (type === 'script'
+                && (p.name === 'setup' || p.name === 'vapor')) {
+                block.setup = attrs[p.name];
             }
         }
     });

package/lib/utils/signals.d.ts

@@ -0,0 +1,2 @@
+export declare function computedArray<I, O>(arr: () => I[], getGetter: (item: () => I, index: number) => () => O): readonly Readonly<O>[];
+export declare function computedSet<T>(source: () => Set<T>): () => Set<T>;

package/lib/utils/signals.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedArray = computedArray;
+exports.computedSet = computedSet;
+const alien_signals_1 = require("alien-signals");
+function computedArray(arr, getGetter) {
+    const length = (0, alien_signals_1.computed)(() => arr().length);
+    const keys = (0, alien_signals_1.computed)(() => {
+        const keys = [];
+        for (let i = 0; i < length(); i++) {
+            keys.push(String(i));
+        }
+        return keys;
+    });
+    const items = (0, alien_signals_1.computed)(array => {
+        array ??= [];
+        while (array.length < length()) {
+            const index = array.length;
+            const item = (0, alien_signals_1.computed)(() => arr()[index]);
+            array.push((0, alien_signals_1.computed)(getGetter(item, index)));
+        }
+        if (array.length > length()) {
+            array.length = length();
+        }
+        return array;
+    });
+    return new Proxy({}, {
+        get(_, p, receiver) {
+            if (p === 'length') {
+                return length();
+            }
+            if (typeof p === 'string' && !isNaN(Number(p))) {
+                return items()[Number(p)]?.();
+            }
+            return Reflect.get(items(), p, receiver);
+        },
+        has(_, p) {
+            return Reflect.has(items(), p);
+        },
+        ownKeys() {
+            return keys();
+        },
+    });
+}
+function computedSet(source) {
+    return (0, alien_signals_1.computed)(oldValue => {
+        const newValue = source();
+        if (oldValue?.size === newValue.size && [...oldValue].every(c => newValue.has(c))) {
+            return oldValue;
+        }
+        return newValue;
+    });
+}
+//# sourceMappingURL=signals.js.map

package/lib/utils/ts.d.ts

@@ -1,5 +1,5 @@
 import type * as ts from 'typescript';
-import type { VueCompilerOptions } from '../types';
+import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from '../types';
 export type ParsedCommandLine = ts.ParsedCommandLine & {
     vueOptions: VueCompilerOptions;
 };
@@ -7,7 +7,19 @@ export declare function createParsedCommandLineByJson(ts: typeof import('typescr
     writeFile?(path: string, data: string): void;
 }, rootDir: string, json: any, configFileName?: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
 export declare function createParsedCommandLine(ts: typeof import('typescript'), parseConfigHost: ts.ParseConfigHost, tsConfigPath: string, skipGlobalTypesSetup?: boolean): ParsedCommandLine;
-export declare function resolveVueCompilerOptions(vueOptions: Partial<VueCompilerOptions>): VueCompilerOptions;
+export declare class CompilerOptionsResolver {
+    options: Omit<RawVueCompilerOptions, 'target' | 'plugin'>;
+    fallbackTarget: number | undefined;
+    target: number | undefined;
+    plugins: VueLanguagePlugin[];
+    addConfig(options: RawVueCompilerOptions, rootDir: string): void;
+    build(defaults?: VueCompilerOptions): VueCompilerOptions;
+}
+export declare function getDefaultCompilerOptions(target?: number, lib?: string, strictTemplates?: boolean): VueCompilerOptions;
+/**
+ * @deprecated use `getDefaultCompilerOptions` instead
+ */
+export declare function resolveVueCompilerOptions(options: Partial<VueCompilerOptions>): VueCompilerOptions;
 export declare function setupGlobalTypes(rootDir: string, vueOptions: VueCompilerOptions, host: {
     fileExists(path: string): boolean;
     writeFile?(path: string, data: string): void;