@vue/language-core 3.1.6 → 3.1.8

package/lib/languagePlugin.js

@@ -47,14 +47,14 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
         createVirtualCode(scriptId, languageId, snapshot) {
             const fileName = asFileName(scriptId);
             if (plugins.some(plugin => plugin.isValidFile?.(fileName, languageId))) {
-                const code = fileRegistry.get(fileName);
+                const code = fileRegistry.get(String(scriptId));
                 if (code) {
                     code.update(snapshot);
                     return code;
                 }
                 else {
                     const code = new virtualCode_1.VueVirtualCode(fileName, languageId, snapshot, vueCompilerOptions, plugins, ts);
-                    fileRegistry.set(fileName, code);
+                    fileRegistry.set(String(scriptId), code);
                     return code;
                 }
             }
@@ -64,8 +64,7 @@ function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFile
             return code;
         },
         disposeVirtualCode(scriptId) {
-            const fileName = asFileName(scriptId);
-            fileRegistry.delete(fileName);
+            fileRegistry.delete(String(scriptId));
         },
         typescript: {
             extraFileExtensions: getAllExtensions(vueCompilerOptions)

package/lib/parsers/scriptRanges.d.ts

@@ -1,12 +1,14 @@
 import type * as ts from 'typescript';
-import type { TextRange } from '../types';
+import type { TextRange, VueCompilerOptions } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
-export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, hasScriptSetup: boolean): {
+export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
     exportDefault: (TextRange & {
         expression: TextRange;
+        isObjectLiteral: boolean;
     }) | undefined;
     componentOptions: {
+        isObjectLiteral: boolean;
         expression: TextRange;
         args: TextRange;
         argsNode: ts.ObjectLiteralExpression;
@@ -16,10 +18,6 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         name: TextRange | undefined;
         inheritAttrs: string | undefined;
     } | undefined;
-    bindings: {
-        range: TextRange;
-        moduleName?: string;
-        isDefaultImport?: boolean;
-        isNamespace?: boolean;
-    }[];
+    bindings: TextRange[];
+    components: TextRange[];
 };

package/lib/parsers/scriptRanges.js

