@vue/language-core 3.3.4 → 3.3.6

package/lib/codegen/template/slotOutlet.js

@@ -77,26 +77,26 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            const token = yield* (0, boundary_1.startBoundary)('template', nameProp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', nameProp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
             yield options.slotsAssignName ?? names_1.names.slots;
             yield* codes;
-            yield (0, boundary_1.endBoundary)(token, nameProp.loc.end.offset);
+            yield boundary.end(nameProp.loc.end.offset);
         }
         else {
-            const token = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
             yield `${options.slotsAssignName ?? names_1.names.slots}[`;
-            const token2 = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+            const boundary2 = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
             yield `'default'`;
-            yield (0, boundary_1.endBoundary)(token2, startTagEndOffset);
+            yield boundary2.end(startTagEndOffset);
             yield `]`;
-            yield (0, boundary_1.endBoundary)(token, startTagEndOffset);
+            yield boundary.end(startTagEndOffset);
         }
         yield `)(`;
-        const token = yield* (0, boundary_1.startBoundary)('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+        const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
         yield `{${utils_1.newLine}`;
         yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true);
         yield `}`;
-        yield (0, boundary_1.endBoundary)(token, startTagEndOffset);
+        yield boundary.end(startTagEndOffset);
         yield `)${utils_1.endOfLine}`;
     }
     else {
@@ -109,7 +109,6 @@ function* generateSlotOutlet(options, ctx, node) {
                 name: nameProp.value.content,
                 offset: nameProp.loc.start.offset + nameProp.loc.source.indexOf(nameProp.value.content, nameProp.name.length),
                 tagRange: [startTagOffset, startTagOffset + node.tag.length],
-                nodeLoc: node.loc,
                 propsVar: ctx.getHoistVariable(propsVar),
             });
         }
@@ -134,7 +133,6 @@ function* generateSlotOutlet(options, ctx, node) {
             ctx.slots.push({
                 name: 'default',
                 tagRange: [startTagOffset, startTagEndOffset],
-                nodeLoc: node.loc,
                 propsVar: ctx.getHoistVariable(propsVar),
             });
         }

package/lib/codegen/template/styleScopedClasses.js

@@ -7,7 +7,7 @@ const names_1 = require("../names");
 const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const escaped_1 = require("../utils/escaped");
