@vue/language-core 2.2.8 → 3.0.0-alpha.2

package/lib/codegen/template/styleScopedClasses.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleScopedClassReferences = generateStyleScopedClassReferences;
 exports.collectStyleScopedClassReferences = collectStyleScopedClassReferences;
 const CompilerDOM = require("@vue/compiler-dom");
-const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
 const escaped_1 = require("../utils/escaped");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -126,7 +126,7 @@ function collectStyleScopedClassReferences(options, ctx, node) {
                 }
             }
             function walkIdentifier(node) {
-                const text = (0, scriptSetupRanges_1.getNodeText)(ts, node, ast);
+                const text = (0, shared_1.getNodeText)(ts, node, ast);
                 ctx.scopedClasses.push({
                     source: 'template',
                     className: text,

package/lib/codegen/template/templateChild.d.ts

@@ -2,6 +2,6 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, prevNode: CompilerDOM.TemplateChildNode | undefined, isVForChild?: boolean): Generator<Code>;
+export declare function generateTemplateChild(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode, enterNode?: boolean): Generator<Code>;
 export declare function getVForNode(node: CompilerDOM.ElementNode): CompilerDOM.ForNode | undefined;
 export declare function parseInterpolationNode(node: CompilerDOM.InterpolationNode, template: string): readonly [string, number];

package/lib/codegen/template/templateChild.js

@@ -7,12 +7,12 @@ const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
 const element_1 = require("./element");
+const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
 const slotOutlet_1 = require("./slotOutlet");
 const vFor_1 = require("./vFor");
 const vIf_1 = require("./vIf");
 const vSlot_1 = require("./vSlot");
-const commentDirectiveRegex = /^<!--\s*@vue-(?<name>[-\w]+)\b(?<content>[\s\S]*)-->$/;
 // @ts-ignore
 const transformContext = {
     onError: () => { },
@@ -28,36 +28,9 @@ const transformContext = {
     },
     expressionPlugins: ['typescript'],
 };
-function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = false) {
-    if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
-        const match = prevNode.loc.source.match(commentDirectiveRegex);
-        if (match) {
-            const { name, content } = match.groups;
-            switch (name) {
-                case 'skip': {
-                    yield `// @vue-skip${utils_1.newLine}`;
-                    return;
-                }
-                case 'ignore': {
-                    yield* ctx.ignoreError();
-                    break;
-                }
-                case 'expect-error': {
-                    yield* ctx.expectError(prevNode);
-                    break;
-                }
-                case 'generic': {
-                    const text = content.trim();
-                    if (text.startsWith('{') && text.endsWith('}')) {
-                        ctx.lastGenericComment = {
-                            content: text.slice(1, -1),
-                            offset: prevNode.loc.start.offset + prevNode.loc.source.indexOf('{') + 1,
-                        };
-                    }
-                    break;
-                }
-            }
-        }
+function* generateTemplateChild(options, ctx, node, enterNode = true) {
+    if (enterNode && !ctx.enter(node)) {
+        return;
     }
     const cur = node;
     if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
@@ -67,12 +40,7 @@ function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = fals
         for (const item of collectSingleRootNodes(options, node.children)) {
             ctx.singleRootNodes.add(item);
         }
-        let prev;
-        for (const childNode of node.children) {
-            yield* generateTemplateChild(options, ctx, childNode, prev);
-            prev = childNode;
-        }
-        yield* ctx.resetDirectiveComments('end of root');
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children);
     }
     else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
         const vForNode = getVForNode(node);
@@ -95,32 +63,27 @@ function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = fals
             }
             else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
                 || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