@@ -3,15 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptRanges = parseScriptRanges;
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
-function parseScriptRanges(ts, ast, hasScriptSetup) {
+function parseScriptRanges(ts, ast, vueCompilerOptions) {
     let exportDefault;
     let componentOptions;
-    const bindings = hasScriptSetup ? (0, utils_1.parseBindingRanges)(ts, ast) : [];
+    const { bindings, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
     ts.forEachChild(ast, raw => {
         if (ts.isExportAssignment(raw)) {
             exportDefault = {
                 ..._getStartEnd(raw),
                 expression: _getStartEnd(raw.expression),
+                isObjectLiteral: ts.isObjectLiteralExpression(raw.expression),
             };
             const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, raw, [], ast);
             if (comment) {
@@ -54,6 +55,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup) {
                     }
                 });
                 componentOptions = {
+                    isObjectLiteral: ts.isObjectLiteralExpression(node.expression),
                     expression: _getStartEnd(node.expression),
                     args: _getStartEnd(obj),
                     argsNode: obj,
@@ -70,6 +72,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup) {
         exportDefault,
         componentOptions,
         bindings,
+        components,
     };
     function _getStartEnd(node) {
         return (0, shared_1.getStartEnd)(ts, node, ast);

package/lib/parsers/scriptSetupRanges.d.ts

@@ -48,12 +48,8 @@ export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRan
 export declare function parseScriptSetupRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
     leadingCommentEndOffset: number;
     importSectionEndOffset: number;
-    bindings: {
-        range: TextRange;
-        moduleName?: string;
-        isDefaultImport?: boolean;
-        isNamespace?: boolean;
-    }[];
+    bindings: TextRange[];
+    components: TextRange[];
     defineModel: DefineModel[];
     defineProps: DefineProps | undefined;
     withDefaults: WithDefaults | undefined;

package/lib/parsers/scriptSetupRanges.js

@@ -20,7 +20,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const text = ast.text;
     const leadingCommentRanges = ts.getLeadingCommentRanges(text, 0)?.reverse() ?? [];
     const leadingCommentEndOffset = leadingCommentRanges.find(range => tsCheckReg.test(text.slice(range.pos, range.end)))?.end ?? 0;
-    let bindings = (0, utils_1.parseBindingRanges)(ts, ast);
+    let { bindings, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
     ts.forEachChild(ast, node => {
@@ -48,7 +48,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     });
     ts.forEachChild(ast, node => visitNode(node, [ast]));
     const templateRefNames = new Set(useTemplateRef.map(ref => ref.name));
-    bindings = bindings.filter(({ range }) => {
+    bindings = bindings.filter(range => {
         const name = text.slice(range.start, range.end);
         return !templateRefNames.has(name);
     });
@@ -56,6 +56,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         leadingCommentEndOffset,
         importSectionEndOffset,
         bindings,
+        components,
         defineModel,
         defineProps,
         withDefaults,

package/lib/parsers/utils.d.ts

@@ -1,11 +1,9 @@
 import type * as ts from 'typescript';
 import type { TextRange } from '../types';
-export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile): {
-    range: TextRange;
-    moduleName?: string;
-    isDefaultImport?: boolean;
-    isNamespace?: boolean;
-}[];
+export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile, componentExtsensions: string[]): {
+    bindings: TextRange[];
+    components: TextRange[];
+};
 export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
     start: number;
     end: number;

package/lib/parsers/utils.js

@@ -4,44 +4,40 @@ exports.parseBindingRanges = parseBindingRanges;
 exports.getClosestMultiLineCommentRange = getClosestMultiLineCommentRange;
 const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
-function parseBindingRanges(ts, ast) {
+function parseBindingRanges(ts, ast, componentExtsensions) {
     const bindings = [];
+    const components = [];
     ts.forEachChild(ast, node => {
         if (ts.isVariableStatement(node)) {
             for (const decl of node.declarationList.declarations) {
                 const ranges = (0, collectBindings_1.collectBindingRanges)(ts, decl.name, ast);
-                bindings.push(...ranges.map(range => ({ range })));
+                bindings.push(...ranges);
             }
         }
         else if (ts.isFunctionDeclaration(node)) {
             if (node.name && ts.isIdentifier(node.name)) {
-                bindings.push({
-                    range: _getStartEnd(node.name),
-                });
+                bindings.push(_getStartEnd(node.name));
             }
         }
         else if (ts.isClassDeclaration(node)) {
             if (node.name) {
-                bindings.push({
-                    range: _getStartEnd(node.name),
-                });
+                bindings.push(_getStartEnd(node.name));
             }
         }
         else if (ts.isEnumDeclaration(node)) {
-            bindings.push({
-                range: _getStartEnd(node.name),
-            });
+            bindings.push(_getStartEnd(node.name));
         }
         if (ts.isImportDeclaration(node)) {
             const moduleName = _getNodeText(node.moduleSpecifier).slice(1, -1);
             if (node.importClause && !node.importClause.isTypeOnly) {
                 const { name, namedBindings } = node.importClause;
                 if (name) {
-                    bindings.push({
-                        range: _getStartEnd(name),
-                        moduleName,
-                        isDefaultImport: true,
-                    });
+                    if (componentExtsensions.some(ext => moduleName.endsWith(ext))) {
+                        components.push(_getStartEnd(name));
+                    }
+                    else {
+                        bindings.push(_getStartEnd(name));
+                    }
                 }
                 if (namedBindings) {
                     if (ts.isNamedImports(namedBindings)) {
@@ -49,25 +45,27 @@ function parseBindingRanges(ts, ast) {
                             if (element.isTypeOnly) {
                                 continue;
                             }
-                            bindings.push({
-                                range: _getStartEnd(element.name),
-                                moduleName,
-                                isDefaultImport: element.propertyName?.text === 'default',
-                            });
+                            if (element.propertyName
+                                && _getNodeText(element.propertyName) === 'default'
+                                && componentExtsensions.some(ext => moduleName.endsWith(ext))) {
+                                components.push(_getStartEnd(element.name));
+                            }
+                            else {
+                                bindings.push(_getStartEnd(element.name));
+                            }
                         }
                     }
                     else {
-                        bindings.push({
-                            range: _getStartEnd(namedBindings.name),
-                            moduleName,
-                            isNamespace: true,
-                        });
+                        bindings.push(_getStartEnd(namedBindings.name));
                     }
                 }
             }
         }
     });
-    return bindings;
+    return {
+        bindings,
+        components,
+    };
     function _getStartEnd(node) {
         return (0, shared_1.getStartEnd)(ts, node, ast);
     }

package/lib/plugins/vue-script-js.js

@@ -6,7 +6,7 @@ const plugin = ({ modules }) => {
         compileSFCScript(lang, script) {
             if (lang === 'js' || lang === 'ts' || lang === 'jsx' || lang === 'tsx') {
                 const ts = modules.typescript;
-                return ts.createSourceFile('test.' + lang, script, 99);
+                return ts.createSourceFile('.' + lang, script, 99);
             }
         },
     };

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

@@ -3,8 +3,10 @@ export declare const tsCodegen: WeakMap<Sfc, {
     getScriptRanges: () => {
         exportDefault: (import("../types").TextRange & {
             expression: import("../types").TextRange;
+            isObjectLiteral: boolean;
         }) | undefined;
         componentOptions: {
+            isObjectLiteral: boolean;
             expression: import("../types").TextRange;
             args: import("../types").TextRange;
             argsNode: import("typescript").ObjectLiteralExpression;
@@ -14,22 +16,14 @@ export declare const tsCodegen: WeakMap<Sfc, {
             name: import("../types").TextRange | undefined;
             inheritAttrs: string | undefined;
         } | undefined;
-        bindings: {
-            range: import("../types").TextRange;
-            moduleName?: string;
-            isDefaultImport?: boolean;
-            isNamespace?: boolean;
-        }[];
+        bindings: import("../types").TextRange[];
+        components: import("../types").TextRange[];
     } | undefined;
     getScriptSetupRanges: () => {
         leadingCommentEndOffset: number;
         importSectionEndOffset: number;
-        bindings: {
-            range: import("../types").TextRange;
-            moduleName?: string;
-            isDefaultImport?: boolean;
-            isNamespace?: boolean;
-        }[];
+        bindings: import("../types").TextRange[];
+        components: import("../types").TextRange[];
         defineModel: {
             localName?: import("../types").TextRange;
             name?: import("../types").TextRange;
@@ -168,15 +162,12 @@ export declare const tsCodegen: WeakMap<Sfc, {
             typeExp: string;
             offset: number;
         }[]>;
-        currentComponent: {
-            get ctxVar(): string;
-            get propsVar(): string;
-        } | undefined;
         singleRootElTypes: Set<string>;
         singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
         addTemplateRef(name: string, typeExp: string, offset: number): void;
         recordComponentAccess(source: string, name: string, offset?: number): void;
         scopes: Set<string>[];
+        components: (() => string)[];
         declare(...varNames: string[]): void;
         startScope(): () => Generator<import("../types").Code, any, any>;
         getInternalVariable(): string;
@@ -188,7 +179,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
     } | undefined;
     getImportComponentNames: () => Set<string>;
     getSetupExposed: () => Set<string>;
-    getSetupConsts: () => Set<string>;
 }>;
 declare const plugin: VueLanguagePlugin;
 export default plugin;

package/lib/plugins/vue-tsx.js

@@ -61,7 +61,7 @@ function useCodegen(fileName, sfc, ctx) {
         return ctx.vueCompilerOptions;
     });
     const getScriptRanges = (0, alien_signals_1.computed)(() => sfc.script && validLangs.has(sfc.script.lang)
-        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, !!sfc.scriptSetup)
+        ? (0, scriptRanges_1.parseScriptRanges)(ts, sfc.script.ast, getResolvedOptions())
         : undefined);
     const getScriptSetupRanges = (0, alien_signals_1.computed)(() => sfc.scriptSetup && validLangs.has(sfc.scriptSetup.lang)
         ? (0, scriptSetupRanges_1.parseScriptSetupRanges)(ts, sfc.scriptSetup.ast, getResolvedOptions())
@@ -70,23 +70,13 @@ function useCodegen(fileName, sfc, ctx) {
         const names = new Set();
         const scriptSetupRanges = getScriptSetupRanges();
         if (sfc.scriptSetup && scriptSetupRanges) {
-            for (const { range, moduleName, isDefaultImport, isNamespace } of scriptSetupRanges.bindings) {
-                if (moduleName
-                    && isDefaultImport
-                    && !isNamespace
-                    && ctx.vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
-                    names.add(sfc.scriptSetup.content.slice(range.start, range.end));
-                }
+            for (const range of scriptSetupRanges.components) {
+                names.add(sfc.scriptSetup.content.slice(range.start, range.end));
             }
             const scriptRange = getScriptRanges();
             if (sfc.script && scriptRange) {
-                for (const { range, moduleName, isDefaultImport, isNamespace } of scriptRange.bindings) {
-                    if (moduleName
-                        && isDefaultImport
-                        && !isNamespace
-                        && ctx.vueCompilerOptions.extensions.some(ext => moduleName.endsWith(ext))) {
-                        names.add(sfc.script.content.slice(range.start, range.end));
-                    }
+                for (const range of scriptRange.components) {
+                    names.add(sfc.script.content.slice(range.start, range.end));
                 }
             }
         }
@@ -176,13 +166,13 @@ function useCodegen(fileName, sfc, ctx) {
         if (!sfc.scriptSetup || !scriptSetupRanges) {
             return allVars;
         }
-        for (const { range } of scriptSetupRanges.bindings) {
+        for (const range of scriptSetupRanges.bindings) {
             const name = sfc.scriptSetup.content.slice(range.start, range.end);
             allVars.add(name);
         }
         const scriptRanges = getScriptRanges();
         if (sfc.script && scriptRanges) {
-            for (const { range } of scriptRanges.bindings) {
+            for (const range of scriptRanges.bindings) {
                 const name = sfc.script.content.slice(range.start, range.end);
                 allVars.add(name);
             }
@@ -236,7 +226,6 @@ function useCodegen(fileName, sfc, ctx) {
         getGeneratedTemplate,
         getImportComponentNames,
         getSetupExposed,
-        getSetupConsts,
     };
 }
 //# sourceMappingURL=vue-tsx.js.map

package/lib/virtualFile/computedEmbeddedCodes.d.ts

@@ -0,0 +1,4 @@
+import type { VirtualCode } from '@volar/language-core';
+import type { Sfc, VueLanguagePluginReturn } from '../types';
+export declare function computedEmbeddedCodes(plugins: VueLanguagePluginReturn[], fileName: string, sfc: Sfc): () => VirtualCode[];
+export declare function resolveCommonLanguageId(lang: string): string;

package/lib/virtualFile/computedEmbeddedCodes.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computedEmbeddedCodes = computedEmbeddedCodes;
+exports.resolveCommonLanguageId = resolveCommonLanguageId;
+const alien_signals_1 = require("alien-signals");
+const muggle_string_1 = require("muggle-string");
+const buildMappings_1 = require("../utils/buildMappings");
+const embeddedFile_1 = require("./embeddedFile");
+function computedEmbeddedCodes(plugins, fileName, sfc) {
+    const getNameToBlockMap = (0, alien_signals_1.computed)(() => {
+        const blocks = {};
+        if (sfc.template) {
+            blocks[sfc.template.name] = sfc.template;
+        }
+        if (sfc.script) {
+            blocks[sfc.script.name] = sfc.script;
+        }
+        if (sfc.scriptSetup) {
+            blocks[sfc.scriptSetup.name] = sfc.scriptSetup;
+        }
+        for (const block of sfc.styles) {
+            blocks[block.name] = block;
+        }
+        for (const block of sfc.customBlocks) {
+            blocks[block.name] = block;
+        }
+        return blocks;
+    });
+    const getPluginsResult = plugins.map(plugin => computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, name => getNameToBlockMap()[name]));
+    const getFlatResult = (0, alien_signals_1.computed)(() => getPluginsResult.map(r => r()).flat());
+    const getStructuredResult = (0, alien_signals_1.computed)(() => {
+        const embeddedCodes = [];
+        let remain = [...getFlatResult()];
+        while (remain.length) {
+            const beforeLength = remain.length;
+            consumeRemain();
+            if (beforeLength === remain.length) {
+                break;
+            }
+        }
+        for (const { code } of remain) {
+            console.error('Unable to resolve embedded: ' + code.parentCodeId + ' -> ' + code.id);
+        }
+        return embeddedCodes;
+        function consumeRemain() {
+            for (let i = remain.length - 1; i >= 0; i--) {
+                const { code, snapshot, mappings } = remain[i];
+                if (!code.parentCodeId) {
+                    embeddedCodes.push({
+                        id: code.id,
+                        languageId: resolveCommonLanguageId(code.lang),
+                        linkedCodeMappings: code.linkedCodeMappings,
+                        snapshot,
+                        mappings,
+                        embeddedCodes: [],
+                    });
+                    remain.splice(i, 1);
+                }
+                else {
+                    const parent = findParentStructure(code.parentCodeId, embeddedCodes);
+                    if (parent) {
+                        parent.embeddedCodes ??= [];
+                        parent.embeddedCodes.push({
+                            id: code.id,
+                            languageId: resolveCommonLanguageId(code.lang),
+                            linkedCodeMappings: code.linkedCodeMappings,
+                            snapshot,
+                            mappings,
+                            embeddedCodes: [],
+                        });
+                        remain.splice(i, 1);
+                    }
+                }
+            }
+        }
+        function findParentStructure(id, current) {
+            for (const child of current) {
+                if (child.id === id) {
+                    return child;
+                }
+                let parent = findParentStructure(id, child.embeddedCodes ?? []);
+                if (parent) {
+                    return parent;
+                }
+            }
+        }
+    });
+    return getStructuredResult;
+}
+function computedPluginEmbeddedCodes(plugins, plugin, fileName, sfc, getBlockByName) {
+    const computeds = new Map();
+    const getComputedKey = (code) => code.id + '__' + code.lang;
+    const getCodes = (0, alien_signals_1.computed)(() => {
+        try {
+            if (!plugin.getEmbeddedCodes) {
+                return [...computeds.values()];
+            }
+            const embeddedCodeInfos = plugin.getEmbeddedCodes(fileName, sfc);
+            for (const oldId of computeds.keys()) {
+                if (!embeddedCodeInfos.some(code => getComputedKey(code) === oldId)) {
+                    computeds.delete(oldId);
+                }
+            }
+            for (const codeInfo of embeddedCodeInfos) {
+                if (!computeds.has(getComputedKey(codeInfo))) {
+                    computeds.set(getComputedKey(codeInfo), (0, alien_signals_1.computed)(() => {
+                        const content = [];
+                        const code = new embeddedFile_1.VueEmbeddedCode(codeInfo.id, codeInfo.lang, content);
+                        for (const plugin of plugins) {
+                            if (!plugin.resolveEmbeddedCode) {
+                                continue;
+                            }
+                            try {
+                                plugin.resolveEmbeddedCode(fileName, sfc, code);
+                            }
+                            catch (e) {
+                                console.error(e);
+                            }
+                        }
+                        const newText = (0, muggle_string_1.toString)(code.content);
+                        const changeRanges = new Map();
+                        const snapshot = {
+                            getText: (start, end) => newText.slice(start, end),
+                            getLength: () => newText.length,
+                            getChangeRange(oldSnapshot) {
+                                if (!changeRanges.has(oldSnapshot)) {
+                                    changeRanges.set(oldSnapshot, undefined);
+                                    const oldText = oldSnapshot.getText(0, oldSnapshot.getLength());
+                                    const changeRange = fullDiffTextChangeRange(oldText, newText);
+                                    if (changeRange) {
+                                        changeRanges.set(oldSnapshot, changeRange);
+                                    }
+                                }
+                                return changeRanges.get(oldSnapshot);
+                            },
+                        };
+                        return {
+                            code,
+                            snapshot,
+                        };
+                    }));
+                }
+            }
+        }
+        catch (e) {
+            console.error(e);
+        }
+        return [...computeds.values()];
+    });
+    return (0, alien_signals_1.computed)(() => {
+        return getCodes().map(_file => {
+            const { code, snapshot } = _file();
+            const mappings = (0, buildMappings_1.buildMappings)(code.content.map(segment => {
+                if (typeof segment === 'string') {
+                    return segment;
+                }
+                const source = segment[1];
+                if (source === undefined) {
+                    return segment;
+                }
+                const block = getBlockByName(source);
+                if (!block) {
+                    // console.warn('Unable to find block: ' + source);
+                    return segment;
+                }
+                return [
+                    segment[0],
+                    undefined,
+                    segment[2] + block.startTagEnd,
+                    segment[3],
+                ];
+            }));
+            const newMappings = [];
+            const tokenMappings = new Map();
+            for (let i = 0; i < mappings.length; i++) {
+                const mapping = mappings[i];
+                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.__combineOffset);
+                    }
+                    offsetMapping.sourceOffsets.push(...mapping.sourceOffsets);
+                    offsetMapping.generatedOffsets.push(...mapping.generatedOffsets);
+                    offsetMapping.lengths.push(...mapping.lengths);
+                    continue;
+                }
+                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;
+                }
+                newMappings.push(mapping);
+            }
+            return {
+                code,
+                snapshot,
+                mappings: newMappings,
+            };
+        });
+    });
+}
+function fullDiffTextChangeRange(oldText, newText) {
+    for (let start = 0; start < oldText.length && start < newText.length; start++) {
+        if (oldText[start] !== newText[start]) {
+            let end = oldText.length;
+            for (let i = 0; i < oldText.length - start && i < newText.length - start; i++) {
+                if (oldText[oldText.length - i - 1] !== newText[newText.length - i - 1]) {
+                    break;
+                }
+                end--;
+            }
+            let length = end - start;
+            let newLength = length + (newText.length - oldText.length);
+            if (newLength < 0) {
+                length -= newLength;
+                newLength = 0;
+            }
+            return {
+                span: { start, length },
+                newLength,
+            };
+        }
+    }
+}
+function resolveCommonLanguageId(lang) {
+    switch (lang) {
+        case 'js':
+            return 'javascript';
+        case 'cjs':
+            return 'javascript';
+        case 'mjs':
+            return 'javascript';
+        case 'ts':
+            return 'typescript';
+        case 'cts':
+            return 'typescript';
+        case 'mts':
+            return 'typescript';
+        case 'jsx':
+            return 'javascriptreact';
+        case 'tsx':
+            return 'typescriptreact';
+        case 'pug':
+            return 'jade';
+        case 'md':
+            return 'markdown';
+    }
+    return lang;
+}
+//# sourceMappingURL=computedEmbeddedCodes.js.map

package/lib/virtualFile/computedSfc.d.ts

@@ -0,0 +1,6 @@
+import * as CompilerDOM from '@vue/compiler-dom';
+import type { SFCParseResult } from '@vue/compiler-sfc';
+import type * as ts from 'typescript';
+import type { Sfc, VueLanguagePluginReturn } from '../types';
+export declare const templateInlineTsAsts: WeakMap<CompilerDOM.RootNode, Map<string, ts.SourceFile>>;
+export declare function computedSfc(ts: typeof import('typescript'), plugins: VueLanguagePluginReturn[], fileName: string, getSnapshot: () => ts.IScriptSnapshot, getParseResult: () => SFCParseResult | undefined): Sfc;