-const classNameEscapeRegex = /([\\'])/;
+const classNameEscapeRE = /([\\'])/;
 // For language-service/lib/plugins/vue-scoped-class-links.ts usage
 exports.references = new WeakMap();
 function* generateStyleScopedClassReference(block, className, offset, fullStart = offset) {
@@ -27,11 +27,11 @@ function* generateStyleScopedClassReference(block, className, offset, fullStart
         cache[1].push([className, offset]);
     }
     yield `/** @type {${names_1.names.StyleScopedClasses}[`;
-    const token = yield* (0, boundary_1.startBoundary)(block.name, fullStart, codeFeatures_1.codeFeatures.navigation);
+    const boundary = yield* boundary_1.Boundary.start(block.name, fullStart, codeFeatures_1.codeFeatures.navigationAndCompletion);
     yield `'`;
-    yield* (0, escaped_1.generateEscaped)(className, block.name, offset, codeFeatures_1.codeFeatures.navigationAndCompletion, classNameEscapeRegex);
+    yield* (0, escaped_1.generateEscaped)(className, block.name, offset, boundary.features, classNameEscapeRE);
     yield `'`;
-    yield (0, boundary_1.endBoundary)(token, offset + className.length);
+    yield boundary.end(offset + className.length);
     yield `]} */${utils_1.endOfLine}`;
 }
 //# sourceMappingURL=styleScopedClasses.js.map

package/lib/codegen/template/vFor.js

@@ -45,11 +45,11 @@ const templateChild_1 = require("./templateChild");
 function* generateVFor(options, ctx, node) {
     const { source } = node.parseResult;
     const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
-    const endScope = ctx.startScope();
+    const scope = ctx.scope();
     yield `for (const [`;
     if (leftExpressionRange && leftExpressionText) {
         const collectAst = (0, utils_1.getTypeScriptAST)(options.typescript, options.template, `const [${leftExpressionText}]`);
-        ctx.declare(...(0, collectBindings_1.collectBindingNames)(options.typescript, collectAst, collectAst));
+        scope.declare(...(0, collectBindings_1.collectBindingNames)(options.typescript, collectAst, collectAst));
         yield [
             leftExpressionText,
             'template',
@@ -73,7 +73,7 @@ function* generateVFor(options, ctx, node) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child, false, true);
     }
     ctx.inVFor = inVFor;
-    yield* endScope();
+    yield* scope.end();
     yield `}${utils_1.newLine}`;
 }
 function parseVForNode(node) {

package/lib/codegen/template/vIf.js

@@ -41,7 +41,7 @@ const utils_1 = require("../utils");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
 function* generateVIf(options, ctx, node) {
-    const originalBlockConditionsLength = ctx.blockConditions.length;
+    const originalBlockConditionsLength = ctx.conditions.length;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
         if (i === 0) {
@@ -57,7 +57,7 @@ function* generateVIf(options, ctx, node) {
         if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
             const codes = [...(0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, `(`, `)`)];
             yield* codes;
-            ctx.blockConditions.push((0, muggle_string_1.toString)(codes));
+            ctx.conditions.push((0, muggle_string_1.toString)(codes));
             addedBlockCondition = true;
             yield ` `;
         }
@@ -67,9 +67,9 @@ function* generateVIf(options, ctx, node) {
         }
         yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {
-            ctx.blockConditions[ctx.blockConditions.length - 1] = `!${ctx.blockConditions[ctx.blockConditions.length - 1]}`;
+            ctx.conditions[ctx.conditions.length - 1] = `!${ctx.conditions[ctx.conditions.length - 1]}`;
         }
     }
-    ctx.blockConditions.length = originalBlockConditionsLength;
+    ctx.conditions.length = originalBlockConditionsLength;
 }
 //# sourceMappingURL=vIf.js.map

package/lib/codegen/template/vSlot.js

@@ -53,29 +53,29 @@ function* generateVSlot(options, ctx, node, slotDir, ctxVar) {
             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 {
-            const token = yield* (0, boundary_1.startBoundary)('template', slotDir.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
+            const boundary = yield* boundary_1.Boundary.start('template', slotDir.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
             yield `default`;
-            yield (0, boundary_1.endBoundary)(token, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0));
+            yield boundary.end(slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0));
         }
     }
     else {
         yield `const { `;
         // #932: reference for implicit default slot
-        const token = yield* (0, boundary_1.startBoundary)('template', node.loc.start.offset, codeFeatures_1.codeFeatures.navigation);
+        const boundary = yield* boundary_1.Boundary.start('template', node.loc.start.offset, codeFeatures_1.codeFeatures.navigation);
         yield `default`;
-        yield (0, boundary_1.endBoundary)(token, node.loc.end.offset);
+        yield boundary.end(node.loc.end.offset);
     }
     yield `: ${slotVar} } = ${ctxVar}.slots!${utils_1.endOfLine}`;
-    const endScope = ctx.startScope();
+    const scope = ctx.scope();
     if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, utils_1.getTypeScriptAST)(options.typescript, options.template, `(${slotDir.exp.content}) => {}`);
         yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
-        ctx.declare(...(0, collectBindings_1.collectBindingNames)(options.typescript, slotAst, slotAst));
+        scope.declare(...(0, collectBindings_1.collectBindingNames)(options.typescript, slotAst, slotAst));
     }
     for (const child of node.children) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
     }
-    yield* endScope();
+    yield* scope.end();
     if (slotDir) {
         let isStatic = true;
         if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -129,11 +129,11 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     yield `] = ${names_1.names.vSlot}(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
-        const token = yield* (0, boundary_1.startBoundary)('template', exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+        const boundary = yield* boundary_1.Boundary.start('template', exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
         yield `(`;
         yield* types.flatMap(type => type ? [`_`, type, `, `] : `_, `);
         yield `) => [] as any`;
-        yield (0, boundary_1.endBoundary)(token, exp.loc.end.offset);
+        yield boundary.end(exp.loc.end.offset);
     }
     yield `)${utils_1.endOfLine}`;
 }

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

@@ -1,3 +1,8 @@
 import type { Code, VueCodeInformation } from '../../types';
-export declare function startBoundary(source: string, startOffset: number, features: VueCodeInformation): Generator<Code, symbol, unknown>;
-export declare function endBoundary(token: symbol, endOffset: number): Code;
+export declare class Boundary {
+    source: string;
+    features: VueCodeInformation;
+    private constructor();
+    static start(source: string, offset: number, features: VueCodeInformation): Generator<Code, Boundary>;
+    end(offset: number): Code;
+}

package/lib/codegen/utils/boundary.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startBoundary = startBoundary;
-exports.endBoundary = endBoundary;
-function* startBoundary(source, startOffset, features) {
-    const token = Symbol(source);
-    yield ['', source, startOffset, { ...features, __combineToken: token }];
-    return token;
-}
-function endBoundary(token, endOffset) {
-    return ['', token.description, endOffset, { __combineToken: token }];
+exports.Boundary = void 0;
+class Boundary {
+    constructor(source, features) {
+        this.source = source;
+        this.features = features;
+    }
+    static *start(source, offset, features) {
+        features = { ...features, __combineToken: Symbol() };
+        yield [``, source, offset, features];
+        return new Boundary(source, features);
+    }
+    end(offset) {
+        return [``, this.source, offset, this.features];
+    }
 }
+exports.Boundary = Boundary;
 //# sourceMappingURL=boundary.js.map

package/lib/codegen/utils/camelized.js

@@ -4,25 +4,17 @@ exports.generateCamelized = generateCamelized;
 const shared_1 = require("@vue/shared");
 function* generateCamelized(code, source, offset, features) {
     const parts = code.split('-');
-    const combineToken = features.__combineToken ?? Symbol();
+    if (!features.__combineToken) {
+        features = { ...features, __combineToken: Symbol() };
+    }
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
         if (part !== '') {
             if (i === 0) {
-                yield [
-                    part,
-                    source,
-                    offset,
-                    { ...features, __combineToken: combineToken },
-                ];
+                yield [part, source, offset, features];
             }
             else {
-                yield [
-                    (0, shared_1.capitalize)(part),
-                    source,
-                    offset,
-                    { __combineToken: combineToken },
-                ];
+                yield [(0, shared_1.capitalize)(part), source, offset, features];
             }
         }
         offset += part.length + 1;

package/lib/codegen/utils/escaped.js

@@ -3,21 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateEscaped = generateEscaped;
 function* generateEscaped(text, source, offset, features, escapeTarget) {
     const parts = text.split(escapeTarget);
-    const combineToken = features.__combineToken ?? Symbol();
+    if (!features.__combineToken) {
+        features = { ...features, __combineToken: Symbol() };
+    }
     let isEscapeTarget = false;
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
         if (isEscapeTarget) {
             yield `\\`;
         }
-        yield [
-            part,
-            source,
-            offset,
-            i === 0
-                ? { ...features, __combineToken: combineToken }
-                : { __combineToken: combineToken },
-        ];
+        yield [part, source, offset, features];
         offset += part.length;
         isEscapeTarget = !isEscapeTarget;
     }

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

@@ -2,7 +2,7 @@ import type * as ts from 'typescript';
 import type { Code, IRBlock, IRScript, IRScriptSetup, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
-export declare const identifierRegex: RegExp;
+export declare const identifierRE: RegExp;
 export declare function getTypeScriptAST(ts: typeof import('typescript'), block: IRBlock, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: IRScript | IRScriptSetup, start: number, end: number, features: VueCodeInformation): Generator<Code>;
 export declare function forEachNode(ts: typeof import('typescript'), node: ts.Node): Generator<ts.Node>;

package/lib/codegen/utils/index.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.identifierRegex = exports.endOfLine = exports.newLine = void 0;
+exports.identifierRE = exports.endOfLine = exports.newLine = void 0;
 exports.getTypeScriptAST = getTypeScriptAST;
 exports.generateSfcBlockSection = generateSfcBlockSection;
 exports.forEachNode = forEachNode;
 const codeFeatures_1 = require("../codeFeatures");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
-exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-const cacheMaps = new Map();
+exports.identifierRE = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
+const cacheMaps = new WeakMap();
 function getTypeScriptAST(ts, block, text) {
     if (!cacheMaps.has(block)) {
         cacheMaps.set(block, [block.content, new Map()]);

package/lib/codegen/utils/stringLiteralKey.js

@@ -7,11 +7,11 @@ function* generateStringLiteralKey(code, offset, info) {
         yield `'${code}'`;
     }
     else {
-        const token = yield* (0, boundary_1.startBoundary)('template', offset, info);
+        const boundary = yield* boundary_1.Boundary.start('template', offset, info);
         yield `'`;
-        yield [code, 'template', offset, { __combineToken: token }];
+        yield [code, 'template', offset, boundary.features];
         yield `'`;
-        yield (0, boundary_1.endBoundary)(token, offset + code.length);
+        yield boundary.end(offset + code.length);
     }
 }
 //# sourceMappingURL=stringLiteralKey.js.map

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

