@vue/language-core 2.2.2 → 2.2.4

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

@@ -1,6 +1,6 @@
 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;
@@ -19,3 +19,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

@@ -7,10 +7,11 @@ 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];
@@ -21,7 +22,7 @@ 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, []);
@@ -76,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.js

@@ -196,26 +196,21 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             }
             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 +232,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 +249,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 +284,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 +304,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);
     }

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) {

package/lib/plugins/vue-tsx.d.ts

@@ -169,7 +169,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             expVar: string;
             propsVar: string;
         }[];
-        specialVars: Set<string>;
+        dollarVars: Set<string>;
         accessExternalVariables: Map<string, Set<number>>;
         lastGenericComment: {
             content: string;
@@ -183,21 +183,25 @@ export declare const tsCodegen: WeakMap<Sfc, {
         }[];
         emptyClassOffsets: number[];
         inlayHints: import("../codegen/inlayHints").InlayHintInfo[];
-        hasSlot: boolean;
         bindingAttrLocs: import("@vue/compiler-dom").SourceLocation[];
         inheritedAttrVars: Set<string>;
-        templateRefs: Map<string, [varName: string, offset: number]>;
+        templateRefs: Map<string, {
+            typeExp: string;
+            offset: number;
+        }>;
         currentComponent: {
             ctxVar: string;
             used: boolean;
         } | undefined;
-        singleRootElType: string | undefined;
-        singleRootNode: import("@vue/compiler-dom").ElementNode | undefined;
+        singleRootElTypes: string[];
+        singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
         accessExternalVariable(name: string, offset?: number): void;
         hasLocalVariable: (name: string) => boolean;
         addLocalVariable: (name: string) => void;
         removeLocalVariable: (name: string) => void;
         getInternalVariable: () => string;
+        getHoistVariable: (originalVar: string) => string;
+        generateHoistVariables: () => Generator<string, void, unknown>;
         ignoreError: () => Generator<Code>;
         expectError: (prevNode: import("@vue/compiler-dom").CommentNode) => Generator<Code>;
         resetDirectiveComments: (endStr: string) => Generator<Code>;

package/lib/plugins/vue-tsx.js

@@ -53,16 +53,16 @@ const plugin = ctx => {
     }
 };
 exports.default = plugin;
-function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
+function createTsx(fileName, sfc, ctx, appendGlobalTypes) {
     const ts = ctx.modules.typescript;
     const getLang = (0, alien_signals_1.computed)(() => {
-        return !_sfc.script && !_sfc.scriptSetup ? 'ts'
-            : _sfc.scriptSetup && _sfc.scriptSetup.lang !== 'js' ? _sfc.scriptSetup.lang
-                : _sfc.script && _sfc.script.lang !== 'js' ? _sfc.script.lang
+        return !sfc.script && !sfc.scriptSetup ? 'ts'
+            : sfc.scriptSetup && sfc.scriptSetup.lang !== 'js' ? sfc.scriptSetup.lang
+                : sfc.script && sfc.script.lang !== 'js' ? sfc.script.lang
                     : 'js';
     });
     const getResolvedOptions = (0, alien_signals_1.computed)(() => {
-        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(_sfc.comments);
+        const options = (0, vueCompilerOptions_1.parseVueCompilerOptions)(sfc.comments);
         if (options) {
             const resolver = new ts_1.CompilerOptionsResolver();
             resolver.addConfig(options, path.dirname(fileName));
@@ -70,18 +70,18 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         }
         return ctx.vueCompilerOptions;
     });
-    const getScriptRanges = (0, alien_signals_1.computed)(() => _sfc.script
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, _sfc.script.ast, !!_sfc.scriptSetup, false)
+    const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup, false)
         : undefined);
-    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => _sfc.scriptSetup
-        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, _sfc.scriptSetup.ast, getResolvedOptions())
+    const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup
+        ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())
         : undefined);
     const getSetupBindingNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
         const newNames = new Set();
         const bindings = getScriptSetupRanges()?.bindings;
