@vue/language-core 3.3.5 → 3.3.7

package/lib/codegen/template/element.js

@@ -130,7 +130,7 @@ function* generateComponent(options, ctx, node) {
                     : codeFeatures_1.codeFeatures.doNotReportTs2339AndTs2551,
             });
             yield `]${utils_1.endOfLine}`;
-            if (utils_1.identifierRegex.test((0, shared_1.camelize)(tag))) {
+            if (utils_1.identifierRE.test((0, shared_1.camelize)(tag))) {
                 // navigation support
                 yield `/** @ts-ignore @type {`;
                 for (const offset of [startTagOffset, endTagOffset]) {
@@ -173,21 +173,22 @@ function* generateComponent(options, ctx, node) {
     yield propsStr;
     yield `}))${utils_1.endOfLine}`;
     yield `const `;
-    const token = yield* (0, boundary_1.startBoundary)('template', node.loc.start.offset, codeFeatures_1.codeFeatures.doNotReportTs6133);
+    const boundary = yield* boundary_1.Boundary.start('template', node.loc.start.offset, codeFeatures_1.codeFeatures.doNotReportTs6133);
     yield vnodeVar;
-    yield (0, boundary_1.endBoundary)(token, node.loc.end.offset);
+    yield boundary.end(node.loc.end.offset);
     yield ` = ${functionalVar}`;
-    if (ctx.currentInfo.generic) {
-        const { content, offset } = ctx.currentInfo.generic;
-        const token = yield* (0, boundary_1.startBoundary)('template', offset, codeFeatures_1.codeFeatures.verification);
+    const commentInfo = ctx.getCommentInfo();
+    if (commentInfo.generic) {
+        const { content, offset } = commentInfo.generic;
+        const boundary = yield* boundary_1.Boundary.start('template', offset, codeFeatures_1.codeFeatures.verification);
         yield `<`;
         yield [content, 'template', offset, codeFeatures_1.codeFeatures.all];
         yield `>`;
-        yield (0, boundary_1.endBoundary)(token, offset + content.length);
+        yield boundary.end(offset + content.length);
     }
     const shouldInheritAttrs = hasVBindAttrs(options, ctx, node);
     yield `(`;
-    const token2 = yield* (0, boundary_1.startBoundary)('template', startTagOffset, shouldInheritAttrs && options.vueCompilerOptions.checkRequiredFallthroughAttributes
+    const boundary2 = yield* boundary_1.Boundary.start('template', startTagOffset, shouldInheritAttrs && options.vueCompilerOptions.checkRequiredFallthroughAttributes
         ? {}
         : codeFeatures_1.codeFeatures.verification);
     yield `{`;
@@ -195,7 +196,7 @@ function* generateComponent(options, ctx, node) {
     yield utils_1.newLine;
     yield* propCodes;
     yield `}`;
-    yield (0, boundary_1.endBoundary)(token2, startTagOffset + tag.length);
+    yield boundary2.end(startTagOffset + tag.length);
     yield `, ...${names_1.names.functionalComponentArgsRest}(${functionalVar}))${utils_1.endOfLine}`;
     yield* generateFailedExpressions(options, ctx, failedPropExps);
     yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, componentVar, getCtxVar, getPropsVar);
@@ -228,16 +229,16 @@ function* generateComponent(options, ctx, node) {
             ctx.inheritedAttrVars.add(getPropsVar());
         }
     }
-    yield* generateStyleScopedClassReferences(options, node);
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(options, node);
     const slotDir = node.props.find(CompilerDOM.isVSlot);
     if (slotDir || node.children.length) {
         yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir, getCtxVar());
     }
     if (isCtxVarUsed) {
-        yield `var ${ctxVar}!: ${names_1.names.FunctionalComponentCtx}<typeof ${componentVar}, typeof ${vnodeVar}>${utils_1.endOfLine}`;
+        yield `var ${ctxVar}!: ${names_1.names.ExtractComponentContext}<typeof ${componentVar}, typeof ${vnodeVar}>${utils_1.endOfLine}`;
     }
     if (isPropsVarUsed) {
-        yield `var ${propsVar}!: ${names_1.names.FunctionalComponentProps}<typeof ${componentVar}, typeof ${vnodeVar}>${utils_1.endOfLine}`;
+        yield `var ${propsVar}!: ${names_1.names.ExtractComponentProps}<typeof ${componentVar}, typeof ${vnodeVar}>${utils_1.endOfLine}`;
     }
     ctx.components.pop();
 }
@@ -252,11 +253,11 @@ function* generateElement(options, ctx, node) {
         yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     }
     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, options.vueCompilerOptions.checkUnknownProps, failedPropExps);
     yield `}`;
-    yield (0, boundary_1.endBoundary)(token, startTagOffset + node.tag.length);
+    yield boundary.end(startTagOffset + node.tag.length);
     yield `)${utils_1.endOfLine}`;
     yield* generateFailedExpressions(options, ctx, failedPropExps);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
@@ -274,7 +275,7 @@ function* generateElement(options, ctx, node) {
     if (hasVBindAttrs(options, ctx, node)) {
         ctx.inheritedAttrVars.add(`${names_1.names.intrinsics}.${node.tag}`);
     }
-    yield* generateStyleScopedClassReferences(options, node);
+    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(options, node);
     for (const child of node.children) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
     }
@@ -284,103 +285,17 @@ function* generateFragment(options, ctx, node) {
     // special case for <template v-for="..." :key="..." />
     if (node.props.length) {
         yield `__VLS_asFunctionalElement(__VLS_intrinsics.template)(`;
-        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, options.vueCompilerOptions.checkUnknownProps);
         yield `}`;
-        yield (0, boundary_1.endBoundary)(token, startTagOffset + node.tag.length);
+        yield boundary.end(startTagOffset + node.tag.length);
         yield `)${utils_1.endOfLine}`;
     }
     for (const child of node.children) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, child);
     }
 }
