@vue/language-core 2.0.13 → 2.0.14

package/lib/codegen/template/camelized.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCamelized = void 0;
+const shared_1 = require("@vue/shared");
+const common_1 = require("../common");
+function* generateCamelized(code, offset, info) {
+    const parts = code.split('-');
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part !== '') {
+            if (i === 0) {
+                yield [
+                    part,
+                    'template',
+                    offset,
+                    info,
+                ];
+            }
+            else {
+                yield [
+                    (0, shared_1.capitalize)(part),
+                    'template',
+                    offset,
+                    common_1.combineLastMapping,
+                ];
+            }
+        }
+        offset += part.length + 1;
+    }
+}
+exports.generateCamelized = generateCamelized;
+//# sourceMappingURL=camelized.js.map

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

@@ -0,0 +1,44 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { Code, VueCodeInformation } from '../../types';
+export type TemplateCodegenContext = ReturnType<typeof createTemplateCodegenContext>;
+export declare function createTemplateCodegenContext(): {
+    slots: {
+        name: string;
+        loc?: number | undefined;
+        tagRange: [number, number];
+        varName: string;
+        nodeLoc: any;
+    }[];
+    dynamicSlots: {
+        expVar: string;
+        varName: string;
+    }[];
+    codeFeatures: {
+        all: VueCodeInformation;
+        verification: VueCodeInformation;
+        completion: VueCodeInformation;
+        additionalCompletion: VueCodeInformation;
+        navigation: VueCodeInformation;
+        navigationAndCompletion: VueCodeInformation;
+        withoutHighlight: VueCodeInformation;
+        withoutHighlightAndCompletion: VueCodeInformation;
+        withoutHighlightAndCompletionAndNavigation: VueCodeInformation;
+    };
+    accessGlobalVariables: Map<string, Set<number>>;
+    hasSlotElements: Set<CompilerDOM.ElementNode>;
+    blockConditions: string[];
+    usedComponentCtxVars: Set<string>;
+    scopedClasses: {
+        className: string;
+        offset: number;
+    }[];
+    accessGlobalVariable(name: string, offset?: number): void;
+    hasLocalVariable: (name: string) => boolean;
+    addLocalVariable: (name: string) => void;
+    removeLocalVariable: (name: string) => void;
+    getInternalVariable: () => string;
+    ignoreError: () => Generator<Code>;
+    expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code>;
+    resetDirectiveComments: (endStr: string) => Generator<Code>;
+    generateAutoImportCompletion: () => Generator<Code>;
+};