-                yield* (0, element_1.generateElement)(options, ctx, node, isVForChild);
+                yield* (0, element_1.generateElement)(options, ctx, node);
             }
             else {
                 const { currentComponent } = ctx;
-                yield* (0, element_1.generateComponent)(options, ctx, node, isVForChild);
+                yield* (0, element_1.generateComponent)(options, ctx, node);
                 ctx.currentComponent = currentComponent;
             }
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.TEXT_CALL) {
         // {{ var }}
-        yield* generateTemplateChild(options, ctx, node.content, undefined);
+        yield* generateTemplateChild(options, ctx, node.content, false);
     }
     else if (node.type === CompilerDOM.NodeTypes.COMPOUND_EXPRESSION) {
         // {{ ... }} {{ ... }}
-        for (const childNode of node.children) {
-            if (typeof childNode === 'object') {
-                yield* generateTemplateChild(options, ctx, childNode, undefined);
-            }
-        }
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children.filter(child => typeof child === 'object'), false);
     }
     else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
         // {{ ... }}
         const [content, start] = parseInterpolationNode(node, options.template.content);
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, content, start, node.content.loc, `(`, `)${utils_1.endOfLine}`);
-        yield* ctx.resetDirectiveComments('end of INTERPOLATION');
     }
     else if (node.type === CompilerDOM.NodeTypes.IF) {
         // v-if / v-else-if / v-else
@@ -133,6 +96,9 @@ function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = fals
     else if (node.type === CompilerDOM.NodeTypes.TEXT) {
         // not needed progress
     }
+    if (enterNode) {
+        yield* ctx.exit();
+    }
 }
 function* collectSingleRootNodes(options, children) {
     if (children.length !== 1) {

package/lib/codegen/template/vFor.js

@@ -4,8 +4,8 @@ exports.generateVFor = generateVFor;
 exports.parseVForNode = parseVForNode;
 const CompilerDOM = require("@vue/compiler-dom");
 const utils_1 = require("../utils");
+const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
-const templateChild_1 = require("./templateChild");
 function* generateVFor(options, ctx, node) {
     const { source } = node.parseResult;
     const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
@@ -52,18 +52,13 @@ function* generateVFor(options, ctx, node) {
             }
         }
     }
-    if (isFragment) {
-        yield* ctx.resetDirectiveComments('end of v-for start');
-    }
-    let prev;
-    for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev, true);
-        prev = childNode;
-    }
+    const { inVFor } = ctx;
+    ctx.inVFor = true;
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children, isFragment);
+    ctx.inVFor = inVFor;
     for (const varName of forBlockVars) {
         ctx.removeLocalVariable(varName);
     }
