@vue/language-core 2.1.8 → 2.2.0

package/lib/parsers/scriptSetupRanges.js

@@ -5,26 +5,31 @@ exports.parseBindingRanges = parseBindingRanges;
 exports.findBindingVars = findBindingVars;
 exports.getStartEnd = getStartEnd;
 exports.getNodeText = getNodeText;
-const common_1 = require("../codegen/common");
+const utils_1 = require("../codegen/utils");
+const tsCheckReg = /^\/\/\s*@ts-(?:no)?check($|\s)/;
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
-    let foundNonImportExportNode = false;
-    let importSectionEndOffset = 0;
-    const props = {};
-    const slots = {};
-    const emits = {};
-    const expose = {};
-    const options = {};
-    const cssModules = [];
-    const templateRefs = [];
-    const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=kevinEdition');
-    const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition' || ast.text.trimStart().startsWith('// @experimentalDefinePropProposal=johnsonEdition');
     const defineProp = [];
+    let defineProps;
+    let withDefaults;
+    let defineEmits;
+    let defineSlots;
+    let defineExpose;
+    let defineOptions;
+    const useAttrs = [];
+    const useCssModule = [];
+    const useSlots = [];
+    const useTemplateRef = [];
+    const definePropProposalA = vueCompilerOptions.experimentalDefinePropProposal === 'kevinEdition';
+    const definePropProposalB = vueCompilerOptions.experimentalDefinePropProposal === 'johnsonEdition';
     const text = ast.text;
-    const leadingCommentEndOffset = ts.getLeadingCommentRanges(text, 0)?.reverse()[0].end ?? 0;
-    const importComponentNames = new Set();
+    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 foundNonImportExportNode = false;
+    let importSectionEndOffset = 0;
     ts.forEachChild(ast, node => {
-        const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
+        const isTypeExport = (ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node))
+            && node.modifiers?.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword);
         if (!foundNonImportExportNode
             && !ts.isImportDeclaration(node)
             && !isTypeExport
@@ -41,51 +46,34 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             foundNonImportExportNode = true;
         }
-        if (ts.isImportDeclaration(node)
-            && node.importClause?.name
-            && !node.importClause.isTypeOnly) {
-            const moduleName = getNodeText(ts, node.moduleSpecifier, ast).slice(1, -1);
-            if (vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
-                importComponentNames.add(getNodeText(ts, node.importClause.name, ast));
-            }
-        }
     });
