@vue/language-core 2.2.0 → 2.2.4

package/lib/codegen/template/styleScopedClasses.js

@@ -1,23 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStyleScopedClassReferences = generateStyleScopedClassReferences;
+exports.collectStyleScopedClassReferences = collectStyleScopedClassReferences;
+const CompilerDOM = require("@vue/compiler-dom");
+const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
 const utils_1 = require("../utils");
 function* generateStyleScopedClassReferences(ctx, withDot = false) {
-    if (!ctx.emptyClassOffsets.length && !ctx.scopedClasses.length) {
-        return;
-    }
-    yield `[`;
     for (const offset of ctx.emptyClassOffsets) {
-        yield `'`;
+        yield `/** @type {__VLS_StyleScopedClasses['`;
         yield [
             '',
             'template',
             offset,
             ctx.codeFeatures.additionalCompletion,
         ];
-        yield `', `;
+        yield `']} */${utils_1.endOfLine}`;
     }
     for (const { source, className, offset } of ctx.scopedClasses) {
+        yield `/** @type {__VLS_StyleScopedClasses[`;
         yield [
             '',
             source,
@@ -32,11 +32,10 @@ function* generateStyleScopedClassReferences(ctx, withDot = false) {
             '',
             source,
             offset + className.length,
-            ctx.codeFeatures.navigationWithoutRename,
+            ctx.codeFeatures.navigation,
         ];
-        yield `, `;
+        yield `]} */${utils_1.endOfLine}`;
     }
-    yield `] as (keyof __VLS_StyleScopedClasses)[]${utils_1.endOfLine}`;
     function* escapeString(source, className, offset, escapeTargets) {
         let count = 0;
         const currentEscapeTargets = [...escapeTargets];
@@ -72,4 +71,142 @@ function* generateStyleScopedClassReferences(ctx, withDot = false) {
         }
     }
 }
+function collectStyleScopedClassReferences(options, ctx, node) {
+    for (const prop of node.props) {
+        if (prop.type === CompilerDOM.NodeTypes.ATTRIBUTE
+            && prop.name === 'class'
+            && prop.value) {
+            if (options.template.lang === 'pug') {
+                const getClassOffset = Reflect.get(prop.value.loc.start, 'getClassOffset');
+                const content = prop.value.loc.source.slice(1, -1);
+                let startOffset = 1;
+                for (const className of content.split(' ')) {
+                    if (className) {
+                        ctx.scopedClasses.push({
+                            source: 'template',
+                            className,
+                            offset: getClassOffset(startOffset),
+                        });
+                    }
+                    startOffset += className.length + 1;
+                }
+            }
+            else {
+                let isWrapped = false;
+                const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
+                if (content) {
+                    const classes = collectClasses(content, startOffset + (isWrapped ? 1 : 0));
+                    ctx.scopedClasses.push(...classes);
+                }
+                else {
+                    ctx.emptyClassOffsets.push(startOffset);
+                }
+            }
+        }
+        else if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+            && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
+            && prop.arg.content === 'class') {
+            const content = '`${' + prop.exp.content + '}`';
+            const startOffset = prop.exp.loc.start.offset - 3;
+            const { ts } = options;
+            const ast = ts.createSourceFile('', content, 99);
+            const literals = [];
+            ts.forEachChild(ast, node => {
+                if (!ts.isExpressionStatement(node) ||
+                    !isTemplateExpression(node.expression)) {
+                    return;
+                }
+                const expression = node.expression.templateSpans[0].expression;
+                if (ts.isStringLiteralLike(expression)) {
+                    literals.push(expression);
+                }
+                if (ts.isArrayLiteralExpression(expression)) {
+                    walkArrayLiteral(expression);
+                }
+                if (ts.isObjectLiteralExpression(expression)) {
+                    walkObjectLiteral(expression);
+                }
+            });
+            for (const literal of literals) {
+                if (literal.text) {
+                    const classes = collectClasses(literal.text, literal.end - literal.text.length - 1 + startOffset);
+                    ctx.scopedClasses.push(...classes);
+                }
+                else {
+                    ctx.emptyClassOffsets.push(literal.end - 1 + startOffset);
+                }
+            }
+            function walkArrayLiteral(node) {
+                const { elements } = node;
+                for (const element of elements) {
+                    if (ts.isStringLiteralLike(element)) {
+                        literals.push(element);
+                    }
+                    else if (ts.isObjectLiteralExpression(element)) {
+                        walkObjectLiteral(element);
+                    }
+                }
+            }
+            function walkObjectLiteral(node) {
+                const { properties } = node;
+                for (const property of properties) {
+                    if (ts.isPropertyAssignment(property)) {
+                        const { name } = property;
+                        if (ts.isIdentifier(name)) {
+                            walkIdentifier(name);
+                        }
+                        else if (ts.isStringLiteral(name)) {
+                            literals.push(name);
+                        }
+                        else if (ts.isComputedPropertyName(name)) {
+                            const { expression } = name;
+                            if (ts.isStringLiteralLike(expression)) {
+                                literals.push(expression);
+                            }
+                        }
+                    }
+                    else if (ts.isShorthandPropertyAssignment(property)) {
+                        walkIdentifier(property.name);
+                    }
+                }
+            }
+            function walkIdentifier(node) {
+                const text = (0, scriptSetupRanges_1.getNodeText)(ts, node, ast);
+                ctx.scopedClasses.push({
+                    source: 'template',
+                    className: text,
+                    offset: node.end - text.length + startOffset
+                });
+            }
+        }
+    }
+}
+function collectClasses(content, startOffset = 0) {
+    const classes = [];
+    let currentClassName = '';
+    let offset = 0;
+    for (const char of (content + ' ')) {
+        if (char.trim() === '') {
+            if (currentClassName !== '') {
+                classes.push({
+                    source: 'template',
+                    className: currentClassName,
+                    offset: offset + startOffset
+                });
+                offset += currentClassName.length;
+                currentClassName = '';
+            }
+            offset += char.length;
+        }
+        else {
+            currentClassName += char;
+        }
+    }
+    return classes;
+}
+// isTemplateExpression is missing in tsc
+function isTemplateExpression(node) {
+    return node.kind === 228;
+}
 //# sourceMappingURL=styleScopedClasses.js.map