-    yield* ctx.generateAutoImportCompletion();
     yield `}${utils_1.newLine}`;
 }
 function parseVForNode(node) {

package/lib/codegen/template/vIf.js

@@ -4,8 +4,8 @@ exports.generateVIf = generateVIf;
 const CompilerDOM = require("@vue/compiler-dom");
 const muggle_string_1 = require("muggle-string");
 const utils_1 = require("../utils");
+const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
-const templateChild_1 = require("./templateChild");
 function* generateVIf(options, ctx, node) {
     const originalBlockConditionsLength = ctx.blockConditions.length;
     for (let i = 0; i < node.branches.length; i++) {
@@ -28,15 +28,7 @@ function* generateVIf(options, ctx, node) {
             yield ` `;
         }
         yield `{${utils_1.newLine}`;
-        if (isFragment(node)) {
-            yield* ctx.resetDirectiveComments('end of v-if start');
-        }
-        let prev;
-        for (const childNode of branch.children) {
-            yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
-            prev = childNode;
-        }
-        yield* ctx.generateAutoImportCompletion();
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, branch.children, isFragment(node));
         yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {
             ctx.blockConditions[ctx.blockConditions.length - 1] = `!${ctx.blockConditions[ctx.blockConditions.length - 1]}`;

package/lib/codegen/template/vSlot.d.ts

@@ -2,5 +2,4 @@ import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateVSlot(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, slotDir: CompilerDOM.DirectiveNode): Generator<Code>;
-export declare function generateImplicitDefaultSlot(ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code, void, any>;
+export declare function generateVSlot(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, slotDir: CompilerDOM.DirectiveNode | undefined): Generator<Code>;

package/lib/codegen/template/vSlot.js

@@ -1,93 +1,115 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateVSlot = generateVSlot;
-exports.generateImplicitDefaultSlot = generateImplicitDefaultSlot;
 const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
+const elementChildren_1 = require("./elementChildren");
 const objectProperty_1 = require("./objectProperty");
-const templateChild_1 = require("./templateChild");
 function* generateVSlot(options, ctx, node, slotDir) {
     if (!ctx.currentComponent) {
         return;
     }
-    ctx.currentComponent.used = true;
     const slotBlockVars = [];
-    yield `{${utils_1.newLine}`;
-    yield `const { `;
-    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 ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+    const slotVar = ctx.getInternalVariable();
+    if (slotDir) {
+        yield `{${utils_1.newLine}`;
     }
-    else {
-        yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+    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 ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+            }
+            else {
+                yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+            }
+        }
+        else {
+            yield* (0, wrapWith_1.wrapWith)(node.children[0].loc.start.offset, node.children.at(-1).loc.end.offset, ctx.codeFeatures.navigation, `default`);
+        }
+        yield `: ${slotVar} } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     }
-    yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
-    if (slotDir.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+    if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         const slotAst = (0, utils_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
         (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
-        if (!slotDir.exp.content.includes(':')) {
-            yield `const [`;
-            yield [
-                slotDir.exp.content,
-                'template',
-                slotDir.exp.loc.start.offset,
-                ctx.codeFeatures.all,
-            ];
-            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${utils_1.endOfLine}`;
+        yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
+    }
+    for (const varName of slotBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node.children);
+    for (const varName of slotBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    if (slotDir) {
+        let isStatic = true;
+        if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            isStatic = slotDir.arg.isStatic;
         }
-        else {
-            yield `const `;
+        if (isStatic && !slotDir.arg) {
+            yield `${ctx.currentComponent.ctxVar}.slots!['`;
             yield [
-                slotDir.exp.content,
+                '',
                 'template',
-                slotDir.exp.loc.start.offset,
-                ctx.codeFeatures.all,
+                slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                    ? '#'.length
+                    : slotDir.loc.source.startsWith('v-slot:')
+                        ? 'v-slot:'.length
+                        : 0),
+                ctx.codeFeatures.completion,
             ];
-            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${utils_1.endOfLine}`;
+            yield `'/* empty slot name completion */]${utils_1.endOfLine}`;
         }
+        yield `}${utils_1.newLine}`;
     }
-    for (const varName of slotBlockVars) {
-        ctx.addLocalVariable(varName);
+}
+function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
+    const { ts } = options;
+    const statement = ast.statements[0];
+    if (!ts.isExpressionStatement(statement) || !ts.isArrowFunction(statement.expression)) {
+        return;
     }
-    yield* ctx.resetDirectiveComments('end of slot children start');
-    let prev;
-    for (const childNode of node.children) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, prev);
-        prev = childNode;
+    const { expression } = statement;
+    const startOffset = exp.loc.start.offset - 1;
+    const modifies = [];
+    const types = [];
+    for (const { name, type } of expression.parameters) {
+        if (type) {
+            modifies.push([
+                [``],
+                name.end,
+                type.end,
+            ]);
+            types.push(chunk((0, shared_1.getStartEnd)(ts, type, ast).start, type.end));
+        }
+        else {
+            types.push(null);
+        }
     }
-    for (const varName of slotBlockVars) {
-        ctx.removeLocalVariable(varName);
+    yield `const [`;
+    let nextStart = 1;
+    for (const [codes, start, end] of modifies) {
+        yield chunk(nextStart, start);
+        yield* codes;
+        nextStart = end;
     }
-    let isStatic = true;
-    if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        isStatic = slotDir.arg.isStatic;
+    yield chunk(nextStart, expression.equalsGreaterThanToken.pos - 1);
+    yield `] = __VLS_getSlotParameters(${slotVar}`;
+    if (types.some(t => t)) {
+        yield `, `;
+        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, ctx.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_: `, type, `, `] : `_, `), `) => [] as any`);
     }
-    if (isStatic && !slotDir.arg) {
-        yield `${ctx.currentComponent.ctxVar}.slots!['`;
-        yield [
-            '',
+    yield `)${utils_1.endOfLine}`;
+    function chunk(start, end) {
+        return [
+            ast.text.slice(start, end),
             'template',
-            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
-                ? '#'.length
-                : slotDir.loc.source.startsWith('v-slot:')
-                    ? 'v-slot:'.length
-                    : 0),
-            ctx.codeFeatures.completion,
+            startOffset + start,
+            ctx.codeFeatures.all,
         ];
-        yield `'/* empty slot name completion */]${utils_1.endOfLine}`;
-    }
-    yield* ctx.generateAutoImportCompletion();
-    yield `}${utils_1.newLine}`;
-}
-function* generateImplicitDefaultSlot(ctx, node) {
-    if (!ctx.currentComponent) {
-        return;
-    }
-    if (node.children.length) {
-        ctx.currentComponent.used = true;
-        yield `${ctx.currentComponent.ctxVar}.slots!.`;
-        yield* (0, wrapWith_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
-        yield utils_1.endOfLine;
     }
 }
 //# sourceMappingURL=vSlot.js.map

package/lib/codegen/utils/index.js

@@ -7,7 +7,7 @@ exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
 exports.generateSfcBlockAttrValue = generateSfcBlockAttrValue;
-const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
+const shared_1 = require("../../utils/shared");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineOffset: 1 };
@@ -15,7 +15,7 @@ exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 function collectVars(ts, node, ast, results = []) {
     const identifiers = collectIdentifiers(ts, node, []);
     for (const { id } of identifiers) {
-        results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
+        results.push((0, shared_1.getNodeText)(ts, id, ast));
     }
     return results;
 }

package/lib/parsers/scriptRanges.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptRanges = parseScriptRanges;
+const shared_1 = require("../utils/shared");
 const scriptSetupRanges_1 = require("./scriptSetupRanges");
 function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
     let exportDefault;
@@ -29,7 +30,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                 let inheritAttrsOption;
                 ts.forEachChild(obj, node => {
                     if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
-                        const name = (0, scriptSetupRanges_1.getNodeText)(ts, node.name, ast);
+                        const name = _getNodeText(node.name);
                         if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
                             componentsOptionNode = node.initializer;
                         }
@@ -40,7 +41,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                             nameOptionNode = node.initializer;
                         }
                         else if (name === 'inheritAttrs') {
-                            inheritAttrsOption = (0, scriptSetupRanges_1.getNodeText)(ts, node.initializer, ast);
+                            inheritAttrsOption = _getNodeText(node.initializer);
                         }
                     }
                 });
@@ -69,7 +70,10 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
         bindings,
     };
     function _getStartEnd(node) {
-        return (0, scriptSetupRanges_1.getStartEnd)(ts, node, ast);
+        return (0, shared_1.getStartEnd)(ts, node, ast);
+    }
+    function _getNodeText(node) {
+        return (0, shared_1.getNodeText)(ts, node, ast);
     }
     // isAsExpression is missing in tsc
     function isAsExpression(node) {

package/lib/parsers/scriptSetupRanges.d.ts

@@ -73,7 +73,4 @@ export declare function parseBindingRanges(ts: typeof import('typescript'), ast:
     isDefaultImport?: boolean;
     isNamespace?: boolean;
 }[];
-export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, ast: ts.SourceFile): TextRange[];
-export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): TextRange;
-export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;
 export {};