-    ts.forEachChild(ast, child => visitNode(child, [ast]));
-    const templateRefNames = new Set(templateRefs.map(ref => ref.name));
-    bindings = bindings.filter(range => {
-        const name = text.substring(range.start, range.end);
+    ts.forEachChild(ast, node => visitNode(node, [ast]));
+    const templateRefNames = new Set(useTemplateRef.map(ref => ref.name));
+    bindings = bindings.filter(({ range }) => {
+        const name = text.slice(range.start, range.end);
         return !templateRefNames.has(name);
     });
     return {
         leadingCommentEndOffset,
         importSectionEndOffset,
         bindings,
-        importComponentNames,
-        props,
-        slots,
-        emits,
-        expose,
-        options,
-        cssModules,
         defineProp,
-        templateRefs,
+        defineProps,
+        withDefaults,
+        defineEmits,
+        defineSlots,
+        defineExpose,
+        defineOptions,
+        useAttrs,
+        useCssModule,
+        useSlots,
+        useTemplateRef,
     };
-    function _getStartEnd(node) {
-        return getStartEnd(ts, node, ast);
-    }
-    function parseDefineFunction(node) {
-        return {
-            ..._getStartEnd(node),
-            exp: _getStartEnd(node.expression),
-            arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
-            typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
-        };
-    }
     function visitNode(node, parents) {
         const parent = parents[parents.length - 1];
         if (ts.isCallExpression(node)
             && ts.isIdentifier(node.expression)) {
-            const callText = getNodeText(ts, node.expression, ast);
+            const callText = _getNodeText(node.expression);
             if (vueCompilerOptions.macros.defineModel.includes(callText)) {
                 let localName;
                 let propName;
@@ -99,7 +87,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     options = node.arguments[1];
                 }
                 else if (node.arguments.length >= 1) {
-                    if (ts.isStringLiteral(node.arguments[0])) {
+                    if (ts.isStringLiteralLike(node.arguments[0])) {
                         propName = _getStartEnd(node.arguments[0]);
                     }
                     else {
@@ -114,7 +102,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                         if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
                             continue;
                         }
-                        const text = getNodeText(ts, property.name, ast);
+                        const text = _getNodeText(property.name);
                         if (text === 'type') {
                             runtimeType = _getStartEnd(property.initializer);
                         }
@@ -160,7 +148,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                             if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
                                 continue;
                             }
-                            const text = getNodeText(ts, property.name, ast);
+                            const text = _getNodeText(property.name);
                             if (text === 'type') {
                                 runtimeType = _getStartEnd(property.initializer);
                             }
@@ -190,7 +178,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                             if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
                                 continue;
                             }
-                            const text = getNodeText(ts, property.name, ast);
+                            const text = _getNodeText(property.name);
                             if (text === 'type') {
                                 runtimeType = _getStartEnd(property.initializer);
                             }
@@ -206,160 +194,198 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     required,
                 });
             }
-            else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
-                slots.define = parseDefineFunction(node);
+            else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+                defineProps = {
+                    ...parseCallExpression(node),
+                    statement: getStatementRange(ts, parents, node, ast)
+                };
                 if (ts.isVariableDeclaration(parent)) {
-                    if (ts.isIdentifier(parent.name)) {
-                        slots.name = getNodeText(ts, parent.name, ast);
+                    if (ts.isObjectBindingPattern(parent.name)) {
+                        defineProps.destructured = new Set();
+                        const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
+                        for (const [id, isRest] of identifiers) {
+                            const name = _getNodeText(id);
+                            if (isRest) {
+                                defineProps.destructuredRest = name;
+                            }
+                            else {
+                                defineProps.destructured.add(name);
+                            }
+                        }
                     }
                     else {
-                        slots.isObjectBindingPattern = ts.isObjectBindingPattern(parent.name);
+                        defineProps.name = _getNodeText(parent.name);
                     }
                 }
+                else if (ts.isCallExpression(parent)
+                    && vueCompilerOptions.macros.withDefaults.includes(_getNodeText(parent.expression))) {
+                    const grand = parents.at(-2);
+                    if (grand && ts.isVariableDeclaration(grand)) {
+                        defineProps.name = _getNodeText(grand.name);
+                    }
+                }
+            }
+            else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
+                const [, arg] = node.arguments;
+                withDefaults = {
+                    callExp: _getStartEnd(node),
+                    exp: _getStartEnd(node.expression),
+                    arg: arg ? _getStartEnd(arg) : undefined
+                };
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
-                emits.define = {
-                    ...parseDefineFunction(node),
+                defineEmits = {
+                    ...parseCallExpression(node),
                     statement: getStatementRange(ts, parents, node, ast)
                 };
                 if (ts.isVariableDeclaration(parent)) {
-                    emits.name = getNodeText(ts, parent.name, ast);
+                    defineEmits.name = _getNodeText(parent.name);
                 }
-                if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0]) && node.typeArguments[0].members.at(0)) {
+                if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0])) {
                     for (const member of node.typeArguments[0].members) {
-                        if (ts.isCallSignatureDeclaration(member) && member.parameters[0].type && ts.isUnionTypeNode(member.parameters[0].type)) {
-                            emits.define.hasUnionTypeArg = true;
-                            return;
+                        if (ts.isCallSignatureDeclaration(member)) {
+                            const type = member.parameters[0]?.type;
+                            if (type && ts.isUnionTypeNode(type)) {
+                                defineEmits.hasUnionTypeArg = true;
+                                break;
+                            }
                         }
                     }
                 }
             }
