@vue/language-core 2.0.13 → 2.0.14

package/lib/codegen/template/elementEvents.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCompoundExpression = exports.generateElementEvents = 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");
+const objectProperty_1 = require("./objectProperty");
+function* generateElementEvents(options, ctx, node, componentVar, componentInstanceVar, eventsVar, used) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'on'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            used();
+            const eventVar = ctx.getInternalVariable();
+            yield `let ${eventVar} = { '${prop.arg.loc.source}': __VLS_pickEvent(`;
+            yield `${eventsVar}['${prop.arg.loc.source}'], `;
+            yield `({} as __VLS_FunctionalComponentProps<typeof ${componentVar}, typeof ${componentInstanceVar}>)`;
+            const startMappingFeatures = {
+                navigation: {
+                    // @click-outside -> onClickOutside
+                    resolveRenameNewName(newName) {
+                        return (0, shared_1.camelize)('on-' + newName);
+                    },
+                    // onClickOutside -> @click-outside
+                    resolveRenameEditText(newName) {
+                        const hName = (0, shared_2.hyphenateAttr)(newName);
+                        if ((0, shared_2.hyphenateAttr)(newName).startsWith('on-')) {
+                            return (0, shared_1.camelize)(hName.slice('on-'.length));
+                        }
+                        return newName;
+                    },
+                },
+            };
+            if (common_1.variableNameRegex.test((0, shared_1.camelize)(prop.arg.loc.source))) {
+                yield `.`;
+                yield ['', 'template', prop.arg.loc.start.offset, startMappingFeatures];
+                yield `on`;
+                yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(prop.arg.loc.source), prop.arg.loc.start.offset, common_1.combineLastMapping);
+            }
+            else {
+                yield `[`;
+                yield* (0, common_1.wrapWith)(prop.arg.loc.start.offset, prop.arg.loc.end.offset, startMappingFeatures, `'`, ['', 'template', prop.arg.loc.start.offset, common_1.combineLastMapping], 'on', ...(0, camelized_1.generateCamelized)((0, shared_1.capitalize)(prop.arg.loc.source), prop.arg.loc.start.offset, common_1.combineLastMapping), `'`);
+                yield `]`;
+            }
+            yield `) }${common_1.endOfLine}`;
+            yield `${eventVar} = { `;
+            if (prop.arg.loc.source.startsWith('[') && prop.arg.loc.source.endsWith(']')) {
+                yield `[(`;
+                yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.arg.loc.source.slice(1, -1), prop.arg.loc, prop.arg.loc.start.offset + 1, ctx.codeFeatures.all, '', '');
+                yield `)!]`;
+            }
+            else {
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, prop.arg.loc.source, prop.arg.loc.start.offset, ctx.codeFeatures.withoutHighlightAndCompletionAndNavigation, prop.arg.loc);
+            }
+            yield `: `;
+            yield* appendExpressionNode(options, ctx, prop);
+            yield ` }${common_1.endOfLine}`;
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'on'
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            // for vue 2 nameless event
+            // https://github.com/johnsoncodehk/vue-tsc/issues/67
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, ctx.codeFeatures.all, '$event => {(', ')}');
+            yield common_1.endOfLine;
+        }
+    }
+}
+exports.generateElementEvents = generateElementEvents;
+function* appendExpressionNode(options, ctx, prop) {
+    if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        let prefix = '(';
+        let suffix = ')';
+        let isFirstMapping = true;
+        const ast = (0, common_1.createTsAst)(options.ts, prop.exp, prop.exp.content);
+        const _isCompoundExpression = isCompoundExpression(options.ts, ast);
+        if (_isCompoundExpression) {
+            yield `$event => {${common_1.newLine}`;
+            ctx.addLocalVariable('$event');
+            prefix = '';
+            suffix = '';
+            for (const blockCondition of ctx.blockConditions) {
+                prefix += `if (!(${blockCondition})) return${common_1.endOfLine}`;
+            }
+        }
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, () => {
+            if (_isCompoundExpression && isFirstMapping) {
+                isFirstMapping = false;
+                return {
+                    ...ctx.codeFeatures.all,
+                    __hint: {
+                        setting: 'vue.inlayHints.inlineHandlerLeading',
+                        label: '$event =>',
+                        tooltip: [
+                            '`$event` is a hidden parameter, you can use it in this callback.',
+                            'To hide this hint, set `vue.inlayHints.inlineHandlerLeading` to `false` in IDE settings.',
+                            '[More info](https://github.com/vuejs/language-tools/issues/2445#issuecomment-1444771420)',
+                        ].join('\n\n'),
+                        paddingRight: true,
+                    },
+                };
+            }
+            return ctx.codeFeatures.all;
+        }, prefix, suffix);
+        if (_isCompoundExpression) {
+            ctx.removeLocalVariable('$event');
+            yield common_1.endOfLine;
+            yield* ctx.generateAutoImportCompletion();
+            yield `}${common_1.newLine}`;
+        }
+    }
+    else {
+        yield `() => {}`;
+    }
+}
+function isCompoundExpression(ts, ast) {
+    let result = true;
+    if (ast.statements.length === 1) {
+        ts.forEachChild(ast, child_1 => {
+            if (ts.isExpressionStatement(child_1)) {
+                ts.forEachChild(child_1, child_2 => {
+                    if (ts.isArrowFunction(child_2)) {
+                        result = false;
+                    }
+                    else if (ts.isIdentifier(child_2)) {
+                        result = false;
+                    }
+                });
+            }
+            else if (ts.isFunctionDeclaration(child_1)) {
+                result = false;
+            }
+        });
+    }
+    return result;
+}
+exports.isCompoundExpression = isCompoundExpression;
+//# sourceMappingURL=elementEvents.js.map

