@vue/language-core 3.3.6 → 3.3.8

package/README.md

@@ -110,6 +110,7 @@ Configure Vue compiler behavior through the `vueCompilerOptions` field in `tscon
 | :--- | :--- | :--- | :--- |
 | `lib` | `string` | `'vue'` | Vue package name, used for generating import statements. |
 | `skipTemplateCodegen` | `boolean` | `false` | Skip virtual code generation for templates. |
+| `vapor` | `boolean` | `false` | Enable Vapor mode for all Vue SFCs. |
 | `fallthroughAttributes` | `boolean` | `false` | Enable type inference for fallthrough attributes. |
 | `checkRequiredFallthroughAttributes` | `boolean` | `false` | Check required fallthrough attributes. |
 | `jsxSlots` | `boolean` | `false` | Use JSX-style slots types. |

package/lib/codegen/script/index.js

@@ -61,7 +61,7 @@ function* generateWorker(options, ctx) {
             src = src.slice(0, -'.tsx'.length) + '.jsx';
         }
         yield `import ${names_1.names.src} from `;
-        const boundary = yield* boundary_1.Boundary.start('main', script.src.offset, {
+        const boundary = yield* boundary_1.Boundary.start('main', script.src.offset, script.src.offset + script.src.text.length, {
             ...codeFeatures_1.codeFeatures.all,
             ...src !== script.src.text ? codeFeatures_1.codeFeatures.navigationWithoutRename : {},
         });
@@ -69,7 +69,7 @@ function* generateWorker(options, ctx) {
         yield [src.slice(0, script.src.text.length), 'main', script.src.offset, boundary.features];
         yield src.slice(script.src.text.length);
         yield `'`;
-        yield boundary.end(script.src.offset + script.src.text.length);
+        yield boundary.end();
         yield utils_1.endOfLine;
         yield `export default ${names_1.names.src}${utils_1.endOfLine}`;
         yield* (0, template_1.generateTemplate)(options, ctx, names_1.names.src);