package/lib/codegen/template/context.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTemplateCodegenContext = void 0;
+const common_1 = require("../common");
+const _codeFeatures = {
+    all: {
+        verification: true,
+        completion: true,
+        semantic: true,
+        navigation: true,
+    },
+    verification: {
+        verification: true,
+    },
+    completion: {
+        completion: true,
+    },
+    additionalCompletion: {
+        completion: { isAdditional: true },
+    },
+    navigation: {
+        navigation: true,
+    },
+    navigationAndCompletion: {
+        navigation: true,
+    },
+    withoutHighlight: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+        completion: true,
+    },
+    withoutHighlightAndCompletion: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+        navigation: true,
+    },
+    withoutHighlightAndCompletionAndNavigation: {
+        semantic: { shouldHighlight: () => false },
+        verification: true,
+    },
+};
+function createTemplateCodegenContext() {
+    let ignoredError = false;
+    let expectErrorToken;
+    let variableId = 0;
+    const codeFeatures = new Proxy(_codeFeatures, {
+        get(target, key) {
+            const data = target[key];
+            if (data.verification) {
+                if (ignoredError) {
+                    return {
+                        ...data,
+                        verification: false,
+                    };
+                }
+                if (expectErrorToken) {
+                    const token = expectErrorToken;
+                    if (typeof data.verification !== 'object' || !data.verification.shouldReport) {
+                        return {
+                            ...data,
+                            verification: {
+                                shouldReport: () => {
+                                    token.errors++;
+                                    return false;
+                                },
+                            },
+                        };
+                    }
+                }
+            }
+            return data;
+        },
+    });
+    const localVars = new Map();
+    const accessGlobalVariables = new Map();
+    const slots = [];
+    const dynamicSlots = [];
+    const hasSlotElements = new Set();
+    ;
+    const blockConditions = [];
+    const usedComponentCtxVars = new Set();
+    const scopedClasses = [];
+    return {
+        slots,
+        dynamicSlots,
+        codeFeatures,
+        accessGlobalVariables,
+        hasSlotElements,
+        blockConditions,
+        usedComponentCtxVars,
+        scopedClasses,
+        accessGlobalVariable(name, offset) {
+            let arr = accessGlobalVariables.get(name);
+            if (!arr) {
+                accessGlobalVariables.set(name, arr = new Set());
+            }
+            if (offset !== undefined) {
+                arr.add(offset);
+            }
+        },
+        hasLocalVariable: (name) => {
+            return !!localVars.get(name);
+        },
+        addLocalVariable: (name) => {
+            localVars.set(name, (localVars.get(name) ?? 0) + 1);
+        },
+        removeLocalVariable: (name) => {
+            localVars.set(name, localVars.get(name) - 1);
+        },
+        getInternalVariable: () => {
+            return `__VLS_${variableId++}`;
+        },
+        ignoreError: function* () {
+            if (!ignoredError) {
+                ignoredError = true;
+                yield `// @vue-ignore start${common_1.newLine}`;
+            }
+        },
+        expectError: function* (prevNode) {
+            if (!expectErrorToken) {
+                expectErrorToken = {
+                    errors: 0,
+                    node: prevNode,
+                };
+                yield `// @vue-expect-error start${common_1.newLine}`;
+            }
+        },
+        resetDirectiveComments: function* (endStr) {
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                yield* (0, common_1.wrapWith)(expectErrorToken.node.loc.start.offset, expectErrorToken.node.loc.end.offset, {
+                    verification: {
+                        shouldReport: () => token.errors === 0,
+                    },
+                }, `// @ts-expect-error __VLS_TS_EXPECT_ERROR`);
+                yield `${common_1.newLine}${common_1.endOfLine}`;
+                expectErrorToken = undefined;
+                yield `// @vue-expect-error ${endStr}${common_1.newLine}`;
+            }
+            if (ignoredError) {
+                ignoredError = false;
+                yield `// @vue-ignore ${endStr}${common_1.newLine}`;
+            }
+        },
+        generateAutoImportCompletion: function* () {
+            const all = [...accessGlobalVariables.entries()];
+            if (!all.some(([_, offsets]) => offsets.size)) {
+                yield `// no auto imports${common_1.endOfLine}`;
+                return;
+            }
+            yield `// @ts-ignore${common_1.newLine}`; // #2304
+            yield `[`;
+            for (const [varName, offsets] of all) {
+                for (const offset of offsets) {
+                    yield [
+                        varName,
+                        'template',
+                        offset,
+                        codeFeatures.additionalCompletion,
+                    ];
+                    yield `,`;
+                }
+                offsets.clear();
+            }
+            yield `]${common_1.endOfLine}`;
+        }
+    };
+}
+exports.createTemplateCodegenContext = createTemplateCodegenContext;
+//# sourceMappingURL=context.js.map

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