package/lib/codegen/template/elementProps.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 generateElementProps(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, props: CompilerDOM.ElementNode['props'], enableCodeFeatures: boolean, propsFailedExps?: CompilerDOM.SimpleExpressionNode[]): Generator<Code>;

package/lib/codegen/template/elementProps.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateElementProps = void 0;
+const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("@vue/shared");
+const minimatch_1 = require("minimatch");
+const shared_2 = require("../../utils/shared");
+const common_1 = require("../common");
+const camelized_1 = require("./camelized");
+const interpolation_1 = require("./interpolation");
+const objectProperty_1 = require("./objectProperty");
+const language_core_1 = require("@volar/language-core");
+function* generateElementProps(options, ctx, node, props, enableCodeFeatures, propsFailedExps) {
+    let styleAttrNum = 0;
+    let classAttrNum = 0;
+    const canCamelize = node.tagType === CompilerDOM.ElementTypes.COMPONENT;
+    if (props.some(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+        && prop.name === 'bind'
+        && !prop.arg
+        && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)) {
+        // fix https://github.com/vuejs/language-tools/issues/2166
+        styleAttrNum++;
+        classAttrNum++;
+    }
+    yield `...{ `;
+    for (const prop of props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'on'
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            yield `'${(0, shared_1.camelize)('on-' + prop.arg.loc.source)}': {} as any, `;
+        }
+    }
+    yield `}, `;
+    for (const prop of props) {
+        if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && (prop.name === 'bind' || prop.name === 'model')
+            && (prop.name === 'model' || prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)
+            && (!prop.exp || prop.exp.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION)) {
+            let propName = prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+                ? prop.arg.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY
+                    ? prop.arg.content
+                    : prop.arg.loc.source
+                : getModelValuePropName(node, options.vueCompilerOptions.target, options.vueCompilerOptions);
+            if (prop.modifiers.some(m => m === 'prop' || m === 'attr')) {
+                propName = propName?.substring(1);
+            }
+            if (propName === undefined
+                || options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern))
+                || (propName === 'style' && ++styleAttrNum >= 2)
+                || (propName === 'class' && ++classAttrNum >= 2)
+                || (propName === 'name' && node.tagType === CompilerDOM.ElementTypes.SLOT) // #2308
+            ) {
+                if (prop.exp && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
+                    propsFailedExps?.push(prop.exp);
+                }
+                continue;
+            }
+            const shouldCamelize = canCamelize
+                && (!prop.arg || (prop.arg.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && prop.arg.isStatic)) // isStatic
+                && (0, shared_2.hyphenateAttr)(propName) === propName
+                && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(propName, pattern));
+            const codes = (0, common_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg
+                ? prop.arg.loc.start.offset
+                : prop.loc.start.offset, prop.arg
+                ? {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                    navigation: ctx.codeFeatures.withoutHighlightAndCompletion.navigation
+                        ? {
+                            resolveRenameNewName: shared_1.camelize,
+                            resolveRenameEditText: shouldCamelize ? shared_2.hyphenateAttr : undefined,
+                        }
+                        : false,
+                }
+                : ctx.codeFeatures.withoutHighlightAndCompletion, prop.loc.name_2 ?? (prop.loc.name_2 = {}), shouldCamelize), `: (`, ...genereatePropExp(options, ctx, prop.exp, ctx.codeFeatures.withoutHighlightAndCompletion, prop.arg?.loc.start.offset === prop.exp?.loc.start.offset, enableCodeFeatures), `)`);
+            if (!enableCodeFeatures) {
+                yield (0, language_core_1.toString)([...codes]);
+            }
+            else {
+                yield* codes;
+            }
+            yield `, `;
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
+            if (options.vueCompilerOptions.dataAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern))
+                || (prop.name === 'style' && ++styleAttrNum >= 2)
+                || (prop.name === 'class' && ++classAttrNum >= 2)
+                || (prop.name === 'name' && node.tagType === CompilerDOM.ElementTypes.SLOT) // #2308
+            ) {
+                continue;
+            }
+            if (options.vueCompilerOptions.target < 3
+                && prop.name === 'persisted'
+                && node.tag.toLowerCase() === 'transition') {
+                // Vue 2 Transition doesn't support "persisted" property but `@vue/compiler-dom always adds it (#3881)
+                continue;
+            }
+            const shouldCamelize = canCamelize
+                && (0, shared_2.hyphenateAttr)(prop.name) === prop.name
+                && !options.vueCompilerOptions.htmlAttributes.some(pattern => (0, minimatch_1.minimatch)(prop.name, pattern));
+            const codes = (0, common_1.conditionWrapWith)(enableCodeFeatures, prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, shouldCamelize
+                ? {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                    navigation: ctx.codeFeatures.withoutHighlightAndCompletion.navigation
+                        ? {
+                            resolveRenameNewName: shared_1.camelize,
+                            resolveRenameEditText: shared_2.hyphenateAttr,
+                        }
+                        : false,
+                }
+                : ctx.codeFeatures.withoutHighlightAndCompletion, prop.loc.name_1 ?? (prop.loc.name_1 = {}), shouldCamelize), `: (`, ...(prop.value
+                ? generateAttrValue(prop.value, ctx.codeFeatures.all)
+                : [`true`]), `)`);
+            if (!enableCodeFeatures) {
+                yield (0, language_core_1.toString)([...codes]);
+            }
+            else {
+                yield* codes;
+            }
+            yield `, `;
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.name === 'bind'
+            && !prop.arg
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+            const codes = (0, common_1.conditionWrapWith)(enableCodeFeatures, 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, '(', ')'));
+            if (!enableCodeFeatures) {
+                yield (0, language_core_1.toString)([...codes]);
+            }
+            else {
+                yield* codes;
+            }
+            yield `, `;
+        }
+        else {
+            // comment this line to avoid affecting comments in prop expressions
+            // tsCodeGen.addText("/* " + [prop.type, prop.name, prop.arg?.loc.source, prop.exp?.loc.source, prop.loc.source].join(", ") + " */ ");
+        }
+    }
+}
+exports.generateElementProps = generateElementProps;
+function* genereatePropExp(options, ctx, exp, features, isShorthand, inlayHints) {
+    if (exp && exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) { // style='z-index: 2' will compile to {'z-index':'2'}
+        if (!isShorthand) { // vue 3.4+
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, exp.loc.source, exp.loc, exp.loc.start.offset, features, '(', ')');
+        }
+        else {
+            const propVariableName = (0, shared_1.camelize)(exp.loc.source);
+            if (common_1.variableNameRegex.test(propVariableName)) {
+                if (!ctx.hasLocalVariable(propVariableName)) {
+                    ctx.accessGlobalVariable(propVariableName, exp.loc.start.offset);
+                    yield `__VLS_ctx.`;
+                }
+                yield* (0, camelized_1.generateCamelized)(exp.loc.source, exp.loc.start.offset, features);
+                if (inlayHints) {
+                    yield [
+                        '',
+                        'template',
+                        exp.loc.end.offset,
+                        {
+                            __hint: {
+                                setting: 'vue.inlayHints.vBindShorthand',
+                                label: `="${propVariableName}"`,
+                                tooltip: [
+                                    `This is a shorthand for \`${exp.loc.source}="${propVariableName}"\`.`,
+                                    'To hide this hint, set `vue.inlayHints.vBindShorthand` to `false` in IDE settings.',
+                                    '[More info](https://github.com/vuejs/core/pull/9451)',
+                                ].join('\n\n'),
+                            },
+                        },
+                    ];
+                }
+            }
+        }
+    }
+    else {
+        yield `{}`;
+    }
+}
+function* generateAttrValue(attrNode, features) {
+    const char = attrNode.loc.source.startsWith("'") ? "'" : '"';
+    yield char;
+    let start = attrNode.loc.start.offset;
+    let end = attrNode.loc.end.offset;
+    let content = attrNode.loc.source;
+    if ((content.startsWith('"') && content.endsWith('"'))
+        || (content.startsWith("'") && content.endsWith("'"))) {
+        start++;
+        end--;
+        content = content.slice(1, -1);
+    }
+    if (needToUnicode(content)) {
+        yield* (0, common_1.wrapWith)(start, end, features, toUnicode(content));
+    }
+    else {
+        yield [content, 'template', start, features];
+    }
+    yield char;
+}
+function needToUnicode(str) {
+    return str.includes('\\') || str.includes('\n');
+}
+function toUnicode(str) {
+    return str.split('').map(value => {
+        const temp = value.charCodeAt(0).toString(16).padStart(4, '0');
+        if (temp.length > 2) {
+            return '\\u' + temp;
+        }
+        return value;
+    }).join('');
+}
+function getModelValuePropName(node, vueVersion, vueCompilerOptions) {
+    for (const modelName in vueCompilerOptions.experimentalModelPropName) {
+        const tags = vueCompilerOptions.experimentalModelPropName[modelName];
+        for (const tag in tags) {
+            if (node.tag === tag || node.tag === (0, shared_2.hyphenateTag)(tag)) {
+                const v = tags[tag];
+                if (typeof v === 'object') {
+                    const arr = Array.isArray(v) ? v : [v];
+                    for (const attrs of arr) {
+                        let failed = false;
+                        for (const attr in attrs) {
+                            const attrNode = node.props.find(prop => prop.type === CompilerDOM.NodeTypes.ATTRIBUTE && prop.name === attr);
+                            if (!attrNode || attrNode.value?.content !== attrs[attr]) {
+                                failed = true;
+                                break;
+                            }
+                        }
+                        if (!failed) {
+                            // all match
+                            return modelName || undefined;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    for (const modelName in vueCompilerOptions.experimentalModelPropName) {
+        const tags = vueCompilerOptions.experimentalModelPropName[modelName];
+        for (const tag in tags) {
+            if (node.tag === tag || node.tag === (0, shared_2.hyphenateTag)(tag)) {
+                const attrs = tags[tag];
+                if (attrs === true) {
+                    return modelName || undefined;
+                }
+            }
+        }
+    }
+    return vueVersion < 3 ? 'value' : 'modelValue';
+}
+//# sourceMappingURL=elementProps.js.map

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

@@ -0,0 +1,60 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type * as ts from 'typescript';
+import type { Code, Sfc, VueCodeInformation, VueCompilerOptions } from '../../types';
+export interface TemplateCodegenOptions {
+    ts: typeof ts;
+    compilerOptions: ts.CompilerOptions;
+    vueCompilerOptions: VueCompilerOptions;
+    template: NonNullable<Sfc['template']>;
+    shouldGenerateScopedClasses?: boolean;
+    stylesScopedClasses: Set<string>;
+    hasDefineSlots?: boolean;
+    slotsAssignName?: string;
+    propsAssignName?: string;
+}
+export declare function generateTemplate(options: TemplateCodegenOptions): Generator<Code, {
+    ctx: {
+        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 | undefined): void;
+        hasLocalVariable: (name: string) => boolean;
+        addLocalVariable: (name: string) => void;
+        removeLocalVariable: (name: string) => void;
+        getInternalVariable: () => string;
+        ignoreError: () => Generator<Code, any, unknown>;
+        expectError: (prevNode: CompilerDOM.CommentNode) => Generator<Code, any, unknown>;
+        resetDirectiveComments: (endStr: string) => Generator<Code, any, unknown>;
+        generateAutoImportCompletion: () => Generator<Code, any, unknown>;
+    };
+    hasSlot: boolean;
+}, unknown>;
+export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;
+export declare function isFragment(node: CompilerDOM.IfNode | CompilerDOM.ForNode): boolean | undefined;

package/lib/codegen/template/index.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFragment = exports.forEachElementNode = exports.generateTemplate = 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 context_1 = require("./context");
+const element_1 = require("./element");
+const objectProperty_1 = require("./objectProperty");
+const propertyAccess_1 = require("./propertyAccess");
+const stringLiteralKey_1 = require("./stringLiteralKey");
+const templateChild_1 = require("./templateChild");
+function* generateTemplate(options) {
+    const ctx = (0, context_1.createTemplateCodegenContext)();
+    const { componentTagNameOffsets, elementTagNameOffsets } = collectTagOffsets();
+    let hasSlot = false;
+    if (options.slotsAssignName) {
+        ctx.addLocalVariable(options.slotsAssignName);
+    }
+    if (options.propsAssignName) {
+        ctx.addLocalVariable(options.propsAssignName);
+    }
+    yield* generatePreResolveComponents();
+    if (options.template.ast) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, options.template.ast, undefined, undefined, undefined);
+    }
+    yield* generateStyleScopedClasses();
+    if (!options.hasDefineSlots) {
+        yield `var __VLS_slots!:`;
+        yield* generateSlotsType();
+        yield common_1.endOfLine;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    return {
+        ctx,
+        hasSlot,
+    };
+    function collectTagOffsets() {
+        const componentTagNameOffsets = new Map();
+        const elementTagNameOffsets = new Map();
+        if (!options.template.ast) {
+            return {
+                componentTagNameOffsets,
+                elementTagNameOffsets,
+            };
+        }
+        for (const node of forEachElementNode(options.template.ast)) {
+            if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
+                // ignore
+                continue;
+            }
+            if (node.tag === 'component' || node.tag === 'Component') {
+                // ignore
+                continue;
+            }
+            const map = node.tagType === CompilerDOM.ElementTypes.COMPONENT
+                ? componentTagNameOffsets
+                : elementTagNameOffsets;
+            let offsets = map.get(node.tag);
+            if (!offsets) {
+                map.set(node.tag, offsets = []);
+            }
+            const source = options.template.content.substring(node.loc.start.offset);
+            const startTagOffset = node.loc.start.offset + source.indexOf(node.tag);
+            offsets.push(startTagOffset); // start tag
+            if (!node.isSelfClosing && options.template.lang === 'html') {
+                const endTagOffset = node.loc.start.offset + node.loc.source.lastIndexOf(node.tag);
+                if (endTagOffset !== startTagOffset) {
+                    offsets.push(endTagOffset); // end tag
+                }
+            }
+        }
+        return {
+            componentTagNameOffsets,
+            elementTagNameOffsets,
+        };
+    }
+    function* generateSlotsType() {
+        for (const { expVar, varName } of ctx.dynamicSlots) {
+            hasSlot = true;
+            yield `Partial<Record<NonNullable<typeof ${expVar}>, (_: typeof ${varName}) => any>> &${common_1.newLine}`;
+        }
+        yield `{${common_1.newLine}`;
+        for (const slot of ctx.slots) {
+            hasSlot = true;
+            if (slot.name && slot.loc !== undefined) {
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.loc, {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                    __referencesCodeLens: true,
+                }, slot.nodeLoc);
+            }
+            else {
+                yield* (0, common_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], {
+                    ...ctx.codeFeatures.withoutHighlightAndCompletion,
+                    __referencesCodeLens: true,
+                }, `default`);
+            }
+            yield `?(_: typeof ${slot.varName}): any,${common_1.newLine}`;
+        }
+        yield `}`;
+    }
+    function* generateStyleScopedClasses() {
+        yield `if (typeof __VLS_styleScopedClasses === 'object' && !Array.isArray(__VLS_styleScopedClasses)) {${common_1.newLine}`;
+        for (const { className, offset } of ctx.scopedClasses) {
+            yield `__VLS_styleScopedClasses[`;
+            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(className, offset, {
+                ...ctx.codeFeatures.navigationAndCompletion,
+                __displayWithLink: options.stylesScopedClasses.has(className),
+            });
+            yield `]${common_1.endOfLine}`;
+        }
+        yield `}${common_1.newLine}`;
+    }
+    function* generatePreResolveComponents() {
+        yield `let __VLS_resolvedLocalAndGlobalComponents!: {}`;
+        for (const [tagName] of componentTagNameOffsets) {
+            const isNamespacedTag = tagName.includes('.');
+            if (isNamespacedTag) {
+                continue;
+            }
+            yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(tagName)}', typeof __VLS_localComponents, `;
+            yield (0, element_1.getPossibleOriginalComponentNames)(tagName, false)
+                .map(name => `"${name}"`)
+                .join(', ');
+            yield `>`;
+        }
+        yield common_1.endOfLine;
+        for (const [tagName, offsets] of elementTagNameOffsets) {
+            for (const tagOffset of offsets) {
+                yield `__VLS_intrinsicElements`;
+                yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, tagName, tagOffset, ctx.codeFeatures.withoutHighlightAndCompletion);
+                yield `;`;
+            }
+            yield `${common_1.newLine}`;
+        }
+        for (const [tagName, offsets] of componentTagNameOffsets) {
+            if (!common_1.variableNameRegex.test((0, shared_1.camelize)(tagName))) {
+                continue;
+            }
+            for (const tagOffset of offsets) {
+                for (const shouldCapitalize of (tagName[0] === tagName[0].toUpperCase() ? [false] : [true, false])) {
+                    const expectName = shouldCapitalize ? (0, shared_1.capitalize)((0, shared_1.camelize)(tagName)) : (0, shared_1.camelize)(tagName);
+                    yield `__VLS_components.`;
+                    yield* (0, camelized_1.generateCamelized)(shouldCapitalize ? (0, shared_1.capitalize)(tagName) : tagName, tagOffset, {
+                        navigation: {
+                            resolveRenameNewName: tagName !== expectName ? camelizeComponentName : undefined,
+                            resolveRenameEditText: getTagRenameApply(tagName),
+                        },
+                    });
+                    yield `;`;
+                }
+            }
+            yield `${common_1.newLine}`;
+            yield `// @ts-ignore${common_1.newLine}`; // #2304
+            yield `[`;
+            for (const tagOffset of offsets) {
+                yield* (0, camelized_1.generateCamelized)((0, shared_1.capitalize)(tagName), tagOffset, {
+                    completion: {
+                        isAdditional: true,
+                        onlyImport: true,
+                    },
+                });
+                yield `,`;
+            }
+            yield `]${common_1.endOfLine}`;
+        }
+    }
+}
+exports.generateTemplate = generateTemplate;
+function* forEachElementNode(node) {
+    if (node.type === CompilerDOM.NodeTypes.ROOT) {
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
+        const patchForNode = (0, templateChild_1.getVForNode)(node);
+        if (patchForNode) {
+            yield* forEachElementNode(patchForNode);
+        }
+        else {
+            yield node;
+            for (const child of node.children) {
+                yield* forEachElementNode(child);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.IF) {
+        // v-if / v-else-if / v-else
+        for (let i = 0; i < node.branches.length; i++) {
+            const branch = node.branches[i];
+            for (const childNode of branch.children) {
+                yield* forEachElementNode(childNode);
+            }
+        }
+    }
+    else if (node.type === CompilerDOM.NodeTypes.FOR) {
+        // v-for
+        for (const child of node.children) {
+            yield* forEachElementNode(child);
+        }
+    }
+}
+exports.forEachElementNode = forEachElementNode;
+function camelizeComponentName(newName) {
+    return (0, shared_1.camelize)('-' + newName);
+}
+function getTagRenameApply(oldName) {
+    return oldName === (0, shared_2.hyphenateTag)(oldName) ? shared_2.hyphenateTag : undefined;
+}
+function isFragment(node) {
+    return node.codegenNode && 'consequent' in node.codegenNode && 'tag' in node.codegenNode.consequent && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
+}
+exports.isFragment = isFragment;
+//# sourceMappingURL=index.js.map