package/lib/parsers/scriptSetupRanges.js

@@ -2,10 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptSetupRanges = parseScriptSetupRanges;
 exports.parseBindingRanges = parseBindingRanges;
-exports.findBindingVars = findBindingVars;
-exports.getStartEnd = getStartEnd;
-exports.getNodeText = getNodeText;
 const utils_1 = require("../codegen/utils");
+const shared_1 = require("../utils/shared");
 const tsCheckReg = /^\/\/\s*@ts-(?:no)?check($|\s)/;
 function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const defineProp = [];
@@ -42,7 +40,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 importSectionEndOffset = commentRange.pos;
             }
             else {
-                importSectionEndOffset = getStartEnd(ts, node, ast).start;
+                importSectionEndOffset = (0, shared_1.getStartEnd)(ts, node, ast).start;
             }
             foundNonImportExportNode = true;
         }
@@ -161,7 +159,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     defaultValue,
                     required,
                     isModel: isDefineModel,
-                    comments: getCommentsRange(ts, node, parents, ast),
+                    comments: getClosestMultiLineCommentRange(ts, node, parents, ast),
                     argNode: options,
                 });
             }
@@ -282,10 +280,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         };
     }
     function _getStartEnd(node) {
-        return getStartEnd(ts, node, ast);
+        return (0, shared_1.getStartEnd)(ts, node, ast);
     }
     function _getNodeText(node) {
-        return getNodeText(ts, node, ast);
+        return (0, shared_1.getNodeText)(ts, node, ast);
     }
 }
 function parseBindingRanges(ts, ast) {
@@ -353,10 +351,10 @@ function parseBindingRanges(ts, ast) {
     });
     return bindings;
     function _getStartEnd(node) {
-        return getStartEnd(ts, node, ast);
+        return (0, shared_1.getStartEnd)(ts, node, ast);
     }
     function _getNodeText(node) {
-        return getNodeText(ts, node, ast);
+        return (0, shared_1.getNodeText)(ts, node, ast);
     }
     function _findBindingVars(left) {
         return findBindingVars(ts, left, ast);
@@ -368,7 +366,7 @@ function findBindingVars(ts, left, ast) {
     return vars;
     function worker(node) {
         if (ts.isIdentifier(node)) {
-            vars.push(getStartEnd(ts, node, ast));
+            vars.push((0, shared_1.getStartEnd)(ts, node, ast));
         }
         // { ? } = ...
         // [ ? ] = ...
@@ -385,7 +383,7 @@ function findBindingVars(ts, left, ast) {
         }
         // { foo } = ...
         else if (ts.isShorthandPropertyAssignment(node)) {
-            vars.push(getStartEnd(ts, node.name, ast));
+            vars.push((0, shared_1.getStartEnd)(ts, node.name, ast));
         }
         // { ...? } = ...
         // [ ...? ] = ...
@@ -394,23 +392,13 @@ function findBindingVars(ts, left, ast) {
         }
     }
 }
-function getStartEnd(ts, node, ast) {
-    return {
-        start: ts.getTokenPosOfNode(node, ast),
-        end: node.end,
-    };
-}
-function getNodeText(ts, node, ast) {
-    const { start, end } = getStartEnd(ts, node, ast);
-    return ast.text.slice(start, end);
-}
 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, ast);
