@vue/language-core 2.2.2 → 2.2.6

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) {
@@ -21,12 +21,8 @@ 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, '(', ')'),
-            ];
-            for (const code of codes) {
-                yield code;
-            }
+            const codes = [...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, `(`, `)`)];
+            yield* codes;
             ctx.blockConditions.push((0, muggle_string_1.toString)(codes));
             addedBlockCondition = true;
             yield ` `;
@@ -43,7 +39,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

@@ -3,3 +3,4 @@ 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

@@ -1,8 +1,10 @@
 "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 wrapWith_1 = require("../utils/wrapWith");
 const objectProperty_1 = require("./objectProperty");
 const templateChild_1 = require("./templateChild");
 function* generateVSlot(options, ctx, node, slotDir) {
@@ -17,7 +19,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
         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* (0, wrapWith_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) {
@@ -77,4 +79,15 @@ function* generateVSlot(options, ctx, node, slotDir) {
     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, wrapWith_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/camelized.d.ts

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

package/lib/codegen/utils/camelized.js

@@ -2,26 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateCamelized = generateCamelized;
 const shared_1 = require("@vue/shared");
-const index_1 = require("./index");
-function* generateCamelized(code, offset, info) {
+function* generateCamelized(code, source, offset, features) {
     const parts = code.split('-');
+    const startCombineOffset = features.__combineOffset ?? 0;
     for (let i = 0; i < parts.length; i++) {
         const part = parts[i];
         if (part !== '') {
             if (i === 0) {
                 yield [
                     part,
-                    'template',
+                    source,
                     offset,
-                    info,
+                    features,
                 ];
             }
             else {
                 yield [
                     (0, shared_1.capitalize)(part),
-                    'template',
+                    source,
                     offset,
-                    index_1.combineLastMapping,
+                    { __combineOffset: startCombineOffset + i },
                 ];
             }
         }

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

@@ -0,0 +1,2 @@
+import type { Code, VueCodeInformation } from "../../types";
+export declare function generateEscaped(text: string, source: string, offset: number, features: VueCodeInformation, escapeTarget: RegExp): Generator<Code>;

package/lib/codegen/utils/escaped.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEscaped = generateEscaped;
+function* generateEscaped(text, source, offset, features, escapeTarget) {
+    const parts = text.split(escapeTarget);
+    const startCombineOffset = features.__combineOffset ?? 0;
+    let isEscapeTarget = false;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (isEscapeTarget) {
+            yield `\\`;
+        }
+        yield [
+            part,
+            source,
+            offset,
+            i === 0 ? features : { __combineOffset: startCombineOffset + i },
+        ];
+        offset += part.length;
+        isEscapeTarget = !isEscapeTarget;
+    }
+}
+//# sourceMappingURL=escaped.js.map

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

@@ -1,11 +1,10 @@
 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 const identifierRegex: RegExp;
 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;
@@ -19,3 +18,4 @@ export declare function collectIdentifiers(ts: typeof import('typescript'), node
 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

@@ -1,28 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.variableNameRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.wrapWith = wrapWith;
+exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
 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.variableNameRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-function* wrapWith(startOffset, endOffset, features, ...wrapCodes) {
-    yield ['', 'template', startOffset, features];
-    let offset = 1;
-    for (const wrapCode of wrapCodes) {
-        if (typeof wrapCode !== 'string') {
-            offset++;
-        }
-        yield wrapCode;
-    }
-    yield ['', 'template', endOffset, { __combineOffsetMapping: offset }];
-}
+exports.combineLastMapping = { __combineOffset: 1 };
+exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 function collectVars(ts, node, ast, results = []) {
     const identifiers = collectIdentifiers(ts, node, []);
     for (const { id } of identifiers) {
@@ -76,4 +65,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/codegen/utils/objectProperty.d.ts

@@ -0,0 +1,3 @@
+import type { Code, VueCodeInformation } from '../../types';
+export declare function getObjectProperty(code: string): string;
+export declare function generateObjectProperty(code: string, source: string, offset: number, features: VueCodeInformation, hasQuotes?: boolean, shouldCamelize?: boolean): Generator<Code>;

package/lib/codegen/utils/objectProperty.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectProperty = getObjectProperty;
+exports.generateObjectProperty = generateObjectProperty;
+const shared_1 = require("@vue/shared");
+const utils_1 = require("../utils");
+const camelized_1 = require("../utils/camelized");
+const stringLiteralKey_1 = require("../utils/stringLiteralKey");
+function getObjectProperty(code) {
+    if (utils_1.identifierRegex.test(code)) {
+        return code;
+    }
+    else {
+        return `'${code}'`;
+    }
+}
+function* generateObjectProperty(code, source, offset, features, hasQuotes = false, shouldCamelize = false) {
+    const start = offset;
+    const end = offset + code.length;
+    if (hasQuotes) {
+        code = code.slice(1, -1);
+        offset++;
+    }
+    if (shouldCamelize) {
+        if (utils_1.identifierRegex.test((0, shared_1.camelize)(code))) {
+            yield* (0, camelized_1.generateCamelized)(code, source, offset, features);
+        }
+        else {
+            yield* (0, utils_1.wrapWith)(start, end, source, features, `'`, ...(0, camelized_1.generateCamelized)(code, source, offset, features), `'`);
+        }
+    }
+    else {
+        if (utils_1.identifierRegex.test(code)) {
+            yield [code, source, offset, features];
+        }
+        else {
+            yield* (0, stringLiteralKey_1.generateStringLiteralKey)(code, source, offset, features);
+        }
+    }
+}
+//# sourceMappingURL=objectProperty.js.map

package/lib/codegen/utils/stringLiteralKey.js

@@ -2,12 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateStringLiteralKey = generateStringLiteralKey;
 const index_1 = require("./index");
+const wrapWith_1 = require("./wrapWith");
 function* generateStringLiteralKey(code, offset, info) {
     if (offset === undefined || !info) {
         yield `'${code}'`;
     }
     else {
-        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
+        yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
     }
 }
 //# sourceMappingURL=stringLiteralKey.js.map

package/lib/codegen/utils/unicode.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateUnicode = generateUnicode;
-const index_1 = require("./index");
+const wrapWith_1 = require("./wrapWith");
 function* generateUnicode(code, offset, info) {
     if (needToUnicode(code)) {
-        yield* (0, index_1.wrapWith)(offset, offset + code.length, info, toUnicode(code));
+        yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, info, toUnicode(code));
     }
     else {
         yield [code, 'template', offset, info];

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

@@ -0,0 +1,3 @@
+import type { Code, VueCodeInformation } from "../../types";
+export declare function wrapWith(startOffset: number, endOffset: number, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;
+export declare function wrapWith(startOffset: number, endOffset: number, source: string, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;

package/lib/codegen/utils/wrapWith.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapWith = wrapWith;
+function* wrapWith(startOffset, endOffset, ...args) {
+    let source = 'template';
+    let features;
+    let codes;
+    if (typeof args[0] === 'string') {
+        [source, features, ...codes] = args;
+    }
+    else {
+        [features, ...codes] = args;
+    }
+    yield ['', source, startOffset, features];
+    let offset = 1;
+    for (const code of codes) {
+        if (typeof code !== 'string') {
+            offset++;
+        }
+        yield code;
+    }
+    yield ['', source, endOffset, { __combineOffset: offset }];
+}
+//# sourceMappingURL=wrapWith.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -15,6 +15,8 @@ type DefineProp = {
     defaultValue?: TextRange;
     required?: boolean;
     isModel?: boolean;
+    comments?: TextRange;
+    argNode?: ts.Expression;
 };
 type DefineProps = CallExpressionRange & {
     name?: string;

package/lib/parsers/scriptSetupRanges.js

@@ -74,91 +74,48 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         if (ts.isCallExpression(node)
             && ts.isIdentifier(node.expression)) {
             const callText = _getNodeText(node.expression);
-            if (vueCompilerOptions.macros.defineModel.includes(callText)) {
+            const isDefineModel = vueCompilerOptions.macros.defineModel.includes(callText);
+            if (isDefineModel || callText === 'defineProp') {
                 let localName;
                 let propName;
                 let options;
+                let type;
+                let modifierType;
+                let runtimeType;
+                let defaultValue;
+                let required = false;
                 if (ts.isVariableDeclaration(parent) &&
                     ts.isIdentifier(parent.name)) {
                     localName = _getStartEnd(parent.name);
                 }
-                if (node.arguments.length >= 2) {
-                    propName = _getStartEnd(node.arguments[0]);
-                    options = node.arguments[1];
-                }
-                else if (node.arguments.length >= 1) {
-                    if (ts.isStringLiteralLike(node.arguments[0])) {
-                        propName = _getStartEnd(node.arguments[0]);
+                if (node.typeArguments) {
+                    if (node.typeArguments.length >= 1) {
+                        type = _getStartEnd(node.typeArguments[0]);
                     }
-                    else {
-                        options = node.arguments[0];
+                    if (node.typeArguments.length >= 2) {
+                        modifierType = _getStartEnd(node.typeArguments[1]);
                     }
                 }
-                let runtimeType;
-                let defaultValue;
-                let required = false;
-                if (options && ts.isObjectLiteralExpression(options)) {
-                    for (const property of options.properties) {
-                        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                            continue;
-                        }
-                        const text = _getNodeText(property.name);
-                        if (text === 'type') {
-                            runtimeType = _getStartEnd(property.initializer);
+                if (isDefineModel) {
+                    if (node.arguments.length >= 2) {
+                        propName = node.arguments[0];
+                        options = node.arguments[1];
+                    }
+                    else if (node.arguments.length >= 1) {
+                        if (ts.isStringLiteralLike(node.arguments[0])) {
+                            propName = node.arguments[0];
                         }
-                        else if (text === 'default') {
-                            defaultValue = _getStartEnd(property.initializer);
-                        }
-                        else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
-                            required = true;
+                        else {
+                            options = node.arguments[0];
                         }
                     }
                 }
-                defineProp.push({
-                    localName,
-                    name: propName,
-                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
-                    modifierType: node.typeArguments && node.typeArguments?.length >= 2 ? _getStartEnd(node.typeArguments[1]) : undefined,
-                    runtimeType,
-                    defaultValue,
-                    required,
-                    isModel: true,
-                });
-            }
-            else if (callText === 'defineProp') {
-                let localName;
-                let propName;
-                let options;
-                if (ts.isVariableDeclaration(parent) &&
-                    ts.isIdentifier(parent.name)) {
-                    localName = _getStartEnd(parent.name);
-                }
-                let runtimeType;
-                let defaultValue;
-                let required = false;
-                if (definePropProposalA) {
+                else if (definePropProposalA) {
                     if (node.arguments.length >= 2) {
                         options = node.arguments[1];
                     }
                     if (node.arguments.length >= 1) {
-                        propName = _getStartEnd(node.arguments[0]);
-                    }
-                    if (options && ts.isObjectLiteralExpression(options)) {
-                        for (const property of options.properties) {
-                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                                continue;
-                            }
-                            const text = _getNodeText(property.name);
-                            if (text === 'type') {
-                                runtimeType = _getStartEnd(property.initializer);
-                            }
-                            else if (text === 'default') {
-                                defaultValue = _getStartEnd(property.initializer);
-                            }
-                            else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
-                                required = true;
-                            }
-                        }
+                        propName = node.arguments[0];
                     }
                 }
                 else if (definePropProposalB) {
@@ -173,49 +130,58 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     if (node.arguments.length >= 1) {
                         defaultValue = _getStartEnd(node.arguments[0]);
                     }
-                    if (options && ts.isObjectLiteralExpression(options)) {
-                        for (const property of options.properties) {
-                            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                                continue;
-                            }
-                            const text = _getNodeText(property.name);
-                            if (text === 'type') {
-                                runtimeType = _getStartEnd(property.initializer);
-                            }
+                }
+                if (options && ts.isObjectLiteralExpression(options)) {
+                    for (const property of options.properties) {
+                        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+                            continue;
+                        }
+                        const text = _getNodeText(property.name);
+                        if (text === 'type') {
+                            runtimeType = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'default') {
+                            defaultValue = _getStartEnd(property.initializer);
+                        }
+                        else if (text === 'required' && property.initializer.kind === ts.SyntaxKind.TrueKeyword) {
+                            required = true;
                         }
                     }
                 }
+                let name;
+                if (propName && ts.isStringLiteralLike(propName)) {
+                    name = _getStartEnd(propName);
+                }
                 defineProp.push({
                     localName,
-                    name: propName,
-                    type: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
+                    name,
+                    type,
+                    modifierType,
                     runtimeType,
                     defaultValue,
                     required,
+                    isModel: isDefineModel,
+                    comments: getCommentsRange(ts, node, parents, ast),
+                    argNode: options,
                 });
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
                 defineProps = {
-                    ...parseCallExpression(node),
+                    ...parseCallExpressionAssignment(node, parent),
                     statement: getStatementRange(ts, parents, node, ast),
                     argNode: node.arguments[0]
                 };
-                if (ts.isVariableDeclaration(parent)) {
-                    if (ts.isObjectBindingPattern(parent.name)) {
-                        defineProps.destructured = new Map();
-                        const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
-                        for (const { id, isRest, initializer } of identifiers) {
-                            const name = _getNodeText(id);
-                            if (isRest) {
-                                defineProps.destructuredRest = name;
-                            }
-                            else {
-                                defineProps.destructured.set(name, initializer);
-                            }
+                if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
+                    defineProps.destructured = new Map();
+                    const identifiers = (0, utils_1.collectIdentifiers)(ts, parent.name, []);
+                    for (const { id, isRest, initializer } of identifiers) {
+                        const name = _getNodeText(id);
+                        if (isRest) {
+                            defineProps.destructuredRest = name;
+                        }
+                        else {
+                            defineProps.destructured.set(name, initializer);
                         }
-                    }
-                    else {
-                        defineProps.name = _getNodeText(parent.name);
                     }
                 }
                 else if (ts.isCallExpression(parent)
@@ -237,12 +203,9 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
                 defineEmits = {
-                    ...parseCallExpression(node),
+                    ...parseCallExpressionAssignment(node, parent),
                     statement: getStatementRange(ts, parents, node, ast)
                 };
-                if (ts.isVariableDeclaration(parent)) {
-                    defineEmits.name = _getNodeText(parent.name);
-                }
                 if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0])) {
                     for (const member of node.typeArguments[0].members) {
                         if (ts.isCallSignatureDeclaration(member)) {
@@ -257,12 +220,9 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
                 defineSlots = {
-                    ...parseCallExpression(node),
+                    ...parseCallExpressionAssignment(node, parent),
                     statement: getStatementRange(ts, parents, node, ast)
                 };
-                if (ts.isVariableDeclaration(parent)) {
-                    defineSlots.name = _getNodeText(parent.name);
-                }
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
                 defineExpose = parseCallExpression(node);
@@ -295,10 +255,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             else if (vueCompilerOptions.composables.useTemplateRef.includes(callText)
                 && !node.typeArguments?.length) {
-                useTemplateRef.push({
-                    name: ts.isVariableDeclaration(parent) ? _getNodeText(parent.name) : undefined,
-                    ...parseCallExpression(node)
-                });
+                useTemplateRef.push(parseCallExpressionAssignment(node, parent));
             }
         }
         ts.forEachChild(node, child => {
@@ -318,6 +275,12 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             typeArg: node.typeArguments?.length ? _getStartEnd(node.typeArguments[0]) : undefined,
         };
     }
+    function parseCallExpressionAssignment(node, parent) {
+        return {
+            name: ts.isVariableDeclaration(parent) ? _getNodeText(parent.name) : undefined,
+            ...parseCallExpression(node),
+        };
+    }
     function _getStartEnd(node) {
         return getStartEnd(ts, node, ast);
     }
@@ -459,4 +422,19 @@ function getStatementRange(ts, parents, node, ast) {
     }
     return statementRange;
 }
+function getCommentsRange(ts, node, parents, ast) {
+    for (let i = parents.length - 1; i >= 0; i--) {
+        if (ts.isStatement(node)) {
+            break;
+        }
+        node = parents[i];
+    }
+    const comments = ts.getLeadingCommentRanges(ast.text, node.pos);
+    if (comments?.length) {
+        return {
+            start: comments[0].pos,
+            end: comments.at(-1).end,
+        };
+    }
+}
 //# sourceMappingURL=scriptSetupRanges.js.map

package/lib/plugins/file-md.js

@@ -6,6 +6,7 @@ const buildMappings_1 = require("../utils/buildMappings");
 const parseSfc_1 = require("../utils/parseSfc");
 const codeblockReg = /(`{3,})[\s\S]+?\1/g;
 const inlineCodeblockReg = /`[^\n`]+?`/g;
+const latexBlockReg = /(\${2,})[\s\S]+?\1/g;
 const scriptSetupReg = /\\\<[\s\S]+?\>\n?/g;
 const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
 const angleBracketReg = /\<\S*\:\S*\>/g;
@@ -31,6 +32,8 @@ const plugin = ({ vueCompilerOptions }) => {
                 .replace(codeblockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
                 // inline code block
                 .replace(inlineCodeblockReg, match => `\`${' '.repeat(match.length - 2)}\``)
+                // latex block
+                .replace(latexBlockReg, (match, quotes) => quotes + ' '.repeat(match.length - quotes.length * 2) + quotes)
                 // # \<script setup>
                 .replace(scriptSetupReg, match => ' '.repeat(match.length))
                 // <<< https://vitepress.dev/guide/markdown#import-code-snippets

package/lib/plugins/vue-template-inline-ts.js

@@ -60,10 +60,10 @@ const plugin = ctx => {
         return data;
         function visit(node) {
             if (node.type === CompilerDOM.NodeTypes.COMMENT) {
-                const match = node.loc.source.match(/^<!--\s*@vue-generic\b\s*\{(?<content>[^}]*)\}/);
+                const match = node.loc.source.match(/^<!--\s*@vue-generic\s*\{(?<content>[\s\S]*)\}\s*-->$/);
                 if (match) {
-                    const { content } = match.groups ?? {};
-                    addFormatCodes(content, node.loc.start.offset + match[0].indexOf(content), formatBrackets.generic);
+                    const { content } = match.groups;
+                    addFormatCodes(content, node.loc.start.offset + node.loc.source.indexOf('{') + 1, formatBrackets.generic);
                 }
             }
             else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {