@vue/language-core 3.0.7-alpha.1 → 3.1.0-alpha.0

package/lib/codegen/template/index.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generate;
 exports.forEachElementNode = forEachElementNode;
 const CompilerDOM = require("@vue/compiler-dom");
-const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -33,9 +32,8 @@ function* generateTemplate(options, ctx) {
     if (options.propsAssignName) {
         ctx.addLocalVariable(options.propsAssignName);
     }
-    const slotsPropertyName = (0, shared_1.getSlotsPropertyName)(options.vueCompilerOptions.target);
     if (options.vueCompilerOptions.inferTemplateDollarSlots) {
-        ctx.dollarVars.add(slotsPropertyName);
+        ctx.dollarVars.add('$slots');
     }
     if (options.vueCompilerOptions.inferTemplateDollarAttrs) {
         ctx.dollarVars.add('$attrs');
@@ -51,17 +49,19 @@ function* generateTemplate(options, ctx) {
     }
     yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(ctx);
     yield* ctx.generateHoistVariables();
-    const speicalTypes = [
-        [slotsPropertyName, yield* generateSlots(options, ctx)],
+    const dollarTypes = [
+        ['$slots', yield* generateSlots(options, ctx)],
         ['$attrs', yield* generateInheritedAttrs(options, ctx)],
         ['$refs', yield* generateTemplateRefs(options, ctx)],
         ['$el', yield* generateRootEl(ctx)],
-    ];
-    yield `var __VLS_dollars!: {${utils_1.newLine}`;
-    for (const [name, type] of speicalTypes) {
-        yield `${name}: ${type}${utils_1.endOfLine}`;
+    ].filter(([name]) => ctx.dollarVars.has(name));
+    if (dollarTypes.length) {
+        yield `var __VLS_dollars!: {${utils_1.newLine}`;
+        for (const [name, type] of dollarTypes) {
+            yield `${name}: ${type}${utils_1.endOfLine}`;
+        }
+        yield `} & { [K in keyof import('${options.vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
     }
-    yield `} & { [K in keyof import('${options.vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
 }
 function* generateSlots(options, ctx) {
     if (!options.hasDefineSlots) {
@@ -79,7 +79,7 @@ function* generateSlots(options, ctx) {
             }
             yield `?: (props: typeof ${slot.propsVar}) => any }`;
         }
-        yield `${utils_1.endOfLine}`;
+        yield utils_1.endOfLine;
     }
     return `__VLS_Slots`;
 }
@@ -160,8 +160,7 @@ function* forEachElementNode(node) {
     }
     else if (node.type === CompilerDOM.NodeTypes.IF) {
         // v-if / v-else-if / v-else
-        for (let i = 0; i < node.branches.length; i++) {
-            const branch = node.branches[i];
+        for (const branch of node.branches) {
             for (const childNode of branch.children) {
                 yield* forEachElementNode(childNode);
             }

package/lib/codegen/template/slotOutlet.js

@@ -19,8 +19,7 @@ function* generateSlotOutlet(options, ctx, node) {
         if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
             return prop.name === 'name';
         }
-        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.name === 'bind'
+        if (prop.name === 'bind'
             && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
             return prop.arg.content === 'name';
         }
@@ -48,7 +47,7 @@ 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)(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'`), `]`);

package/lib/codegen/template/styleScopedClasses.js

@@ -47,10 +47,9 @@ function collectStyleScopedClassReferences(options, ctx, node) {
                 }
             }
             else {
-                let isWrapped = false;
                 const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
                 if (content) {
-                    const classes = collectClasses(content, startOffset + (isWrapped ? 1 : 0));
+                    const classes = collectClasses(content, startOffset);
                     ctx.scopedClasses.push(...classes);
                 }
                 else {

package/lib/codegen/template/vFor.js

@@ -40,7 +40,7 @@ function* generateVFor(options, ctx, node) {
     for (const argument of node.codegenNode?.children.arguments ?? []) {
         if (argument.type === CompilerDOM.NodeTypes.JS_FUNCTION_EXPRESSION
             && argument.returns?.type === CompilerDOM.NodeTypes.VNODE_CALL
-            && argument.returns?.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
+            && argument.returns.props?.type === CompilerDOM.NodeTypes.JS_OBJECT_EXPRESSION) {
             if (argument.returns.tag !== CompilerDOM.FRAGMENT) {
                 isFragment = false;
                 continue;

package/lib/codegen/template/vSlot.js

@@ -73,7 +73,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
 function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     const { ts } = options;
     const statement = ast.statements[0];
-    if (!ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
+    if (!statement || !ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
         return;
     }
     const { expression } = statement;

package/lib/codegen/tenp.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/codegen/tenp.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tenp.js.map

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

@@ -8,3 +8,4 @@ export declare const identifierRegex: RegExp;
 export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [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

@@ -4,6 +4,8 @@ exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = expor
 exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
+exports.generatePartiallyEnding = generatePartiallyEnding;
+const codeFeatures_1 = require("../codeFeatures");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineOffset: 1 };
@@ -35,4 +37,9 @@ function generateSfcBlockSection(block, start, end, features) {
         features,
     ];
 }
+function* generatePartiallyEnding(source, end, mark, delimiter = 'debugger') {
+    yield delimiter;
+    yield [``, source, end, codeFeatures_1.codeFeatures.verification];
+    yield `/* PartiallyEnd: ${mark} */${exports.newLine}`;
+}
 //# sourceMappingURL=index.js.map

package/lib/compilerOptions.js

@@ -245,9 +245,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         ],
         dataAttributes: [],
         htmlAttributes: ['aria-*'],
-        optionsWrapper: target >= 2.7
-            ? [`(await import('${lib}')).defineComponent(`, `)`]
-            : [`(await import('${lib}')).default.extend(`, `)`],
+        optionsWrapper: [`(await import('${lib}')).defineComponent(`, `)`],
         macros: {
             defineProps: ['defineProps'],
             defineSlots: ['defineSlots'],
@@ -277,13 +275,10 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
     };
 }
 function writeGlobalTypes(vueOptions, writeFile) {
-    const originalFn = vueOptions.globalTypesPath;
-    if (!originalFn) {
-        return;
-    }
     const writed = new Set();
+    const { globalTypesPath } = vueOptions;
     vueOptions.globalTypesPath = (fileName) => {
-        const result = originalFn(fileName);
+        const result = globalTypesPath(fileName);
         if (result && !writed.has(result)) {
             writed.add(result);
             writeFile(result, (0, globalTypes_1.generateGlobalTypes)(vueOptions));

package/lib/languagePlugin.js

@@ -6,7 +6,6 @@ exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const plugins_1 = require("./plugins");
-const CompilerVue2 = require("./utils/vue2TemplateCompiler");
 const vueFile_1 = require("./virtualFile/vueFile");
 const fileRegistries = [];
 function getVueFileRegistry(key, plugins) {
@@ -38,12 +37,7 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
 function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFileName) {
     const pluginContext = {
         modules: {
-            '@vue/compiler-dom': vueCompilerOptions.target < 3
-                ? {
-                    ...CompilerDOM,
-                    compile: CompilerVue2.compile,
-                }
-                : CompilerDOM,
+            '@vue/compiler-dom': CompilerDOM,
             typescript: ts,
         },
         compilerOptions,
@@ -109,17 +103,12 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
     };
 }
 function getAllExtensions(options) {
-    const result = new Set();
-    for (const key in options) {
-        if (key === 'extensions' || key.endsWith('Extensions')) {
-            const value = options[key];
-            if (Array.isArray(value) && value.every(v => typeof v === 'string')) {
-                for (const ext of value) {
-                    result.add(ext);
-                }
-            }
-        }
-    }
-    return [...result];
+    return [
+        ...new Set([
+            'extensions',
+            'vitePressExtensions',
+            'petiteVueExtensions',
+        ].flatMap(key => options[key])),
+    ];
 }
 //# sourceMappingURL=languagePlugin.js.map

package/lib/parsers/scriptRanges.d.ts

@@ -13,7 +13,6 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         nameOption: TextRange | undefined;
         inheritAttrsOption: string | undefined;
     }) | undefined;
-    classBlockEnd: number | undefined;
     bindings: {
         range: TextRange;
         moduleName?: string;

package/lib/parsers/scriptRanges.js

@@ -2,11 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptRanges = parseScriptRanges;
 const shared_1 = require("../utils/shared");
-const scriptSetupRanges_1 = require("./scriptSetupRanges");
+const utils_1 = require("./utils");
 function parseScriptRanges(ts, ast, hasScriptSetup) {
     let exportDefault;
-    let classBlockEnd;
-    const bindings = hasScriptSetup ? (0, scriptSetupRanges_1.parseBindingRanges)(ts, ast) : [];
+    const bindings = hasScriptSetup ? (0, utils_1.parseBindingRanges)(ts, ast) : [];
     ts.forEachChild(ast, raw => {
         if (ts.isExportAssignment(raw)) {
             let node = raw;
@@ -56,17 +55,15 @@ function parseScriptRanges(ts, ast, hasScriptSetup) {
                     nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
                     inheritAttrsOption,
                 };
+                const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, raw, [], ast);
+                if (comment) {
+                    exportDefault.start = comment.start;
+                }
             }
         }
-        if (ts.isClassDeclaration(raw)
-            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)
-            && raw.modifiers?.some(mod => mod.kind === ts.SyntaxKind.DefaultKeyword)) {
-            classBlockEnd = raw.end - 1;
-        }
     });
     return {
         exportDefault,
-        classBlockEnd,
         bindings,
     };
     function _getStartEnd(node) {

package/lib/parsers/scriptSetupRanges.d.ts

@@ -66,10 +66,4 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     useSlots: CallExpressionRange[];
     useTemplateRef: UseTemplateRef[];
 };
-export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
-    range: TextRange;
-    moduleName?: string;
-    isDefaultImport?: boolean;
-    isNamespace?: boolean;
-}[];
 export {};

package/lib/parsers/scriptSetupRanges.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptSetupRanges = parseScriptSetupRanges;
-exports.parseBindingRanges = parseBindingRanges;
 const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
-const tsCheckReg = /^\/\/\s*@ts-(?:no)?check($|\s)/;
+const utils_1 = require("./utils");
+const tsCheckReg = /^\/\/\s*@ts-(?:no)?check(?:$|\s)/;
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const defineModel = [];
     let defineProps;
@@ -20,7 +20,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const text = ast.text;
     const leadingCommentRanges = ts.getLeadingCommentRanges(text, 0)?.reverse() ?? [];
     const leadingCommentEndOffset = leadingCommentRanges.find(range => tsCheckReg.test(text.slice(range.pos, range.end)))?.end ?? 0;
-    let bindings = parseBindingRanges(ts, ast);
+    let bindings = (0, utils_1.parseBindingRanges)(ts, ast);
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
     ts.forEachChild(ast, node => {
@@ -134,7 +134,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     runtimeType,
                     defaultValue,
                     required,
-                    comments: getClosestMultiLineCommentRange(ts, node, parents, ast),
+                    comments: (0, utils_1.getClosestMultiLineCommentRange)(ts, node, parents, ast),
                     argNode: options,
                 });
             }
@@ -250,7 +250,9 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     }
     function parseCallExpressionAssignment(node, parent) {
         return {
-            name: ts.isVariableDeclaration(parent) ? _getNodeText(parent.name) : undefined,
+            name: ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)
+                ? _getNodeText(parent.name)
+                : undefined,
             ...parseCallExpression(node),
         };
     }
@@ -261,82 +263,11 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         return (0, shared_1.getNodeText)(ts, node, ast);
     }
 }
-function parseBindingRanges(ts, ast) {
-    const bindings = [];
-    ts.forEachChild(ast, node => {
-        if (ts.isVariableStatement(node)) {
-            for (const decl of node.declarationList.declarations) {
-                const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
-                bindings.push(...ranges.map(range => ({ range })));
-            }
-        }
-        else if (ts.isFunctionDeclaration(node)) {
-            if (node.name && ts.isIdentifier(node.name)) {
-                bindings.push({
-                    range: _getStartEnd(node.name),
-                });
-            }
-        }
-        else if (ts.isClassDeclaration(node)) {
-            if (node.name) {
-                bindings.push({
-                    range: _getStartEnd(node.name),
-                });
-            }
-        }
-        else if (ts.isEnumDeclaration(node)) {
-            bindings.push({
-                range: _getStartEnd(node.name),
-            });
-        }
-        if (ts.isImportDeclaration(node)) {
-            const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
-            if (node.importClause && !node.importClause.isTypeOnly) {
-                const { name, namedBindings } = node.importClause;
-                if (name) {
-                    bindings.push({
-                        range: _getStartEnd(name),
-                        moduleName,
-                        isDefaultImport: true,
-                    });
-                }
-                if (namedBindings) {
-                    if (ts.isNamedImports(namedBindings)) {
-                        for (const element of namedBindings.elements) {
-                            if (element.isTypeOnly) {
-                                continue;
-                            }
-                            bindings.push({
-                                range: _getStartEnd(element.name),
-                                moduleName,
-                                isDefaultImport: element.propertyName?.text === 'default',
-                            });
-                        }
-                    }
-                    else {
-                        bindings.push({
-                            range: _getStartEnd(namedBindings.name),
-                            moduleName,
-                            isNamespace: true,
-                        });
-                    }
-                }
-            }
-        }
-    });
-    return bindings;
-    function _getStartEnd(node) {
-        return (0, shared_1.getStartEnd)(ts, node, ast);
-    }
-    function _getNodeText(node) {
-        return (0, shared_1.getNodeText)(ts, node, ast);
-    }
-}
 function getStatementRange(ts, parents, node, ast) {
     let statementRange;
     for (let i = parents.length - 1; i >= 0; i--) {
-        if (ts.isStatement(parents[i])) {
-            const statement = parents[i];
+        const statement = parents[i];
+        if (ts.isStatement(statement)) {
             ts.forEachChild(statement, child => {
                 const range = (0, shared_1.getStartEnd)(ts, child, ast);
                 statementRange ??= range;
@@ -350,21 +281,4 @@ function getStatementRange(ts, parents, node, ast) {
     }
     return statementRange;
 }
-function getClosestMultiLineCommentRange(ts, node, parents, ast) {
-    for (let i = parents.length - 1; i >= 0; i--) {
-        if (ts.isStatement(node)) {
-            break;
-        }
-        node = parents[i];
-    }
-    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
-        ?.reverse()
-        .find(range => range.kind === 3);
-    if (comment) {
-        return {
-            start: comment.pos,
-            end: comment.end,
-        };
-    }
-}
 //# sourceMappingURL=scriptSetupRanges.js.map

package/lib/parsers/utils.d.ts

@@ -0,0 +1,12 @@
+import type * as ts from 'typescript';
+import type { TextRange } from '../types';
+export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
+    range: TextRange;
+    moduleName?: string;
+    isDefaultImport?: boolean;
+    isNamespace?: boolean;
+}[];
+export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
+    start: number;
+    end: number;
+} | undefined;

package/lib/parsers/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseBindingRanges = parseBindingRanges;
+exports.getClosestMultiLineCommentRange = getClosestMultiLineCommentRange;
+const collectBindings_1 = require("../utils/collectBindings");
+const shared_1 = require("../utils/shared");
+function parseBindingRanges(ts, ast) {
+    const bindings = [];
+    ts.forEachChild(ast, node => {
+        if (ts.isVariableStatement(node)) {
+            for (const decl of node.declarationList.declarations) {
+                const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
+                bindings.push(...ranges.map(range => ({ range })));
+            }
+        }
+        else if (ts.isFunctionDeclaration(node)) {
+            if (node.name && ts.isIdentifier(node.name)) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isClassDeclaration(node)) {
+            if (node.name) {
+                bindings.push({
+                    range: _getStartEnd(node.name),
+                });
+            }
+        }
+        else if (ts.isEnumDeclaration(node)) {
+            bindings.push({
+                range: _getStartEnd(node.name),
+            });
+        }
+        if (ts.isImportDeclaration(node)) {
+            const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
+            if (node.importClause && !node.importClause.isTypeOnly) {
+                const { name, namedBindings } = node.importClause;
+                if (name) {
+                    bindings.push({
+                        range: _getStartEnd(name),
+                        moduleName,
+                        isDefaultImport: true,
+                    });
+                }
+                if (namedBindings) {
+                    if (ts.isNamedImports(namedBindings)) {
+                        for (const element of namedBindings.elements) {
+                            if (element.isTypeOnly) {
+                                continue;
+                            }
+                            bindings.push({
+                                range: _getStartEnd(element.name),
+                                moduleName,
+                                isDefaultImport: element.propertyName?.text === 'default',
+                            });
+                        }
+                    }
+                    else {
+                        bindings.push({
+                            range: _getStartEnd(namedBindings.name),
+                            moduleName,
+                            isNamespace: true,
+                        });
+                    }
+                }
+            }
+        }
+    });
+    return bindings;
+    function _getStartEnd(node) {
+        return (0, shared_1.getStartEnd)(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return (0, shared_1.getNodeText)(ts, node, ast);
+    }
+}
+function getClosestMultiLineCommentRange(ts, node, parents, ast) {
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(node)) {
+            break;
+        }
+        node = parents[i];
+    }
+    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
+        ?.reverse()
+        .find(range => range.kind === 3);
+    if (comment) {
+        return {
+            start: comment.pos,
+            end: comment.end,
+        };
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/plugins/file-css.d.ts

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

package/lib/plugins/file-css.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSfc_1 = require("../utils/parseSfc");
+const plugin = ({ vueCompilerOptions }) => {
+    return {
+        version: 2.1,
+        getLanguageId(fileName) {
+            if (vueCompilerOptions.extensions.some(ext => fileName.endsWith(ext))) {
+                return 'vue';
+            }
+        },
+        isValidFile(_fileName, languageId) {
+            return languageId === 'vue';
+        },
+        parseSFC2(_fileName, languageId, content) {
+            if (languageId !== 'vue') {
+                return;
+            }
+            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;
+            }
+            const oldContent = hitBlock.content;
+            const newContent = hitBlock.content = hitBlock.content.slice(0, change.start - hitBlock.loc.start.offset)
+                + change.newText
+                + hitBlock.content.slice(change.end - hitBlock.loc.start.offset);
+            // #3449
+            const endTagRegex = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
+            const insertedEndTag = endTagRegex.test(oldContent) !== endTagRegex.test(newContent);
+            if (insertedEndTag) {
+                return;
+            }
+            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;
+        },
+    };
+};
+exports.default = plugin;
+//# sourceMappingURL=file-css.js.map

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

@@ -59,7 +59,7 @@ const plugin = ctx => {
             return data;
         }
         const templateContent = sfc.template.content;
-        const inlineTsAsts = sfc.template.ast && computedSfc_1.templateInlineTsAsts.get(sfc.template.ast);
+        const inlineTsAsts = computedSfc_1.templateInlineTsAsts.get(sfc.template.ast);
         let i = 0;
         sfc.template.ast.children.forEach(visit);
         return data;
@@ -120,8 +120,7 @@ const plugin = ctx => {
                 }
             }
             else if (node.type === CompilerDOM.NodeTypes.IF) {
-                for (let i = 0; i < node.branches.length; i++) {
-                    const branch = node.branches[i];
+                for (const branch of node.branches) {
                     if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
                         addFormatCodes(branch.condition.loc.source, branch.condition.loc.start.offset, formatBrackets.if);
                     }

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

@@ -12,7 +12,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
             nameOption: import("../types").TextRange | undefined;
             inheritAttrsOption: string | undefined;
         }) | undefined;
-        classBlockEnd: number | undefined;
         bindings: {
             range: import("../types").TextRange;
             moduleName?: string;
@@ -124,11 +123,9 @@ export declare const tsCodegen: WeakMap<Sfc, {
         bypassDefineComponent: boolean;
         bindingNames: Set<string>;
         localTypes: {
-            generate: (names: string[]) => Generator<string, void, unknown>;
-            getUsedNames(): Set<string>;
+            generate: () => Generator<string, void, unknown>;
             readonly PrettifyLocal: string;
-            readonly OmitKeepDiscriminatedUnion: string;
-            readonly WithDefaults: string;
+            readonly WithDefaultsLocal: string;
             readonly WithSlots: string;
             readonly PropsChildren: string;
             readonly TypePropsToOption: string;