@@ -0,0 +1,7 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElement(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentElement: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;
+export declare function getCanonicalComponentName(tagText: string): string;
+export declare function getPossibleOriginalComponentNames(tagText: string, deduplicate: boolean): string[];

package/lib/codegen/template/element.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPossibleOriginalComponentNames = exports.getCanonicalComponentName = exports.generateElement = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const elementChildren_1 = require("./elementChildren");
+const elementDirectives_1 = require("./elementDirectives");
+const elementEvents_1 = require("./elementEvents");
+const elementProps_1 = require("./elementProps");
+const interpolation_1 = require("./interpolation");
+const propertyAccess_1 = require("./propertyAccess");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+const templateChild_1 = require("./templateChild");
+const colonReg = /:/g;
+function* generateElement(options, ctx, node, currentElement, componentCtxVar) {
+    const startTagOffset = node.loc.start.offset + options.template.content.substring(node.loc.start.offset).indexOf(node.tag);
+    const propsFailedExps = [];
+    const var_originalComponent = ctx.getInternalVariable();
+    const var_functionalComponent = ctx.getInternalVariable();
+    const var_componentInstance = ctx.getInternalVariable();
+    const var_componentEvents = ctx.getInternalVariable();
+    const isIntrinsicElement = node.tagType === CompilerDOM.ElementTypes.ELEMENT
+        || node.tagType === CompilerDOM.ElementTypes.TEMPLATE;
+    const isComponentTag = node.tag.toLowerCase() === 'component';
+    let endTagOffset = !node.isSelfClosing && options.template.lang === 'html' ? node.loc.start.offset + node.loc.source.lastIndexOf(node.tag) : undefined;
+    let tag = node.tag;
+    let tagOffsets = endTagOffset !== undefined
+        ? [startTagOffset, endTagOffset]
+        : [startTagOffset];
+    let props = node.props;
+    let dynamicTagInfo;
+    let defineComponentCtxVar;
+    let usedComponentEventsVar = false;
+    if (isComponentTag) {
+        for (const prop of node.props) {
+            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE && prop.name === 'bind' && prop.arg?.loc.source === 'is' && prop.exp) {
+                dynamicTagInfo = {
+                    exp: prop.exp.loc.source,
+                    offset: prop.exp.loc.start.offset,
+                    astHolder: prop.exp.loc,
+                };
+                props = props.filter(p => p !== prop);
+                break;
+            }
+        }
+    }
+    else if (tag.includes('.')) {
+        // namespace tag
+        dynamicTagInfo = {
+            exp: tag,
+            astHolder: node.loc,
+            offset: startTagOffset,
+        };
+    }
+    if (isIntrinsicElement) {
+        yield `const ${var_originalComponent} = __VLS_intrinsicElements[`;
+        yield* (0, stringLiteralKey_1.generateStringLiteralKey)(tag, startTagOffset, ctx.codeFeatures.verification);
+        yield `]${common_1.endOfLine}`;
+    }
+    else if (dynamicTagInfo) {
+        yield `const ${var_originalComponent} = `;
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, dynamicTagInfo.exp, dynamicTagInfo.astHolder, dynamicTagInfo.offset, ctx.codeFeatures.all, '(', ')');
+        yield common_1.endOfLine;
+    }
+    else if (!isComponentTag) {
+        yield `const ${var_originalComponent} = ({} as `;
+        for (const componentName of getPossibleOriginalComponentNames(tag, true)) {
+            yield `'${componentName}' extends keyof typeof __VLS_ctx ? { '${getCanonicalComponentName(tag)}': typeof __VLS_ctx`;
+            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, componentName);
+            yield ` }: `;
+        }
+        yield `typeof __VLS_resolvedLocalAndGlobalComponents)`;
+        yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, getCanonicalComponentName(tag), startTagOffset, ctx.codeFeatures.verification);
+        yield common_1.endOfLine;
+    }
+    else {
+        yield `const ${var_originalComponent} = {} as any${common_1.endOfLine}`;
+    }
+    if (isIntrinsicElement) {
+        yield `const ${var_functionalComponent} = __VLS_elementAsFunctionalComponent(${var_originalComponent})${common_1.endOfLine}`;
+    }
+    else {
+        yield `const ${var_functionalComponent} = __VLS_asFunctionalComponent(${var_originalComponent}, new ${var_originalComponent}({`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, false);
+        yield `}))${common_1.endOfLine}`;
+    }
+    if (!dynamicTagInfo
+        && !isIntrinsicElement
+        && !isComponentTag) {
+        for (const offset of tagOffsets) {
+            yield `({} as { ${getCanonicalComponentName(tag)}: typeof ${var_originalComponent} }).`;
+            yield* generateCanonicalComponentName(tag, offset, ctx.codeFeatures.withoutHighlightAndCompletionAndNavigation);
+            yield common_1.endOfLine;
+        }
+    }
+    if (options.vueCompilerOptions.strictTemplates) {
+        // with strictTemplates, generate once for props type-checking + instance type
+        yield `const ${var_componentInstance} = ${var_functionalComponent}(`;
+        yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + tag.length, ctx.codeFeatures.verification, `{`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, true, propsFailedExps), `}`);
+        yield `, ...__VLS_functionalComponentArgsRest(${var_functionalComponent}))${common_1.endOfLine}`;
+    }
+    else {
+        // without strictTemplates, this only for instacne type
+        yield `const ${var_componentInstance} = ${var_functionalComponent}({`;
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, props, false);
+        yield `}, ...__VLS_functionalComponentArgsRest(${var_functionalComponent}))${common_1.endOfLine}`;
+        // and this for props type-checking
+        yield `({} as (props: __VLS_FunctionalComponentProps<typeof ${var_originalComponent}, typeof ${var_componentInstance}> & Record<string, unknown>) => void)(`;
+        yield* (0, common_1.wrapWith)(startTagOffset, startTagOffset + tag.length, ctx.codeFeatures.verification, `{`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, props, true, propsFailedExps), `}`);
+        yield `)${common_1.endOfLine}`;
+    }
+    if (node.tagType !== CompilerDOM.ElementTypes.TEMPLATE) {
+        defineComponentCtxVar = ctx.getInternalVariable();
+        componentCtxVar = defineComponentCtxVar;
+        currentElement = node;
+    }
+    //#region fix #1775
+    for (const failedExp of propsFailedExps) {
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, failedExp.loc.source, failedExp.loc, failedExp.loc.start.offset, ctx.codeFeatures.all, '(', ')');
+        yield common_1.endOfLine;
+    }
+    const vScope = props.find(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && (prop.name === 'scope' || prop.name === 'data'));
+    let inScope = false;
+    let originalConditionsNum = ctx.blockConditions.length;
+    if (vScope?.type === CompilerDOM.NodeTypes.DIRECTIVE && vScope.exp) {
+        const scopeVar = ctx.getInternalVariable();
+        const condition = `__VLS_withScope(__VLS_ctx, ${scopeVar})`;
+        yield `const ${scopeVar} = `;
+        yield [
+            vScope.exp.loc.source,
+            'template',
+            vScope.exp.loc.start.offset,
+            ctx.codeFeatures.all,
+        ];
+        yield common_1.endOfLine;
+        yield `if (${condition}) {${common_1.newLine}`;
+        ctx.blockConditions.push(condition);
+        inScope = true;
+    }
+    yield* (0, elementDirectives_1.generateElementDirectives)(options, ctx, node);
+    yield* generateReferencesForElements(options, ctx, node); // <el ref="foo" />
+    if (options.shouldGenerateScopedClasses) {
+        yield* generateReferencesForScopedCssClasses(ctx, node);
+    }
+    if (componentCtxVar) {
+        ctx.usedComponentCtxVars.add(componentCtxVar);
+        yield* (0, elementEvents_1.generateElementEvents)(options, ctx, node, var_functionalComponent, var_componentInstance, var_componentEvents, () => usedComponentEventsVar = true);
+    }
+    if (inScope) {
+        yield `}${common_1.newLine}`;
+        ctx.blockConditions.length = originalConditionsNum;
+    }
+    //#endregion
+    const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+    if (slotDir && componentCtxVar) {
+        yield* generateComponentSlot(options, ctx, node, slotDir, currentElement, componentCtxVar);
+    }
+    else {
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, node, currentElement, componentCtxVar);
+    }
+    if (defineComponentCtxVar && ctx.usedComponentCtxVars.has(defineComponentCtxVar)) {
+        yield `const ${componentCtxVar} = __VLS_pickFunctionalComponentCtx(${var_originalComponent}, ${var_componentInstance})!${common_1.endOfLine}`;
+    }
+    if (usedComponentEventsVar) {
+        yield `let ${var_componentEvents}!: __VLS_NormalizeEmits<typeof ${componentCtxVar}.emit>${common_1.endOfLine}`;
+    }
+}
+exports.generateElement = generateElement;
+function getCanonicalComponentName(tagText) {
+    return common_1.variableNameRegex.test(tagText)
+        ? tagText
+        : (0, shared_1.capitalize)((0, shared_1.camelize)(tagText.replace(colonReg, '-')));
+}
+exports.getCanonicalComponentName = getCanonicalComponentName;
+function getPossibleOriginalComponentNames(tagText, deduplicate) {
+    const name1 = (0, shared_1.capitalize)((0, shared_1.camelize)(tagText));
+    const name2 = (0, shared_1.camelize)(tagText);
+    const name3 = tagText;
+    const names = [name1];
+    if (!deduplicate || name2 !== name1) {
+        names.push(name2);
+    }
+    if (!deduplicate || name3 !== name2) {
+        names.push(name3);
+    }
+    return names;
+}
+exports.getPossibleOriginalComponentNames = getPossibleOriginalComponentNames;
+function* generateCanonicalComponentName(tagText, offset, features) {
+    if (common_1.variableNameRegex.test(tagText)) {
+        yield [tagText, 'template', offset, features];
+    }
+    else {
+        yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tagText.replace(colonReg, '-')), offset, features);
+    }
+}
+function* generateComponentSlot(options, ctx, node, slotDir, currentElement, componentCtxVar) {
+    yield `{${common_1.newLine}`;
+    ctx.usedComponentCtxVars.add(componentCtxVar);
+    if (currentElement) {
+        ctx.hasSlotElements.add(currentElement);
+    }
+    const slotBlockVars = [];
+    let hasProps = false;
+    if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const slotAst = (0, common_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
+        (0, common_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
+        hasProps = true;
+        if (!slotDir.exp.content.includes(':')) {
+            yield `const [`;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield `] = __VLS_getSlotParams(`;
+        }
+        else {
+            yield `const `;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield ` = __VLS_getSlotParam(`;
+        }
+    }
+    yield* (0, common_1.wrapWith)((slotDir.arg ?? slotDir).loc.start.offset, (slotDir.arg ?? slotDir).loc.end.offset, ctx.codeFeatures.verification, `(${componentCtxVar}.slots!)`, ...(slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content
+        ? (0, propertyAccess_1.generatePropertyAccess)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc)
+        : [
+            `.`,
+            ...(0, common_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                ? '#'.length
+                : slotDir.loc.source.startsWith('v-slot:')
+                    ? 'v-slot:'.length
+                    : 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`)
+        ]));
+    if (hasProps) {
+        yield `)`;
+    }
+    yield common_1.endOfLine;
+    for (const varName of slotBlockVars) {
+        ctx.addLocalVariable(varName);
+    }
+    yield* ctx.resetDirectiveComments('end of slot children start');
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentElement, prev, componentCtxVar);
+        prev = childNode;
+    }
+    for (const varName of slotBlockVars) {
+        ctx.removeLocalVariable(varName);
+    }
+    let isStatic = true;
+    if (slotDir?.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        isStatic = slotDir.arg.isStatic;
+    }
+    if (isStatic && slotDir && !slotDir.arg) {
+        yield `${componentCtxVar}.slots!['`;
+        yield [
+            '',
+            'template',
+            slotDir.loc.start.offset + (slotDir.loc.source.startsWith('#')
+                ? '#'.length : slotDir.loc.source.startsWith('v-slot:')
+                ? 'v-slot:'.length
+                : 0),
+            ctx.codeFeatures.completion,
+        ];
+        yield `'/* empty slot name completion */]${common_1.newLine}`;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${common_1.newLine}`;
+}
+function* generateReferencesForElements(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'ref'
+            && prop.value) {
+            yield `// @ts-ignore${common_1.newLine}`;
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.value.content, prop.value.loc, prop.value.loc.start.offset + 1, ctx.codeFeatures.navigation, '(', ')');
+            yield common_1.endOfLine;
+        }
+    }
+}
+function* generateReferencesForScopedCssClasses(ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'class'
+            && prop.value) {
+            let startOffset = prop.value.loc.start.offset;
+            let tempClassName = '';
+            for (const char of (prop.value.loc.source + ' ')) {
+                if (char.trim() === '' || char === '"' || char === "'") {
+                    if (tempClassName !== '') {
+                        ctx.scopedClasses.push({ className: tempClassName, offset: startOffset });
+                        startOffset += tempClassName.length;
+                        tempClassName = '';
+                    }
+                    startOffset += char.length;
+                }
+                else {
+                    tempClassName += char;
+                }
+            }
+        }
+        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') {
+            yield `__VLS_styleScopedClasses = (`;
+            yield [
+                prop.exp.content,
+                'template',
+                prop.exp.loc.start.offset,
+                ctx.codeFeatures.navigationAndCompletion,
+            ];
+            yield `)${common_1.endOfLine}`;
+        }
+    }
+}
+//# sourceMappingURL=element.js.map

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

