@vue/language-core 2.2.2 → 2.2.6

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

@@ -1,4 +1,3 @@
-import type { Mapping } from '@volar/language-core';
 import type { Code, Sfc, VueLanguagePlugin } from '../types';
 export declare const tsCodegen: WeakMap<Sfc, {
     getScriptRanges: () => {
@@ -38,6 +37,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
             defaultValue?: import("../types").TextRange;
             required?: boolean;
             isModel?: boolean;
+            comments?: import("../types").TextRange;
+            argNode?: import("typescript").Expression;
         }[];
         defineProps: ({
             callExp: import("../types").TextRange;
@@ -118,10 +119,8 @@ export declare const tsCodegen: WeakMap<Sfc, {
     getLang: () => string;
     getGeneratedScript: () => {
         codes: Code[];
-        linkedCodeMappings: Mapping<unknown>[];
         generatedTemplate: boolean;
         generatedPropsType: boolean;
-        scriptSetupGeneratedOffset: number | undefined;
         bypassDefineComponent: boolean;
         bindingNames: Set<string>;
         localTypes: {
@@ -169,7 +168,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 +182,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

@@ -35,7 +35,6 @@ const plugin = ctx => {
                 const tsx = codegen.getGeneratedScript();
                 if (tsx) {
                     embeddedFile.content = [...tsx.codes];
-                    embeddedFile.linkedCodeMappings = [...tsx.linkedCodeMappings];
                 }
             }
         },
@@ -53,16 +52,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 +69,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 +88,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 +123,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 +143,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(),
@@ -169,13 +168,11 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
     });
     const getGeneratedScript = (0, alien_signals_1.computed)(() => {
         const codes = [];
-        const linkedCodeMappings = [];
-        let generatedLength = 0;
         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(),
@@ -184,8 +181,6 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
             templateCodegen: getGeneratedTemplate(),
             destructuredPropNames: getSetupDestructuredPropNames(),
             templateRefNames: getSetupTemplateRefNames(),
-            getGeneratedLength: () => generatedLength,
-            linkedCodeMappings,
             appendGlobalTypes,
         });
         fileEditTimes.set(fileName, (fileEditTimes.get(fileName) ?? 0) + 1);
@@ -193,15 +188,11 @@ function createTsx(fileName, _sfc, ctx, appendGlobalTypes) {
         while (!current.done) {
             const code = current.value;
             codes.push(code);
-            generatedLength += typeof code === 'string'
-                ? code.length
-                : code[0].length;
             current = codegen.next();
         }
         return {
             ...current.value,
             codes,
-            linkedCodeMappings,
         };
     });
     return {

package/lib/types.d.ts

@@ -12,8 +12,8 @@ export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' |
     plugins?: string[];
 };
 export interface VueCodeInformation extends CodeInformation {
-    __combineLastMapping?: boolean;
-    __combineOffsetMapping?: number;
+    __combineOffset?: number;
+    __linkedToken?: symbol;
 }
 export type Code = Segment<VueCodeInformation>;
 export interface VueCompilerOptions {
@@ -27,8 +27,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 +110,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 +124,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 +148,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,35 @@ function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByN
                 ];
             }));
             const newMappings = [];
-            let lastValidMapping;
+            const tokenMappings = new Map();
             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);
+                if (mapping.data.__linkedToken !== undefined) {
+                    const token = mapping.data.__linkedToken;
+                    if (tokenMappings.has(token)) {
+                        const prevMapping = tokenMappings.get(token);
+                        code.linkedCodeMappings.push({
+                            sourceOffsets: [prevMapping.generatedOffsets[0]],
+                            generatedOffsets: [mapping.generatedOffsets[0]],
+                            lengths: [Number(token.description)],
+                            data: undefined,
+                        });
+                    }
+                    else {
+                        tokenMappings.set(token, mapping);
+                    }
                     continue;
                 }