package/lib/codegen/template/templateChild.js

@@ -4,12 +4,15 @@ exports.generateTemplateChild = generateTemplateChild;
 exports.getVForNode = getVForNode;
 exports.parseInterpolationNode = parseInterpolationNode;
 const CompilerDOM = require("@vue/compiler-dom");
+const shared_1 = require("../../utils/shared");
 const utils_1 = require("../utils");
 const element_1 = require("./element");
 const interpolation_1 = require("./interpolation");
 const slotOutlet_1 = require("./slotOutlet");
 const vFor_1 = require("./vFor");
 const vIf_1 = require("./vIf");
+const vSlot_1 = require("./vSlot");
+const commentDirectiveRegex = /^<!--\s*@vue-(?<name>[-\w]+)\b(?<content>[\s\S]*)-->$/;
 // @ts-ignore
 const transformContext = {
     onError: () => { },
@@ -27,38 +30,44 @@ const transformContext = {
 };
 function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = false) {
     if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
-        const commentText = prevNode.content.trim().split(' ')[0];
-        if (/^@vue-skip\b[\s\S]*/.test(commentText)) {
-            yield `// @vue-skip${utils_1.newLine}`;
-            return;
-        }
-        else if (/^@vue-ignore\b[\s\S]*/.test(commentText)) {
-            yield* ctx.ignoreError();
-        }
-        else if (/^@vue-expect-error\b[\s\S]*/.test(commentText)) {
-            yield* ctx.expectError(prevNode);
-        }
-        else {
-            const match = prevNode.loc.source.match(/^<!--\s*@vue-generic\b\s*\{(?<content>[^}]*)\}/);
-            if (match) {
-                const { content } = match.groups ?? {};
-                ctx.lastGenericComment = {
-                    content,
-                    offset: prevNode.loc.start.offset + match[0].indexOf(content)
-                };
+        const match = prevNode.loc.source.match(commentDirectiveRegex);
+        if (match) {
+            const { name, content } = match.groups;
+            switch (name) {
+                case 'skip': {
+                    yield `// @vue-skip${utils_1.newLine}`;
+                    return;
+                }
+                case 'ignore': {
+                    yield* ctx.ignoreError();
+                    break;
+                }
+                case 'expect-error': {
+                    yield* ctx.expectError(prevNode);
+                    break;
+                }
+                case 'generic': {
+                    const text = content.trim();
+                    if (text.startsWith('{') && text.endsWith('}')) {
+                        ctx.lastGenericComment = {
+                            content: text.slice(1, -1),
+                            offset: prevNode.loc.start.offset + prevNode.loc.source.indexOf('{') + 1,
+                        };
+                    }
+                    break;
+                }
             }
         }
     }
-    const shouldInheritRootNodeAttrs = options.inheritAttrs;
     const cur = node;
     if (cur.codegenNode?.type === CompilerDOM.NodeTypes.JS_CACHE_EXPRESSION) {
         cur.codegenNode = cur.codegenNode.value;
     }
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
-        let prev;
-        if (shouldInheritRootNodeAttrs && node.children.length === 1 && node.children[0].type === CompilerDOM.NodeTypes.ELEMENT) {
-            ctx.singleRootNode = node.children[0];
+        for (const item of collectSingleRootNodes(options, node.children)) {
+            ctx.singleRootNodes.add(item);
         }
+        let prev;
         for (const childNode of node.children) {
             yield* generateTemplateChild(options, ctx, childNode, prev);
             prev = childNode;
@@ -74,9 +83,15 @@ function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = fals
         else if (vIfNode) {
             yield* (0, vIf_1.generateVIf)(options, ctx, vIfNode);
         }
+        else if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
+            yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
+        }
         else {
-            if (node.tagType === CompilerDOM.ElementTypes.SLOT) {
-                yield* (0, slotOutlet_1.generateSlotOutlet)(options, ctx, node);
+            const slotDir = node.props.find(p => p.type === CompilerDOM.NodeTypes.DIRECTIVE && p.name === 'slot');
+            if (node.tagType === CompilerDOM.ElementTypes.TEMPLATE
+                && ctx.currentComponent
+                && slotDir) {
+                yield* (0, vSlot_1.generateVSlot)(options, ctx, node, slotDir);
             }
             else if (node.tagType === CompilerDOM.ElementTypes.ELEMENT
                 || node.tagType === CompilerDOM.ElementTypes.TEMPLATE) {
@@ -84,7 +99,7 @@ function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = fals
             }
             else {
                 const { currentComponent } = ctx;
-                yield* (0, element_1.generateComponent)(options, ctx, node);
+                yield* (0, element_1.generateComponent)(options, ctx, node, isVForChild);
                 ctx.currentComponent = currentComponent;
             }
         }
@@ -119,6 +134,30 @@ function* generateTemplateChild(options, ctx, node, prevNode, isVForChild = fals
         // not needed progress
     }
 }
+function* collectSingleRootNodes(options, children) {
+    if (children.length !== 1) {
+        // "null" is used to determine whether the component is not always has a single root
+        if (children.length > 1) {
+            yield null;
+        }
+        return;
+    }
+    const child = children[0];
+    if (child.type === CompilerDOM.NodeTypes.IF) {
+        for (const branch of child.branches) {
+            yield* collectSingleRootNodes(options, branch.children);
+        }
+        return;
+    }
+    else if (child.type !== CompilerDOM.NodeTypes.ELEMENT) {
+        return;
+    }
+    yield child;
+    const tag = (0, shared_1.hyphenateTag)(child.tag);
+    if (options.vueCompilerOptions.fallthroughComponentNames.includes(tag)) {
+        yield* collectSingleRootNodes(options, child.children);
+    }
+}
 // TODO: track https://github.com/vuejs/vue-next/issues/3498
 function getVForNode(node) {
     const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
@@ -139,11 +178,11 @@ function getVForNode(node) {
     }
 }
 function getVIfNode(node) {
-    const forDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
+    const ifDirective = node.props.find((prop) => prop.type === CompilerDOM.NodeTypes.DIRECTIVE
         && prop.name === 'if');
-    if (forDirective) {
+    if (ifDirective) {
         let ifNode;
-        CompilerDOM.processIf(node, forDirective, transformContext, _ifNode => {
+        CompilerDOM.processIf(node, ifDirective, transformContext, _ifNode => {
             ifNode = { ..._ifNode };
             return undefined;
         });
@@ -151,7 +190,7 @@ function getVIfNode(node) {
             for (const branch of ifNode.branches) {
                 branch.children = [{
                         ...node,
-                        props: node.props.filter(prop => prop !== forDirective),
+                        props: node.props.filter(prop => prop !== ifDirective),
                     }];
             }
             return ifNode;

package/lib/codegen/template/vFor.js

@@ -24,7 +24,7 @@ function* generateVFor(options, ctx, node) {
     yield `] of `;
     if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         yield `__VLS_getVForSourceType(`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, source.loc, '(', ')');
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, source.loc, `(`, `)`);
         yield `!)`; // #3102
     }
     else {
@@ -46,7 +46,7 @@ function* generateVFor(options, ctx, node) {
             for (const prop of argument.returns.props.properties) {
                 if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                     && !prop.value.isStatic) {
-                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, prop.value.loc, '(', ')');
+                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, prop.value.loc, `(`, `)`);
                     yield utils_1.endOfLine;
                 }
             }

package/lib/codegen/template/vIf.js

@@ -7,7 +7,7 @@ const utils_1 = require("../utils");
 const interpolation_1 = require("./interpolation");
 const templateChild_1 = require("./templateChild");
 function* generateVIf(options, ctx, node) {
-    let originalBlockConditionsLength = ctx.blockConditions.length;
+    const originalBlockConditionsLength = ctx.blockConditions.length;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
         if (i === 0) {
@@ -22,7 +22,7 @@ function* generateVIf(options, ctx, node) {
         let addedBlockCondition = false;
         if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
             const codes = [
-                ...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, '(', ')'),
+                ...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, `(`, `)`),
             ];
             for (const code of codes) {
                 yield code;
@@ -43,7 +43,7 @@ function* generateVIf(options, ctx, node) {
         yield* ctx.generateAutoImportCompletion();
         yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {
-            ctx.blockConditions[ctx.blockConditions.length - 1] = `!(${ctx.blockConditions[ctx.blockConditions.length - 1]})`;
+            ctx.blockConditions[ctx.blockConditions.length - 1] = `!${ctx.blockConditions[ctx.blockConditions.length - 1]}`;
         }
     }
     ctx.blockConditions.length = originalBlockConditionsLength;

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

@@ -0,0 +1,6 @@
+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 generateVSlot(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode, slotDir: CompilerDOM.DirectiveNode): Generator<Code>;
+export declare function generateImplicitDefaultSlot(ctx: TemplateCodegenContext, node: CompilerDOM.ElementNode): Generator<Code, void, any>;

package/lib/codegen/template/vSlot.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVSlot = generateVSlot;
+exports.generateImplicitDefaultSlot = generateImplicitDefaultSlot;
+const CompilerDOM = require("@vue/compiler-dom");
+const utils_1 = require("../utils");
+const objectProperty_1 = require("./objectProperty");
+const templateChild_1 = require("./templateChild");
+function* generateVSlot(options, ctx, node, slotDir) {
+    if (!ctx.currentComponent) {
+        return;
+    }
+    ctx.currentComponent.used = true;
+    const slotBlockVars = [];
+    yield `{${utils_1.newLine}`;
+    yield `const { `;
+    if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
+        yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+    }
+    else {
+        yield* (0, utils_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
+    }
+    yield `: __VLS_thisSlot } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
+    if (slotDir.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
+        const slotAst = (0, utils_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
+        (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
+        if (!slotDir.exp.content.includes(':')) {
+            yield `const [`;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield `] = __VLS_getSlotParams(__VLS_thisSlot)${utils_1.endOfLine}`;
+        }
+        else {
+            yield `const `;
+            yield [
+                slotDir.exp.content,
+                'template',
+                slotDir.exp.loc.start.offset,
+                ctx.codeFeatures.all,
+            ];
+            yield ` = __VLS_getSlotParam(__VLS_thisSlot)${utils_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, prev);
+        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.arg) {
+        yield `${ctx.currentComponent.ctxVar}.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 */]${utils_1.endOfLine}`;
+    }
+    yield* ctx.generateAutoImportCompletion();
+    yield `}${utils_1.newLine}`;
+}
+function* generateImplicitDefaultSlot(ctx, node) {
+    if (!ctx.currentComponent) {
+        return;
+    }
+    if (node.children.length) {
+        ctx.currentComponent.used = true;
+        yield `${ctx.currentComponent.ctxVar}.slots!.`;
+        yield* (0, utils_1.wrapWith)(node.children[0].loc.start.offset, node.children[node.children.length - 1].loc.end.offset, ctx.codeFeatures.navigation, `default`);
+        yield utils_1.endOfLine;
+    }
+}
+//# sourceMappingURL=vSlot.js.map

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

@@ -1,11 +1,22 @@
+import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
-import type { Code, SfcBlock, VueCodeInformation } from '../../types';
+import type { Code, SfcBlock, SfcBlockAttr, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
 export declare const variableNameRegex: RegExp;
 export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
 export declare function collectVars(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile, results?: string[]): string[];
-export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: [id: ts.Identifier, isRest: boolean][], isRest?: boolean): [id: ts.Identifier, isRest: boolean][];
+export declare function collectIdentifiers(ts: typeof import('typescript'), node: ts.Node, results?: {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[], isRest?: boolean, initializer?: ts.Expression | undefined): {
+    id: ts.Identifier;
+    isRest: boolean;
+    initializer: ts.Expression | undefined;
+}[];
+export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;
+export declare function generateSfcBlockAttrValue(src: SfcBlockAttr & object, text: string, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/utils/index.js

@@ -4,12 +4,14 @@ exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exp
 exports.wrapWith = wrapWith;
 exports.collectVars = collectVars;
 exports.collectIdentifiers = collectIdentifiers;
+exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
+exports.generateSfcBlockAttrValue = generateSfcBlockAttrValue;
 const scriptSetupRanges_1 = require("../../parsers/scriptSetupRanges");
 exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
-exports.combineLastMapping = { __combineLastMapping: true };
+exports.combineLastMapping = { __combineOffset: 1 };
 exports.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
     yield ['', 'template', startOffset, features];
@@ -20,22 +22,22 @@ function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
         }
         yield wrapCode;
     }
-    yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
+    yield ['', 'template', endOffset, { __combineOffset: offset }];
 }
 function collectVars(ts, node, ast, results = []) {
     const identifiers = collectIdentifiers(ts, node, []);
-    for (const [id] of identifiers) {
+    for (const { id } of identifiers) {
         results.push((0, scriptSetupRanges_1.getNodeText)(ts, id, ast));
     }
     return results;
 }
-function collectIdentifiers(ts, node, results = [], isRest = false) {
+function collectIdentifiers(ts, node, results = [], isRest = false, initializer = undefined) {
     if (ts.isIdentifier(node)) {
-        results.push([node, isRest]);
+        results.push({ id: node, isRest, initializer });
     }
     else if (ts.isObjectBindingPattern(node)) {
         for (const el of node.elements) {
-            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken);
+            collectIdentifiers(ts, el.name, results, !!el.dotDotDotToken, el.initializer);
         }
     }
     else if (ts.isArrayBindingPattern(node)) {
@@ -50,6 +52,16 @@ function collectIdentifiers(ts, node, results = [], isRest = false) {
     }
     return results;
 }
+function normalizeAttributeValue(node) {
+    let offset = node.loc.start.offset;
+    let content = node.loc.source;
+    if ((content.startsWith(`'`) && content.endsWith(`'`))
+        || (content.startsWith(`"`) && content.endsWith(`"`))) {
+        offset++;
+        content = content.slice(1, -1);
+    }
+    return [content, offset];
+}
 function createTsAst(ts, astHolder, text) {
     if (astHolder.__volar_ast_text !== text) {
         astHolder.__volar_ast_text = text;
@@ -65,4 +77,19 @@ function generateSfcBlockSection(block, start, end, features) {
         features,
     ];
 }
+function* generateSfcBlockAttrValue(src, text, features) {
+    const { offset, quotes } = src;
+    if (!quotes) {
+        yield [``, 'main', offset, { verification: true }];
+    }
+    yield [
+        `'${text}'`,
+        'main',
+        quotes ? offset - 1 : offset,
+        features
+    ];
+    if (!quotes) {
+        yield [``, 'main', offset + text.length, { __combineOffset: 2 }];
+    }
+}
 //# sourceMappingURL=index.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -18,11 +18,14 @@ type DefineProp = {
 };
 type DefineProps = CallExpressionRange & {
     name?: string;
-    destructured?: Set<string>;
+    destructured?: Map<string, ts.Expression | undefined>;
     destructuredRest?: string;
     statement: TextRange;
+    argNode?: ts.Expression;
+};
+type WithDefaults = Omit<CallExpressionRange, 'typeArg'> & {
+    argNode?: ts.Expression;
 };
-type WithDefaults = Pick<CallExpressionRange, 'callExp' | 'exp' | 'arg'>;
 type DefineEmits = CallExpressionRange & {
     name?: string;
     hasUnionTypeArg?: boolean;
@@ -30,7 +33,6 @@ type DefineEmits = CallExpressionRange & {
 };
 type DefineSlots = CallExpressionRange & {
     name?: string;
-    isObjectBindingPattern?: boolean;
     statement: TextRange;
 };
 type DefineOptions = {