+                const range = (0, shared_1.getStartEnd)(ts, child, ast);
                 statementRange ??= range;
                 statementRange.end = range.end;
             });
@@ -418,22 +406,24 @@ function getStatementRange(ts, parents, node, ast) {
         }
     }
     if (!statementRange) {
-        statementRange = getStartEnd(ts, node, ast);
+        statementRange = (0, shared_1.getStartEnd)(ts, node, ast);
     }
     return statementRange;
 }
-function getCommentsRange(ts, node, parents, 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 comments = ts.getLeadingCommentRanges(ast.text, node.pos);
-    if (comments?.length) {
+    const comment = ts.getLeadingCommentRanges(ast.text, node.pos)
+        ?.reverse()
+        .find(range => range.kind === 3);
+    if (comment) {
         return {
-            start: comments[0].pos,
-            end: comments.at(-1).end,
+            start: comment.pos,
+            end: comment.end,
         };
     }
 }

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

@@ -138,6 +138,17 @@ export declare const tsCodegen: WeakMap<Sfc, {
     };
     getGeneratedTemplate: () => {
         codes: Code[];
+        currentInfo: {
+            ignoreError?: boolean;
+            expectError?: {
+                token: number;
+                node: import("@vue/compiler-dom").CommentNode;
+            };
+            generic?: {
+                content: string;
+                offset: number;
+            };
+        };
         codeFeatures: {
             all: import("../types").VueCodeInformation;
             none: import("../types").VueCodeInformation;
@@ -157,6 +168,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             withoutHighlightAndCompletionAndNavigation: import("../types").VueCodeInformation;
         };
         resolveCodeFeatures: (features: import("../types").VueCodeInformation) => import("../types").VueCodeInformation;
+        inVFor: boolean;
         slots: {
             name: string;
             offset?: number;
@@ -170,10 +182,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
         dollarVars: Set<string>;
         accessExternalVariables: Map<string, Set<number>>;
-        lastGenericComment: {
-            content: string;
-            offset: number;
-        } | undefined;
         blockConditions: string[];
         scopedClasses: {
             source: string;
@@ -187,24 +195,25 @@ export declare const tsCodegen: WeakMap<Sfc, {
         templateRefs: Map<string, {
             typeExp: string;
             offset: number;
-        }>;
+        }[]>;
         currentComponent: {
             ctxVar: string;
             used: boolean;
         } | undefined;
         singleRootElTypes: string[];
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
+        addTemplateRef(name: string, typeExp: string, offset: number): void;
         accessExternalVariable(name: string, offset?: number): void;
-        hasLocalVariable: (name: string) => boolean;
-        addLocalVariable: (name: string) => void;
-        removeLocalVariable: (name: string) => void;
-        getInternalVariable: () => string;
-        getHoistVariable: (originalVar: string) => string;
-        generateHoistVariables: () => Generator<string, void, unknown>;
-        ignoreError: () => Generator<Code>;
-        expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
-        resetDirectiveComments: (endStr: string) => Generator<Code>;
-        generateAutoImportCompletion: () => Generator<Code>;
+        hasLocalVariable(name: string): boolean;
+        addLocalVariable(name: string): void;
+        removeLocalVariable(name: string): void;
+        getInternalVariable(): string;
+        getHoistVariable(originalVar: string): string;
+        generateHoistVariables(): Generator<string, void, unknown>;
+        generateConditionGuards(): Generator<string, void, unknown>;
+        generateAutoImportCompletion(): Generator<Code>;
+        enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
+        exit(): Generator<Code>;
     } | undefined;
 }>;
 declare const plugin: VueLanguagePlugin;