@@ -1,2 +1,2 @@
 import type { Code, VueCodeInformation } from '../../types';
-export declare function generateUnicode(code: string, offset: number, info: VueCodeInformation): Generator<Code>;
+export declare function generateUnicode(code: string, offset: number, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/unicode.js

@@ -2,14 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUnicode = generateUnicode;
 const boundary_1 = require("./boundary");
-function* generateUnicode(code, offset, info) {
+function* generateUnicode(code, offset, features) {
     if (needToUnicode(code)) {
-        const token = yield* (0, boundary_1.startBoundary)('template', offset, info);
+        const boundary = yield* boundary_1.Boundary.start('template', offset, features);
         yield toUnicode(code);
-        yield (0, boundary_1.endBoundary)(token, offset + code.length);
+        yield boundary.end(offset + code.length);
     }
     else {
-        yield [code, 'template', offset, info];
+        yield [code, 'template', offset, features];
     }
 }
 function needToUnicode(str) {

package/lib/languagePlugin.js

@@ -40,6 +40,7 @@ const language_core_1 = require("@volar/language-core");
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const LanguageCore = __importStar(require("../index"));
 const plugins_1 = require("./plugins");
+const vue_tsx_1 = require("./plugins/vue-tsx");
 const virtualCode_1 = require("./virtualCode");
 const fileRegistries = {};
 function getVueFileRegistry(compilerOptions, vueCompilerOptions, plugins) {
@@ -111,7 +112,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
             })),
             getServiceScript(root) {
                 for (const code of (0, language_core_1.forEachEmbeddedCode)(root)) {
-                    if (/script_(js|jsx|ts|tsx)/.test(code.id)) {
+                    if (vue_tsx_1.serviceScriptRE.test(code.id)) {
                         const lang = code.id.slice('script_'.length);
                         return {
                             code,

package/lib/parsers/scriptRanges.d.ts

@@ -3,6 +3,8 @@ import type { TextRange, VueCompilerOptions } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
 export declare function parseScriptRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+    bindings: TextRange<ts.Node>[];
+    components: TextRange<ts.Node>[];
     exportDefault: (TextRange<ts.Node> & {
         expression: TextRange<ts.Expression>;
         isObjectLiteral: boolean;
@@ -16,8 +18,6 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), sourc
             inheritAttrs: string | undefined;
         };
     }) | undefined;
-    bindings: TextRange<ts.Node>[];
-    components: TextRange<ts.Node>[];
 };
 export declare function parseOptionsFromExtression(ts: typeof import('typescript'), exp: ts.Node, sourceFile: ts.SourceFile): {
     isObjectLiteral: boolean;

package/lib/parsers/scriptRanges.js

@@ -6,7 +6,6 @@ const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
 function parseScriptRanges(ts, sourceFile, vueCompilerOptions) {
     let exportDefault;
-    const { bindings, components } = (0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions);
     ts.forEachChild(sourceFile, child => {
         if (ts.isExportAssignment(child)) {
             exportDefault = {
@@ -22,16 +21,14 @@ function parseScriptRanges(ts, sourceFile, vueCompilerOptions) {
         }
     });
     return {
+        ...(0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions),
         exportDefault,
-        bindings,
-        components,
     };
 }
 function parseOptionsFromExtression(ts, exp, sourceFile) {
     let obj;
-    while (isAsExpression(ts, exp) || ts.isParenthesizedExpression(exp)) { // fix https://github.com/vuejs/language-tools/issues/1882
-        exp = exp.expression;
-    }
+    // #1882
+    exp = (0, utils_1.getUnwrappedExpression)(ts, exp);
     if (ts.isObjectLiteralExpression(exp)) {
         obj = exp;
     }
@@ -83,8 +80,4 @@ function parseOptionsFromExtression(ts, exp, sourceFile) {
         return (0, shared_1.getNodeText)(ts, node, sourceFile);
     }
 }
-// isAsExpression is missing in tsc
-function isAsExpression(ts, node) {
-    return node.kind === ts.SyntaxKind.AsExpression;
-}
 //# sourceMappingURL=scriptRanges.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -42,10 +42,10 @@ export interface UseTemplateRef extends CallExpressionRange {
 export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
 }
 export declare function parseScriptSetupRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
-    leadingCommentEndOffset: number;
-    importSectionEndOffset: number;
     bindings: TextRange<ts.Node>[];
     components: TextRange<ts.Node>[];
+    leadingCommentEndOffset: number;
+    importSectionEndOffset: number;
     defineModel: DefineModel[];
     defineProps: DefineProps | undefined;
     withDefaults: CallExpressionRange | undefined;

package/lib/parsers/scriptSetupRanges.js

@@ -4,7 +4,7 @@ exports.parseScriptSetupRanges = parseScriptSetupRanges;
 const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
-const tsCheckReg = /^\/\/\s*@ts-(?:no)?check(?:$|\s)/;
+const tsCheckRE = /^\/\/\s*@ts-(?:no)?check(?:$|\s)/;
 function parseScriptSetupRanges(ts, sourceFile, vueCompilerOptions) {
     const defineModel = [];
     let defineProps;
@@ -19,8 +19,7 @@ function parseScriptSetupRanges(ts, sourceFile, vueCompilerOptions) {
     const useTemplateRef = [];
     const text = sourceFile.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, components } = (0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions);
+    const leadingCommentEndOffset = leadingCommentRanges.find(range => tsCheckRE.test(text.slice(range.pos, range.end)))?.end ?? 0;
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
     ts.forEachChild(sourceFile, node => {
@@ -47,16 +46,10 @@ function parseScriptSetupRanges(ts, sourceFile, vueCompilerOptions) {
         foundNonImportExportNode = true;
     });
     ts.forEachChild(sourceFile, node => visitNode(node, [sourceFile]));
-    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 {
+        ...(0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions),
         leadingCommentEndOffset,
         importSectionEndOffset,
-        bindings,
-        components,
         defineModel,
         defineProps,
         withDefaults,

package/lib/parsers/utils.d.ts

@@ -5,3 +5,4 @@ export declare function parseBindingRanges(ts: typeof import('typescript'), ast:
     components: TextRange<ts.Node>[];
 };
 export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): TextRange | undefined;
+export declare function getUnwrappedExpression(ts: typeof import('typescript'), node: ts.Node): ts.Node;

package/lib/parsers/utils.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseBindingRanges = parseBindingRanges;
 exports.getClosestMultiLineCommentRange = getClosestMultiLineCommentRange;
+exports.getUnwrappedExpression = getUnwrappedExpression;
 const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
 function parseBindingRanges(ts, ast, componentExtsensions) {
@@ -91,4 +92,13 @@ function getClosestMultiLineCommentRange(ts, node, parents, ast) {
         };
     }
 }
+function getUnwrappedExpression(ts, node) {
+    while (ts.isParenthesizedExpression(node)
+        || ts.isAssertionExpression(node)
+        || ts.isNonNullExpression(node)
+        || ts.isSatisfiesExpression(node)) {
+        node = node.expression;
+    }
+    return node;
+}
 //# sourceMappingURL=utils.js.map

package/lib/parsers/vueCompilerOptions.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVueCompilerOptions = parseVueCompilerOptions;
-const syntaxReg = /^\s*@(?<key>.+?)\s+(?<value>.+?)\s*$/m;
+const syntaxRE = /^\s*@(?<key>.+?)\s+(?<value>.+?)\s*$/m;
 function parseVueCompilerOptions(comments) {
     const entries = comments
         .map(text => {
         try {
-            const match = text.match(syntaxReg);
+            const match = text.match(syntaxRE);
             if (match) {
                 const { key, value } = match.groups ?? {};
                 return [key, JSON.parse(value)];

package/lib/plugins/file-html.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const sfcBlockReg = /<(script|style)\b([\s\S]*?)>([\s\S]*?)<\/\1>/g;
-const langReg = /\blang\s*=\s*(['"]?)(\S*)\b\1/;
+const sfcBlockRE = /<(script|style)\b([\s\S]*?)>([\s\S]*?)<\/\1>/g;
+const langRE = /\blang\s*=\s*(['"]?)(\S*)\b\1/;
 const plugin = ({ vueCompilerOptions }) => {
     return {
         version: 2.2,
@@ -34,11 +34,11 @@ const plugin = ({ vueCompilerOptions }) => {
                 errors: [],
             };
             let templateContent = content;
-            for (const match of content.matchAll(sfcBlockReg)) {
+            for (const match of content.matchAll(sfcBlockRE)) {
                 const matchText = match[0];
                 const tag = match[1];
                 const attrs = match[2];
-                const lang = attrs.match(langReg)?.[2];
+                const lang = attrs.match(langRE)?.[2];
                 const content = match[3];
                 const contentStart = match.index + matchText.indexOf(content);
                 if (tag === 'style') {

package/lib/plugins/file-md.js

@@ -4,14 +4,14 @@ const language_core_1 = require("@volar/language-core");
 const muggle_string_1 = require("muggle-string");
 const buildMappings_1 = require("../utils/buildMappings");
 const parseSfc_1 = require("../utils/parseSfc");
-const frontmatterReg = /^---[\s\S]*?\n---(?:\r?\n|$)/;
-const codeblockReg = /(`{3}|\${2})[\s\S]+?\1/g;
-const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
-const sfcBlockReg = /<(script|style)\b[^>]*>([\s\S]*?)<\/\1>/g;
-const htmlTagReg = /(?<=<\/?)([a-z][a-z0-9-]*)\b[^>]*(?=>)/gi;
-const interpolationReg = /(?<=\{\{)[\s\S]*?(?=\}\})/g;
-const inlineCodeReg = /(`{1,2})[^`]+\1/g;
-const angleBracketReg = /<[^\s:]*:\S*>/g;
+const frontmatterRE = /^---[\s\S]*?\n---(?:\r?\n|$)/;
+const codeblockRE = /(`{3}|\${2})[\s\S]+?\1/g;
+const codeSnippetImportRE = /^\s*<<<\s*.+/gm;
+const sfcBlockRE = /<(script|style)\b[^>]*>([\s\S]*?)<\/\1>/g;
+const htmlTagRE = /(?<=<\/?)([a-z][a-z0-9-]*)\b[^>]*(?=>)/gi;
+const interpolationRE = /(?<=\{\{)[\s\S]*?(?=\}\})/g;
+const inlineCodeRE = /(`{1,2})[^`]+\1/g;
+const angleBracketRE = /<[^\s:]*:\S*>/g;
 const plugin = ({ vueCompilerOptions }) => {
     return {
         version: 2.2,
@@ -27,23 +27,23 @@ const plugin = ({ vueCompilerOptions }) => {
             if (languageId !== 'markdown') {
                 return;
             }
-            for (const reg of [frontmatterReg, codeblockReg, codeSnippetImportReg]) {
-                content = content.replace(reg, match => ' '.repeat(match.length));
+            for (const pattern of [frontmatterRE, codeblockRE, codeSnippetImportRE]) {
+                content = content.replace(pattern, match => ' '.repeat(match.length));
             }
             const codes = [];
-            for (const { 0: text, index } of content.matchAll(sfcBlockReg)) {
+            for (const { 0: text, index } of content.matchAll(sfcBlockRE)) {
                 codes.push([text, undefined, index]);
                 codes.push('\n\n');
                 content = content.slice(0, index) + ' '.repeat(text.length) + content.slice(index + text.length);
             }
             const ranges = [];
-            for (const reg of [htmlTagReg, interpolationReg]) {
-                for (const { 0: text, index } of content.matchAll(reg)) {
+            for (const pattern of [htmlTagRE, interpolationRE]) {
+                for (const { 0: text, index } of content.matchAll(pattern)) {
                     ranges.push([index, index + text.length]);
                 }
             }
-            for (const reg of [inlineCodeReg, angleBracketReg]) {
-                for (const { 0: text, index } of content.matchAll(reg)) {
+            for (const pattern of [inlineCodeRE, angleBracketRE]) {
+                for (const { 0: text, index } of content.matchAll(pattern)) {
                     if (ranges.some(([start, end]) => index >= start && index < end)) {
                         continue;
                     }

package/lib/plugins/file-vue.js

@@ -50,8 +50,8 @@ const plugin = ({ vueCompilerOptions }) => {
                 + 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);
+            const endTagRE = new RegExp(`</\\s*${hitBlock.type}\\s*>`);
+            const insertedEndTag = endTagRE.test(oldContent) !== endTagRE.test(newContent);
             if (insertedEndTag) {
                 return;
             }