@vue/language-core 3.1.3 → 3.1.5

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

@@ -1,4 +1,3 @@
-import * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, Sfc, VueCompilerOptions } from '../../types';
 export interface TemplateCodegenOptions {
@@ -23,7 +22,7 @@ declare function generate(options: TemplateCodegenOptions): {
         ignoreError?: boolean;
         expectError?: {
             token: number;
-            node: CompilerDOM.CommentNode;
+            node: import("@vue/compiler-dom").CommentNode;
         };
         generic?: {
             content: string;
@@ -54,18 +53,18 @@ declare function generate(options: TemplateCodegenOptions): {
     }[];
     emptyClassOffsets: number[];
     inlayHints: import("../inlayHints").InlayHintInfo[];
-    bindingAttrLocs: CompilerDOM.SourceLocation[];
+    bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
     inheritedAttrVars: Set<string>;
     templateRefs: Map<string, {
         typeExp: string;
         offset: number;
     }[]>;
     currentComponent: {
-        ctxVar: string;
-        used: boolean;
+        get ctxVar(): string;
+        get propsVar(): string;
     } | undefined;
-    singleRootElTypes: string[];
-    singleRootNodes: Set<CompilerDOM.ElementNode | null>;
+    singleRootElTypes: Set<string>;
+    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
     addTemplateRef(name: string, typeExp: string, offset: number): void;
     accessExternalVariable(name: string, offset?: number): void;
     hasLocalVariable(name: string): boolean;
@@ -76,7 +75,6 @@ declare function generate(options: TemplateCodegenOptions): {
     generateHoistVariables(): Generator<string, void, unknown>;
     generateConditionGuards(): Generator<string, void, unknown>;
     generateAutoImportCompletion(): Generator<Code>;
-    enter(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode | CompilerDOM.SimpleExpressionNode): boolean;
+    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
     exit(): Generator<Code>;
 };
-export declare function forEachElementNode(node: CompilerDOM.RootNode | CompilerDOM.TemplateChildNode): Generator<CompilerDOM.ElementNode>;

package/lib/codegen/template/index.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generate;
-exports.forEachElementNode = forEachElementNode;
-const CompilerDOM = require("@vue/compiler-dom");
 const codeFeatures_1 = require("../codeFeatures");
 const utils_1 = require("../utils");
 const wrapWith_1 = require("../utils/wrapWith");
@@ -75,7 +73,7 @@ function* generateSlots(options, ctx) {
                 yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, codeFeatures_1.codeFeatures.navigation);
             }
             else {
-                yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], codeFeatures_1.codeFeatures.navigation, `default`);
+                yield* (0, wrapWith_1.wrapWith)('template', slot.tagRange[0], slot.tagRange[1], codeFeatures_1.codeFeatures.navigation, `default`);
             }
             yield `?: (props: typeof ${slot.propsVar}) => any }`;
         }
@@ -129,7 +127,7 @@ function* generateTemplateRefs(options, ctx) {
 }
 function* generateRootEl(ctx) {
     yield `type __VLS_RootEl = `;
-    if (ctx.singleRootElTypes.length && !ctx.singleRootNodes.has(null)) {
+    if (ctx.singleRootElTypes.size && !ctx.singleRootNodes.has(null)) {
         for (const type of ctx.singleRootElTypes) {
             yield `${utils_1.newLine}| ${type}`;
         }
@@ -140,37 +138,4 @@ function* generateRootEl(ctx) {
     yield utils_1.endOfLine;
     return `__VLS_RootEl`;
 }
-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 (const branch of node.branches) {
-            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);
-        }
-    }
-}
 //# sourceMappingURL=index.js.map

package/lib/codegen/template/interpolation.js