-            else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
-                expose.define = parseDefineFunction(node);
-            }
-            else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
+            else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
+                defineSlots = {
+                    ...parseCallExpression(node),
+                    statement: getStatementRange(ts, parents, node, ast)
+                };
                 if (ts.isVariableDeclaration(parent)) {
-                    if (ts.isObjectBindingPattern(parent.name)) {
-                        props.destructured = new Set();
-                        const identifiers = (0, common_1.collectIdentifiers)(ts, parent.name, []);
-                        for (const [id, isRest] of identifiers) {
-                            const name = getNodeText(ts, id, ast);
-                            if (isRest) {
-                                props.destructuredRest = name;
-                            }
-                            else {
-                                props.destructured.add(name);
-                            }
-                        }
+                    if (ts.isIdentifier(parent.name)) {
+                        defineSlots.name = _getNodeText(parent.name);
                     }
                     else {
-                        props.name = getNodeText(ts, parent.name, ast);
+                        defineSlots.isObjectBindingPattern = ts.isObjectBindingPattern(parent.name);
                     }
                 }
-                props.define = {
-                    ...parseDefineFunction(node),
-                    statement: getStatementRange(ts, parents, node, ast),
-                };
-                if (node.arguments.length) {
-                    props.define.arg = _getStartEnd(node.arguments[0]);
-                }
-                if (node.typeArguments?.length) {
-                    props.define.typeArg = _getStartEnd(node.typeArguments[0]);
-                }
             }
-            else if (vueCompilerOptions.macros.withDefaults.includes(callText)) {
-                props.withDefaults = _getStartEnd(node);
-                if (node.arguments.length >= 2) {
-                    const arg = node.arguments[1];
-                    props.withDefaults.arg = _getStartEnd(arg);
-                }
-                if (ts.isVariableDeclaration(parent)) {
-                    props.name = getNodeText(ts, parent.name, ast);
-                }
+            else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
+                defineExpose = parseCallExpression(node);
             }
