@vue/language-core 3.1.7 → 3.2.0

package/lib/compilerOptions.js

@@ -4,11 +4,8 @@ exports.CompilerOptionsResolver = void 0;
 exports.createParsedCommandLineByJson = createParsedCommandLineByJson;
 exports.createParsedCommandLine = createParsedCommandLine;
 exports.getDefaultCompilerOptions = getDefaultCompilerOptions;
-exports.createGlobalTypesWriter = createGlobalTypesWriter;
-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("./utils/shared");
 function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName) {
     const extendedPaths = new Set();
@@ -26,7 +23,7 @@ function createParsedCommandLineByJson(ts, host, rootDir, json, configFileName)
     };
     const config = ts.readJsonConfigFile(rootDir, () => JSON.stringify(json));
     const parsed = ts.parseJsonSourceFileConfigFileContent(config, proxyHost, rootDir, {}, configFileName);
-    const resolver = new CompilerOptionsResolver(host.fileExists);
+    const resolver = new CompilerOptionsResolver(ts, host.readFile);
     for (const extendPath of [...extendedPaths].reverse()) {
         try {
             const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
@@ -59,7 +56,7 @@ function createParsedCommandLine(ts, host, configFileName) {
         };
         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);
+        const resolver = new CompilerOptionsResolver(ts, host.readFile);
         for (const extendPath of [...extendedPaths].reverse()) {
             try {
                 const configFile = ts.readJsonConfigFile(extendPath, host.readFile);
@@ -82,32 +79,51 @@ function createParsedCommandLine(ts, host, configFileName) {
     };
 }
 class CompilerOptionsResolver {
-    constructor(fileExists) {
-        this.fileExists = fileExists;
-        this.options = {};
-        this.plugins = [];
+    ts;
+    readFile;
+    options = {};
+    target;
+    typesRoot;
+    plugins = [];
+    constructor(ts, readFile) {
+        this.ts = ts;
+        this.readFile = readFile;
     }
     addConfig(options, rootDir) {
         for (const key in options) {
             switch (key) {
                 case 'target':
                     if (options[key] === 'auto') {
-                        this.target = findVueVersion(rootDir);
+                        this.target = this.resolveVueVersion(rootDir);
                     }
                     else {
                         this.target = options[key];
                     }
                     break;
-                case 'globalTypesPath':
+                case 'strictTemplates':
+                    const strict = !!options.strictTemplates;
+                    this.options.strictVModel ??= strict;
+                    this.options.checkUnknownProps ??= strict;
+                    this.options.checkUnknownEvents ??= strict;
+                    this.options.checkUnknownDirectives ??= strict;
+                    this.options.checkUnknownComponents ??= strict;
+                    break;
+                case 'typesRoot':
                     if (options[key] !== undefined) {
-                        this.globalTypesPath = path_browserify_1.posix.join(rootDir, options[key]);
+                        if (path_browserify_1.posix.isAbsolute(options[key])) {
+                            this.typesRoot = options[key];
+                        }
+                        else {
+                            this.typesRoot = path_browserify_1.posix.join(rootDir, options[key]);
+                        }
                     }
                     break;
                 case 'plugins':
                     this.plugins = (options.plugins ?? [])
                         .flatMap((pluginPath) => {
                         try {
-                            const resolvedPath = resolvePath(pluginPath, rootDir);
+                            const resolve = require?.resolve;
+                            const resolvedPath = resolve?.(pluginPath, { paths: [rootDir] });
                             if (resolvedPath) {
                                 const plugin = require(resolvedPath);
                                 plugin.__moduleName = pluginPath;
@@ -130,11 +146,10 @@ class CompilerOptionsResolver {
             }
         }
         if (options.target === undefined) {
-            this.target ??= findVueVersion(rootDir);
+            this.target ??= this.resolveVueVersion(rootDir);
         }
     }
-    build(defaults) {
-        defaults ??= getDefaultCompilerOptions(this.target, this.options.lib, this.options.strictTemplates);
+    build(defaults = getDefaultCompilerOptions(this.target, this.options.lib, undefined, this.typesRoot)) {
         const resolvedOptions = {
             ...defaults,
             ...this.options,
@@ -155,75 +170,37 @@ class CompilerOptionsResolver {
             // 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] });
+    resolveVueVersion(folder) {
+        const packageJsonPath = this.ts.findConfigFile(folder, fileName => this.readFile(fileName) !== undefined, 'node_modules/vue/package.json');
+        if (!packageJsonPath) {
+            return;
         }
-        else {
-            // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
+        const packageJsonContent = this.readFile(packageJsonPath);
+        if (!packageJsonContent) {
+            return;
         }
-    }
-    catch {
-        // console.warn(error);
+        const packageJson = JSON.parse(packageJsonContent);
+        const version = packageJson.version;
+        const [majorVersion, minorVersion] = version.split('.');
+        return Number(majorVersion + '.' + minorVersion);
     }
 }
-function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = false) {
+exports.CompilerOptionsResolver = CompilerOptionsResolver;
+function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = false, typesRoot = typeof __dirname !== 'undefined'
+    ? path_browserify_1.posix.join(__dirname.replace(/\\/g, '/'), '..', 'types')
+    : '@vue/language-core/types') {
     return {
         target,
         lib,
-        globalTypesPath: shared_1.NOOP,
+        typesRoot,
         extensions: ['.vue'],
         vitePressExtensions: [],
         petiteVueExtensions: [],
         jsxSlots: false,
-        strictVModel: strictTemplates,
         strictCssModules: false,
+        strictVModel: strictTemplates,
         checkUnknownProps: strictTemplates,
         checkUnknownEvents: strictTemplates,
         checkUnknownDirectives: strictTemplates,
@@ -275,22 +252,4 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         },
     };
 }
-function createGlobalTypesWriter(vueOptions, writeFile) {
-    const writed = new Set();
-    const { globalTypesPath } = vueOptions;
-    return (fileName) => {
-        const result = globalTypesPath(fileName);
-        if (result && !writed.has(result)) {
-            writed.add(result);
-            writeFile(result, (0, globalTypes_1.generateGlobalTypes)(vueOptions));
-        }
-        return result;
-    };
-}
-/**
- * @deprecated use `createGlobalTypesWriter` instead
- */
-function writeGlobalTypes(vueOptions, writeFile) {
-    vueOptions.globalTypesPath = createGlobalTypesWriter(vueOptions, writeFile);
-}
 //# sourceMappingURL=compilerOptions.js.map

package/lib/languagePlugin.js

@@ -1,10 +1,43 @@
 "use strict";
 /// <reference types="@volar/typescript" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createVueLanguagePlugin = createVueLanguagePlugin;
 exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
-const CompilerDOM = require("@vue/compiler-dom");
+const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const plugins_1 = require("./plugins");
 const virtualCode_1 = require("./virtualCode");
 const fileRegistries = {};

package/lib/parsers/scriptRanges.d.ts

@@ -2,20 +2,32 @@ import type * as ts from 'typescript';
 import type { TextRange, VueCompilerOptions } from '../types';
 export interface ScriptRanges extends ReturnType<typeof parseScriptRanges> {
 }
-export declare function parseScriptRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
-    exportDefault: (TextRange & {
-        expression: TextRange;
+export declare function parseScriptRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+    exportDefault: (TextRange<ts.Node> & {
+        expression: TextRange<ts.Expression>;
+        isObjectLiteral: boolean;
+        options?: {
+            isObjectLiteral: boolean;
+            expression: TextRange<ts.Node>;
+            args: TextRange<ts.ObjectLiteralExpression>;
+            components: TextRange<ts.ObjectLiteralExpression> | undefined;
+            directives: TextRange<ts.Node> | undefined;
+            name: TextRange<ts.StringLiteral> | undefined;
+            inheritAttrs: string | undefined;
+        } | undefined;
     }) | undefined;
-    componentOptions: {
-        expression: TextRange;
-        args: TextRange;
-        argsNode: ts.ObjectLiteralExpression;
-        components: TextRange | undefined;
-        componentsNode: ts.ObjectLiteralExpression | undefined;
-        directives: TextRange | undefined;
-        name: TextRange | undefined;
-        inheritAttrs: string | undefined;
-    } | undefined;
-    bindings: TextRange[];
-    components: TextRange[];
+    bindings: TextRange<ts.Node>[];
+    components: TextRange<ts.Node>[];
 };
+export declare function parseOptionsFromExtression(ts: typeof import('typescript'), exp: ts.Node, sourceFile: ts.SourceFile): {
+    isObjectLiteral: boolean;
+    expression: TextRange<ts.Node>;
+    args: TextRange<ts.ObjectLiteralExpression>;
+    argsNode: ts.ObjectLiteralExpression;
+    components: TextRange<ts.ObjectLiteralExpression> | undefined;
+    componentsNode: ts.ObjectLiteralExpression | undefined;
+    directives: TextRange<ts.ObjectLiteralExpression> | undefined;
+    name: TextRange<ts.StringLiteral> | undefined;
+    nameNode: ts.StringLiteral | undefined;
+    inheritAttrs: string | undefined;
+} | undefined;

package/lib/parsers/scriptRanges.js

@@ -1,86 +1,90 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseScriptRanges = parseScriptRanges;
+exports.parseOptionsFromExtression = parseOptionsFromExtression;
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
-function parseScriptRanges(ts, ast, vueCompilerOptions) {
+function parseScriptRanges(ts, sourceFile, vueCompilerOptions) {
     let exportDefault;
-    let componentOptions;
-    const { bindings, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
-    ts.forEachChild(ast, raw => {
-        if (ts.isExportAssignment(raw)) {
+    const { bindings, components } = (0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions);
+    ts.forEachChild(sourceFile, child => {
+        if (ts.isExportAssignment(child)) {
             exportDefault = {
-                ..._getStartEnd(raw),
-                expression: _getStartEnd(raw.expression),
+                ...(0, shared_1.getStartEnd)(ts, child, sourceFile),
+                expression: (0, shared_1.getStartEnd)(ts, child.expression, sourceFile),
+                isObjectLiteral: ts.isObjectLiteralExpression(child.expression),
+                options: parseOptionsFromExtression(ts, child.expression, sourceFile),
             };
-            const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, raw, [], ast);
+            const comment = (0, utils_1.getClosestMultiLineCommentRange)(ts, child, [], sourceFile);
             if (comment) {
                 exportDefault.start = comment.start;
             }
-            let node = raw;
-            while (isAsExpression(node.expression) || ts.isParenthesizedExpression(node.expression)) { // fix https://github.com/vuejs/language-tools/issues/1882
-                node = node.expression;
-            }
-            let obj;
-            if (ts.isObjectLiteralExpression(node.expression)) {
-                obj = node.expression;
-            }
-            else if (ts.isCallExpression(node.expression) && node.expression.arguments.length) {
-                const arg0 = node.expression.arguments[0];
-                if (ts.isObjectLiteralExpression(arg0)) {
-                    obj = arg0;
-                }
-            }
-            if (obj) {
-                let componentsOptionNode;
-                let directivesOptionNode;
-                let nameOptionNode;
-                let inheritAttrsOption;
-                ts.forEachChild(obj, node => {
-                    if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
-                        const name = _getNodeText(node.name);
-                        if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
-                            componentsOptionNode = node.initializer;
-                        }
-                        else if (name === 'directives' && ts.isObjectLiteralExpression(node.initializer)) {
-                            directivesOptionNode = node.initializer;
-                        }
-                        else if (name === 'name') {
-                            nameOptionNode = node.initializer;
-                        }
-                        else if (name === 'inheritAttrs') {
-                            inheritAttrsOption = _getNodeText(node.initializer);
-                        }
-                    }
-                });
-                componentOptions = {
-                    expression: _getStartEnd(node.expression),
-                    args: _getStartEnd(obj),
-                    argsNode: obj,
-                    components: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
-                    componentsNode: componentsOptionNode,
-                    directives: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
-                    name: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
-                    inheritAttrs: inheritAttrsOption,
-                };
-            }
         }
     });
     return {
         exportDefault,
-        componentOptions,
         bindings,
         components,
     };
+}
+function parseOptionsFromExtression(ts, exp, sourceFile) {
+    let obj;
+    while (isAsExpression(ts, exp) || ts.isParenthesizedExpression(exp)) { // fix https://github.com/vuejs/language-tools/issues/1882
+        exp = exp.expression;
+    }
+    if (ts.isObjectLiteralExpression(exp)) {
+        obj = exp;
+    }
+    else if (ts.isCallExpression(exp) && exp.arguments.length) {
+        const arg0 = exp.arguments[0];
+        if (ts.isObjectLiteralExpression(arg0)) {
+            obj = arg0;
+        }
+    }
+    if (obj) {
+        let componentsOptionNode;
+        let directivesOptionNode;
+        let nameOptionNode;
+        let inheritAttrsOption;
+        ts.forEachChild(obj, node => {
+            if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
+                const name = _getNodeText(node.name);
+                if (name === 'components' && ts.isObjectLiteralExpression(node.initializer)) {
+                    componentsOptionNode = node.initializer;
+                }
+                else if (name === 'directives' && ts.isObjectLiteralExpression(node.initializer)) {
+                    directivesOptionNode = node.initializer;
+                }
+                else if (name === 'name' && ts.isStringLiteral(node.initializer)) {
+                    nameOptionNode = node.initializer;
+                }
+                else if (name === 'inheritAttrs') {
+                    inheritAttrsOption = _getNodeText(node.initializer);
+                }
+            }
+        });
+        return {
+            isObjectLiteral: ts.isObjectLiteralExpression(exp),
+            expression: _getStartEnd(exp),
+            args: _getStartEnd(obj),
+            argsNode: obj,
+            components: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
+            componentsNode: componentsOptionNode,
+            directives: directivesOptionNode ? _getStartEnd(directivesOptionNode) : undefined,
+            name: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
+            nameNode: nameOptionNode,
+            inheritAttrs: inheritAttrsOption,
+        };
+    }
     function _getStartEnd(node) {
-        return (0, shared_1.getStartEnd)(ts, node, ast);
+        return (0, shared_1.getStartEnd)(ts, node, sourceFile);
     }
     function _getNodeText(node) {
-        return (0, shared_1.getNodeText)(ts, node, ast);
-    }
-    // isAsExpression is missing in tsc
-    function isAsExpression(node) {
-        return node.kind === ts.SyntaxKind.AsExpression;
+        return (0, shared_1.getNodeText)(ts, node, sourceFile);
     }
 }
+// isAsExpression is missing in tsc
+function isAsExpression(ts, node) {
+    return node.kind === ts.SyntaxKind.AsExpression;
+}
 //# sourceMappingURL=scriptRanges.js.map

package/lib/parsers/scriptSetupRanges.d.ts

@@ -1,12 +1,13 @@
 import type * as ts from 'typescript';
 import type { TextRange, VueCompilerOptions } from '../types';
-type CallExpressionRange = {
+export interface CallExpressionRange {
     callExp: TextRange;
     exp: TextRange;
     arg?: TextRange;
     typeArg?: TextRange;
-};
-type DefineModel = {
+}
+export interface DefineModel {
+    arg?: TextRange;
     localName?: TextRange;
     name?: TextRange;
     type?: TextRange;
@@ -15,44 +16,39 @@ type DefineModel = {
     defaultValue?: TextRange;
     required?: boolean;
     comments?: TextRange;
-    argNode?: ts.Expression;
-};
-type DefineProps = CallExpressionRange & {
+}
+export interface DefineProps extends CallExpressionRange {
     name?: string;
     destructured?: Map<string, ts.Expression | undefined>;
     destructuredRest?: string;
     statement: TextRange;
-    argNode?: ts.Expression;
-};
-type WithDefaults = Omit<CallExpressionRange, 'typeArg'> & {
-    argNode?: ts.Expression;
-};
-type DefineEmits = CallExpressionRange & {
+}
+export interface DefineEmits extends CallExpressionRange {
     name?: string;
     hasUnionTypeArg?: boolean;
     statement: TextRange;
-};
-type DefineSlots = CallExpressionRange & {
+}
+export interface DefineSlots extends CallExpressionRange {
     name?: string;
     statement: TextRange;
-};
-type DefineOptions = {
+}
+export interface DefineOptions {
     name?: string;
     inheritAttrs?: string;
-};
-type UseTemplateRef = CallExpressionRange & {
+}
+export interface UseTemplateRef extends CallExpressionRange {
     name?: string;
-};
+}
 export interface ScriptSetupRanges extends ReturnType<typeof parseScriptSetupRanges> {
 }
-export declare function parseScriptSetupRanges(ts: typeof import('typescript'), ast: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
+export declare function parseScriptSetupRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile, vueCompilerOptions: VueCompilerOptions): {
     leadingCommentEndOffset: number;
     importSectionEndOffset: number;
-    bindings: TextRange[];
-    components: TextRange[];
+    bindings: TextRange<ts.Node>[];
+    components: TextRange<ts.Node>[];
     defineModel: DefineModel[];
     defineProps: DefineProps | undefined;
-    withDefaults: WithDefaults | undefined;
+    withDefaults: CallExpressionRange | undefined;
     defineEmits: DefineEmits | undefined;
     defineSlots: DefineSlots | undefined;
     defineExpose: CallExpressionRange | undefined;
@@ -62,4 +58,3 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     useSlots: CallExpressionRange[];
     useTemplateRef: UseTemplateRef[];
 };
-export {};

package/lib/parsers/scriptSetupRanges.js

@@ -5,7 +5,7 @@ const collectBindings_1 = require("../utils/collectBindings");
 const shared_1 = require("../utils/shared");
 const utils_1 = require("./utils");
 const tsCheckReg = /^\/\/\s*@ts-(?:no)?check(?:$|\s)/;
-function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
+function parseScriptSetupRanges(ts, sourceFile, vueCompilerOptions) {
     const defineModel = [];
     let defineProps;
     let withDefaults;
@@ -17,13 +17,13 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
     const useCssModule = [];
     const useSlots = [];
     const useTemplateRef = [];
-    const text = ast.text;
+    const text = sourceFile.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, components } = (0, utils_1.parseBindingRanges)(ts, ast, vueCompilerOptions.extensions);
+    let { bindings, components } = (0, utils_1.parseBindingRanges)(ts, sourceFile, vueCompilerOptions.extensions);
     let foundNonImportExportNode = false;
     let importSectionEndOffset = 0;
-    ts.forEachChild(ast, node => {
+    ts.forEachChild(sourceFile, node => {
         if (foundNonImportExportNode
             || ts.isImportDeclaration(node)
             || ts.isExportDeclaration(node)
@@ -42,11 +42,11 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             importSectionEndOffset = commentRange.pos;
         }
         else {
-            importSectionEndOffset = (0, shared_1.getStartEnd)(ts, node, ast).start;
+            importSectionEndOffset = (0, shared_1.getStartEnd)(ts, node, sourceFile).start;
         }
         foundNonImportExportNode = true;
     });
-    ts.forEachChild(ast, node => visitNode(node, [ast]));
+    ts.forEachChild(sourceFile, node => visitNode(node, [sourceFile]));
     const templateRefNames = new Set(useTemplateRef.map(ref => ref.name));
     bindings = bindings.filter(range => {
         const name = text.slice(range.start, range.end);
@@ -135,15 +135,14 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     runtimeType,
                     defaultValue,
                     required,
-                    comments: (0, utils_1.getClosestMultiLineCommentRange)(ts, node, parents, ast),
-                    argNode: options,
+                    comments: (0, utils_1.getClosestMultiLineCommentRange)(ts, node, parents, sourceFile),
+                    arg: _getStartEnd(node),
                 });
             }
             else if (vueCompilerOptions.macros.defineProps.includes(callText)) {
                 defineProps = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast),
-                    argNode: node.arguments[0],
+                    statement: getStatementRange(ts, parents, node, sourceFile),
                 };
                 if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
                     defineProps.destructured = new Map();
@@ -172,13 +171,12 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     callExp: _getStartEnd(node),
                     exp: _getStartEnd(node.expression),
                     arg: arg ? _getStartEnd(arg) : undefined,
-                    argNode: arg,
                 };
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
                 defineEmits = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast),
+                    statement: getStatementRange(ts, parents, node, sourceFile),
                 };
                 if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0])) {
                     for (const member of node.typeArguments[0].members) {
@@ -195,7 +193,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
                 defineSlots = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast),
+                    statement: getStatementRange(ts, parents, node, sourceFile),
                 };
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
@@ -258,10 +256,10 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
         };
     }
     function _getStartEnd(node) {
-        return (0, shared_1.getStartEnd)(ts, node, ast);
+        return (0, shared_1.getStartEnd)(ts, node, sourceFile);
     }
     function _getNodeText(node) {
-        return (0, shared_1.getNodeText)(ts, node, ast);
+        return (0, shared_1.getNodeText)(ts, node, sourceFile);
     }
 }
 function getStatementRange(ts, parents, node, ast) {

package/lib/parsers/utils.d.ts

@@ -1,10 +1,7 @@
 import type * as ts from 'typescript';
 import type { TextRange } from '../types';
 export declare function parseBindingRanges(ts: typeof import('typescript'), ast: ts.SourceFile, componentExtsensions: string[]): {
-    bindings: TextRange[];
-    components: TextRange[];
+    bindings: TextRange<ts.Node>[];
+    components: TextRange<ts.Node>[];
 };
-export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): {
-    start: number;
-    end: number;
-} | undefined;
+export declare function getClosestMultiLineCommentRange(ts: typeof import('typescript'), node: ts.Node, parents: ts.Node[], ast: ts.SourceFile): TextRange | undefined;