@@ -0,0 +1,5 @@
+import type * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementChildren(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, currentElement: CompilerDOM.ElementNode | undefined, componentCtxVar: string | undefined): Generator<Code>;

package/lib/codegen/template/elementChildren.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementChildren = void 0;
+const common_1 = require("../common");
+const templateChild_1 = require("./templateChild");
+function* generateElementChildren(options, ctx, node, currentElement, componentCtxVar) {
+    yield* ctx.resetDirectiveComments('end of element children start');
+    let prev;
+    for (const childNode of node.children) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, childNode, currentElement, prev, componentCtxVar);
+        prev = childNode;
+    }
+    // fix https://github.com/vuejs/language-tools/issues/932
+    if (!ctx.hasSlotElements.has(node) && node.children.length) {
+        yield `(${componentCtxVar}.slots!).`;
+        yield* (0, common_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
+        yield common_1.endOfLine;
+    }
+}
+exports.generateElementChildren = generateElementChildren;
+//# sourceMappingURL=elementChildren.js.map

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

@@ -0,0 +1,5 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementDirectives(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code>;

package/lib/codegen/template/elementDirectives.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementDirectives = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const shared_2 = require("../../utils/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const interpolation_1 = require("./interpolation");
+function* generateElementDirectives(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name !== 'slot'
+            && prop.name !== 'on'
+            && prop.name !== 'model'
+            && prop.name !== 'bind'
+            && prop.name !== 'scope'
+            && prop.name !== 'data') {
+            ctx.accessGlobalVariable((0, shared_1.camelize)('v-' + prop.name), prop.loc.start.offset);
+            if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && !prop.arg.isStatic) {
+                yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.arg.content, prop.arg.loc, prop.arg.loc.start.offset + prop.arg.loc.source.indexOf(prop.arg.content), ctx.codeFeatures.all, '(', ')');
+                yield common_1.endOfLine;
+            }
+            yield* (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, `__VLS_directiveFunction(__VLS_ctx.`, ...(0, camelized_1.generateCamelized)('v-' + prop.name, prop.loc.start.offset, {
+                ...ctx.codeFeatures.all,
+                verification: false,
+                completion: {
+                    // fix https://github.com/vuejs/language-tools/issues/1905
+                    isAdditional: true,
+                },
+                navigation: {
+                    resolveRenameNewName: shared_1.camelize,
+                    resolveRenameEditText: getPropRenameApply(prop.name),
+                },
+            }), `)(`, ...(prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                ? (0, common_1.wrapWith)(prop.exp.loc.start.offset, prop.exp.loc.end.offset, ctx.codeFeatures.verification, ...(0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '(', ')'))
+                : [`undefined`]), `)`);
+            yield common_1.endOfLine;
+        }
+    }
+}
+exports.generateElementDirectives = generateElementDirectives;
+function getPropRenameApply(oldName) {
+    return oldName === (0, shared_2.hyphenateAttr)(oldName) ? shared_2.hyphenateAttr : undefined;
+}
+//# sourceMappingURL=elementDirectives.js.map

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

@@ -0,0 +1,7 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+import type { TemplateCodegenOptions } from './index';
+export declare function generateElementEvents(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, componentVar: string, componentInstanceVar: string, eventsVar: string, used: () => void): Generator<Code>;
+export declare function isCompoundExpression(ts: typeof import('typescript'), ast: ts.SourceFile): boolean;