-            else if (vueCompilerOptions.macros.defineOptions.includes(callText)) {
-                if (node.arguments.length && ts.isObjectLiteralExpression(node.arguments[0])) {
-                    const obj = node.arguments[0];
-                    ts.forEachChild(obj, node => {
-                        if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
-                            const name = getNodeText(ts, node.name, ast);
-                            if (name === 'inheritAttrs') {
-                                options.inheritAttrs = getNodeText(ts, node.initializer, ast);
-                            }
+            else if (vueCompilerOptions.macros.defineOptions.includes(callText)
+                && node.arguments.length
+                && ts.isObjectLiteralExpression(node.arguments[0])) {
+                defineOptions = {};
+                const obj = node.arguments[0];
+                for (const prop of obj.properties) {
+                    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                        const name = _getNodeText(prop.name);
+                        if (name === 'inheritAttrs') {
+                            defineOptions.inheritAttrs = _getNodeText(prop.initializer);
                         }
-                    });
-                    for (const prop of node.arguments[0].properties) {
-                        if ((ts.isPropertyAssignment(prop)) && getNodeText(ts, prop.name, ast) === 'name' && ts.isStringLiteral(prop.initializer)) {
-                            options.name = prop.initializer.text;
+                        else if (name === 'name' && ts.isStringLiteral(prop.initializer)) {
+                            defineOptions.name = prop.initializer.text;
                         }
                     }
                 }
             }
-            else if (vueCompilerOptions.composibles.useTemplateRef.includes(callText) && node.arguments.length && !node.typeArguments?.length) {
-                const define = parseDefineFunction(node);
-                let name;
-                if (ts.isVariableDeclaration(parent)) {
-                    name = getNodeText(ts, parent.name, ast);
-                }
-                templateRefs.push({
-                    name,
-                    define
-                });
+            else if (vueCompilerOptions.composables.useAttrs.includes(callText)) {
+                useAttrs.push(parseCallExpression(node));
+            }
+            else if (vueCompilerOptions.composables.useCssModule.includes(callText)) {
+                useCssModule.push(parseCallExpression(node));
+            }
+            else if (vueCompilerOptions.composables.useSlots.includes(callText)) {
+                useSlots.push(parseCallExpression(node));
             }
-            else if (vueCompilerOptions.composibles.useCssModule.includes(callText)) {
-                const define = parseDefineFunction(node);
-                cssModules.push({
-                    define
+            else if (vueCompilerOptions.composables.useTemplateRef.includes(callText)
+                && !node.typeArguments?.length) {
+                useTemplateRef.push({
+                    name: ts.isVariableDeclaration(parent) ? _getNodeText(parent.name) : undefined,
+                    ...parseCallExpression(node)
                 });
             }
         }
         ts.forEachChild(node, child => {
+            if (ts.isFunctionLike(node)) {
+                return;
+            }
             parents.push(node);
             visitNode(child, parents);
             parents.pop();
         });
     }
+    function parseCallExpression(node) {
+        return {
+            callExp: _getStartEnd(node),
+            exp: _getStartEnd(node.expression),
+            arg: node.arguments.length ? _getStartEnd(node.arguments[0]) : undefined,
+            typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+        };
+    }
+    function _getStartEnd(node) {
+        return getStartEnd(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return getNodeText(ts, node, ast);
+    }
 }
-function parseBindingRanges(ts, sourceFile) {
+function parseBindingRanges(ts, ast) {
     const bindings = [];
-    ts.forEachChild(sourceFile, node => {
+    ts.forEachChild(ast, node => {
         if (ts.isVariableStatement(node)) {
-            for (const node_2 of node.declarationList.declarations) {
-                const vars = _findBindingVars(node_2.name);
-                for (const _var of vars) {
-                    bindings.push(_var);
-                }
+            for (const decl of node.declarationList.declarations) {
+                const vars = _findBindingVars(decl.name);
+                bindings.push(...vars.map(range => ({ range })));
             }
         }
         else if (ts.isFunctionDeclaration(node)) {
             if (node.name && ts.isIdentifier(node.name)) {
-                bindings.push(_getStartEnd(node.name));
+                bindings.push({
+                    range: _getStartEnd(node.name)
+                });
             }
         }
         else if (ts.isClassDeclaration(node)) {
             if (node.name) {
-                bindings.push(_getStartEnd(node.name));
+                bindings.push({
+                    range: _getStartEnd(node.name)
+                });
             }
         }
         else if (ts.isEnumDeclaration(node)) {
-            bindings.push(_getStartEnd(node.name));
+            bindings.push({
+                range: _getStartEnd(node.name)
+            });
         }
         if (ts.isImportDeclaration(node)) {
+            const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
             if (node.importClause && !node.importClause.isTypeOnly) {
-                if (node.importClause.name) {
-                    bindings.push(_getStartEnd(node.importClause.name));
+                const { name, namedBindings } = node.importClause;
+                if (name) {
+                    bindings.push({
+                        range: _getStartEnd(name),
+                        moduleName,
+                        isDefaultImport: true
+                    });
                 }
-                if (node.importClause.namedBindings) {
-                    if (ts.isNamedImports(node.importClause.namedBindings)) {
-                        for (const element of node.importClause.namedBindings.elements) {
+                if (namedBindings) {
+                    if (ts.isNamedImports(namedBindings)) {
+                        for (const element of namedBindings.elements) {
                             if (element.isTypeOnly) {
                                 continue;
                             }
-                            bindings.push(_getStartEnd(element.name));
+                            bindings.push({
+                                range: _getStartEnd(element.name),
+                                moduleName,
+                                isDefaultImport: element.propertyName?.text === 'default'
+                            });
                         }
                     }
-                    else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
-                        bindings.push(_getStartEnd(node.importClause.namedBindings.name));
+                    else {
+                        bindings.push({
+                            range: _getStartEnd(namedBindings.name),
+                            moduleName,
+                            isNamespace: true
+                        });
                     }
                 }
             }
@@ -367,61 +393,64 @@ function parseBindingRanges(ts, sourceFile) {
     });
     return bindings;
     function _getStartEnd(node) {
-        return getStartEnd(ts, node, sourceFile);
+        return getStartEnd(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return getNodeText(ts, node, ast);
     }
     function _findBindingVars(left) {
-        return findBindingVars(ts, left, sourceFile);
+        return findBindingVars(ts, left, ast);
     }
 }
-function findBindingVars(ts, left, sourceFile) {
+function findBindingVars(ts, left, ast) {
     const vars = [];
     worker(left);
     return vars;
-    function worker(_node) {
-        if (ts.isIdentifier(_node)) {
-            vars.push(getStartEnd(ts, _node, sourceFile));
+    function worker(node) {
+        if (ts.isIdentifier(node)) {
+            vars.push(getStartEnd(ts, node, ast));
         }
         // { ? } = ...
         // [ ? ] = ...
-        else if (ts.isObjectBindingPattern(_node) || ts.isArrayBindingPattern(_node)) {
-            for (const property of _node.elements) {
+        else if (ts.isObjectBindingPattern(node) || ts.isArrayBindingPattern(node)) {
+            for (const property of node.elements) {
                 if (ts.isBindingElement(property)) {
                     worker(property.name);
                 }
             }
         }
         // { foo: ? } = ...
-        else if (ts.isPropertyAssignment(_node)) {
-            worker(_node.initializer);
+        else if (ts.isPropertyAssignment(node)) {
+            worker(node.initializer);
         }
         // { foo } = ...
-        else if (ts.isShorthandPropertyAssignment(_node)) {
-            vars.push(getStartEnd(ts, _node.name, sourceFile));
+        else if (ts.isShorthandPropertyAssignment(node)) {
+            vars.push(getStartEnd(ts, node.name, ast));
         }
         // { ...? } = ...
         // [ ...? ] = ...
-        else if (ts.isSpreadAssignment(_node) || ts.isSpreadElement(_node)) {
-            worker(_node.expression);
+        else if (ts.isSpreadAssignment(node) || ts.isSpreadElement(node)) {
+            worker(node.expression);
         }
     }
 }
-function getStartEnd(ts, node, sourceFile) {
+function getStartEnd(ts, node, ast) {
     return {
-        start: ts.getTokenPosOfNode(node, sourceFile),
+        start: ts.getTokenPosOfNode(node, ast),
         end: node.end,
     };
 }
-function getNodeText(ts, node, sourceFile) {
-    const { start, end } = getStartEnd(ts, node, sourceFile);
-    return sourceFile.text.substring(start, end);
+function getNodeText(ts, node, ast) {
+    const { start, end } = getStartEnd(ts, node, ast);
+    return ast.text.slice(start, end);
 }
-function getStatementRange(ts, parents, node, sourceFile) {
+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];
             ts.forEachChild(statement, child => {
-                const range = getStartEnd(ts, child, sourceFile);
+                const range = getStartEnd(ts, child, ast);
                 statementRange ??= range;
                 statementRange.end = range.end;
             });
@@ -429,7 +458,7 @@ function getStatementRange(ts, parents, node, sourceFile) {
         }
     }
     if (!statementRange) {
-        statementRange = getStartEnd(ts, node, sourceFile);
+        statementRange = getStartEnd(ts, node, ast);
     }
     return statementRange;
 }

package/lib/parsers/vueCompilerOptions.d.ts

@@ -0,0 +1,2 @@
+import type { VueCompilerOptions } from '../types';
+export declare function parseVueCompilerOptions(comments: string[]): Partial<VueCompilerOptions> | undefined;

package/lib/parsers/vueCompilerOptions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVueCompilerOptions = parseVueCompilerOptions;
+const syntaxReg = /^\s*@(?<key>.+?)\s+(?<value>.+?)\s*$/m;
+function parseVueCompilerOptions(comments) {
+    const entries = comments
+        .map(text => {
+        try {
+            const match = text.match(syntaxReg);
+            if (match) {
+                const { key, value } = match.groups ?? {};
+                return [key, JSON.parse(value)];
+            }
+        }
+        catch { }
+        ;
+    })
+        .filter(item => !!item);
+    if (entries.length) {
+        return Object.fromEntries(entries);
+    }
+}
+//# sourceMappingURL=vueCompilerOptions.js.map

package/lib/plugins/file-html.js

@@ -21,6 +21,7 @@ const plugin = ({ vueCompilerOptions }) => {
                 descriptor: {
                     filename: fileName,
                     source: content,
+                    comments: [],
                     template: null,
                     script: null,
                     scriptSetup: null,
@@ -54,8 +55,8 @@ const plugin = ({ vueCompilerOptions }) => {
                     });
                 }
                 // ignore `<script src="...">`
-                else if (tag === 'script' && attrs.indexOf('src=') === -1) {
-                    let type = attrs.indexOf('type=') >= 0 ? 'scriptSetup' : 'script';
+                else if (tag === 'script' && !attrs.includes('src=')) {
+                    let type = attrs.includes('type=') ? 'scriptSetup' : 'script';
                     sfc.descriptor[type] = {
                         attrs: {},
                         content,
@@ -68,7 +69,7 @@ const plugin = ({ vueCompilerOptions }) => {
                         lang,
                     };
                 }
-                templateContent = templateContent.substring(0, match.index) + ' '.repeat(matchText.length) + templateContent.substring(match.index + matchText.length);
+                templateContent = templateContent.slice(0, match.index) + ' '.repeat(matchText.length) + templateContent.slice(match.index + matchText.length);
             }
             sfc.descriptor.template = {
                 attrs: {},

package/lib/plugins/file-md.js

@@ -41,7 +41,7 @@ const plugin = ({ vueCompilerOptions }) => {
                     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.slice(0, match.index) + ' '.repeat(matchText.length) + content.slice(match.index + matchText.length);
                 }
             }
             content = content

package/lib/plugins/file-vue.js

@@ -25,19 +25,19 @@ const plugin = ({ vueCompilerOptions }) => {
                 sfc.descriptor.scriptSetup,
                 ...sfc.descriptor.styles,
                 ...sfc.descriptor.customBlocks,
-            ].filter((block) => !!block);
+            ].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.substring(0, change.start - hitBlock.loc.start.offset)
+                hitBlock.content.slice(0, change.start - hitBlock.loc.start.offset)
                     + change.newText
-                    + hitBlock.content.substring(change.end - hitBlock.loc.start.offset);
+                    + hitBlock.content.slice(change.end - hitBlock.loc.start.offset);
             // #3449
             const endTagRegex = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
-            const insertedEndTag = !!oldContent.match(endTagRegex) !== !!newContent.match(endTagRegex);
+            const insertedEndTag = endTagRegex.test(oldContent) !== endTagRegex.test(newContent);
             if (insertedEndTag) {
                 return;
             }

package/lib/plugins/vue-root-tags.js

@@ -33,12 +33,12 @@ const plugin = () => {
                     }
                     const offset = content.lastIndexOf('\n') + 1;
                     // fix folding range end position failed to mapping
-                    (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, sfc.content.substring(block.startTagEnd, block.startTagEnd + offset), [
+                    (0, muggle_string_1.replaceSourceRange)(embeddedFile.content, undefined, block.startTagEnd, block.endTagStart, sfc.content.slice(block.startTagEnd, block.startTagEnd + offset), [
                         '',
                         undefined,
                         block.startTagEnd + offset,
                         { structure: true },
-                    ], sfc.content.substring(block.startTagEnd + offset, block.endTagStart));
+                    ], sfc.content.slice(block.startTagEnd + offset, block.endTagStart));
                 }
             }
             else {