-        if (_sfc.scriptSetup && bindings) {
+        if (sfc.scriptSetup && bindings) {
             for (const { range } of bindings) {
-                newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+                newNames.add(sfc.scriptSetup.content.slice(range.start, range.end));
             }
         }
         return newNames;
@@ -89,13 +89,13 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     const getSetupImportComponentNames = (0, signals_1.computedSet)((0, alien_signals_1.computed)(() => {
         const newNames = new Set();
         const bindings = getScriptSetupRanges()?.bindings;
-        if (_sfc.scriptSetup && bindings) {
+        if (sfc.scriptSetup && bindings) {
             for (const { range, moduleName, isDefaultImport, isNamespace } of bindings) {
                 if (moduleName
                     && isDefaultImport
                     && !isNamespace
                     && ctx.vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
-                    newNames.add(_sfc.scriptSetup.content.slice(range.start, range.end));
+                    newNames.add(sfc.scriptSetup.content.slice(range.start, range.end));
                 }
             }
         }
@@ -124,19 +124,19 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     });
     const getComponentSelfName = (0, alien_signals_1.computed)(() => {
         const { exportDefault } = getScriptRanges() ?? {};
-        if (_sfc.script && exportDefault?.nameOption) {
+        if (sfc.script && exportDefault?.nameOption) {
             const { nameOption } = exportDefault;
-            return _sfc.script.content.slice(nameOption.start + 1, nameOption.end - 1);
+            return sfc.script.content.slice(nameOption.start + 1, nameOption.end - 1);
         }
         const { defineOptions } = getScriptSetupRanges() ?? {};
-        if (_sfc.scriptSetup && defineOptions?.name) {
+        if (sfc.scriptSetup && defineOptions?.name) {
             return defineOptions.name;
         }
         const baseName = path.basename(fileName);
         return (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
     });
     const getGeneratedTemplate = (0, alien_signals_1.computed)(() => {
-        if (getResolvedOptions().skipTemplateCodegen || !_sfc.template) {
+        if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
             return;
         }
         const codes = [];
@@ -144,7 +144,7 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
-            template: _sfc.template,
+            template: sfc.template,
             edited: getResolvedOptions().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             scriptSetupBindingNames: getSetupBindingNames(),
             scriptSetupImportComponentNames: getSetupImportComponentNames(),
@@ -168,14 +168,14 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         };
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
-        const codes = [];
         const linkedCodeMappings = [];
         let generatedLength = 0;
+        const codes = [];
         const codegen = (0, script_1.generateScript)({
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
-            sfc: _sfc,
+            sfc: sfc,
             edited: getResolvedOptions().__test || (fileEditTimes.get(fileName) ?? 0) >= 2,
             fileName,
             lang: getLang(),

package/lib/types.d.ts

@@ -12,8 +12,7 @@ export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' |
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
-    __combineLastMapping?: boolean;
-    __combineOffsetMapping?: number;
+    __combineOffset?: number;
 }
 export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {
@@ -27,8 +26,15 @@ export interface VueCompilerOptions {
     checkUnknownEvents: boolean;
     checkUnknownDirectives: boolean;
     checkUnknownComponents: boolean;
+    inferComponentDollarEl: boolean;
+    inferComponentDollarRefs: boolean;
+    inferTemplateDollarAttrs: boolean;
+    inferTemplateDollarEl: boolean;
+    inferTemplateDollarRefs: boolean;
+    inferTemplateDollarSlots: boolean;
     skipTemplateCodegen: boolean;
     fallthroughAttributes: boolean;
+    fallthroughComponentNames: string[];
     dataAttributes: string[];
     htmlAttributes: string[];
     optionsWrapper: [string, string] | [];
@@ -103,6 +109,11 @@ export interface SfcBlock {
     content: string;
     attrs: Record<string, string | true>;
 }
+export type SfcBlockAttr = true | {
+    text: string;
+    offset: number;
+    quotes: boolean;
+};
 export interface Sfc {
     content: string;
     comments: string[];
@@ -112,21 +123,16 @@ export interface Sfc {
         warnings: CompilerDOM.CompilerError[];
     } | undefined;
     script: (SfcBlock & {
-        src: string | undefined;
-        srcOffset: number;
+        src: SfcBlockAttr | undefined;
         ast: ts.SourceFile;
     }) | undefined;
     scriptSetup: SfcBlock & {
-        generic: string | undefined;
-        genericOffset: number;
+        generic: SfcBlockAttr | undefined;
         ast: ts.SourceFile;
     } | undefined;
     styles: readonly (SfcBlock & {
         scoped: boolean;
-        module?: {
-            name: string;
-            offset?: number;
-        };
+        module?: SfcBlockAttr | undefined;
         cssVars: {
             text: string;
             offset: number;
@@ -141,11 +147,14 @@ export interface Sfc {
     })[];
 }
 declare module '@vue/compiler-sfc' {
+    interface SFCBlock {
+        __src?: SfcBlockAttr;
+    }
+    interface SFCScriptBlock {
+        __generic?: SfcBlockAttr;
+    }
     interface SFCStyleBlock {
-        __module?: {
-            name: string;
-            offset?: number;
-        };
+        __module?: SfcBlockAttr;
     }
 }
 export interface TextRange {

package/lib/utils/parseSfc.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parse = parse;
-const compiler = require("@vue/compiler-dom");
+const CompilerDOM = require("@vue/compiler-dom");
 function parse(source) {
     const errors = [];
-    const ast = compiler.parse(source, {
+    const ast = CompilerDOM.parse(source, {
         // there are no components at SFC parsing level
         isNativeTag: () => true,
         // preserve all whitespaces
@@ -29,11 +29,11 @@ function parse(source) {
         shouldForceReload: () => false,
     };
     ast.children.forEach(node => {
-        if (node.type === compiler.NodeTypes.COMMENT) {
+        if (node.type === CompilerDOM.NodeTypes.COMMENT) {
             descriptor.comments.push(node.content);
             return;
         }
-        else if (node.type !== compiler.NodeTypes.ELEMENT) {
+        else if (node.type !== CompilerDOM.NodeTypes.ELEMENT) {
             return;
         }
         switch (node.tag) {
@@ -99,31 +99,55 @@ function createBlock(node, source) {
         attrs
     };
     node.props.forEach(p => {
-        if (p.type === compiler.NodeTypes.ATTRIBUTE) {
+        if (p.type === CompilerDOM.NodeTypes.ATTRIBUTE) {
             attrs[p.name] = p.value ? p.value.content || true : true;
             if (p.name === 'lang') {
-                block.lang = p.value && p.value.content;
+                block.lang = p.value?.content;
             }
             else if (p.name === 'src') {
-                block.src = p.value && p.value.content;
+                block.__src = parseAttr(p, node);
             }
-            else if (type === 'style') {
+            else if (isScriptBlock(block)) {
+                if (p.name === 'setup' || p.name === 'vapor') {
+                    block.setup = attrs[p.name];
+                }
+                else if (p.name === 'generic') {
+                    block.__generic = parseAttr(p, node);
+                }
+            }
+            else if (isStyleBlock(block)) {
                 if (p.name === 'scoped') {
                     block.scoped = true;
                 }
                 else if (p.name === 'module') {
-                    block.__module = {
-                        name: p.value?.content ?? '$style',
-                        offset: p.value?.content ? p.value?.loc.start.offset - node.loc.start.offset : undefined
-                    };
+                    block.__module = parseAttr(p, node);
                 }
             }
-            else if (type === 'script'
-                && (p.name === 'setup' || p.name === 'vapor')) {
-                block.setup = attrs[p.name];
-            }
         }
     });
     return block;
 }
+function isScriptBlock(block) {
+    return block.type === 'script';
+}
+function isStyleBlock(block) {
+    return block.type === 'style';
+}
+function parseAttr(p, node) {
+    if (!p.value) {
+        return true;
+    }
+    const text = p.value.content;
+    const source = p.value.loc.source;
+    let offset = p.value.loc.start.offset - node.loc.start.offset;
+    const quotes = source.startsWith('"') || source.startsWith("'");
+    if (quotes) {
+        offset++;
+    }
+    return {
+        text,
+        offset,
+        quotes,
+    };
+}
 //# sourceMappingURL=parseSfc.js.map

package/lib/utils/ts.js

@@ -10,6 +10,7 @@ const shared_1 = require("@vue/shared");
 const path_browserify_1 = require("path-browserify");
 const globalTypes_1 = require("../codegen/globalTypes");
 const languagePlugin_1 = require("../languagePlugin");
+const shared_2 = require("./shared");
 function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, configFileName = rootDir + '/jsconfig.json', skipGlobalTypesSetup = false) {
     const proxyHost = proxyParseConfigHostForExtendConfigPaths(parseConfigHost);
     ts.parseJsonConfigFileContent(json, proxyHost.host, rootDir, {}, configFileName);
@@ -174,6 +175,10 @@ class CompilerOptionsResolver {
                 ...defaults.composables,
                 ...this.options.composables,
             },
+            fallthroughComponentNames: [
+                ...defaults.fallthroughComponentNames,
+                ...this.options.fallthroughComponentNames ?? []
+            ].map(shared_2.hyphenateTag),
             // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
             // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
             experimentalModelPropName: Object.fromEntries(Object.entries(this.options.experimentalModelPropName ?? defaults.experimentalModelPropName).map(([k, v]) => [(0, shared_1.camelize)(k), v])),
@@ -217,8 +222,20 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         checkUnknownEvents: strictTemplates,
         checkUnknownDirectives: strictTemplates,
         checkUnknownComponents: strictTemplates,
+        inferComponentDollarEl: false,
+        inferComponentDollarRefs: false,
+        inferTemplateDollarAttrs: false,
+        inferTemplateDollarEl: false,
+        inferTemplateDollarRefs: false,
+        inferTemplateDollarSlots: false,
         skipTemplateCodegen: false,
         fallthroughAttributes: false,
+        fallthroughComponentNames: [
+            'Transition',
+            'KeepAlive',
+            'Teleport',
+            'Suspense',
+        ],
         dataAttributes: [],
         htmlAttributes: ['aria-*'],
         optionsWrapper: target >= 2.7

package/lib/virtualFile/computedEmbeddedCodes.js

@@ -171,28 +171,18 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByN
                 ];
             }));
             const newMappings = [];
-            let lastValidMapping;
             for (let i = 0; i < mappings.length; i++) {
                 const mapping = mappings[i];
-                if (mapping.data.__combineOffsetMapping !== undefined) {
-                    const offsetMapping = mappings[i - mapping.data.__combineOffsetMapping];
+                if (mapping.data.__combineOffset !== undefined) {
+                    const offsetMapping = mappings[i - mapping.data.__combineOffset];
                     if (typeof offsetMapping === 'string' || !offsetMapping) {
-                        throw new Error('Invalid offset mapping, mappings: ' + mappings.length + ', i: ' + i + ', offset: ' + mapping.data.__combineOffsetMapping);
+                        throw new Error('Invalid offset mapping, mappings: ' + mappings.length + ', i: ' + i + ', offset: ' + mapping.data.__combineOffset);
                     }
                     offsetMapping.sourceOffsets.push(...mapping.sourceOffsets);
                     offsetMapping.generatedOffsets.push(...mapping.generatedOffsets);
                     offsetMapping.lengths.push(...mapping.lengths);
                     continue;
                 }
-                else if (mapping.data.__combineLastMapping) {
-                    lastValidMapping.sourceOffsets.push(...mapping.sourceOffsets);
-                    lastValidMapping.generatedOffsets.push(...mapping.generatedOffsets);
-                    lastValidMapping.lengths.push(...mapping.lengths);
-                    continue;
-                }
-                else {
-                    lastValidMapping = mapping;
-                }
                 newMappings.push(mapping);
             }
             return {