@@ -10,44 +10,43 @@ const utils_1 = require("../utils");
 const isLiteralWhitelisted = /*@__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
 function* generateInterpolation(options, ctx, source, data, code, start, prefix = '', suffix = '') {
     const { ts, destructuredPropNames, templateRefNames, } = options;
-    for (let [section, offset, type] of forEachInterpolationSegment(ts, ctx.inlineTsAsts, destructuredPropNames, templateRefNames, ctx, code, start, prefix, suffix)) {
-        if (offset === undefined) {
-            yield section;
+    for (const segment of forEachInterpolationSegment(ts, ctx.inlineTsAsts, destructuredPropNames, templateRefNames, ctx, code, start, prefix, suffix)) {
+        if (typeof segment === 'string') {
+            yield segment;
+            continue;
         }
-        else {
-            offset -= prefix.length;
-            let addSuffix = '';
-            const overLength = offset + section.length - code.length;
-            if (overLength > 0) {
-                addSuffix = section.slice(section.length - overLength);
-                section = section.slice(0, -overLength);
-            }
-            if (offset < 0) {
-                yield section.slice(0, -offset);
-                section = section.slice(-offset);
-                offset = 0;
+        let [section, offset, type] = segment;
+        offset -= prefix.length;
+        let addSuffix = '';
+        const overLength = offset + section.length - code.length;
+        if (overLength > 0) {
+            addSuffix = section.slice(section.length - overLength);
+            section = section.slice(0, -overLength);
+        }
+        if (offset < 0) {
+            yield section.slice(0, -offset);
+            section = section.slice(-offset);
+            offset = 0;
+        }
+        const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
+        if (!shouldSkip) {
+            if (start !== undefined && data) {
+                yield [
+                    section,
+                    source,
+                    start + offset,
+                    type === 'errorMappingOnly'
+                        ? codeFeatures_1.codeFeatures.verification
+                        : typeof data === 'function'
+                            ? data(start + offset)
+                            : data,
+                ];
             }
-            const shouldSkip = section.length === 0 && (type === 'startText' || type === 'endText');
-            if (!shouldSkip) {
-                if (start !== undefined
-                    && data) {
-                    yield [
-                        section,
-                        source,
-                        start + offset,
-                        type === 'errorMappingOnly'
-                            ? codeFeatures_1.codeFeatures.verification
-                            : typeof data === 'function'
-                                ? data(start + offset)
-                                : data,
-                    ];
-                }
-                else {
-                    yield section;
-                }
+            else {
+                yield section;
             }
-            yield addSuffix;
         }
+        yield addSuffix;
     }
 }
 function* forEachInterpolationSegment(ts, inlineTsAsts, destructuredPropNames, templateRefNames, ctx, originalCode, start, prefix, suffix) {
@@ -82,7 +81,7 @@ function* forEachInterpolationSegment(ts, inlineTsAsts, destructuredPropNames, t
             const lastVarEnd = lastVar ? lastVar.offset + lastVar.text.length : 0;
             if (curVar.isShorthand) {
                 yield [code.slice(lastVarEnd, curVar.offset + curVar.text.length), lastVarEnd];
-                yield [': ', undefined];
+                yield `: `;
             }
             else {
                 yield [code.slice(lastVarEnd, curVar.offset), lastVarEnd, i ? undefined : 'startText'];
@@ -104,9 +103,9 @@ function* generateVar(templateRefNames, ctx, code, offset, curVar) {
     yield ['', curVar.offset, 'errorMappingOnly'];
     const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
     if (isTemplateRef) {
-        yield [`__VLS_unref(`, undefined];
+        yield `__VLS_unref(`;
         yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
-        yield [`)`, undefined];
+        yield `)`;
     }
     else {
         if (offset !== undefined) {
@@ -116,10 +115,10 @@ function* generateVar(templateRefNames, ctx, code, offset, curVar) {
             ctx.accessExternalVariable(curVar.text);
         }
         if (ctx.dollarVars.has(curVar.text)) {
-            yield [`__VLS_dollars.`, undefined];
+            yield `__VLS_dollars.`;
         }
         else {
-            yield [`__VLS_ctx.`, undefined];
+            yield `__VLS_ctx.`;
         }
         yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
     }

package/lib/codegen/template/objectProperty.js

@@ -21,7 +21,7 @@ function* generateObjectProperty(options, ctx, code, offset, features, shouldCam
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, 'template', offset, utils_1.combineLastMapping), `'`);
+            yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, 'template', offset, utils_1.combineLastMapping), `'`);
         }
     }
     else {

package/lib/codegen/template/slotOutlet.js

@@ -29,12 +29,7 @@ function* generateSlotOutlet(options, ctx, node) {
         if (nameProp) {
             let codes;
             if (nameProp.type === CompilerDOM.NodeTypes.ATTRIBUTE && nameProp.value) {
-                let { source, start: { offset } } = nameProp.value.loc;
-                if (source.startsWith('"') || source.startsWith("'")) {
-                    source = source.slice(1, -1);
-                    offset++;
-                }
-                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, source, offset, codeFeatures_1.codeFeatures.navigationAndVerification);
+                codes = (0, propertyAccess_1.generatePropertyAccess)(options, ctx, nameProp.value.content, (0, shared_1.getAttributeValueOffset)(nameProp.value), codeFeatures_1.codeFeatures.navigationAndVerification);
             }
             else if (nameProp.type === CompilerDOM.NodeTypes.DIRECTIVE
                 && nameProp.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -47,18 +42,18 @@ function* generateSlotOutlet(options, ctx, node) {
             else {
                 codes = [`['default']`];
             }
-            yield* (0, wrapWith_1.wrapWith)(nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, options.slotsAssignName ?? '__VLS_slots', ...codes);
+            yield* (0, wrapWith_1.wrapWith)('template', nameProp.loc.start.offset, nameProp.loc.end.offset, codeFeatures_1.codeFeatures.verification, options.slotsAssignName ?? '__VLS_slots', ...codes);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `'default'`), `]`);
+            yield* (0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `${options.slotsAssignName ?? '__VLS_slots'}[`, ...(0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `'default'`), `]`);
         }
         yield `)(`;
-        yield* (0, wrapWith_1.wrapWith)(startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true, true), `}`);
+        yield* (0, wrapWith_1.wrapWith)('template', startTagOffset, startTagEndOffset, codeFeatures_1.codeFeatures.verification, `{${utils_1.newLine}`, ...(0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), true), `}`);
         yield `)${utils_1.endOfLine}`;
     }
     else {
         yield `var ${propsVar} = {${utils_1.newLine}`;
-        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), options.vueCompilerOptions.checkUnknownProps, true);
+        yield* (0, elementProps_1.generateElementProps)(options, ctx, node, node.props.filter(prop => prop !== nameProp), options.vueCompilerOptions.checkUnknownProps);
         yield `}${utils_1.endOfLine}`;
         if (nameProp?.type === CompilerDOM.NodeTypes.ATTRIBUTE
             && nameProp.value) {

package/lib/codegen/template/styleScopedClasses.js

@@ -22,7 +22,7 @@ function* generateStyleScopedClassReferences(ctx, withDot = false) {
     }
     for (const { source, className, offset } of ctx.scopedClasses) {
         yield `/** @type {__VLS_StyleScopedClasses[`;
-        yield* (0, wrapWith_1.wrapWith)(offset - (withDot ? 1 : 0), offset + className.length, source, codeFeatures_1.codeFeatures.navigation, `'`, ...(0, escaped_1.generateEscaped)(className, source, offset, codeFeatures_1.codeFeatures.navigationAndAdditionalCompletion, classNameEscapeRegex), `'`);
+        yield* (0, wrapWith_1.wrapWith)(source, offset - (withDot ? 1 : 0), offset + className.length, codeFeatures_1.codeFeatures.navigation, `'`, ...(0, escaped_1.generateEscaped)(className, source, offset, codeFeatures_1.codeFeatures.navigationAndAdditionalCompletion, classNameEscapeRegex), `'`);
         yield `]} */${utils_1.endOfLine}`;
     }
 }
@@ -34,26 +34,26 @@ function collectStyleScopedClassReferences(options, ctx, node) {
             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;
+                let offset = 1;
                 for (const className of content.split(' ')) {
                     if (className) {
                         ctx.scopedClasses.push({
                             source: 'template',
                             className,
-                            offset: getClassOffset(startOffset),
+                            offset: getClassOffset(offset),
                         });
                     }
-                    startOffset += className.length + 1;
+                    offset += className.length + 1;
                 }
             }
             else {
-                const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
-                if (content) {
-                    const classes = collectClasses(content, startOffset);
+                const offset = (0, shared_1.getAttributeValueOffset)(prop.value);
+                if (prop.value.content) {
+                    const classes = collectClasses(prop.value.content, offset);
                     ctx.scopedClasses.push(...classes);
                 }
                 else {
-                    ctx.emptyClassOffsets.push(startOffset);
+                    ctx.emptyClassOffsets.push(offset);
                 }
             }
         }

package/lib/codegen/template/templateChild.js

@@ -167,22 +167,15 @@ function getVIfNode(node) {
     }
 }
 function parseInterpolationNode(node, template) {
-    let content = node.content.loc.source;
     let start = node.content.loc.start.offset;
-    let leftCharacter;
-    let rightCharacter;
+    let end = node.content.loc.end.offset;
     // fix https://github.com/vuejs/language-tools/issues/1787
-    while ((leftCharacter = template.slice(start - 1, start)).trim() === '' && leftCharacter.length) {
+    while (template[start - 1]?.trim() === '') {
         start--;
-        content = leftCharacter + content;
     }
-    while ((rightCharacter = template.slice(start + content.length, start + content.length + 1)).trim() === ''
-        && rightCharacter.length) {
-        content = content + rightCharacter;
+    while (template[end]?.trim() === '') {
+        end++;
     }
-    return [
-        content,
-        start,
-    ];
+    return [template.slice(start, end), start];
 }
 //# sourceMappingURL=templateChild.js.map

package/lib/codegen/template/vIf.js

@@ -9,6 +9,10 @@ const elementChildren_1 = require("./elementChildren");
 const interpolation_1 = require("./interpolation");
 function* generateVIf(options, ctx, node) {
     const originalBlockConditionsLength = ctx.blockConditions.length;
+    const isFragment = node.codegenNode
+        && 'consequent' in node.codegenNode
+        && 'tag' in node.codegenNode.consequent
+        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
     for (let i = 0; i < node.branches.length; i++) {
         const branch = node.branches[i];
         if (i === 0) {
@@ -29,7 +33,7 @@ function* generateVIf(options, ctx, node) {
             yield ` `;
         }
         yield `{${utils_1.newLine}`;
-        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, branch.children, isFragment(node));
+        yield* (0, elementChildren_1.generateElementChildren)(options, ctx, branch.children, i !== 0 || isFragment);
         yield `}${utils_1.newLine}`;
         if (addedBlockCondition) {
             ctx.blockConditions[ctx.blockConditions.length - 1] = `!${ctx.blockConditions[ctx.blockConditions.length - 1]}`;
@@ -37,10 +41,4 @@ function* generateVIf(options, ctx, node) {
     }
     ctx.blockConditions.length = originalBlockConditionsLength;
 }
-function isFragment(node) {
-    return node.codegenNode
-        && 'consequent' in node.codegenNode
-        && 'tag' in node.codegenNode.consequent
-        && node.codegenNode.consequent.tag === CompilerDOM.FRAGMENT;
-}
 //# sourceMappingURL=vIf.js.map

package/lib/codegen/template/vSlot.js

@@ -20,19 +20,18 @@ function* generateVSlot(options, ctx, node, slotDir) {
         yield `{${utils_1.newLine}`;
     }
     if (slotDir || node.children.length) {
-        ctx.currentComponent.used = true;
         yield `const { `;
         if (slotDir) {
             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 ? codeFeatures_1.codeFeatures.withoutHighlight : codeFeatures_1.codeFeatures.all, false, true);
             }
             else {
-                yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), codeFeatures_1.codeFeatures.withoutHighlightAndCompletion, `default`);
+                yield* (0, wrapWith_1.wrapWith)('template', slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), codeFeatures_1.codeFeatures.withoutHighlightAndCompletion, `default`);
             }
         }
         else {
             // #932: reference for implicit default slot
-            yield* (0, wrapWith_1.wrapWith)(node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.navigation, `default`);
+            yield* (0, wrapWith_1.wrapWith)('template', node.loc.start.offset, node.loc.end.offset, codeFeatures_1.codeFeatures.navigation, `default`);
         }
         yield `: ${slotVar} } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     }
