@vue/language-core 3.3.5 → 3.3.7

package/lib/codegen/template/index.js

@@ -21,14 +21,14 @@ function generate(options) {
     return { ...ctx, codes };
 }
 function* generateWorker(options, ctx) {
-    const endScope = ctx.startScope();
-    ctx.declare(...options.setupConsts);
+    const scope = ctx.scope();
+    scope.declare(...options.setupConsts);
     const { slotsAssignName, propsAssignName, vueCompilerOptions, template, } = options;
     if (slotsAssignName) {
-        ctx.declare(slotsAssignName);
+        scope.declare(slotsAssignName);
     }
     if (propsAssignName) {
-        ctx.declare(propsAssignName);
+        scope.declare(propsAssignName);
     }
     if (vueCompilerOptions.inferTemplateDollarSlots) {
         ctx.dollarVars.add('$slots');
@@ -73,7 +73,7 @@ function* generateWorker(options, ctx) {
         }
         yield `} & { [K in keyof import('${vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
     }
-    yield* endScope();
+    yield* scope.end();
 }
 function* generateSlotsType(options, ctx) {
     if (options.hasDefineSlots) {
@@ -94,9 +94,9 @@ function* generateSlotsType(options, ctx) {
             yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, codeFeatures_1.codeFeatures.navigation);
         }
         else {
-            const token = yield* (0, boundary_1.startBoundary)('template', slot.tagRange[0], codeFeatures_1.codeFeatures.navigation);
+            const boundary = yield* boundary_1.Boundary.start('template', slot.tagRange[0], codeFeatures_1.codeFeatures.navigation);
             yield `default`;
-            yield (0, boundary_1.endBoundary)(token, slot.tagRange[1]);
+            yield boundary.end(slot.tagRange[1]);
         }
         yield `?: (props: typeof ${slot.propsVar}) => any }`;
     }

package/lib/codegen/template/interpolation.js

@@ -45,12 +45,12 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
         }
         else {
             // #1205, #1264
-            const token = yield* (0, boundary_1.startBoundary)(block.name, start + offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start(block.name, start + offset, codeFeatures_1.codeFeatures.verification);
             if (ctx.dollarVars.has(name)) {
                 yield names_1.names.dollars;
             }
             else {
-                ctx.recordComponentAccess(block.name, name, start + offset);
+                ctx.accessVariable(block.name, name, start + offset);
                 yield names_1.names.ctx;
             }
             yield `.`;
@@ -62,7 +62,7 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
                     ? { ...data, __shorthandExpression: 'js' }
                     : data,
             ];
-            yield (0, boundary_1.endBoundary)(token, start + offset + name.length);
+            yield boundary.end(start + offset + name.length);
         }
         prevEnd = offset + name.length;
     }
@@ -79,22 +79,22 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
     }
 }
 function* forEachIdentifiers(ts, ctx, block, code, prefix, suffix) {
-    if (utils_1.identifierRegex.test(code) && !shouldIdentifierSkipped(ctx, code)) {
+    if (utils_1.identifierRE.test(code) && !shouldIdentifierSkipped(ctx, code)) {
         yield [code, 0, false];
         return;
     }
-    const endScope = ctx.startScope();
+    const scope = ctx.scope();
     const ast = (0, utils_1.getTypeScriptAST)(ts, block, prefix + code + suffix);
-    for (const [id, isShorthand] of forEachDeclarations(ts, ast, ast, ctx)) {
+    for (const [id, isShorthand] of forEachDeclarations(ts, ast, ast, ctx, scope)) {
         const text = (0, shared_2.getNodeText)(ts, id, ast);
         if (shouldIdentifierSkipped(ctx, text)) {
             continue;
         }
         yield [text, (0, shared_2.getStartEnd)(ts, id, ast).start - prefix.length, isShorthand];
     }
-    endScope();
+    scope.end();
 }
-function* forEachDeclarations(ts, node, ast, ctx) {
+function* forEachDeclarations(ts, node, ast, ctx, scope) {
     if (ts.isIdentifier(node)) {
         yield [node, false];
     }
@@ -102,16 +102,16 @@ function* forEachDeclarations(ts, node, ast, ctx) {
         yield [node.name, true];
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        yield* forEachDeclarations(ts, node.expression, ast, ctx);
+        yield* forEachDeclarations(ts, node.expression, ast, ctx, scope);
     }
     else if (ts.isVariableDeclaration(node)) {
-        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, node.name, ast));
-        yield* forEachDeclarationsInBinding(ts, node, ast, ctx);
+        scope.declare(...(0, collectBindings_1.collectBindingNames)(ts, node.name, ast));
+        yield* forEachDeclarationsInBinding(ts, node, ast, ctx, scope);
     }
     else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
         for (const element of node.elements) {
             if (ts.isBindingElement(element)) {
-                yield* forEachDeclarationsInBinding(ts, element, ast, ctx);
+                yield* forEachDeclarationsInBinding(ts, element, ast, ctx, scope);
             }
         }
     }
@@ -123,18 +123,18 @@ function* forEachDeclarations(ts, node, ast, ctx) {
             if (ts.isPropertyAssignment(prop)) {
                 // fix https://github.com/vuejs/language-tools/issues/1176
                 if (ts.isComputedPropertyName(prop.name)) {
-                    yield* forEachDeclarations(ts, prop.name.expression, ast, ctx);
+                    yield* forEachDeclarations(ts, prop.name.expression, ast, ctx, scope);
                 }
-                yield* forEachDeclarations(ts, prop.initializer, ast, ctx);
+                yield* forEachDeclarations(ts, prop.initializer, ast, ctx, scope);
             }
             // fix https://github.com/vuejs/language-tools/issues/1156
             else if (ts.isShorthandPropertyAssignment(prop)) {
-                yield* forEachDeclarations(ts, prop, ast, ctx);
+                yield* forEachDeclarations(ts, prop, ast, ctx, scope);
             }
             // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
             else if (ts.isSpreadAssignment(prop)) {
                 // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
-                yield* forEachDeclarations(ts, prop.expression, ast, ctx);
+                yield* forEachDeclarations(ts, prop.expression, ast, ctx, scope);
             }
             // fix https://github.com/vuejs/language-tools/issues/4604
             else if (ts.isFunctionLike(prop) && prop.body) {
@@ -147,39 +147,39 @@ function* forEachDeclarations(ts, node, ast, ctx) {
         yield* forEachDeclarationsInTypeNode(ts, node);
     }
     else if (ts.isBlock(node)) {
-        const endScope = ctx.startScope();
+        const scope = ctx.scope();
         for (const child of (0, utils_1.forEachNode)(ts, node)) {
-            yield* forEachDeclarations(ts, child, ast, ctx);
+            yield* forEachDeclarations(ts, child, ast, ctx, scope);
         }
-        endScope();
+        scope.end();
     }
     else {
         for (const child of (0, utils_1.forEachNode)(ts, node)) {
-            yield* forEachDeclarations(ts, child, ast, ctx);
+            yield* forEachDeclarations(ts, child, ast, ctx, scope);
         }
     }
 }
-function* forEachDeclarationsInBinding(ts, node, ast, ctx) {
+function* forEachDeclarationsInBinding(ts, node, ast, ctx, scope) {
     if ('type' in node && node.type) {
         yield* forEachDeclarationsInTypeNode(ts, node.type);
     }
     if (!ts.isIdentifier(node.name)) {
-        yield* forEachDeclarations(ts, node.name, ast, ctx);
+        yield* forEachDeclarations(ts, node.name, ast, ctx, scope);
     }
     if (node.initializer) {
-        yield* forEachDeclarations(ts, node.initializer, ast, ctx);
+        yield* forEachDeclarations(ts, node.initializer, ast, ctx, scope);
     }
 }
 function* forEachDeclarationsInFunction(ts, node, ast, ctx) {
-    const endScope = ctx.startScope();
+    const scope = ctx.scope();
     for (const param of node.parameters) {
-        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
-        yield* forEachDeclarationsInBinding(ts, param, ast, ctx);
+        scope.declare(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
+        yield* forEachDeclarationsInBinding(ts, param, ast, ctx, scope);
     }
     if (node.body) {
-        yield* forEachDeclarations(ts, node.body, ast, ctx);
+        yield* forEachDeclarations(ts, node.body, ast, ctx, scope);
     }
-    endScope();
+    scope.end();
 }
 function* forEachDeclarationsInTypeNode(ts, node) {
     if (ts.isTypeQueryNode(node)) {

package/lib/codegen/template/objectProperty.js

@@ -18,19 +18,19 @@ function* generateObjectProperty(options, ctx, code, offset, features, shouldCam
         }
     }
     else if (shouldCamelize) {
-        if (utils_1.identifierRegex.test((0, shared_1.camelize)(code))) {
+        if (utils_1.identifierRE.test((0, shared_1.camelize)(code))) {
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            const token = yield* (0, boundary_1.startBoundary)('template', offset, features);
+            const boundary = yield* boundary_1.Boundary.start('template', offset, features);
             yield `'`;
-            yield* (0, camelized_1.generateCamelized)(code, 'template', offset, { __combineToken: token });
+            yield* (0, camelized_1.generateCamelized)(code, 'template', offset, boundary.features);
             yield `'`;
-            yield (0, boundary_1.endBoundary)(token, offset + code.length);
+            yield boundary.end(offset + code.length);
         }
     }
     else {
-        if (utils_1.identifierRegex.test(code)) {
+        if (utils_1.identifierRE.test(code)) {
             yield [code, 'template', offset, features];
         }
         else {

package/lib/codegen/template/propertyAccess.js

@@ -8,7 +8,7 @@ function* generatePropertyAccess(options, ctx, code, offset, features) {
     if (code.startsWith('[') && code.endsWith(']')) {
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code, offset);
     }
-    else if (utils_1.identifierRegex.test(code)) {
+    else if (utils_1.identifierRE.test(code)) {
         yield `.`;
         yield [code, 'template', offset, features];
     }

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.d.ts

@@ -1,3 +1,6 @@
+import * as CompilerDOM from '@vue/compiler-dom';
 import type { Code, IRBlock } from '../../types';
+import type { TemplateCodegenOptions } from './index';
 export declare const references: WeakMap<IRBlock, [version: string, [className: string, offset: number][]]>;
+export declare function generateStyleScopedClassReferences({ template, typescript: ts }: TemplateCodegenOptions, node: CompilerDOM.ElementNode): Generator<Code>;
 export declare function generateStyleScopedClassReference(block: IRBlock, className: string, offset: number, fullStart?: number): Generator<Code>;

package/lib/codegen/template/styleScopedClasses.js

@@ -1,15 +1,137 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.references = void 0;
+exports.generateStyleScopedClassReferences = generateStyleScopedClassReferences;
 exports.generateStyleScopedClassReference = generateStyleScopedClassReference;
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
+const shared_1 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 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* 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_1.normalizeAttributeValue)(prop.value);
+            for (const [className, offset] of forEachClassName(text)) {
+                yield* 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* 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_1.getNodeText)(ts, name, ast);
+                            yield* 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_1.getNodeText)(ts, property.name, ast);
+                        yield* 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* generateStyleScopedClassReference(block, className, offset, fullStart = offset) {
     if (!className) {
         yield `/** @type {${names_1.names.StyleScopedClasses}['`;
@@ -27,11 +149,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>;