@vue/language-core 3.3.7 → 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/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);
@@ -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);
@@ -285,11 +285,11 @@ 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) {

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) {

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.js

@@ -149,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;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.3.7",
+	"version": "3.3.8",
 	"license": "MIT",
 	"files": [
 		"index.d.ts",
@@ -34,5 +34,5 @@
 		"@volar/typescript": "2.4.28",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
-	"gitHead": "f6cc297eb9b2fddb3bed535b099b9697c909764d"
+	"gitHead": "876b0278ad0d1995c74c975c1f9fd4a8dc00e092"
 }