@vue/language-core 3.1.4 → 3.1.5

package/lib/codegen/template/interpolation.js

@@ -10,44 +10,43 @@ const utils_1 = require("../utils");
 const isLiteralWhitelisted = /*@__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
 function* generateInterpolation(options, ctx, source, data, code, start, prefix = '', suffix = '') {
     const { ts, destructuredPropNames, templateRefNames, } = options;
-    for (let [section, offset, type] of forEachInterpolationSegment(ts, ctx.inlineTsAsts, destructuredPropNames, templateRefNames, ctx, code, start, prefix, suffix)) {
-        if (offset === undefined) {
-            yield section;
+    for (const segment of forEachInterpolationSegment(ts, ctx.inlineTsAsts, destructuredPropNames, templateRefNames, ctx, code, start, prefix, suffix)) {
+        if (typeof segment === 'string') {
+            yield segment;
+            continue;
         }
-        else {
-            offset -= prefix.length;
-            let addSuffix = '';
-            const overLength = offset + section.length - code.length;
-            if (overLength > 0) {
-                addSuffix = section.slice(section.length - overLength);
-                section = section.slice(0, -overLength);
-            }
-            if (offset < 0) {
-                yield section.slice(0, -offset);
-                section = section.slice(-offset);
-                offset = 0;
+        let [section, offset, type] = segment;
+        offset -= prefix.length;
+        let addSuffix = '';
+        const overLength = offset + section.length - code.length;
+        if (overLength > 0) {
+            addSuffix = section.slice(section.length - overLength);
+            section = section.slice(0, -overLength);
+        }
+        if (offset < 0) {
+            yield section.slice(0, -offset);
+            section = section.slice(-offset);
+            offset = 0;
+        }
+        const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
+        if (!shouldSkip) {
+            if (start !== undefined && data) {
+                yield [
+                    section,
+                    source,
+                    start + offset,
+                    type === 'errorMappingOnly'
+                        ? codeFeatures_1.codeFeatures.verification
+                        : typeof data === 'function'
+                            ? data(start + offset)
+                            : data,
+                ];
             }
-            const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
-            if (!shouldSkip) {
-                if (start !== undefined
-                    && data) {
-                    yield [
-                        section,
-                        source,
-                        start + offset,
-                        type === 'errorMappingOnly'
-                            ? codeFeatures_1.codeFeatures.verification
-                            : typeof data === 'function'
-                                ? data(start + offset)
-                                : data,
-                    ];
-                }
-                else {
-                    yield section;
-                }
+            else {
+                yield section;
             }
-            yield addSuffix;
         }
+        yield addSuffix;
     }
 }
 function* forEachInterpolationSegment(ts, inlineTsAsts, destructuredPropNames, templateRefNames, ctx, originalCode, start, prefix, suffix) {
@@ -82,7 +81,7 @@ function* forEachInterpolationSegment(ts, inlineTsAsts, destructuredPropNames, t
             const lastVarEnd = lastVar ? lastVar.offset + lastVar.text.length : 0;
             if (curVar.isShorthand) {
                 yield [code.slice(lastVarEnd, curVar.offset + curVar.text.length), lastVarEnd];
-                yield [': ', undefined];
+                yield `: `;
             }
             else {
                 yield [code.slice(lastVarEnd, curVar.offset), lastVarEnd, i ? undefined : 'startText'];
@@ -104,9 +103,9 @@ function* generateVar(templateRefNames, ctx, code, offset, curVar) {
     yield ['', curVar.offset, 'errorMappingOnly'];
     const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
     if (isTemplateRef) {
-        yield [`__VLS_unref(`, undefined];
+        yield `__VLS_unref(`;
         yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
-        yield [`)`, undefined];
+        yield `)`;
     }
     else {
         if (offset !== undefined) {
@@ -116,10 +115,10 @@ function* generateVar(templateRefNames, ctx, code, offset, curVar) {
             ctx.accessExternalVariable(curVar.text);
         }
         if (ctx.dollarVars.has(curVar.text)) {
-            yield [`__VLS_dollars.`, undefined];
+            yield `__VLS_dollars.`;
         }
         else {
-            yield [`__VLS_ctx.`, undefined];
+            yield `__VLS_ctx.`;
         }
         yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
     }

package/lib/codegen/template/objectProperty.js

@@ -21,7 +21,7 @@ function* generateObjectProperty(options, ctx, code, offset, features, shouldCam
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, 'template', offset, utils_1.combineLastMapping), `'`);
+            yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, 'template', offset, utils_1.combineLastMapping), `'`);
         }
     }
     else {

package/lib/codegen/template/slotOutlet.js

@@ -29,12 +29,7 @@ function* generateSlotOutlet(options, ctx, node) {
         if (nameProp) {
             let codes;
             if (nameProp.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value) {
-                let { source, start: { offset } } = nameProp.value.loc;
-                if (source.startsWith('"') || source.startsWith("'")) {
-                    source = source.slice(1, -1);
-                    offset++;
-                }
-                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, source, offset, codeFeatures_1.codeFeatures.navigationAndVerification);
+                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, nameProp.value.content, (0, shared_1.getAttributeValueOffset)(nameProp.value), codeFeatures_1.codeFeatures.navigationAndVerification);
             }
             else if (nameProp.type === CompilerDOM.NodeTypes.DIRECTIVE
                 && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -47,18 +42,18 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            yield* (0, wrapWith_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, options.slotsAssignName ?? '__VLS_slots', ...codes);
+            yield* (0, wrapWith_1.wrapWith)('template', nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, options.slotsAssignName ?? '__VLS_slots', ...codes);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `'default'`), `]`);
+            yield* (0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `'default'`), `]`);
         }
         yield `)(`;
-        yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
+        yield* (0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true), `}`);
         yield `)${utils_1.endOfLine}`;
     }
     else {
         yield `var ${propsVar} = {${utils_1.newLine}`;
-        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), options.vueCompilerOptions.checkUnknownProps, true);
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), options.vueCompilerOptions.checkUnknownProps);
         yield `}${utils_1.endOfLine}`;
         if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
             && nameProp.value) {

package/lib/codegen/template/styleScopedClasses.js

@@ -22,7 +22,7 @@ function* generateStyleScopedClassReferences(ctx, withDot = false) {
     }
     for (const { source, className, offset } of ctx.scopedClasses) {
         yield `/** @type {__VLS_StyleScopedClasses[`;
-        yield* (0, wrapWith_1.wrapWith)(offset - (withDot ? 1 : 0), offset + className.length, source, codeFeatures_1.codeFeatures.navigation, `'`, ...(0, escaped_1.generateEscaped)(className, source, offset, codeFeatures_1.codeFeatures.navigationAndAdditionalCompletion, classNameEscapeRegex), `'`);
+        yield* (0, wrapWith_1.wrapWith)(source, offset - (withDot ? 1 : 0), offset + className.length, codeFeatures_1.codeFeatures.navigation, `'`, ...(0, escaped_1.generateEscaped)(className, source, offset, codeFeatures_1.codeFeatures.navigationAndAdditionalCompletion, classNameEscapeRegex), `'`);
         yield `]} */${utils_1.endOfLine}`;
     }
 }
@@ -34,26 +34,26 @@ function collectStyleScopedClassReferences(options, ctx, node) {
             if (options.template.lang === 'pug') {
                 const getClassOffset = Reflect.get(prop.value.loc.start, 'getClassOffset');
                 const content = prop.value.loc.source.slice(1, -1);
-                let startOffset = 1;
+                let offset = 1;
                 for (const className of content.split(' ')) {
                     if (className) {
                         ctx.scopedClasses.push({
                             source: 'template',
                             className,
-                            offset: getClassOffset(startOffset),
+                            offset: getClassOffset(offset),
                         });
                     }
-                    startOffset += className.length + 1;
+                    offset += className.length + 1;
                 }
             }
             else {
-                const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
-                if (content) {
-                    const classes = collectClasses(content, startOffset);
+                const offset = (0, shared_1.getAttributeValueOffset)(prop.value);
+                if (prop.value.content) {
+                    const classes = collectClasses(prop.value.content, offset);
                     ctx.scopedClasses.push(...classes);
                 }
                 else {
-                    ctx.emptyClassOffsets.push(startOffset);
+                    ctx.emptyClassOffsets.push(offset);
                 }
             }
         }

package/lib/codegen/template/vSlot.js

@@ -20,19 +20,18 @@ function* generateVSlot(options, ctx, node, slotDir) {
         yield `{${utils_1.newLine}`;
     }
     if (slotDir || node.children.length) {
-        ctx.currentComponent.used = true;
         yield `const { `;
         if (slotDir) {
             if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
                 yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? codeFeatures_1.codeFeatures.withoutHighlight : codeFeatures_1.codeFeatures.all, false, true);
             }
             else {
-                yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), codeFeatures_1.codeFeatures.withoutHighlightAndCompletion, `default`);
+                yield* (0, wrapWith_1.wrapWith)('template', slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), codeFeatures_1.codeFeatures.withoutHighlightAndCompletion, `default`);
             }
         }
         else {
             // #932: reference for implicit default slot
-            yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.navigation, `default`);
+            yield* (0, wrapWith_1.wrapWith)('template', node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.navigation, `default`);
         }
         yield `: ${slotVar} } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     }