@@ -101,7 +100,7 @@ function* generateSlotParameters(options, ctx, ast, exp, slotVar) {
     yield `] = __VLS_getSlotParameters(${slotVar}!`;
     if (types.some(t => t)) {
         yield `, `;
-        yield* (0, wrapWith_1.wrapWith)(exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_`, type, `, `] : `_, `), `) => [] as any`);
+        yield* (0, wrapWith_1.wrapWith)('template', exp.loc.start.offset, exp.loc.end.offset, codeFeatures_1.codeFeatures.verification, `(`, ...types.flatMap(type => type ? [`_`, type, `, `] : `_, `), `) => [] as any`);
     }
     yield `)${utils_1.endOfLine}`;
 }

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

@@ -1,11 +1,9 @@
-import type * as CompilerDOM from '@vue/compiler-dom';
 import type * as ts from 'typescript';
 import type { Code, SfcBlock, VueCodeInformation } from '../../types';
 export declare const newLine = "\n";
 export declare const endOfLine = ";\n";
 export declare const combineLastMapping: VueCodeInformation;
 export declare const identifierRegex: RegExp;
-export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): readonly [string, number];
 export declare function createTsAst(ts: typeof import('typescript'), inlineTsAsts: Map<string, ts.SourceFile> | undefined, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;
 export declare function generatePartiallyEnding(source: string, end: number, mark: string, delimiter?: string): Generator<Code>;

package/lib/codegen/utils/index.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.identifierRegex = exports.combineLastMapping = exports.endOfLine = exports.newLine = void 0;
-exports.normalizeAttributeValue = normalizeAttributeValue;
 exports.createTsAst = createTsAst;
 exports.generateSfcBlockSection = generateSfcBlockSection;
 exports.generatePartiallyEnding = generatePartiallyEnding;
@@ -10,16 +9,6 @@ exports.newLine = `\n`;
 exports.endOfLine = `;${exports.newLine}`;
 exports.combineLastMapping = { __combineOffset: 1 };
 exports.identifierRegex = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-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, inlineTsAsts, text) {
     let ast = inlineTsAsts?.get(text);
     if (!ast) {

package/lib/codegen/utils/stringLiteralKey.js

@@ -8,7 +8,7 @@ function* generateStringLiteralKey(code, offset, info) {
         yield `'${code}'`;
     }
     else {
-        yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
+        yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, info, `'`, [code, 'template', offset, index_1.combineLastMapping], `'`);
     }
 }
 //# sourceMappingURL=stringLiteralKey.js.map

package/lib/codegen/utils/unicode.js

@@ -4,7 +4,7 @@ exports.generateUnicode = generateUnicode;
 const wrapWith_1 = require("./wrapWith");
 function* generateUnicode(code, offset, info) {
     if (needToUnicode(code)) {
-        yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, info, toUnicode(code));
+        yield* (0, wrapWith_1.wrapWith)('template', offset, offset + code.length, info, toUnicode(code));
     }
     else {
         yield [code, 'template', offset, info];

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

@@ -1,3 +1,2 @@
 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>;
+export declare function wrapWith(source: string, startOffset: number, endOffset: number, features: VueCodeInformation, ...codes: Code[]): Generator<Code>;

package/lib/codegen/utils/wrapWith.js

@@ -1,16 +1,7 @@
 "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;
-    }
+function* wrapWith(source, startOffset, endOffset, features, ...codes) {
     yield ['', source, startOffset, features];
     let offset = 1;
     for (const code of codes) {

package/lib/compilerOptions.d.ts

@@ -1,12 +1,10 @@
 import type * as ts from 'typescript';
 import type { RawVueCompilerOptions, VueCompilerOptions, VueLanguagePlugin } from './types';
-interface ParseConfigHost extends Omit<ts.ParseConfigHost, 'readDirectory'> {
-}
 export interface ParsedCommandLine extends Omit<ts.ParsedCommandLine, 'fileNames'> {
     vueOptions: VueCompilerOptions;
 }
-export declare function createParsedCommandLineByJson(ts: typeof import('typescript'), host: ParseConfigHost, rootDir: string, json: any, configFileName?: string): ParsedCommandLine;
-export declare function createParsedCommandLine(ts: typeof import('typescript'), host: ParseConfigHost, configFileName: string): ParsedCommandLine;
+export declare const createParsedCommandLineByJson: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, rootDir: string, json: any, configFileName?: string | undefined) => ParsedCommandLine;
+export declare const createParsedCommandLine: (ts: typeof import("typescript"), host: Omit<ts.ParseConfigHost, "readDirectory">, configFileName: string) => ParsedCommandLine;
 export declare class CompilerOptionsResolver {
     fileExists?: ((path: string) => boolean) | undefined;
     options: Omit<RawVueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>;
@@ -24,4 +22,3 @@ export declare function createGlobalTypesWriter(vueOptions: VueCompilerOptions,
  * @deprecated use `createGlobalTypesWriter` instead
  */
 export declare function writeGlobalTypes(vueOptions: VueCompilerOptions, writeFile: (fileName: string, data: string) => void): void;
-export {};

package/lib/compilerOptions.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompilerOptionsResolver = void 0;
-exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
-exports.createParsedCommandLine = createParsedCommandLine;
+exports.CompilerOptionsResolver = exports.createParsedCommandLine = exports.createParsedCommandLineByJson = void 0;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
 exports.createGlobalTypesWriter = createGlobalTypesWriter;
 exports.writeGlobalTypes = writeGlobalTypes;
@@ -10,75 +8,54 @@ const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("./codegen/globalTypes");
 const shared_2 = require("./utils/shared");
-function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName) {
-    const extendedPaths = new Set();
-    const proxyHost = {
-        ...host,
-        readFile(fileName) {
-            if (!fileName.endsWith('/package.json')) {
-                extendedPaths.add(fileName);
-            }
-            return host.readFile(fileName);
-        },
-        readDirectory() {
-            return [];
-        },
-    };
-    const parsed = ts.parseJsonConfigFileContent(json, proxyHost, rootDir, {}, configFileName);
-    const resolver = new CompilerOptionsResolver(host.fileExists);
-    for (const extendPath of [...extendedPaths].reverse()) {
+exports.createParsedCommandLineByJson = create((ts, host, rootDir, json, configFileName) => {
+    // `parseJsonConfigFileContent` is missing in tsc
+    return 'parseJsonConfigFileContent' in ts
+        ? ts.parseJsonConfigFileContent(json, host, rootDir, {}, configFileName)
+        : ts.parseJsonSourceFileConfigFileContent(ts.parseJsonText(configFileName ?? 'tsconfig.json', JSON.stringify(json)), host, rootDir, {}, configFileName);
+});
+exports.createParsedCommandLine = create((ts, host, configFileName) => {
+    const config = ts.readJsonConfigFile(configFileName, host.readFile);
+    return ts.parseJsonSourceFileConfigFileContent(config, host, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
+});
+function create(getParsedCommandLine) {
+    return (ts, host, ...args) => {
         try {
-            const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-            const obj = ts.convertToObject(configFile, []);
-            const rawOptions = obj?.vueCompilerOptions ?? {};
-            resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
-        }
-        catch { }
-    }
-    // ensure the rootDir is added to the config roots
-    resolver.addConfig({}, rootDir);
-    return {
-        ...parsed,
-        vueOptions: resolver.build(),
-    };
-}
-function createParsedCommandLine(ts, host, configFileName) {
-    try {
-        const extendedPaths = new Set();
-        const proxyHost = {
-            ...host,
-            readFile(fileName) {
-                if (!fileName.endsWith('/package.json')) {
-                    extendedPaths.add(fileName);
+            const extendedPaths = new Set();
+            const proxyHost = {
+                ...host,
+                readFile(fileName) {
+                    if (!fileName.endsWith('/package.json')) {
+                        extendedPaths.add(fileName);
+                    }
+                    return host.readFile(fileName);
+                },
+                readDirectory() {
+                    return [];
+                },
+            };
+            const parsed = getParsedCommandLine(ts, proxyHost, ...args);
+            const resolver = new CompilerOptionsResolver(host.fileExists);
+            for (const extendPath of [...extendedPaths].reverse()) {
+                try {
+                    const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
+                    const obj = ts.convertToObject(configFile, []);
+                    const rawOptions = obj?.vueCompilerOptions ?? {};
+                    resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
                 }
-                return host.readFile(fileName);
-            },
-            readDirectory() {
-                return [];
-            },
-        };
-        const config = ts.readJsonConfigFile(configFileName, proxyHost.readFile);
-        const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, path_browserify_1.posix.dirname(configFileName), {}, configFileName);
-        const resolver = new CompilerOptionsResolver(host.fileExists);
-        for (const extendPath of [...extendedPaths].reverse()) {
-            try {
-                const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
-                const obj = ts.convertToObject(configFile, []);
-                const rawOptions = obj?.vueCompilerOptions ?? {};
-                resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
+                catch { }
             }
-            catch { }
+            return {
+                ...parsed,
+                vueOptions: resolver.build(),
+            };
         }
+        catch { }
         return {
-            ...parsed,
-            vueOptions: resolver.build(),
+            options: {},
+            errors: [],
+            vueOptions: getDefaultCompilerOptions(),
         };
-    }
-    catch { }
-    return {
-        options: {},
-        errors: [],
-        vueOptions: getDefaultCompilerOptions(),
     };
 }
 class CompilerOptionsResolver {