@vue/language-core 3.0.7-alpha.1 → 3.1.0-alpha.0

package/lib/plugins/vue-tsx.js

@@ -31,9 +31,7 @@ const plugin = ctx => {
             if (/script_(js|jsx|ts|tsx)/.test(embeddedFile.id)) {
                 const codegen = useCodegen(fileName, sfc);
                 const tsx = codegen.getGeneratedScript();
-                if (tsx) {
-                    embeddedFile.content = [...tsx.codes];
-                }
+                embeddedFile.content = [...tsx.codes];
             }
         },
     };
@@ -120,25 +118,30 @@ function createTsx(fileName, sfc, ctx) {
         return newNames;
     });
     const setupHasDefineSlots = (0, alien_signals_1.computed)(() => !!getScriptSetupRanges()?.defineSlots);
-    const getSetupSlotsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineSlots?.name);
     const getSetupPropsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineProps?.name);
+    const getSetupSlotsAssignName = (0, alien_signals_1.computed)(() => getScriptSetupRanges()?.defineSlots?.name);
     const getSetupInheritAttrs = (0, alien_signals_1.computed)(() => {
         const value = getScriptSetupRanges()?.defineOptions?.inheritAttrs
             ?? getScriptRanges()?.exportDefault?.inheritAttrsOption;
         return value !== 'false';
     });
     const getComponentSelfName = (0, alien_signals_1.computed)(() => {
+        let name;
         const { exportDefault } = getScriptRanges() ?? {};
         if (sfc.script && exportDefault?.nameOption) {
-            const { nameOption } = exportDefault;
-            return sfc.script.content.slice(nameOption.start + 1, nameOption.end - 1);
+            name = sfc.script.content.slice(exportDefault.nameOption.start + 1, exportDefault.nameOption.end - 1);
         }
-        const { defineOptions } = getScriptSetupRanges() ?? {};
-        if (sfc.scriptSetup && defineOptions?.name) {
-            return defineOptions.name;
+        else {
+            const { defineOptions } = getScriptSetupRanges() ?? {};
+            if (sfc.scriptSetup && defineOptions?.name) {
+                name = defineOptions.name;
+            }
+            else {
+                const baseName = path.basename(fileName);
+                name = baseName.slice(0, baseName.lastIndexOf('.'));
+            }
         }
-        const baseName = path.basename(fileName);
-        return (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
+        return (0, shared_1.capitalize)((0, shared_1.camelize)(name));
     });
     const getGeneratedTemplate = (0, alien_signals_1.computed)(() => {
         if (getResolvedOptions().skipTemplateCodegen || !sfc.template) {
@@ -154,8 +157,8 @@ function createTsx(fileName, sfc, ctx) {
             destructuredPropNames: getSetupDestructuredPropNames(),
             templateRefNames: getSetupTemplateRefNames(),
             hasDefineSlots: setupHasDefineSlots(),
-            slotsAssignName: getSetupSlotsAssignName(),
             propsAssignName: getSetupPropsAssignName(),
+            slotsAssignName: getSetupSlotsAssignName(),
             inheritAttrs: getSetupInheritAttrs(),
             selfComponentName: getComponentSelfName(),
         });
@@ -165,7 +168,7 @@ function createTsx(fileName, sfc, ctx) {
             ts,
             compilerOptions: ctx.compilerOptions,
             vueCompilerOptions: getResolvedOptions(),
-            sfc: sfc,
+            sfc,
             fileName,
             lang: getLang(),
             scriptRanges: getScriptRanges(),

package/lib/types.d.ts

@@ -8,7 +8,7 @@ export type { SFCParseResult } from '@vue/compiler-sfc';
 export { VueEmbeddedCode };
 export type RawVueCompilerOptions = Partial<Omit<VueCompilerOptions, 'target' | 'globalTypesPath' | 'plugins'>> & {
     strictTemplates?: boolean;
-    target?: 'auto' | 2 | 2.7 | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
+    target?: 'auto' | 3 | 3.3 | 3.5 | 3.6 | 99 | number;
     globalTypesPath?: string;
     plugins?: string[];
 };

package/lib/utils/parseCssClassNames.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCssClassNames(css: string): Generator<{
+    offset: number;
+    text: string;
+}, void, unknown>;

package/lib/utils/parseCssClassNames.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssClassNames = parseCssClassNames;
+const parseCssVars_1 = require("./parseCssVars");
+const cssClassNameReg = /(?=(\.[a-z_][-\w]*)[\s.,+~>:#)[{])/gi;
+const fragmentReg = /(?<={)[^{]*(?=(?<!\\);)/g;
+function* parseCssClassNames(css) {
+    css = (0, parseCssVars_1.fillBlank)(css, parseCssVars_1.commentReg, fragmentReg);
+    const matches = css.matchAll(cssClassNameReg);
+    for (const match of matches) {
+        const matchText = match[1];
+        if (matchText) {
+            yield { offset: match.index, text: matchText };
+        }
+    }
+}
+//# sourceMappingURL=parseCssClassNames.js.map

package/lib/utils/parseCssImports.d.ts

@@ -0,0 +1,4 @@
+export declare function parseCssImports(css: string): Generator<{
+    text: string;
+    offset: number;
+}, void, unknown>;

package/lib/utils/parseCssImports.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCssImports = parseCssImports;
+const cssImportReg = /(?<=@import\s+url\()(["']?).*?\1(?=\))|(?<=@import\b\s*)(["']).*?\2/g;
+function* parseCssImports(css) {
+    const matches = css.matchAll(cssImportReg);
+    for (const match of matches) {
+        let text = match[0];
+        let offset = match.index;
+        if (text.startsWith("'") || text.startsWith('"')) {
+            text = text.slice(1, -1);
+            offset += 1;
+        }
+        if (text) {
+            yield { text, offset };
+        }
+    }
+}
+//# sourceMappingURL=parseCssImports.js.map

package/lib/utils/parseCssVars.d.ts

@@ -0,0 +1,6 @@
+export declare const commentReg: RegExp;
+export declare function parseCssVars(css: string): Generator<{
+    offset: number;
+    text: string;
+}, void, unknown>;
+export declare function fillBlank(css: string, ...regs: RegExp[]): string;

package/lib/utils/parseCssVars.js

@@ -0,0 +1,26 @@
+"use strict";
+// https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/cssVars.ts#L47-L61
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commentReg = void 0;
+exports.parseCssVars = parseCssVars;
+exports.fillBlank = fillBlank;
+const vBindCssVarReg = /\bv-bind\(\s*(?:'([^']+)'|"([^"]+)"|([a-z_]\w*))\s*\)/gi;
+exports.commentReg = /(?<=\/\*)[\s\S]*?(?=\*\/)|(?<=\/\/)[\s\S]*?(?=\n)/g;
+function* parseCssVars(css) {
+    css = fillBlank(css, exports.commentReg);
+    const matchs = css.matchAll(vBindCssVarReg);
+    for (const match of matchs) {
+        const matchText = match.slice(1).find(t => t);
+        if (matchText) {
+            const offset = match.index + css.slice(match.index).indexOf(matchText);
+            yield { offset, text: matchText };
+        }
+    }
+}
+function fillBlank(css, ...regs) {
+    for (const reg of regs) {
+        css = css.replace(reg, match => ' '.repeat(match.length));
+    }
+    return css;
+}
+//# sourceMappingURL=parseCssVars.js.map

package/lib/utils/shared.d.ts

@@ -3,7 +3,6 @@ import type * as ts from 'typescript';
 import type { Sfc, TextRange } from '../types';
 export { hyphenate as hyphenateTag } from '@vue/shared';
 export declare function hyphenateAttr(str: string): string;
-export declare function getSlotsPropertyName(vueVersion: number): "$scopedSlots" | "$slots";
-export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: NonNullable<Sfc['template']>): number[];
+export declare function getElementTagOffsets(node: CompilerDOM.ElementNode, template: NonNullable<Sfc['template']>): [number] | [number, number];
 export declare function getStartEnd(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): TextRange;
 export declare function getNodeText(ts: typeof import('typescript'), node: ts.Node, ast: ts.SourceFile): string;

package/lib/utils/shared.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.hyphenateTag = void 0;
 exports.hyphenateAttr = hyphenateAttr;
-exports.getSlotsPropertyName = getSlotsPropertyName;
 exports.getElementTagOffsets = getElementTagOffsets;
 exports.getStartEnd = getStartEnd;
 exports.getNodeText = getNodeText;
@@ -17,9 +16,6 @@ function hyphenateAttr(str) {
     }
     return hyphencase;
 }
-function getSlotsPropertyName(vueVersion) {
-    return vueVersion < 3 ? '$scopedSlots' : '$slots';
-}
 function getElementTagOffsets(node, template) {
     const tagOffsets = [
         template.content.indexOf(node.tag, node.loc.start.offset),

package/lib/virtualFile/computedSfc.js

@@ -18,7 +18,7 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
     const getComments = (0, alien_signals_1.computed)(oldValue => {
         const newValue = getParseResult()?.descriptor.comments ?? [];
         if (oldValue?.length === newValue.length
-            && oldValue?.every((v, i) => v === newValue[i])) {
+            && oldValue.every((v, i) => v === newValue[i])) {
             return oldValue;
         }
         return newValue;
@@ -27,13 +27,13 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
         const compiledAst = computedTemplateAst(base);
         return mergeObject(base, {
             get ast() {
-                return compiledAst()?.ast;
+                return compiledAst().ast;
             },
             get errors() {
-                return compiledAst()?.errors;
+                return compiledAst().errors;
             },
             get warnings() {
-                return compiledAst()?.warnings;
+                return compiledAst().warnings;
             },
         });
     });

package/lib/virtualFile/vueFile.d.ts

@@ -1,6 +1,7 @@
-import type { VirtualCode } from '@volar/language-core';
+import type { CodeInformation, Mapping, VirtualCode } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions, VueLanguagePluginReturn } from '../types';
+import { computedSfc } from './computedSfc';
 export declare class VueVirtualCode implements VirtualCode {
     fileName: string;
     languageId: string;
@@ -8,22 +9,16 @@ export declare class VueVirtualCode implements VirtualCode {
     vueCompilerOptions: VueCompilerOptions;
     plugins: VueLanguagePluginReturn[];
     ts: typeof import('typescript');
-    id: string;
+    readonly id = "main";
+    readonly sfc: ReturnType<typeof computedSfc>;
     private _snapshot;
     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[];
-        lengths: number[];
-        data: import("@volar/language-core").CodeInformation;
-    }[];
+    get mappings(): Mapping<CodeInformation>[];
     constructor(fileName: string, languageId: string, initSnapshot: ts.IScriptSnapshot, vueCompilerOptions: VueCompilerOptions, plugins: VueLanguagePluginReturn[], ts: typeof import('typescript'));
     update(newSnapshot: ts.IScriptSnapshot): void;
 }

package/lib/virtualFile/vueFile.js

@@ -7,16 +7,12 @@ const computedEmbeddedCodes_1 = require("./computedEmbeddedCodes");
 const computedSfc_1 = require("./computedSfc");
 const computedVueSfc_1 = require("./computedVueSfc");
 class VueVirtualCode {
-    // others
     get snapshot() {
         return this._snapshot();
     }
     get vueSfc() {
         return this._vueSfc();
     }
-    get sfc() {
-        return this._sfc;
-    }
     get embeddedCodes() {
         return this._embeddedCodes();
     }
@@ -30,13 +26,11 @@ class VueVirtualCode {
         this.vueCompilerOptions = vueCompilerOptions;
         this.plugins = plugins;
         this.ts = ts;
-        // sources
         this.id = 'main';
-        this._snapshot = (0, alien_signals_1.signal)(undefined);
-        // computeds
+        this._snapshot = (0, alien_signals_1.signal)(initSnapshot);
         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.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 [{
@@ -46,7 +40,6 @@ class VueVirtualCode {
                     data: plugins_1.allCodeFeatures,
                 }];
         });
-        this._snapshot(initSnapshot);
     }
     update(newSnapshot) {
         this._snapshot(newSnapshot);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.7-alpha.1",
+	"version": "3.1.0-alpha.0",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -15,7 +15,6 @@
 	"dependencies": {
 		"@volar/language-core": "2.4.23",
 		"@vue/compiler-dom": "^3.5.0",
-		"@vue/compiler-vue2": "^2.7.16",
 		"@vue/shared": "^3.5.0",
 		"alien-signals": "^2.0.5",
 		"muggle-string": "^0.4.1",
@@ -37,5 +36,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "320fc626c871e9ff17c0e4e92ea7ddb0c7641f34"
+	"gitHead": "adcbd8b1a7bf432844230755de999d22b95dc160"
 }

package/lib/utils/ts.js

@@ -1,296 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompilerOptionsResolver = void 0;
-exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
-exports.createParsedCommandLine = createParsedCommandLine;
-exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
-exports.writeGlobalTypes = writeGlobalTypes;
-const shared_1 = require("@vue/shared");
-const path_browserify_1 = require("path-browserify");
-const globalTypes_1 = require("../codegen/globalTypes");
-const shared_2 = require("./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()) {
-        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);
-                }
-                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 { }
-        }
-        return {
-            ...parsed,
-            vueOptions: resolver.build(),
-        };
-    }
-    catch { }
-    return {
-        options: {},
-        errors: [],
-        vueOptions: getDefaultCompilerOptions(),
-    };
-}
-class CompilerOptionsResolver {
-    constructor(fileExists) {
-        this.fileExists = fileExists;
-        this.configRoots = new Set();
-        this.options = {};
-        this.plugins = [];
-    }
-    addConfig(options, rootDir) {
-        this.configRoots.add(rootDir);
-        for (const key in options) {
-            switch (key) {
-                case 'target':
-                    if (options[key] === 'auto') {
-                        this.target = findVueVersion(rootDir);
-                    }
-                    else {
-                        this.target = options[key];
-                    }
-                    break;
-                case 'globalTypesPath':
-                    if (options[key] !== undefined) {
-                        this.globalTypesPath = path_browserify_1.posix.join(rootDir, options[key]);
-                    }
-                    break;
-                case 'plugins':
-                    this.plugins = (options.plugins ?? [])
-                        .flatMap((pluginPath) => {
-                        try {
-                            const resolvedPath = resolvePath(pluginPath, rootDir);
-                            if (resolvedPath) {
-                                const plugin = require(resolvedPath);
-                                plugin.__moduleName = pluginPath;
-                                return plugin;
-                            }
-                            else {
-                                console.warn('[Vue] Load plugin failed:', pluginPath);
-                            }
-                        }
-                        catch (error) {
-                            console.warn('[Vue] Resolve plugin path failed:', pluginPath, error);
-                        }
-                        return [];
-                    });
-                    break;
-                default:
-                    // @ts-expect-error
-                    this.options[key] = options[key];
-                    break;
-            }
-        }
-        if (options.target === undefined) {
-            this.target ??= findVueVersion(rootDir);
-        }
-    }
-    build(defaults) {
-        defaults ??= getDefaultCompilerOptions(this.target, this.options.lib, this.options.strictTemplates);
-        const resolvedOptions = {
-            ...defaults,
-            ...this.options,
-            plugins: this.plugins,
-            macros: {
-                ...defaults.macros,
-                ...this.options.macros,
-            },
-            composables: {
-                ...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])),
-        };
-        if (resolvedOptions.globalTypesPath === shared_1.NOOP) {
-            if (this.fileExists && this.globalTypesPath === undefined) {
-                const fileDirToGlobalTypesPath = new Map();
-                resolvedOptions.globalTypesPath = fileName => {
-                    const fileDir = path_browserify_1.posix.dirname(fileName);
-                    if (fileDirToGlobalTypesPath.has(fileDir)) {
-                        return fileDirToGlobalTypesPath.get(fileDir);
-                    }
-                    const root = this.findNodeModulesRoot(fileDir, resolvedOptions.lib);
-                    const result = root
-                        ? path_browserify_1.posix.join(root, 'node_modules', '.vue-global-types', (0, globalTypes_1.getGlobalTypesFileName)(resolvedOptions))
-                        : undefined;
-                    fileDirToGlobalTypesPath.set(fileDir, result);
-                    return result;
-                };
-            }
-            else {
-                resolvedOptions.globalTypesPath = () => this.globalTypesPath;
-            }
-        }
-        return resolvedOptions;
-    }
-    findNodeModulesRoot(dir, lib) {
-        while (!this.fileExists(path_browserify_1.posix.join(dir, 'node_modules', lib, 'package.json'))) {
-            const parentDir = path_browserify_1.posix.dirname(dir);
-            if (dir === parentDir) {
-                return;
-            }
-            dir = parentDir;
-        }
-        return dir;
-    }
-}
-exports.CompilerOptionsResolver = CompilerOptionsResolver;
-function findVueVersion(rootDir) {
-    const resolvedPath = resolvePath('vue/package.json', rootDir);
-    if (resolvedPath) {
-        const vuePackageJson = require(resolvedPath);
-        const versionNumbers = vuePackageJson.version.split('.');
-        return Number(versionNumbers[0] + '.' + versionNumbers[1]);
-    }
-    else {
-        // console.warn('Load vue/package.json failed from', folder);
-    }
-}
-function resolvePath(scriptPath, root) {
-    try {
-        if (require?.resolve) {
-            return require.resolve(scriptPath, { paths: [root] });
-        }
-        else {
-            // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
-        }
-    }
-    catch {
-        // console.warn(error);
-    }
-}
-function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = false) {
-    return {
-        target,
-        lib,
-        globalTypesPath: shared_1.NOOP,
-        extensions: ['.vue'],
-        vitePressExtensions: [],
-        petiteVueExtensions: [],
-        jsxSlots: false,
-        strictVModel: strictTemplates,
-        strictCssModules: false,
-        checkUnknownProps: strictTemplates,
-        checkUnknownEvents: strictTemplates,
-        checkUnknownDirectives: strictTemplates,
-        checkUnknownComponents: strictTemplates,
-        inferComponentDollarEl: false,
-        inferComponentDollarRefs: false,
-        inferTemplateDollarAttrs: false,
-        inferTemplateDollarEl: false,
-        inferTemplateDollarRefs: false,
-        inferTemplateDollarSlots: false,
-        skipTemplateCodegen: false,
-        fallthroughAttributes: false,
-        resolveStyleImports: false,
-        resolveStyleClassNames: 'scoped',
-        fallthroughComponentNames: [
-            'Transition',
-            'KeepAlive',
-            'Teleport',
-            'Suspense',
-        ],
-        dataAttributes: [],
-        htmlAttributes: ['aria-*'],
-        optionsWrapper: target >= 2.7
-            ? [`(await import('${lib}')).defineComponent(`, `)`]
-            : [`(await import('${lib}')).default.extend(`, `)`],
-        macros: {
-            defineProps: ['defineProps'],
-            defineSlots: ['defineSlots'],
-            defineEmits: ['defineEmits'],
-            defineExpose: ['defineExpose'],
-            defineModel: ['defineModel'],
-            defineOptions: ['defineOptions'],
-            withDefaults: ['withDefaults'],
-        },
-        composables: {
-            useAttrs: ['useAttrs'],
-            useCssModule: ['useCssModule'],
-            useSlots: ['useSlots'],
-            useTemplateRef: ['useTemplateRef', 'templateRef'],
-        },
-        plugins: [],
-        experimentalModelPropName: {
-            '': {
-                input: true,
-            },
-            value: {
-                input: { type: 'text' },
-                textarea: true,
-                select: true,
-            },
-        },
-    };
-}
-function writeGlobalTypes(vueOptions, writeFile) {
-    const originalFn = vueOptions.globalTypesPath;
-    if (!originalFn) {
-        return;
-    }
-    const writed = new Set();
-    vueOptions.globalTypesPath = (fileName) => {
-        const result = originalFn(fileName);
-        if (result && !writed.has(result)) {
-            writed.add(result);
-            writeFile(result, (0, globalTypes_1.generateGlobalTypes)(vueOptions));
-        }
-        return result;
-    };
-}
-//# sourceMappingURL=ts.js.map

package/lib/utils/vue2TemplateCompiler.d.ts

@@ -1,2 +0,0 @@
-import * as CompilerDOM from '@vue/compiler-dom';
-export declare const compile: typeof CompilerDOM.compile;