-function* generateStyleScopedClassReferences({ template, typescript: ts }, node) {
-    for (const prop of node.props) {
-        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
-            && prop.name === 'class'
-            && prop.value) {
-            const [text, start] = (0, shared_2.normalizeAttributeValue)(prop.value);
-            for (const [className, offset] of forEachClassName(text)) {
-                yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, className, start + offset);
-            }
-        }
-        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-            && prop.arg.content === 'class') {
-            const content = '(' + prop.exp.content + ')';
-            const startOffset = prop.exp.loc.start.offset - 1;
-            const ast = (0, utils_1.getTypeScriptAST)(ts, template, content);
-            const literals = [];
-            for (const node of (0, utils_1.forEachNode)(ts, ast)) {
-                if (!ts.isExpressionStatement(node)
-                    || !ts.isParenthesizedExpression(node.expression)) {
-                    continue;
-                }
-                const { expression } = node.expression;
-                if (ts.isStringLiteralLike(expression)) {
-                    literals.push(expression);
-                }
-                else if (ts.isArrayLiteralExpression(expression)) {
-                    yield* walkArrayLiteral(expression);
-                }
-                else if (ts.isObjectLiteralExpression(expression)) {
-                    yield* walkObjectLiteral(expression);
-                }
-            }
-            for (const literal of literals) {
-                const start = literal.end - literal.text.length - 1 + startOffset;
-                for (const [className, offset] of forEachClassName(literal.text)) {
-                    yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, className, start + offset);
-                }
-            }
-            function* walkArrayLiteral(node) {
-                const { elements } = node;
-                for (const element of elements) {
-                    if (ts.isStringLiteralLike(element)) {
-                        literals.push(element);
-                    }
-                    else if (ts.isObjectLiteralExpression(element)) {
-                        yield* walkObjectLiteral(element);
-                    }
-                }
-            }
-            function* walkObjectLiteral(node) {
-                const { properties } = node;
-                for (const property of properties) {
-                    if (ts.isPropertyAssignment(property)) {
-                        const { name } = property;
-                        if (ts.isIdentifier(name)) {
-                            const text = (0, shared_2.getNodeText)(ts, name, ast);
-                            yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, text, name.end - text.length + startOffset);
-                        }
-                        else if (ts.isStringLiteral(name)) {
-                            literals.push(name);
-                        }
-                        else if (ts.isComputedPropertyName(name)) {
-                            const { expression } = name;
-                            if (ts.isStringLiteralLike(expression)) {
-                                literals.push(expression);
-                            }
-                        }
-                    }
-                    else if (ts.isShorthandPropertyAssignment(property)) {
-                        const text = (0, shared_2.getNodeText)(ts, property.name, ast);
-                        yield* (0, styleScopedClasses_1.generateStyleScopedClassReference)(template, text, property.name.end - text.length + startOffset);
-                    }
-                }
-            }
-        }
-    }
-}
-function* forEachClassName(content) {
-    let offset = 0;
-    for (const className of content.split(' ')) {
-        yield [className, offset];
-        offset += className.length + 1;
-    }
-}
 function* generateFailedExpressions(options, ctx, failedPropExps) {
     for (const { node, prefix, suffix } of failedPropExps) {
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, node.loc.source, node.loc.start.offset, prefix, suffix);

package/lib/codegen/template/elementDirectives.js

@@ -55,7 +55,7 @@ function* generateElementDirectives(options, ctx, node) {
             || prop.name === 'bind') {
             continue;
         }
-        const token = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+        const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
         yield `${names_1.names.asFunctionalDirective}(`;
         yield* generateIdentifier(options, ctx, prop);
         yield `, {} as import('${options.vueCompilerOptions.lib}').ObjectDirective)(null!, { ...${names_1.names.directiveBindingRestFields}, `;
@@ -63,14 +63,14 @@ function* generateElementDirectives(options, ctx, node) {
         yield* generateModifiers(options, ctx, prop);
         yield* generateValue(options, ctx, prop);
         yield ` }, null!, null!)`;
-        yield (0, boundary_1.endBoundary)(token, prop.loc.end.offset);
+        yield boundary.end(prop.loc.end.offset);
         yield utils_1.endOfLine;
     }
 }
 function* generateIdentifier(options, ctx, prop) {
     const rawName = 'v-' + prop.name;
     const startOffset = prop.loc.start.offset;
-    const token = yield* (0, boundary_1.startBoundary)('template', startOffset, codeFeatures_1.codeFeatures.verification);
+    const boundary = yield* boundary_1.Boundary.start('template', startOffset, codeFeatures_1.codeFeatures.verification);
     yield names_1.names.directives;
     yield `.`;
     yield* (0, camelized_1.generateCamelized)(rawName, 'template', prop.loc.start.offset, {
@@ -78,9 +78,9 @@ function* generateIdentifier(options, ctx, prop) {
         verification: options.vueCompilerOptions.checkUnknownDirectives && !(0, shared_1.isBuiltInDirective)(prop.name),
     });
     if (!(0, shared_1.isBuiltInDirective)(prop.name)) {
-        ctx.recordComponentAccess('template', (0, shared_1.camelize)(rawName), prop.loc.start.offset);
+        ctx.accessVariable('template', (0, shared_1.camelize)(rawName), prop.loc.start.offset);
     }
-    yield (0, boundary_1.endBoundary)(token, startOffset + rawName.length);
+    yield boundary.end(startOffset + rawName.length);
 }
 function* generateArg(options, ctx, prop) {
     const { arg } = prop;
@@ -88,9 +88,9 @@ function* generateArg(options, ctx, prop) {
         return;
     }
     const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
-    const token = yield* (0, boundary_1.startBoundary)('template', startOffset, codeFeatures_1.codeFeatures.verification);
+    const boundary = yield* boundary_1.Boundary.start('template', startOffset, codeFeatures_1.codeFeatures.verification);
     yield `arg`;
-    yield (0, boundary_1.endBoundary)(token, startOffset + arg.content.length);
+    yield boundary.end(startOffset + arg.content.length);
     yield `: `;
     if (arg.isStatic) {
         yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, codeFeatures_1.codeFeatures.all);
@@ -107,9 +107,9 @@ function* generateModifiers(options, ctx, prop, propertyName = 'modifiers') {
     }
     const startOffset = modifiers[0].loc.start.offset - 1;
     const endOffset = modifiers.at(-1).loc.end.offset;
-    const token = yield* (0, boundary_1.startBoundary)('template', startOffset, codeFeatures_1.codeFeatures.verification);
+    const boundary = yield* boundary_1.Boundary.start('template', startOffset, codeFeatures_1.codeFeatures.verification);
     yield propertyName;
-    yield (0, boundary_1.endBoundary)(token, endOffset);
+    yield boundary.end(endOffset);
     yield `: { `;
     for (const mod of modifiers) {
         yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlight);
@@ -122,9 +122,9 @@ function* generateValue(options, ctx, prop) {
     if (exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         return;
     }
-    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 `value`;
-    yield (0, boundary_1.endBoundary)(token, exp.loc.end.offset);
+    yield boundary.end(exp.loc.end.offset);
     yield `: `;
     yield* (0, elementProps_1.generatePropExp)(options, ctx, prop, exp);
 }

package/lib/codegen/template/elementEvents.js

@@ -40,9 +40,10 @@ exports.generateModelEventExpression = generateModelEventExpression;
 exports.isCompoundExpression = isCompoundExpression;
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const shared_1 = require("@vue/shared");
+const utils_1 = require("../../parsers/utils");
 const codeFeatures_1 = require("../codeFeatures");
 const names_1 = require("../names");
-const utils_1 = require("../utils");
+const utils_2 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
 const interpolation_1 = require("./interpolation");
@@ -94,14 +95,14 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, getCtx
         return;
     }
     const emitsVar = ctx.getInternalVariable();
-    yield `let ${emitsVar}!: ${names_1.names.ResolveEmits}<typeof ${componentOriginalVar}, typeof ${getCtxVar()}.emit>${utils_1.endOfLine}`;
+    yield `let ${emitsVar}!: ${names_1.names.ResolveEmits}<typeof ${componentOriginalVar}, typeof ${getCtxVar()}.emit>${utils_2.endOfLine}`;
     for (const { propPrefix, emitPrefix, propName, emitName, items } of Object.values(definitions)) {
-        yield `const ${ctx.getInternalVariable()}: ${names_1.names.ResolveEvent}<typeof ${getPropsVar()}, typeof ${emitsVar}, '${propName}', '${emitName}', '${(0, shared_1.camelize)(emitName)}'> = {${utils_1.newLine}`;
+        yield `const ${ctx.getInternalVariable()}: ${names_1.names.ResolveEvent}<typeof ${getPropsVar()}, typeof ${emitsVar}, '${propName}', '${emitName}', '${(0, shared_1.camelize)(emitName)}'> = {${utils_2.newLine}`;
         for (const { prop, source, offset } of items) {
             if (prop.name === 'on') {
                 yield `/** @type {typeof ${emitsVar}.`;
                 yield* generateEventArg(options, source, offset, emitPrefix.slice(0, -1), codeFeatures_1.codeFeatures.navigation);
-                yield `} */${utils_1.newLine}`;
+                yield `} */${utils_2.newLine}`;
             }
             if (prop.name === 'on') {
                 yield* generateEventArg(options, source, offset, propPrefix.slice(0, -1));
@@ -112,9 +113,9 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, getCtx
                 yield `'${propName}': `;
                 yield* generateModelEventExpression(options, ctx, prop);
             }
-            yield `,${utils_1.newLine}`;
+            yield `,${utils_2.newLine}`;
         }
-        yield `}${utils_1.endOfLine}`;
+        yield `}${utils_2.endOfLine}`;
     }
 }
 function* generateEventArg(options, name, start, directive = 'on', features) {
@@ -128,33 +129,40 @@ function* generateEventArg(options, name, start, directive = 'on', features) {
     if (directive.length) {
         name = (0, shared_1.capitalize)(name);
     }
-    if (utils_1.identifierRegex.test((0, shared_1.camelize)(name))) {
-        const token = yield* (0, boundary_1.startBoundary)('template', start, features);
+    if (utils_2.identifierRE.test((0, shared_1.camelize)(name))) {
+        const boundary = yield* boundary_1.Boundary.start('template', start, features);
         yield directive;
-        yield* (0, camelized_1.generateCamelized)(name, 'template', start, { __combineToken: token });
+        yield* (0, camelized_1.generateCamelized)(name, 'template', start, boundary.features);
     }
     else {
-        const token = yield* (0, boundary_1.startBoundary)('template', start, features);
+        const boundary = yield* boundary_1.Boundary.start('template', start, features);
         yield `'`;
         yield directive;
-        yield* (0, camelized_1.generateCamelized)(name, 'template', start, { __combineToken: token });
+        yield* (0, camelized_1.generateCamelized)(name, 'template', start, boundary.features);
         yield `'`;
-        yield (0, boundary_1.endBoundary)(token, start + name.length);
+        yield boundary.end(start + name.length);
     }
 }
 function* generateEventExpression(options, ctx, prop) {
     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        const ast = (0, utils_1.getTypeScriptAST)(options.typescript, options.template, prop.exp.content);
+        const ast = (0, utils_2.getTypeScriptAST)(options.typescript, options.template, prop.exp.content);
         const isCompound = isCompoundExpression(options.typescript, ast);
         const interpolation = (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, prop.exp.content, prop.exp.loc.start.offset, isCompound ? `` : `(`, isCompound ? `` : `)`);
         if (isCompound) {
-            yield `(...[$event]) => {${utils_1.newLine}`;
-            const endScope = ctx.startScope();
-            ctx.declare('$event');
+            yield `(...[$event]) => {${utils_2.newLine}`;
+            const scope = ctx.scope();
+            scope.declare('$event');
             yield* ctx.generateConditionGuards();
-            yield* interpolation;
-            yield utils_1.endOfLine;
-            yield* endScope();
+            if (isSingleExpression(options.typescript, ast)) {
+                yield `return (`;
+                yield* interpolation;
+                yield `)`;
+            }
+            else {
+                yield* interpolation;
+            }
+            yield utils_2.endOfLine;
+            yield* scope.end();
             yield `}`;
             ctx.inlayHints.push({
                 blockName: 'template',
@@ -179,10 +187,10 @@ function* generateEventExpression(options, ctx, prop) {
 }
 function* generateModelEventExpression(options, ctx, prop) {
     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        yield `(...[$event]) => {${utils_1.newLine}`;
+        yield `(...[$event]) => {${utils_2.newLine}`;
         yield* ctx.generateConditionGuards();
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.verification, prop.exp.content, prop.exp.loc.start.offset);
-        yield ` = $event${utils_1.endOfLine}`;
+        yield ` = $event${utils_2.endOfLine}`;
         yield `}`;
     }
     else {
@@ -190,35 +198,32 @@ function* generateModelEventExpression(options, ctx, prop) {
     }
 }
 function isCompoundExpression(ts, ast) {
-    let result = true;
     if (ast.statements.length === 0) {
-        result = false;
+        return false;
     }
-    else if (ast.statements.length === 1) {
-        ts.forEachChild(ast, child_1 => {
-            if (ts.isExpressionStatement(child_1)) {
-                ts.forEachChild(child_1, child_2 => {
-                    if (ts.isArrowFunction(child_2)) {
-                        result = false;
-                    }
-                    else if (isPropertyAccessOrId(ts, child_2)) {
-                        result = false;
-                    }
-                });
-            }
-            else if (ts.isFunctionDeclaration(child_1)) {
-                result = false;
+    if (ast.statements.length === 1 && ast.text[ast.endOfFileToken.pos - 1] !== ';') {
+        const statement = ast.statements[0];
+        if (ts.isExpressionStatement(statement)) {
+            const node = (0, utils_1.getUnwrappedExpression)(ts, statement.expression);
+            if (ts.isArrowFunction(node)
+                || ts.isIdentifier(node)
+                || ts.isElementAccessExpression(node)
+                || ts.isPropertyAccessExpression(node)) {
+                return false;
             }
-        });
+        }
+        else if (ts.isFunctionDeclaration(statement)) {
+            return false;
+        }
     }
-    return result;
+    return true;
 }
-function isPropertyAccessOrId(ts, node) {
-    if (ts.isIdentifier(node)) {
-        return true;
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-        return isPropertyAccessOrId(ts, node.expression);
+function isSingleExpression(ts, ast) {
+    if (ast.statements.length === 1 && ast.text[ast.endOfFileToken.pos - 1] !== ';') {
+        const statement = ast.statements[0];
+        if (ts.isExpressionStatement(statement)) {
+            return true;
+        }
     }
     return false;
 }

package/lib/codegen/template/elementProps.js

@@ -114,21 +114,21 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const token = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
             if (prop.arg) {
                 yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, features, shouldCamelize);
             }
             else {
-                const token2 = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
+                const boundary2 = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
                 yield propName;
-                yield (0, boundary_1.endBoundary)(token2, prop.loc.start.offset + 'v-model'.length);
+                yield boundary2.end(prop.loc.start.offset + 'v-model'.length);
             }
             yield `: `;
             const argLoc = prop.arg?.loc ?? prop.loc;
-            const token3 = yield* (0, boundary_1.startBoundary)('template', argLoc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary3 = yield* boundary_1.Boundary.start('template', argLoc.start.offset, codeFeatures_1.codeFeatures.verification);
             yield* generatePropExp(options, ctx, prop, prop.exp);
-            yield (0, boundary_1.endBoundary)(token3, argLoc.end.offset);
-            yield (0, boundary_1.endBoundary)(token, prop.loc.end.offset);
+            yield boundary3.end(argLoc.end.offset);
+            yield boundary.end(prop.loc.end.offset);
             if (shouldSpread) {
                 yield ` }`;
             }
@@ -153,7 +153,7 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const token = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
             const prefix = options.template.content.slice(prop.loc.start.offset, prop.loc.start.offset + 1);
             if (prefix === '.' || prefix === '#') {
                 // Pug shorthand syntax
@@ -174,7 +174,7 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             else {
                 yield `true`;
             }
-            yield (0, boundary_1.endBoundary)(token, prop.loc.end.offset);
+            yield boundary.end(prop.loc.end.offset);
             if (shouldSpread) {
                 yield ` }`;
             }
@@ -187,10 +187,10 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
                 failedPropExps?.push({ node: prop.exp, prefix: `(`, suffix: `)` });
             }
             else {
-                const token = yield* (0, boundary_1.startBoundary)('template', prop.exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+                const boundary = yield* boundary_1.Boundary.start('template', prop.exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
                 yield `...`;
                 yield* generatePropExp(options, ctx, prop, prop.exp);
-                yield (0, boundary_1.endBoundary)(token, prop.exp.loc.end.offset);
+                yield boundary.end(prop.exp.loc.end.offset);
                 yield `,${utils_1.newLine}`;
             }
         }
@@ -205,7 +205,7 @@ function* generatePropExp(options, ctx, prop, exp) {
     }
     else {
         const propVariableName = (0, shared_1.camelize)(exp.loc.source);
-        if (utils_1.identifierRegex.test(propVariableName)) {
+        if (utils_1.identifierRE.test(propVariableName)) {
             const codes = (0, camelized_1.generateCamelized)(exp.loc.source, 'template', exp.loc.start.offset, {
                 ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
                 __shorthandExpression: 'html',
@@ -218,7 +218,7 @@ function* generatePropExp(options, ctx, prop, exp) {
                 yield `.value`;
             }
             else {
-                ctx.recordComponentAccess('template', propVariableName, exp.loc.start.offset);
+                ctx.accessVariable('template', propVariableName, exp.loc.start.offset);
                 yield names_1.names.ctx;
                 yield `.`;
                 yield* codes;

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

@@ -14,8 +14,7 @@ export interface TemplateCodegenOptions {
 }
 export { generate as generateTemplate };
 declare function generate(options: TemplateCodegenOptions): {
-    generatedTypes: Set<string>;
-    currentInfo: {
+    getCommentInfo: () => {
         ignoreError?: boolean;
         expectError?: {
             token: number;
@@ -26,41 +25,70 @@ declare function generate(options: TemplateCodegenOptions): {
             offset: number;
         };
     };
+    enter: (node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode) => boolean;
+    exit: () => Generator<Code>;
     resolveCodeFeatures: (features: import("../../types").VueCodeInformation) => import("../../types").VueCodeInformation;
-    inVFor: boolean;
+    getInternalVariable: () => string;
+    scopes: {
+        add(value: string): /*elided*/ any;
+        declare(...variables: string[]): void;
+        end(): Generator<Code, any, any>;
+        clear(): void;
+        delete(value: string): boolean;
+        forEach(callbackfn: (value: string, value2: string, set: Set<string>) => void, thisArg?: any): void;
+        has(value: string): boolean;
+        readonly size: number;
+        [Symbol.iterator](): SetIterator<string>;
+        entries(): SetIterator<[string, string]>;
+        keys(): SetIterator<string>;
+        values(): SetIterator<string>;
+        readonly [Symbol.toStringTag]: string;
+    }[];
+    scope: () => {
+        add(value: string): any;
+        declare(...variables: string[]): void;
+        end(): Generator<Code, any, any>;
+        clear(): void;
+        delete(value: string): boolean;
+        forEach(callbackfn: (value: string, value2: string, set: Set<string>) => void, thisArg?: any): void;
+        has(value: string): boolean;
+        readonly size: number;
+        [Symbol.iterator](): SetIterator<string>;
+        entries(): SetIterator<[string, string]>;
+        keys(): SetIterator<string>;
+        values(): SetIterator<string>;
+        readonly [Symbol.toStringTag]: string;
+    };
+    contextAccesses: Map<string, Map<string, Set<number>>>;
+    accessVariable: (source: string, name: string, offset?: number) => void;
+    generateAutoImport: () => Generator<Code>;
+    conditions: string[];
+    generateConditionGuards: () => Generator<string, void, unknown>;
+    hoistVars: Map<string, string>;
+    getHoistVariable: (originalVar: string) => string;
+    generateHoistVariables: () => Generator<string, void, unknown>;
+    templateRefs: Map<string, {
+        typeExp: string;
+        offset: number;
+    }[]>;
+    addTemplateRef: (name: string, typeExp: string, offset: number) => void;
+    components: (() => string)[];
+    dollarVars: Set<string>;
+    inlayHints: import("../inlayHints").InlayHintInfo[];
+    generatedTypes: Set<string>;
+    inheritedAttrVars: Set<string>;
+    singleRootElTypes: Set<string>;
+    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
     slots: {
         name: string;
         offset?: number;
         tagRange: [number, number];
-        nodeLoc: any;
         propsVar: string;
     }[];
     dynamicSlots: {
         expVar: string;
         propsVar: string;
     }[];
-    dollarVars: Set<string>;
-    componentAccessMap: Map<string, Map<string, Set<number>>>;
-    blockConditions: string[];
-    inlayHints: import("../inlayHints").InlayHintInfo[];
-    inheritedAttrVars: Set<string>;
-    templateRefs: Map<string, {
-        typeExp: string;
-        offset: number;
-    }[]>;
-    singleRootElTypes: Set<string>;
-    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
-    addTemplateRef(name: string, typeExp: string, offset: number): void;
-    recordComponentAccess(source: string, name: string, offset?: number): void;
-    scopes: Set<string>[];
-    components: (() => string)[];
-    declare(...varNames: string[]): void;
-    startScope(): () => Generator<Code, any, any>;
-    getInternalVariable(): string;
-    getHoistVariable(originalVar: string): string;
-    generateHoistVariables(): Generator<string, void, unknown>;
-    generateConditionGuards(): Generator<string, void, unknown>;
-    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
-    exit(): Generator<Code>;
+    inVFor: boolean;
     codes: Code[];
 };