@@ -101,7 +100,7 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     yield `] = __VLS_getSlotParameters(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
-        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_`, type, `, `] : `_, `), `) => [] as any`);
+        yield* (0, wrapWith_1.wrapWith)('template', exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_`, type, `, `] : `_, `), `) => [] as any`);
     }
     yield `)${utils_1.endOfLine}`;
 }

package/lib/codegen/utils/index.d.ts

@@ -1,11 +1,9 @@
-import type * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
 export declare const identifierRegex: RegExp;
-export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): readonly [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), inlineTsAsts: Map<string, ts.SourceFile> | undefined, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;
 export declare function generatePartiallyEnding(source: string, end: number, mark: string, delimiter?: string): Generator<Code>;

package/lib/codegen/utils/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
 exports.generatePartiallyEnding = generatePartiallyEnding;
@@ -10,16 +9,6 @@ exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineOffset: 1 };
 exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function normalizeAttributeValue(node) {
-    let offset = node.loc.start.offset;
-    let content = node.loc.source;
-    if ((content.startsWith(`'`) && content.endsWith(`'`))
-        || (content.startsWith(`"`) && content.endsWith(`"`))) {
-        offset++;
-        content = content.slice(1, -1);
-    }
-    return [content, offset];
-}
 function createTsAst(ts, inlineTsAsts, text) {
     let ast = inlineTsAsts?.get(text);
     if (!ast) {

package/lib/codegen/utils/stringLiteralKey.js

@@ -8,7 +8,7 @@ function* generateStringLiteralKey(code, offset, info) {
         yield `'${code}'`;
     }
     else {
-        yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
+        yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
     }
 }
 //# sourceMappingURL=stringLiteralKey.js.map

package/lib/codegen/utils/unicode.js

@@ -4,7 +4,7 @@ exports.generateUnicode = generateUnicode;
 const wrapWith_1 = require("./wrapWith");
 function* generateUnicode(code, offset, info) {
     if (needToUnicode(code)) {
-        yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, info, toUnicode(code));
+        yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, info, toUnicode(code));
     }
     else {
         yield [code, 'template', offset, info];

package/lib/codegen/utils/wrapWith.d.ts

@@ -1,3 +1,2 @@
 import type { Code, VueCodeInformation } from '../../types';
-export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;
-export declare function wrapWith(startOffset: number, endOffset: number, source: string, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;
+export declare function wrapWith(source: string, startOffset: number, endOffset: number, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;

package/lib/codegen/utils/wrapWith.js

@@ -1,16 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.wrapWith = wrapWith;
-function* wrapWith(startOffset, endOffset, ...args) {
-    let source = 'template';
-    let features;
-    let codes;
-    if (typeof args[0] === 'string') {
-        [source, features, ...codes] = args;
-    }
-    else {
-        [features, ...codes] = args;
-    }
+function* wrapWith(source, startOffset, endOffset, features, ...codes) {
     yield ['', source, startOffset, features];
     let offset = 1;
     for (const code of codes) {

package/lib/compilerOptions.d.ts

@@ -1,12 +1,10 @@
 import type * as ts from 'typescript';
 import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from './types';
-interface ParseConfigHost extends Omit<ts.ParseConfigHost, 'readDirectory'> {
-}
 export interface ParsedCommandLine extends Omit<ts.ParsedCommandLine, 'fileNames'> {
     vueOptions: VueCompilerOptions;
 }
-export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), host: ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript'), host: ParseConfigHost, configFileName: string): ParsedCommandLine;
+export declare const createParsedCommandLineByJson: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, rootDir: string, json: any, configFileName?: string | undefined) => ParsedCommandLine;
+export declare const createParsedCommandLine: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, configFileName: string) => ParsedCommandLine;
 export declare class CompilerOptionsResolver {
     fileExists?: ((path: string) => boolean) | undefined;
     options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
@@ -24,4 +22,3 @@ export declare function createGlobalTypesWriter(vueOptions: VueCompilerOptions,
  * @deprecated use `createGlobalTypesWriter` instead
  */
 export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
-export {};

package/lib/compilerOptions.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompilerOptionsResolver = void 0;
-exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
-exports.createParsedCommandLine = createParsedCommandLine;
+exports.CompilerOptionsResolver = exports.createParsedCommandLine = exports.createParsedCommandLineByJson = void 0;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
 exports.createGlobalTypesWriter = createGlobalTypesWriter;
 exports.writeGlobalTypes = writeGlobalTypes;
@@ -10,75 +8,54 @@ const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("./codegen/globalTypes");
 const shared_2 = require("./utils/shared");
-function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName) {
-    const extendedPaths = new Set();
-    const proxyHost = {
-        ...host,
-        readFile(fileName) {
-            if (!fileName.endsWith('/package.json')) {
-                extendedPaths.add(fileName);
-            }
-            return host.readFile(fileName);
-        },
-        readDirectory() {
-            return [];
-        },
-    };
-    const parsed = ts.parseJsonConfigFileContent(json, proxyHost, rootDir, {}, configFileName);
-    const resolver = new CompilerOptionsResolver(host.fileExists);
-    for (const extendPath of [...extendedPaths].reverse()) {
+exports.createParsedCommandLineByJson = create((ts, host, rootDir, json, configFileName) => {
+    // `parseJsonConfigFileContent` is missing in tsc
+    return 'parseJsonConfigFileContent' in ts
+        ? ts.parseJsonConfigFileContent(json, host, rootDir, {}, configFileName)
+        : ts.parseJsonSourceFileConfigFileContent(ts.parseJsonText(configFileName ?? 'tsconfig.json', JSON.stringify(json)), host, rootDir, {}, configFileName);
+});
+exports.createParsedCommandLine = create((ts, host, configFileName) => {
+    const config = ts.readJsonConfigFile(configFileName, host.readFile);
+    return ts.parseJsonSourceFileConfigFileContent(config, host, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
+});
+function create(getParsedCommandLine) {
+    return (ts, host, ...args) => {
         try {
-            const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-            const obj = ts.convertToObject(configFile, []);
-            const rawOptions = obj?.vueCompilerOptions ?? {};
-            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
-        }
-        catch { }
-    }
-    // ensure the rootDir is added to the config roots
-    resolver.addConfig({}, rootDir);
-    return {
-        ...parsed,
-        vueOptions: resolver.build(),
-    };
-}
-function createParsedCommandLine(ts, host, configFileName) {
-    try {
-        const extendedPaths = new Set();
-        const proxyHost = {
-            ...host,
-            readFile(fileName) {
-                if (!fileName.endsWith('/package.json')) {
-                    extendedPaths.add(fileName);
+            const extendedPaths = new Set();
+            const proxyHost = {
+                ...host,
+                readFile(fileName) {
+                    if (!fileName.endsWith('/package.json')) {
+                        extendedPaths.add(fileName);
+                    }
+                    return host.readFile(fileName);
+                },
+                readDirectory() {
+                    return [];
+                },
+            };
+            const parsed = getParsedCommandLine(ts, proxyHost, ...args);
+            const resolver = new CompilerOptionsResolver(host.fileExists);
+            for (const extendPath of [...extendedPaths].reverse()) {
+                try {
+                    const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+                    const obj = ts.convertToObject(configFile, []);
+                    const rawOptions = obj?.vueCompilerOptions ?? {};
+                    resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
                 }
-                return host.readFile(fileName);
-            },
-            readDirectory() {
-                return [];
-            },
-        };
-        const config = ts.readJsonConfigFile(configFileName, proxyHost.readFile);
-        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
-        const resolver = new CompilerOptionsResolver(host.fileExists);
-        for (const extendPath of [...extendedPaths].reverse()) {
-            try {
-                const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-                const obj = ts.convertToObject(configFile, []);
-                const rawOptions = obj?.vueCompilerOptions ?? {};
-                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+                catch { }
             }
-            catch { }
+            return {
+                ...parsed,
+                vueOptions: resolver.build(),
+            };
         }
+        catch { }
         return {
-            ...parsed,
-            vueOptions: resolver.build(),
+            options: {},
+            errors: [],
+            vueOptions: getDefaultCompilerOptions(),
         };
-    }
-    catch { }
-    return {
-        options: {},
-        errors: [],
-        vueOptions: getDefaultCompilerOptions(),
     };
 }
 class CompilerOptionsResolver {

package/lib/languagePlugin.js

@@ -7,32 +7,21 @@ const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const plugins_1 = require("./plugins");
 const vueFile_1 = require("./virtualFile/vueFile");
-const fileRegistries = [];
-function getVueFileRegistry(key, plugins) {
-    let fileRegistry = fileRegistries.find(r => r.key === key
-        && r.plugins.length === plugins.length
-        && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
-    if (!fileRegistry) {
-        fileRegistry = new Map();
-        fileRegistries.push({
-            key: key,
-            plugins: plugins,
-            files: fileRegistry,
-        });
-    }
-    return fileRegistry;
-}
-function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
-    const values = [
+const fileRegistries = {};
+function getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins) {
+    const key = JSON.stringify([
+        ...plugins.map(plugin => plugin.name)
+            .filter(name => typeof name === 'string')
+            .sort(),
         ...Object.keys(vueCompilerOptions)
-            .sort()
             .filter(key => key !== 'plugins')
+            .sort()
             .map(key => [key, vueCompilerOptions[key]]),
-        [...new Set(plugins.map(plugin => plugin.requiredCompilerOptions ?? []).flat())]
+        ...[...new Set(plugins.flatMap(plugin => plugin.requiredCompilerOptions ?? []))]
             .sort()
             .map(key => [key, compilerOptions[key]]),
-    ];
-    return JSON.stringify(values);
+    ]);
+    return fileRegistries[key] ??= new Map();
 }
 function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFileName) {
     const pluginContext = {
@@ -44,7 +33,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
         vueCompilerOptions,
     };
     const plugins = (0, plugins_1.createPlugins)(pluginContext);
-    const fileRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
+    const fileRegistry = getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins);
     return {
         getLanguageId(scriptId) {
             const fileName = asFileName(scriptId);
@@ -70,10 +59,14 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
                 }
             }
         },
-        updateVirtualCode(_fileId, code, snapshot) {
+        updateVirtualCode(_scriptId, code, snapshot) {
             code.update(snapshot);
             return code;
         },
+        disposeVirtualCode(scriptId) {
+            const fileName = asFileName(scriptId);
+            fileRegistry.delete(fileName);
+        },
         typescript: {
             extraFileExtensions: getAllExtensions(vueCompilerOptions)
                 .map(ext => ({

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

@@ -2,38 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const shouldAddSuffix = /(?<=<[^>/]+)$/;
 const plugin = ({ modules }) => {
+    const CompilerDOM = modules['@vue/compiler-dom'];
     return {
         version: 2.2,
         compileSFCTemplate(lang, template, options) {
             if (lang === 'html' || lang === 'md') {
-                const compiler = modules['@vue/compiler-dom'];
                 let addedSuffix = false;
                 // #4583
                 if (shouldAddSuffix.test(template)) {
                     template += '>';
                     addedSuffix = true;
                 }
-                const result = compiler.compile(template, {
+                const ast = CompilerDOM.parse(template, {
                     ...options,
                     comments: true,
                 });
-                // @ts-expect-error
-                result.__addedSuffix = addedSuffix;
-                return result;
+                CompilerDOM.transform(ast, options);
+                return {
+                    ast,
+                    code: '',
+                    preamble: '',
+                    __addedSuffix: addedSuffix,
+                };
             }
         },
         updateSFCTemplate(oldResult, change) {
-            oldResult.code = oldResult.code.slice(0, change.start)
+            const newSource = oldResult.ast.source.slice(0, change.start)
                 + change.newText
-                + oldResult.code.slice(change.end);
+                + oldResult.ast.source.slice(change.end);
             // @ts-expect-error
             if (oldResult.__addedSuffix) {
-                const originalTemplate = oldResult.code.slice(0, -1); // remove added '>'
+                const originalTemplate = newSource.slice(0, -1); // remove added '>'
                 if (!shouldAddSuffix.test(originalTemplate)) {
                     return undefined;
                 }
             }
-            const CompilerDOM = modules['@vue/compiler-dom'];
             const lengthDiff = change.newText.length - (change.end - change.start);
             let hitNodes = [];
             if (tryUpdateNode(oldResult.ast) && hitNodes.length) {

package/lib/plugins/vue-template-inline-css.js

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const CompilerDOM = require("@vue/compiler-dom");
 const forEachTemplateNode_1 = require("../utils/forEachTemplateNode");
-const shared_1 = require("./shared");
+const shared_1 = require("../utils/shared");
+const shared_2 = require("./shared");
 const codeFeatures = {
-    ...shared_1.allCodeFeatures,
+    ...shared_2.allCodeFeatures,
     format: false,
     structure: false,
 };
@@ -30,21 +31,14 @@ exports.default = plugin;
 function* generate(templateAst) {
     for (const node of (0, forEachTemplateNode_1.forEachElementNode)(templateAst)) {
         for (const prop of node.props) {
-            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-                && prop.name === 'bind'
-                && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.arg.content === 'style'
-                && prop.exp.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
-                const endCrt = prop.arg.loc.source[prop.arg.loc.source.length - 1]; // " | '
-                const start = prop.arg.loc.source.indexOf(endCrt) + 1;
-                const end = prop.arg.loc.source.lastIndexOf(endCrt);
-                const content = prop.arg.loc.source.slice(start, end);
+            if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+                && prop.name === 'style'
+                && prop.value) {
                 yield `x { `;
                 yield [
-                    content,
+                    prop.value.content,
                     'template',
-                    prop.arg.loc.start.offset + start,
+                    (0, shared_1.getAttributeValueOffset)(prop.value),
                     codeFeatures,
                 ];
                 yield ` }\n`;