@@ -194,9 +194,9 @@ function* generateGlobalTypesReference({ typesRoot, lib, target, checkUnknownPro
 }
 function* generateExportDeclareEqual(block, name) {
     yield `const `;
-    const boundary = yield* boundary_1.Boundary.start(block.name, 0, codeFeatures_1.codeFeatures.doNotReportTs6133);
+    const boundary = yield* boundary_1.Boundary.start(block.name, 0, block.content.length, codeFeatures_1.codeFeatures.doNotReportTs6133);
     yield name;
-    yield boundary.end(block.content.length);
+    yield boundary.end();
     yield ` = `;
 }
 //# sourceMappingURL=index.js.map

package/lib/codegen/script/scriptSetup.js

@@ -161,9 +161,9 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, bo
         else {
             transforms.push((0, transform_1.insert)(callExp.end, function* () {
                 yield ` as ${type}[`;
-                const boundary = yield* boundary_1.Boundary.start(scriptSetup.name, exp.start, codeFeatures_1.codeFeatures.verification);
+                const boundary = yield* boundary_1.Boundary.start(scriptSetup.name, exp.start, exp.end, codeFeatures_1.codeFeatures.verification);
                 yield `'$style'`;
-                yield boundary.end(exp.end);
+                yield boundary.end();
                 yield `])`;
             }));
         }

package/lib/codegen/style/common.js

@@ -7,22 +7,22 @@ const utils_1 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 function* generateClassProperty(source, classNameWithDot, offset, propertyType) {
     yield `${utils_1.newLine} & { `;
-    const boundary = yield* boundary_1.Boundary.start(source, offset, codeFeatures_1.codeFeatures.navigation);
+    const boundary = yield* boundary_1.Boundary.start(source, offset, offset + classNameWithDot.length, codeFeatures_1.codeFeatures.navigation);
     yield `'`;
     yield [classNameWithDot.slice(1), source, offset + 1, boundary.features];
     yield `'`;
-    yield boundary.end(offset + classNameWithDot.length);
+    yield boundary.end();
     yield `: ${propertyType}`;
     yield ` }`;
 }
 function* generateStyleImports(style) {
     if (typeof style.src === 'object') {
         yield `${utils_1.newLine} & typeof import(`;
-        const boundary = yield* boundary_1.Boundary.start('main', style.src.offset, codeFeatures_1.codeFeatures.navigationAndVerification);
+        const boundary = yield* boundary_1.Boundary.start('main', style.src.offset, style.src.offset + style.src.text.length, codeFeatures_1.codeFeatures.navigationAndVerification);
         yield `'`;
         yield [style.src.text, 'main', style.src.offset, boundary.features];
         yield `'`;
-        yield boundary.end(style.src.offset + style.src.text.length);
+        yield boundary.end();
         yield `).default`;
     }
     for (const { text, offset } of style.imports) {

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

@@ -25,9 +25,9 @@ declare function generate(options: StyleCodegenOptions): {
     getInternalVariable: () => string;
     scopes: {
         add(value: string): /*elided*/ any;
+        clear(): void;
         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;
@@ -40,9 +40,9 @@ declare function generate(options: StyleCodegenOptions): {
     }[];
     scope: () => {
         add(value: string): any;
+        clear(): void;
         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;

package/lib/codegen/style/index.js

@@ -22,7 +22,7 @@ function generate(options) {
 function* generateWorker(options, ctx) {
     const scope = ctx.scope();
     scope.declare(...options.setupConsts);
-    yield* (0, scopedClasses_1.generateStyleScopedClasses)(options);
+    yield* (0, scopedClasses_1.generateStyleScopedClasses)(options, ctx);
     yield* (0, modules_1.generateStyleModules)(options, ctx);
     yield* generateCssVars(options, ctx);
     yield* scope.end();

package/lib/codegen/style/modules.d.ts

@@ -1,4 +1,4 @@
 import type { Code } from '../../types';
 import type { TemplateCodegenContext } from '../template/context';
 import type { StyleCodegenOptions } from '.';
-export declare function generateStyleModules({ styles, vueCompilerOptions }: StyleCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;
+export declare function generateStyleModules({ vueCompilerOptions, styles }: StyleCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/style/modules.js

@@ -5,7 +5,7 @@ const codeFeatures_1 = require("../codeFeatures");
 const names_1 = require("../names");
 const utils_1 = require("../utils");
 const common_1 = require("./common");
-function* generateStyleModules({ styles, vueCompilerOptions }, ctx) {
+function* generateStyleModules({ vueCompilerOptions, styles }, ctx) {
     const styleModules = styles.filter(style => style.module);
     if (!styleModules.length) {
         return;

package/lib/codegen/style/scopedClasses.d.ts

@@ -1,3 +1,4 @@
 import type { Code } from '../../types';
+import type { TemplateCodegenContext } from '../template/context';
 import type { StyleCodegenOptions } from '.';
-export declare function generateStyleScopedClasses({ vueCompilerOptions, styles }: StyleCodegenOptions): Generator<Code>;
+export declare function generateStyleScopedClasses({ vueCompilerOptions, styles }: StyleCodegenOptions, ctx: TemplateCodegenContext): Generator<Code>;

package/lib/codegen/style/scopedClasses.js

@@ -5,7 +5,7 @@ const names_1 = require("../names");
 const styleScopedClasses_1 = require("../template/styleScopedClasses");
 const utils_1 = require("../utils");
 const common_1 = require("./common");
-function* generateStyleScopedClasses({ vueCompilerOptions, styles }) {
+function* generateStyleScopedClasses({ vueCompilerOptions, styles }, ctx) {
     const { resolveStyleClassNames, resolveStyleImports } = vueCompilerOptions;
     if (!resolveStyleClassNames) {
         return;
@@ -14,8 +14,9 @@ function* generateStyleScopedClasses({ vueCompilerOptions, styles }) {
     if (!scopedStyles.length) {
         return;
     }
+    ctx.generatedTypes.add(names_1.names.StyleScopedClasses);
     const visited = new Set();
-    const deferredGenerations = [];
+    const deferredGenerates = [];
     yield `type ${names_1.names.StyleScopedClasses} = {}`;
     for (const style of scopedStyles) {
         if (resolveStyleImports) {
@@ -27,12 +28,12 @@ function* generateStyleScopedClasses({ vueCompilerOptions, styles }) {
                 yield* (0, common_1.generateClassProperty)(style.name, className.text, className.offset, 'boolean');
             }
             else {
-                deferredGenerations.push((0, styleScopedClasses_1.generateStyleScopedClassReference)(style, className.text.slice(1), className.offset + 1));
+                deferredGenerates.push((0, styleScopedClasses_1.generateStyleScopedClassReference)(style, className.text.slice(1), className.offset + 1));
             }
         }
     }
     yield utils_1.endOfLine;
-    for (const generate of deferredGenerations) {
+    for (const generate of deferredGenerates) {
         yield* generate;
     }
 }

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

@@ -20,9 +20,9 @@ export declare function createTemplateCodegenContext(): {
     getInternalVariable: () => string;
     scopes: {
         add(value: string): /*elided*/ any;
+        clear(): void;
         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;
@@ -35,9 +35,9 @@ export declare function createTemplateCodegenContext(): {
     }[];
     scope: () => {
         add(value: string): any;
+        clear(): void;
         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;

package/lib/codegen/template/context.js

@@ -94,13 +94,13 @@ function createTemplateCodegenContext() {
         const info = stack.pop();
         commentBuffer.length = 0;
         if (info.expectError !== undefined) {
-            const boundary = yield* boundary_1.Boundary.start('template', info.expectError.node.loc.start.offset, {
+            const boundary = yield* boundary_1.Boundary.start('template', info.expectError.node.loc.start.offset, info.expectError.node.loc.end.offset, {
                 verification: {
                     shouldReport: () => info.expectError.token === 0,
                 },
             });
             yield `// @ts-expect-error`;
-            yield boundary.end(info.expectError.node.loc.end.offset);
+            yield boundary.end();
             yield `${utils_1.newLine}${utils_1.endOfLine}`;
         }
     }

package/lib/codegen/template/element.js

@@ -173,22 +173,22 @@ function* generateComponent(options, ctx, node) {
     yield propsStr;
     yield `}))${utils_1.endOfLine}`;
     yield `const `;
-    const boundary = yield* boundary_1.Boundary.start('template', node.loc.start.offset, codeFeatures_1.codeFeatures.doNotReportTs6133);
+    const boundary = yield* boundary_1.Boundary.start('template', node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.doNotReportTs6133);
     yield vnodeVar;
-    yield boundary.end(node.loc.end.offset);
+    yield boundary.end();
     yield ` = ${functionalVar}`;
     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);
+        const boundary = yield* boundary_1.Boundary.start('template', offset, offset + content.length, codeFeatures_1.codeFeatures.verification);
         yield `<`;
         yield [content, 'template', offset, codeFeatures_1.codeFeatures.all];
         yield `>`;
-        yield boundary.end(offset + content.length);
+        yield boundary.end();
     }
     const shouldInheritAttrs = hasVBindAttrs(options, ctx, node);
     yield `(`;
-    const boundary2 = yield* boundary_1.Boundary.start('template', startTagOffset, shouldInheritAttrs && options.vueCompilerOptions.checkRequiredFallthroughAttributes
+    const boundary2 = yield* boundary_1.Boundary.start('template', startTagOffset, startTagOffset + tag.length, shouldInheritAttrs && options.vueCompilerOptions.checkRequiredFallthroughAttributes
         ? {}
         : codeFeatures_1.codeFeatures.verification);
     yield `{`;
@@ -196,7 +196,7 @@ function* generateComponent(options, ctx, node) {
     yield utils_1.newLine;
     yield* propCodes;
     yield `}`;
-    yield boundary2.end(startTagOffset + tag.length);
+    yield boundary2.end();
     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);
@@ -229,7 +229,7 @@ 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());
@@ -253,11 +253,11 @@ function* generateElement(options, ctx, node) {
         yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, node.tag, endTagOffset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
     }
     yield `)(`;
-    const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+    const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, startTagOffset + node.tag.length, codeFeatures_1.codeFeatures.verification);
     yield `{${utils_1.newLine}`;
     yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props, options.vueCompilerOptions.checkUnknownProps, failedPropExps);
     yield `}`;
-    yield boundary.end(startTagOffset + node.tag.length);
+    yield boundary.end();
     yield `)${utils_1.endOfLine}`;
     yield* generateFailedExpressions(options, ctx, failedPropExps);
     yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
@@ -275,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);
     }
@@ -285,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 boundary = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+        const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, startTagOffset + node.tag.length, codeFeatures_1.codeFeatures.verification);
         yield `{${utils_1.newLine}`;
         yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props, options.vueCompilerOptions.checkUnknownProps);
         yield `}`;
-        yield boundary.end(startTagOffset + node.tag.length);
+        yield boundary.end();
         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.d.ts

@@ -3,4 +3,4 @@ import type { Code } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
 export declare function generateElementDirectives(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;
-export declare function generateModifiers(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode, propertyName?: string): Generator<Code>;
+export declare function generateModifiers(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, prop: CompilerDOM.DirectiveNode, propertyName?: string, asBindingProperty?: boolean): Generator<Code>;

package/lib/codegen/template/elementDirectives.js

@@ -55,22 +55,33 @@ function* generateElementDirectives(options, ctx, node) {
             || prop.name === 'bind') {
             continue;
         }
-        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}, `;
-        yield* generateArg(options, ctx, prop);
-        yield* generateModifiers(options, ctx, prop);
-        yield* generateValue(options, ctx, prop);
-        yield ` }, null!, null!)`;
-        yield boundary.end(prop.loc.end.offset);
+        const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, prop.loc.end.offset, codeFeatures_1.codeFeatures.verification);
+        if (options.isVapor && !(0, shared_1.isBuiltInDirective)(prop.name)) {
+            // vapor custom directives receive a value getter instead of a vdom binding object
+            yield* generateIdentifier(options, ctx, prop);
+            yield `(null!, `;
+            yield* generateValue(options, ctx, prop, false);
+            yield* generateArg(options, ctx, prop, false);
+            yield* generateModifiers(options, ctx, prop, 'modifiers', false);
+            yield `)`;
+        }
+        else {
+            yield `${names_1.names.asFunctionalDirective}(`;
+            yield* generateIdentifier(options, ctx, prop);
+            yield `, {} as import('${options.vueCompilerOptions.lib}').ObjectDirective)(null!, { ...${names_1.names.directiveBindingRestFields}, `;
+            yield* generateArg(options, ctx, prop);
+            yield* generateModifiers(options, ctx, prop);
+            yield* generateValue(options, ctx, prop);
+            yield `}, null!, null!)`;
+        }
+        yield boundary.end();
         yield utils_1.endOfLine;
     }
 }
 function* generateIdentifier(options, ctx, prop) {
     const rawName = 'v-' + prop.name;
     const startOffset = prop.loc.start.offset;
-    const boundary = yield* boundary_1.Boundary.start('template', startOffset, codeFeatures_1.codeFeatures.verification);
+    const boundary = yield* boundary_1.Boundary.start('template', startOffset, startOffset + rawName.length, codeFeatures_1.codeFeatures.verification);
     yield names_1.names.directives;
     yield `.`;
     yield* (0, camelized_1.generateCamelized)(rawName, 'template', prop.loc.start.offset, {
@@ -80,52 +91,69 @@ function* generateIdentifier(options, ctx, prop) {
     if (!(0, shared_1.isBuiltInDirective)(prop.name)) {
         ctx.accessVariable('template', (0, shared_1.camelize)(rawName), prop.loc.start.offset);
     }
-    yield boundary.end(startOffset + rawName.length);
+    yield boundary.end();
 }
-function* generateArg(options, ctx, prop) {
+function* generateArg(options, ctx, prop, asBindingProperty = true) {
     const { arg } = prop;
-    if (arg?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        return;
-    }
-    const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
-    const boundary = yield* boundary_1.Boundary.start('template', startOffset, codeFeatures_1.codeFeatures.verification);
-    yield `arg`;
-    yield boundary.end(startOffset + arg.content.length);
-    yield `: `;
-    if (arg.isStatic) {
-        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, codeFeatures_1.codeFeatures.all);
+    if (arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const startOffset = arg.loc.start.offset + arg.loc.source.indexOf(arg.content);
+        if (asBindingProperty) {
+            const boundary = yield* boundary_1.Boundary.start('template', startOffset, startOffset + arg.content.length, codeFeatures_1.codeFeatures.verification);
+            yield `arg`;
+            yield boundary.end();
+            yield `: `;
+        }
+        if (arg.isStatic) {
+            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, codeFeatures_1.codeFeatures.all);
+        }
+        else {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, arg.content, startOffset, `(`, `)`);
+        }
+        yield `, `;
     }
-    else {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, arg.content, startOffset, `(`, `)`);
+    else if (!asBindingProperty) {
+        yield `undefined, `;
     }
-    yield `, `;
 }
-function* generateModifiers(options, ctx, prop, propertyName = 'modifiers') {
+function* generateModifiers(options, ctx, prop, propertyName = 'modifiers', asBindingProperty = true) {
     const { modifiers } = prop;
-    if (!modifiers.length) {
-        return;
+    if (modifiers.length) {
+        if (asBindingProperty) {
+            const boundary = yield* boundary_1.Boundary.start('template', modifiers[0].loc.start.offset - 1, modifiers.at(-1).loc.end.offset, codeFeatures_1.codeFeatures.verification);
+            yield propertyName;
+            yield boundary.end();
+            yield `: `;
+        }
+        yield `{ `;
+        for (const mod of modifiers) {
+            yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, mod.content, mod.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlight);
+            yield `: true, `;
+        }
+        yield `}, `;
     }
-    const startOffset = modifiers[0].loc.start.offset - 1;
-    const endOffset = modifiers.at(-1).loc.end.offset;
-    const boundary = yield* boundary_1.Boundary.start('template', startOffset, codeFeatures_1.codeFeatures.verification);
-    yield propertyName;
-    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);
-        yield `: true, `;
+    else if (!asBindingProperty) {
+        yield `undefined, `;
     }
-    yield `}, `;
 }
-function* generateValue(options, ctx, prop) {
+function* generateValue(options, ctx, prop, asBindingProperty = true) {
     const { exp } = prop;
-    if (exp?.type !== CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        return;
+    if (exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const boundary = yield* boundary_1.Boundary.start('template', exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification);
+        if (asBindingProperty) {
+            yield `value`;
+            yield boundary.end();
+            yield `: `;
+            yield* (0, elementProps_1.generatePropExp)(options, ctx, prop, exp);
+        }
+        else {
+            yield `() => `;
+            yield* (0, elementProps_1.generatePropExp)(options, ctx, prop, exp);
+            yield boundary.end();
+        }
+        yield `, `;
+    }
+    else if (!asBindingProperty) {
+        yield `undefined, `;
     }
-    const boundary = yield* boundary_1.Boundary.start('template', exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
-    yield `value`;
-    yield boundary.end(exp.loc.end.offset);
-    yield `: `;
-    yield* (0, elementProps_1.generatePropExp)(options, ctx, prop, exp);
 }
 //# sourceMappingURL=elementDirectives.js.map

package/lib/codegen/template/elementEvents.js

@@ -129,18 +129,17 @@ function* generateEventArg(options, name, start, directive = 'on', features) {
     if (directive.length) {
         name = (0, shared_1.capitalize)(name);
     }
+    const boundary = yield* boundary_1.Boundary.start('template', start, start + name.length, 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, boundary.features);
     }
     else {
-        const boundary = yield* boundary_1.Boundary.start('template', start, features);
         yield `'`;
         yield directive;
         yield* (0, camelized_1.generateCamelized)(name, 'template', start, boundary.features);
         yield `'`;
-        yield boundary.end(start + name.length);
+        yield boundary.end();
     }
 }
 function* generateEventExpression(options, ctx, prop) {
@@ -154,9 +153,13 @@ function* generateEventExpression(options, ctx, prop) {
             scope.declare('$event');
             yield* ctx.generateConditionGuards();
             if (isSingleExpression(options.typescript, ast)) {
-                yield `return `;
+                yield `return (`;
+                yield* interpolation;
+                yield `)`;
+            }
+            else {
+                yield* interpolation;
             }
-            yield* interpolation;
             yield utils_2.endOfLine;
             yield* scope.end();
             yield `}`;

package/lib/codegen/template/elementProps.js

@@ -114,21 +114,21 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, prop.loc.end.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 boundary2 = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
+                const boundary2 = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
                 yield propName;
-                yield boundary2.end(prop.loc.start.offset + 'v-model'.length);
+                yield boundary2.end();
             }
             yield `: `;
             const argLoc = prop.arg?.loc ?? prop.loc;
-            const boundary3 = yield* boundary_1.Boundary.start('template', argLoc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary3 = yield* boundary_1.Boundary.start('template', argLoc.start.offset, argLoc.end.offset, codeFeatures_1.codeFeatures.verification);
             yield* generatePropExp(options, ctx, prop, prop.exp);
-            yield boundary3.end(argLoc.end.offset);
-            yield boundary.end(prop.loc.end.offset);
+            yield boundary3.end();
+            yield boundary.end();
             if (shouldSpread) {
                 yield ` }`;
             }
@@ -153,7 +153,7 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, prop.loc.end.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 boundary.end(prop.loc.end.offset);
+            yield boundary.end();
             if (shouldSpread) {
                 yield ` }`;
             }
@@ -187,10 +187,10 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
                 failedPropExps?.push({ node: prop.exp, prefix: `(`, suffix: `)` });
             }
             else {
-                const boundary = yield* boundary_1.Boundary.start('template', prop.exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+                const boundary = yield* boundary_1.Boundary.start('template', prop.exp.loc.start.offset, prop.exp.loc.end.offset, codeFeatures_1.codeFeatures.verification);
                 yield `...`;
                 yield* generatePropExp(options, ctx, prop, prop.exp);
-                yield boundary.end(prop.exp.loc.end.offset);
+                yield boundary.end();
                 yield `,${utils_1.newLine}`;
             }
         }

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

@@ -4,6 +4,7 @@ export interface TemplateCodegenOptions {
     typescript: typeof ts;
     vueCompilerOptions: VueCompilerOptions;
     template: IRTemplate;
+    isVapor: boolean;
     setupRefs: Set<string>;
     setupConsts: Set<string>;
     hasDefineSlots?: boolean;
@@ -31,9 +32,9 @@ declare function generate(options: TemplateCodegenOptions): {
     getInternalVariable: () => string;
     scopes: {
         add(value: string): /*elided*/ any;
+        clear(): void;
         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;
@@ -46,9 +47,9 @@ declare function generate(options: TemplateCodegenOptions): {
     }[];
     scope: () => {
         add(value: string): any;
+        clear(): void;
         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;

package/lib/codegen/template/index.js

@@ -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 boundary = yield* boundary_1.Boundary.start('template', slot.tagRange[0], codeFeatures_1.codeFeatures.navigation);
+            const boundary = yield* boundary_1.Boundary.start('template', ...slot.tagRange, codeFeatures_1.codeFeatures.navigation);
             yield `default`;
-            yield boundary.end(slot.tagRange[1]);
+            yield boundary.end();
         }
         yield `?: (props: typeof ${slot.propsVar}) => any }`;
     }

package/lib/codegen/template/interpolation.js

@@ -45,7 +45,7 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
         }
         else {
             // #1205, #1264
-            const boundary = yield* boundary_1.Boundary.start(block.name, start + offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start(block.name, start + offset, start + offset + name.length, codeFeatures_1.codeFeatures.verification);
             if (ctx.dollarVars.has(name)) {
                 yield names_1.names.dollars;
             }
@@ -62,7 +62,7 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
                     ? { ...data, __shorthandExpression: 'js' }
                     : data,
             ];
-            yield boundary.end(start + offset + name.length);
+            yield boundary.end();
         }
         prevEnd = offset + name.length;
     }

package/lib/codegen/template/objectProperty.js

@@ -22,11 +22,11 @@ function* generateObjectProperty(options, ctx, code, offset, features, shouldCam
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            const boundary = yield* boundary_1.Boundary.start('template', offset, features);
+            const boundary = yield* boundary_1.Boundary.start('template', offset, offset + code.length, features);
             yield `'`;
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, boundary.features);
             yield `'`;
-            yield boundary.end(offset + code.length);
+            yield boundary.end();
         }
     }
     else {

package/lib/codegen/template/slotOutlet.js

@@ -77,26 +77,26 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            const boundary = yield* boundary_1.Boundary.start('template', nameProp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification);
             yield options.slotsAssignName ?? names_1.names.slots;
             yield* codes;
-            yield boundary.end(nameProp.loc.end.offset);
+            yield boundary.end();
         }
         else {
-            const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification);
             yield `${options.slotsAssignName ?? names_1.names.slots}[`;
-            const boundary2 = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+            const boundary2 = yield* boundary_1.Boundary.start('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification);
             yield `'default'`;
-            yield boundary2.end(startTagEndOffset);
+            yield boundary2.end();
             yield `]`;
-            yield boundary.end(startTagEndOffset);
+            yield boundary.end();
         }
         yield `)(`;
-        const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, codeFeatures_1.codeFeatures.verification);
+        const boundary = yield* boundary_1.Boundary.start('template', startTagOffset, startTagEndOffset, 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 boundary.end(startTagEndOffset);
+        yield boundary.end();
         yield `)${utils_1.endOfLine}`;
     }
     else {

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,7 +1,43 @@
 "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");
@@ -10,6 +46,92 @@ const escaped_1 = require("../utils/escaped");
 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 boundary = yield* boundary_1.Boundary.start(block.name, fullStart, codeFeatures_1.codeFeatures.navigationAndCompletion);
+    const boundary = yield* boundary_1.Boundary.start(block.name, fullStart, offset + className.length, codeFeatures_1.codeFeatures.navigationAndCompletion);
     yield `'`;
     yield* (0, escaped_1.generateEscaped)(className, block.name, offset, boundary.features, classNameEscapeRE);
     yield `'`;
-    yield boundary.end(offset + className.length);
+    yield boundary.end();
     yield `]} */${utils_1.endOfLine}`;
 }
 //# sourceMappingURL=styleScopedClasses.js.map

package/lib/codegen/template/vSlot.js

@@ -53,17 +53,17 @@ 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 boundary = yield* boundary_1.Boundary.start('template', slotDir.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
+            const boundary = yield* boundary_1.Boundary.start('template', slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
             yield `default`;
-            yield boundary.end(slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0));
+            yield boundary.end();
         }
     }
     else {
         yield `const { `;
         // #932: reference for implicit default slot
-        const boundary = yield* boundary_1.Boundary.start('template', node.loc.start.offset, codeFeatures_1.codeFeatures.navigation);
+        const boundary = yield* boundary_1.Boundary.start('template', node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.navigation);
         yield `default`;
-        yield boundary.end(node.loc.end.offset);
+        yield boundary.end();
     }
     yield `: ${slotVar} } = ${ctxVar}.slots!${utils_1.endOfLine}`;
     const scope = ctx.scope();
@@ -129,11 +129,11 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     yield `] = ${names_1.names.vSlot}(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
-        const boundary = yield* boundary_1.Boundary.start('template', exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+        const boundary = yield* boundary_1.Boundary.start('template', exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification);
         yield `(`;
         yield* types.flatMap(type => type ? [`_`, type, `, `] : `_, `);
         yield `) => [] as any`;
-        yield boundary.end(exp.loc.end.offset);
+        yield boundary.end();
     }
     yield `)${utils_1.endOfLine}`;
 }

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

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

package/lib/codegen/utils/boundary.js

@@ -2,17 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Boundary = void 0;
 class Boundary {
-    constructor(source, features) {
+    constructor(source, endOffset, features) {
         this.source = source;
+        this.endOffset = endOffset;
         this.features = features;
     }
-    static *start(source, offset, features) {
+    static *start(source, start, end, features) {
         features = { ...features, __combineToken: Symbol() };
-        yield [``, source, offset, features];
-        return new Boundary(source, features);
+        yield [``, source, start, features];
+        return new Boundary(source, end, features);
     }
-    end(offset) {
-        return [``, this.source, offset, this.features];
+    end() {
+        return [``, this.source, this.endOffset, this.features];
     }
 }
 exports.Boundary = Boundary;

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

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

package/lib/codegen/utils/stringLiteralKey.js

@@ -2,16 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStringLiteralKey = generateStringLiteralKey;
 const boundary_1 = require("./boundary");
-function* generateStringLiteralKey(code, offset, info) {
-    if (offset === undefined || !info) {
-        yield `'${code}'`;
-    }
-    else {
-        const boundary = yield* boundary_1.Boundary.start('template', offset, info);
-        yield `'`;
-        yield [code, 'template', offset, boundary.features];
-        yield `'`;
-        yield boundary.end(offset + code.length);
-    }
+function* generateStringLiteralKey(code, offset, features) {
+    const boundary = yield* boundary_1.Boundary.start('template', offset, offset + code.length, features);
+    yield `'`;
+    yield [code, 'template', offset, boundary.features];
+    yield `'`;
+    yield boundary.end();
 }
 //# sourceMappingURL=stringLiteralKey.js.map

package/lib/codegen/utils/unicode.js

@@ -4,9 +4,9 @@ exports.generateUnicode = generateUnicode;
 const boundary_1 = require("./boundary");
 function* generateUnicode(code, offset, features) {
     if (needToUnicode(code)) {
-        const boundary = yield* boundary_1.Boundary.start('template', offset, features);
+        const boundary = yield* boundary_1.Boundary.start('template', offset, offset + code.length, features);
         yield toUnicode(code);
-        yield boundary.end(offset + code.length);
+        yield boundary.end();
     }
     else {
         yield [code, 'template', offset, features];

package/lib/compilerOptions.js

@@ -210,6 +210,7 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         inferTemplateDollarRefs: false,
         inferTemplateDollarSlots: false,
         skipTemplateCodegen: false,
+        vapor: false,
         fallthroughAttributes: false,
         checkRequiredFallthroughAttributes: false,
         resolveStyleImports: false,

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

@@ -67,9 +67,9 @@ export declare const tsCodegen: WeakMap<IR, {
         getInternalVariable: () => string;
         scopes: {
             add(value: string): /*elided*/ any;
+            clear(): void;
             declare(...variables: string[]): void;
             end(): Generator<import("../types").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;
@@ -82,9 +82,9 @@ export declare const tsCodegen: WeakMap<IR, {
         }[];
         scope: () => {
             add(value: string): any;
+            clear(): void;
             declare(...variables: string[]): void;
             end(): Generator<import("../types").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;

package/lib/plugins/vue-tsx.js

@@ -93,6 +93,7 @@ function useCodegen(ts, vueCompilerOptions, fileName, ir) {
         }
         return vueCompilerOptions;
     });
+    const getIsVapor = (0, alien_signals_1.computed)(() => getResolvedOptions().vapor || !!(ir.scriptSetup?.attrs.vapor || ir.template?.attrs.vapor));
     const getScriptRanges = (0, alien_signals_1.computed)(() => ir.script && validLangs.has(ir.script.lang)
         ? (0, scriptRanges_1.parseScriptRanges)(ts, ir.script.ast, getResolvedOptions())
         : undefined);
@@ -182,6 +183,7 @@ function useCodegen(ts, vueCompilerOptions, fileName, ir) {
             typescript: ts,
             vueCompilerOptions: getResolvedOptions(),
             template: ir.template,
+            isVapor: getIsVapor(),
             componentName: getComponentName(),
             setupConsts: getSetupConsts(),
             setupRefs: getSetupRefs(),

package/lib/types.d.ts

@@ -43,6 +43,7 @@ export interface VueCompilerOptions {
     inferTemplateDollarRefs: boolean;
     inferTemplateDollarSlots: boolean;
     skipTemplateCodegen: boolean;
+    vapor: boolean;
     fallthroughAttributes: boolean;
     checkRequiredFallthroughAttributes: boolean;
     resolveStyleImports: boolean;
@@ -71,7 +72,7 @@ export interface VueCompilerOptions {
 }
 export declare const validVersions: readonly [2, 2.1, 2.2];
 export interface VueLanguagePluginReturn {
-    version: (typeof validVersions)[number];
+    version: typeof validVersions[number];
     name?: string;
     order?: number;
     requiredCompilerOptions?: string[];

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.3.6",
+	"version": "3.3.8",
 	"license": "MIT",
 	"files": [
 		"index.d.ts",
@@ -22,17 +22,17 @@
 		"@volar/language-core": "2.4.28",
 		"@vue/compiler-dom": "^3.5.0",
 		"@vue/shared": "^3.5.0",
-		"alien-signals": "^3.2.0",
+		"alien-signals": "^3.2.1",
 		"muggle-string": "^0.4.1",
 		"path-browserify": "^1.0.1",
 		"picomatch": "^4.0.4"
 	},
 	"devDependencies": {
-		"@types/node": "^24.1.0",
+		"@types/node": "^26.0.1",
 		"@types/path-browserify": "^1.0.3",
 		"@types/picomatch": "^4.0.3",
 		"@volar/typescript": "2.4.28",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
-	"gitHead": "4893ec6a4b5ca0d00f8add9aa36c17c47085f05a"
+	"gitHead": "876b0278ad0d1995c74c975c1f9fd4a8dc00e092"
 }