-                else {
-                    lastValidMapping = mapping;
-                }
                 newMappings.push(mapping);
             }
             return {

package/lib/virtualFile/computedSfc.js

@@ -32,12 +32,8 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
         });
     });
     const getScript = computedNullableSfcBlock('script', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.script ?? undefined), (block, base) => {
-        const src = (0, alien_signals_1.computed)(() => block().src);
-        const srcOffset = (0, alien_signals_1.computed)(() => {
-            const _src = src();
-            return _src ? getUntrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_src) - base.startTagEnd : -1;
-        });
-        const ast = (0, alien_signals_1.computed)(() => {
+        const getSrc = computedAttrValue('__src', base, block);
+        const getAst = (0, alien_signals_1.computed)(() => {
             for (const plugin of plugins) {
                 const ast = plugin.compileSFCScript?.(base.lang, base.content);
                 if (ast) {
@@ -47,21 +43,13 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
         });
         return mergeObject(base, {
-            get src() { return src(); },
-            get srcOffset() { return srcOffset(); },
-            get ast() { return ast(); },
+            get src() { return getSrc(); },
+            get ast() { return getAst(); },
         });
     });
     const getOriginalScriptSetup = computedNullableSfcBlock('scriptSetup', 'js', (0, alien_signals_1.computed)(() => getParseResult()?.descriptor.scriptSetup ?? undefined), (block, base) => {
-        const generic = (0, alien_signals_1.computed)(() => {
-            const _block = block();
-            return typeof _block.attrs.generic === 'string' ? _block.attrs.generic : undefined;
-        });
-        const genericOffset = (0, alien_signals_1.computed)(() => {
-            const _generic = generic();
-            return _generic !== undefined ? getUntrackedSnapshot().getText(0, base.startTagEnd).lastIndexOf(_generic) - base.startTagEnd : -1;
-        });
-        const ast = (0, alien_signals_1.computed)(() => {
+        const getGeneric = computedAttrValue('__generic', base, block);
+        const getAst = (0, alien_signals_1.computed)(() => {
             for (const plugin of plugins) {
                 const ast = plugin.compileSFCScript?.(base.lang, base.content);
                 if (ast) {
@@ -71,9 +59,8 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             return ts.createSourceFile(fileName + '.' + base.lang, '', 99);
         });
         return mergeObject(base, {
-            get generic() { return generic(); },
-            get genericOffset() { return genericOffset(); },
-            get ast() { return ast(); },
+            get generic() { return getGeneric(); },
+            get ast() { return getAst(); },
         });
     });
     const hasScript = (0, alien_signals_1.computed)(() => !!getParseResult()?.descriptor.script);
@@ -99,13 +86,7 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
     });
     const styles = (0, signals_1.computedArray)((0, alien_signals_1.computed)(() => getParseResult()?.descriptor.styles ?? []), (getBlock, i) => {
         const base = computedSfcBlock('style_' + i, 'css', getBlock);
-        const getModule = (0, alien_signals_1.computed)(() => {
-            const { __module } = getBlock();
-            return __module ? {
-                name: __module.name,
-                offset: __module.offset ? base.start + __module.offset : undefined
-            } : undefined;
-        });
+        const getModule = computedAttrValue('__module', base, getBlock);
         const getScoped = (0, alien_signals_1.computed)(() => !!getBlock().scoped);
         const getCssVars = (0, alien_signals_1.computed)(() => [...(0, parseCssVars_1.parseCssVars)(base.content)]);
         const getClassNames = (0, alien_signals_1.computed)(() => [...(0, parseCssClassNames_1.parseCssClassNames)(base.content)]);
@@ -243,6 +224,18 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
             get end() { return getEnd(); },
         };
     }
+    function computedAttrValue(key, base, getBlock) {
+        return (0, alien_signals_1.computed)(() => {
+            const val = getBlock()[key];
+            if (typeof val === 'object') {
+                return {
+                    ...val,
+                    offset: base.start + val.offset,
+                };
+            }
+            return val;
+        });
+    }
 }
 function mergeObject(a, b) {
     return Object.defineProperties(a, Object.getOwnPropertyDescriptors(b));

package/lib/virtualFile/vueFile.d.ts

@@ -10,17 +10,14 @@ export declare class VueVirtualCode implements VirtualCode {
     ts: typeof import('typescript');
     id: string;
     private _snapshot;
-    _vueSfc: () => import("@vue/compiler-sfc").SFCParseResult | undefined;
-    _sfc: import("../types").Sfc;
-    _mappings: () => {
-        sourceOffsets: number[];
-        generatedOffsets: number[];
-        lengths: number[];
-        data: import("@volar/language-core").CodeInformation;
-    }[];
-    _embeddedCodes: () => VirtualCode[];
-    get embeddedCodes(): VirtualCode[];
+    private _vueSfc;
+    private _sfc;
+    private _embeddedCodes;
+    private _mappings;
     get snapshot(): ts.IScriptSnapshot;
+    get vueSfc(): import("@vue/compiler-sfc").SFCParseResult | undefined;
+    get sfc(): import("../types").Sfc;
+    get embeddedCodes(): VirtualCode[];
     get mappings(): {
         sourceOffsets: number[];
         generatedOffsets: number[];

package/lib/virtualFile/vueFile.js

@@ -8,12 +8,18 @@ const computedSfc_1 = require("./computedSfc");
 const computedVueSfc_1 = require("./computedVueSfc");
 class VueVirtualCode {
     // others
-    get embeddedCodes() {
-        return this._embeddedCodes();
-    }
     get snapshot() {
         return this._snapshot();
     }
+    get vueSfc() {
+        return this._vueSfc();
+    }
+    get sfc() {
+        return this._sfc;
+    }
+    get embeddedCodes() {
+        return this._embeddedCodes();
+    }
     get mappings() {
         return this._mappings();
     }
@@ -30,6 +36,7 @@ class VueVirtualCode {
         // computeds
         this._vueSfc = (0, computedVueSfc_1.computedVueSfc)(this.plugins, this.fileName, this.languageId, this._snapshot);
         this._sfc = (0, computedSfc_1.computedSfc)(this.ts, this.plugins, this.fileName, this._snapshot, this._vueSfc);
+        this._embeddedCodes = (0, computedEmbeddedCodes_1.computedEmbeddedCodes)(this.plugins, this.fileName, this._sfc);
         this._mappings = (0, alien_signals_1.computed)(() => {
             const snapshot = this._snapshot();
             return [{
@@ -39,7 +46,6 @@ class VueVirtualCode {
                     data: plugins_1.allCodeFeatures,
                 }];
         });
-        this._embeddedCodes = (0, computedEmbeddedCodes_1.computedEmbeddedCodes)(this.plugins, this.fileName, this._sfc);
         this._snapshot(initSnapshot);
     }
     update(newSnapshot) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "2.2.2",
+	"version": "2.2.6",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -37,5 +37,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "30757908b67f40f779c36795665163634fb81868"
+	"gitHead": "f2088e256dc0220db9549d28d9f865a5711dcfbe"
 }

package/lib/codeFeatures.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/codeFeatures.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=codeFeatures.js.map

package/lib/codegen/common.d.ts

@@ -1,12 +0,0 @@
-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 variableNameRegex: RegExp;
-export declare function conditionWrapWith(condition: boolean, startOffset: number, endOffset: number, features: VueCodeInformation, ...wrapCodes: Code[]): Generator<Code>;
-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 createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
-export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;