@vue/language-core 2.0.29 → 2.1.2

package/lib/codegen/template/index.js

@@ -8,8 +8,9 @@ const context_1 = require("./context");
 const element_1 = require("./element");
 const objectProperty_1 = require("./objectProperty");
 const templateChild_1 = require("./templateChild");
+const styleScopedClasses_1 = require("./styleScopedClasses");
 function* generateTemplate(options) {
-    const ctx = (0, context_1.createTemplateCodegenContext)(options.scriptSetupBindingNames);
+    const ctx = (0, context_1.createTemplateCodegenContext)(options);
     if (options.slotsAssignName) {
         ctx.addLocalVariable(options.slotsAssignName);
     }
@@ -20,14 +21,26 @@ function* generateTemplate(options) {
     if (options.template.ast) {
         yield* (0, templateChild_1.generateTemplateChild)(options, ctx, options.template.ast, undefined, undefined, undefined);
     }
-    yield* generateStyleScopedClasses();
+    yield* (0, styleScopedClasses_1.generateStyleScopedClasses)(ctx);
     if (!options.hasDefineSlots) {
         yield `var __VLS_slots!:`;
         yield* generateSlotsType();
         yield common_1.endOfLine;
     }
+    yield* generateInheritedAttrs();
     yield* ctx.generateAutoImportCompletion();
+    yield* generateRefs();
     return ctx;
+    function* generateRefs() {
+        for (const [, validId] of options.templateRefNames) {
+            yield `let ${validId}${common_1.newLine}`;
+        }
+        yield `const __VLS_refs = {${common_1.newLine}`;
+        for (const [name, validId] of options.templateRefNames) {
+            yield `'${name}': ${validId}!,${common_1.newLine}`;
+        }
+        yield `}${common_1.endOfLine}`;
+    }
     function* generateSlotsType() {
         for (const { expVar, varName } of ctx.dynamicSlots) {
             ctx.hasSlot = true;
@@ -46,53 +59,28 @@ function* generateTemplate(options) {
         }
         yield `}`;
     }
-    function* generateStyleScopedClasses() {
-        yield `if (typeof __VLS_styleScopedClasses === 'object' && !Array.isArray(__VLS_styleScopedClasses)) {${common_1.newLine}`;
-        for (const offset of ctx.emptyClassOffsets) {
-            yield `__VLS_styleScopedClasses['`;
-            yield [
-                '',
-                'template',
-                offset,
-                ctx.codeFeatures.additionalCompletion,
-            ];
-            yield `']${common_1.endOfLine}`;
+    function* generateInheritedAttrs() {
+        yield 'var __VLS_inheritedAttrs!: {}';
+        for (const varName of ctx.inheritedAttrVars) {
+            yield ` & typeof ${varName}`;
         }
-        for (const { className, offset } of ctx.scopedClasses) {
-            yield `__VLS_styleScopedClasses[`;
-            yield [
-                '',
-                'template',
-                offset,
-                ctx.codeFeatures.navigationWithoutRename,
-            ];
-            yield `'`;
-            yield [
-                className,
-                'template',
-                offset,
-                ctx.codeFeatures.navigationAndAdditionalCompletion,
-            ];
-            yield `'`;
-            yield [
-                '',
-                'template',
-                offset + className.length,
-                ctx.codeFeatures.navigationWithoutRename,
-            ];
-            yield `]${common_1.endOfLine}`;
-        }
-        yield `}${common_1.newLine}`;
+        yield common_1.endOfLine;
     }
     function* generatePreResolveComponents() {
-        yield `let __VLS_resolvedLocalAndGlobalComponents!: {}`;
+        yield `let __VLS_resolvedLocalAndGlobalComponents!: Required<{}`;
         if (options.template.ast) {
+            const components = new Set();
             for (const node of forEachElementNode(options.template.ast)) {
                 if (node.tagType === CompilerDOM.ElementTypes.COMPONENT
                     && node.tag.toLowerCase() !== 'component'
                     && !node.tag.includes('.') // namespace tag 
                 ) {
-                    yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_localComponents, `;
+                    if (components.has(node.tag)) {
+                        continue;
+                    }
+                    components.add(node.tag);
+                    yield common_1.newLine;
+                    yield ` & __VLS_WithComponent<'${(0, element_1.getCanonicalComponentName)(node.tag)}', typeof __VLS_components, `;
                     yield (0, element_1.getPossibleOriginalComponentNames)(node.tag, false)
                         .map(name => `"${name}"`)
                         .join(', ');
@@ -100,7 +88,7 @@ function* generateTemplate(options) {
                 }
             }
         }
-        yield common_1.endOfLine;
+        yield `>${common_1.endOfLine}`;
     }
 }
 function* forEachElementNode(node) {

package/lib/codegen/template/interpolation.d.ts

@@ -2,5 +2,5 @@ import type * as ts from 'typescript';
 import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateInterpolation(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, _code: string, astHolder: any, start: number | undefined, data: VueCodeInformation | (() => VueCodeInformation) | undefined, prefix: string, suffix: string): Generator<Code>;
+export declare function generateInterpolation(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, _code: string, astHolder: any, start: number | undefined, data: VueCodeInformation | ((offset: number) => VueCodeInformation) | undefined, prefix: string, suffix: string): Generator<Code>;
 export declare function forEachInterpolationSegment(ts: typeof import('typescript'), ctx: TemplateCodegenContext, code: string, offset: number | undefined, ast: ts.SourceFile): Generator<[fragment: string, offset: number | undefined, isJustForErrorMapping?: boolean]>;

package/lib/codegen/template/interpolation.js

@@ -33,7 +33,7 @@ function* generateInterpolation(options, ctx, _code, astHolder, start, data, pre
                     start + offset,
                     onlyError
                         ? ctx.codeFeatures.verification
-                        : typeof data === 'function' ? data() : data,
+                        : typeof data === 'function' ? data(start + offset) : data,
                 ];
             }
             else {
@@ -124,20 +124,7 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true)
         }
     }
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-        const functionArgs = [];
-        for (const param of node.parameters) {
-            (0, common_1.collectVars)(ts, param.name, ast, functionArgs);
-            if (param.type) {
-                walkIdentifiers(ts, param.type, ast, cb, ctx, blockVars, false);
-            }
-        }
-        for (const varName of functionArgs) {
-            ctx.addLocalVariable(varName);
-        }
-        walkIdentifiers(ts, node.body, ast, cb, ctx, blockVars, false);
-        for (const varName of functionArgs) {
-            ctx.removeLocalVariable(varName);
-        }
+        processFunction(ts, node, ast, cb, ctx);
     }
     else if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {
@@ -157,6 +144,10 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true)
                 // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
                 walkIdentifiers(ts, prop.expression, ast, cb, ctx, blockVars, false);
             }
+            // fix https://github.com/vuejs/language-tools/issues/4604
+            else if (ts.isFunctionLike(prop) && prop.body) {
+                processFunction(ts, prop, ast, cb, ctx);
+            }
         }
     }
     else if (ts.isTypeReferenceNode(node)) {
@@ -182,6 +173,24 @@ function walkIdentifiers(ts, node, ast, cb, ctx, blockVars = [], isRoot = true)
         }
     }
 }
+function processFunction(ts, node, ast, cb, ctx) {
+    const functionArgs = [];
+    for (const param of node.parameters) {
+        (0, common_1.collectVars)(ts, param.name, ast, functionArgs);
+        if (param.type) {
+            walkIdentifiers(ts, param.type, ast, cb, ctx);
+        }
+    }
+    for (const varName of functionArgs) {
+        ctx.addLocalVariable(varName);
+    }
+    if (node.body) {
+        walkIdentifiers(ts, node.body, ast, cb, ctx);
+    }
+    for (const varName of functionArgs) {
+        ctx.removeLocalVariable(varName);
+    }
+}
 function walkIdentifiersInTypeReference(ts, node, cb) {
     if (ts.isTypeQueryNode(node) && ts.isIdentifier(node.exprName)) {
         cb(node.exprName, false);

package/lib/codegen/template/objectProperty.d.ts

@@ -1,4 +1,4 @@
 import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateObjectProperty(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation, astHolder?: any, shouldCamelize?: boolean): Generator<Code>;
+export declare function generateObjectProperty(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation, astHolder?: any, shouldCamelize?: boolean, shouldBeConstant?: boolean): Generator<Code>;

package/lib/codegen/template/objectProperty.js

@@ -6,9 +6,14 @@ const common_1 = require("../common");
 const camelized_1 = require("./camelized");
 const interpolation_1 = require("./interpolation");
 const stringLiteralKey_1 = require("./stringLiteralKey");
-function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false) {
+function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false, shouldBeConstant = false) {
     if (code.startsWith('[') && code.endsWith(']') && astHolder) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+        if (shouldBeConstant) {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, code.slice(1, -1), astHolder, offset + 1, features, `[__VLS_tryAsConstant(`, `)]`);
+        }
+        else {
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, code, astHolder, offset, features, '', '');
+        }
     }
     else if (shouldCamelize) {
         if (common_1.variableNameRegex.test((0, shared_1.camelize)(code))) {

package/lib/codegen/template/styleScopedClasses.d.ts

@@ -0,0 +1,3 @@
+import type { Code } from '../../types';
+import type { TemplateCodegenContext } from './context';
+export declare function generateStyleScopedClasses(ctx: TemplateCodegenContext, withDot?: boolean): Generator<Code>;

package/lib/codegen/template/styleScopedClasses.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStyleScopedClasses = generateStyleScopedClasses;
+const common_1 = require("../common");
+function* generateStyleScopedClasses(ctx, withDot = false) {
+    for (const offset of ctx.emptyClassOffsets) {
+        yield `__VLS_styleScopedClasses['`;
+        yield [
+            '',
+            'template',
+            offset,
+            ctx.codeFeatures.additionalCompletion,
+        ];
+        yield `']${common_1.endOfLine}`;
+    }
+    for (const { source, className, offset } of ctx.scopedClasses) {
+        yield `__VLS_styleScopedClasses[`;
+        yield [
+            '',
+            source,
+            offset - (withDot ? 1 : 0),
+            ctx.codeFeatures.navigation,
+        ];
+        yield `'`;
+        // fix https://github.com/vuejs/language-tools/issues/4537
+        yield* escapeString(source, className, offset, ['\\', '\'']);
+        yield `'`;
+        yield [
+            '',
+            source,
+            offset + className.length,
+            ctx.codeFeatures.navigationWithoutRename,
+        ];
+        yield `]${common_1.endOfLine}`;
+    }
+    yield common_1.newLine;
+    function* escapeString(source, className, offset, escapeTargets) {
+        let count = 0;
+        const currentEscapeTargets = [...escapeTargets];
+        const firstEscapeTarget = currentEscapeTargets.shift();
+        const splitted = className.split(firstEscapeTarget);
+        for (let i = 0; i < splitted.length; i++) {
+            const part = splitted[i];
+            const partLength = part.length;
+            if (escapeTargets.length > 0) {
+                yield* escapeString(source, part, offset + count, [...currentEscapeTargets]);
+            }
+            else {
+                yield [
+                    part,
+                    source,
+                    offset + count,
+                    ctx.codeFeatures.navigationAndAdditionalCompletion,
+                ];
+            }
+            if (i !== splitted.length - 1) {
+                yield '\\';
+                yield [
+                    firstEscapeTarget,
+                    source,
+                    offset + count + partLength,
+                    ctx.codeFeatures.navigationAndAdditionalCompletion,
+                ];
+                count += partLength + 1;
+            }
+            else {
+                count += partLength;
+            }
+        }
+    }
+}
+//# sourceMappingURL=styleScopedClasses.js.map

package/lib/codegen/template/templateChild.js

@@ -39,8 +39,12 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
             yield* ctx.expectError(prevNode);
         }
     }
+    const shouldInheritRootNodeAttrs = options.inheritAttrs;
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         let prev;
+        if (shouldInheritRootNodeAttrs && node.children.length === 1 && node.children[0].type === CompilerDOM.NodeTypes.ELEMENT) {
+            ctx.singleRootNode = node.children[0];
+        }
         for (const childNode of node.children) {
             yield* generateTemplateChild(options, ctx, childNode, currentComponent, prev, componentCtxVar);
             prev = childNode;
@@ -65,7 +69,7 @@ function* generateTemplateChild(options, ctx, node, currentComponent, prevNode,
                 yield* (0, element_1.generateElement)(options, ctx, node, currentComponent, componentCtxVar);
             }
             else {
-                yield* (0, element_1.generateComponent)(options, ctx, node, currentComponent, componentCtxVar);
+                yield* (0, element_1.generateComponent)(options, ctx, node, currentComponent);
             }
         }
     }

package/lib/codegen/types.d.ts

@@ -0,0 +1,9 @@
+export interface InlayHintInfo {
+    blockName: string;
+    offset: number;
+    setting: string;
+    label: string;
+    tooltip?: string;
+    paddingRight?: boolean;
+    paddingLeft?: boolean;
+}

package/lib/codegen/types.js

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

package/lib/languagePlugin.d.ts

@@ -1,8 +1,6 @@
-import { type LanguagePlugin } from '@volar/language-core';
+import { LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
 import type { VueCompilerOptions } from './types';
 import { VueVirtualCode } from './virtualFile/vueFile';
-export declare function createRootFileChecker(getProjectVersion: (() => string) | undefined, getRootFileNames: () => string[], caseSensitive: boolean): (fileName: string) => boolean;
-export declare function createVueLanguagePlugin<T>(ts: typeof import('typescript'), asFileName: (scriptId: T) => string, _getProjectVersion: (() => string) | undefined, isRootFile: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): LanguagePlugin<T, VueVirtualCode>;
-export declare function createVueLanguagePlugin2<T>(ts: typeof import('typescript'), asFileName: (scriptId: T) => string, isRootFile: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions): LanguagePlugin<T, VueVirtualCode>;
+export declare function createVueLanguagePlugin<T>(ts: typeof import('typescript'), compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, asFileName: (scriptId: T) => string): LanguagePlugin<T, VueVirtualCode>;
 export declare function getAllExtensions(options: VueCompilerOptions): string[];

package/lib/languagePlugin.js

@@ -1,19 +1,15 @@
 "use strict";
 /// <reference types="@volar/typescript" />
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRootFileChecker = createRootFileChecker;
 exports.createVueLanguagePlugin = createVueLanguagePlugin;
-exports.createVueLanguagePlugin2 = createVueLanguagePlugin2;
 exports.getAllExtensions = getAllExtensions;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const plugins_1 = require("./plugins");
 const CompilerVue2 = require("./utils/vue2TemplateCompiler");
 const vueFile_1 = require("./virtualFile/vueFile");
-const normalFileRegistries = [];
-const holderFileRegistries = [];
-function getVueFileRegistry(isGlobalTypesHolder, key, plugins) {
-    const fileRegistries = isGlobalTypesHolder ? holderFileRegistries : normalFileRegistries;
+const fileRegistries = [];
+function getVueFileRegistry(key, plugins) {
     let fileRegistry = fileRegistries.find(r => r.key === key
         && r.plugins.length === plugins.length
         && r.plugins.every(plugin => plugins.includes(plugin)))?.files;
@@ -39,25 +35,7 @@ function getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins) {
     ];
     return JSON.stringify(values);
 }
-function createRootFileChecker(getProjectVersion, getRootFileNames, caseSensitive) {
-    const fileNames = new language_core_1.FileMap(caseSensitive);
-    let projectVersion;
-    return (fileName) => {
-        if (!getProjectVersion || projectVersion !== getProjectVersion()) {
-            projectVersion = getProjectVersion?.();
-            fileNames.clear();
-            for (const rootFileName of getRootFileNames()) {
-                fileNames.set(rootFileName, undefined);
-            }
-        }
-        return fileNames.has(fileName);
-    };
-}
-// TODO: replace `createVueLanguagePlugin` with `createVueLanguagePlugin2` in 2.1
-function createVueLanguagePlugin(ts, asFileName, _getProjectVersion, isRootFile, compilerOptions, vueCompilerOptions) {
-    return createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, vueCompilerOptions);
-}
-function createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, vueCompilerOptions) {
+function createVueLanguagePlugin(ts, compilerOptions, vueCompilerOptions, asFileName) {
     const pluginContext = {
         modules: {
             '@vue/compiler-dom': vueCompilerOptions.target < 3
@@ -70,9 +48,9 @@ function createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, v
         },
         compilerOptions,
         vueCompilerOptions,
-        globalTypesHolder: undefined,
     };
     const plugins = (0, plugins_1.createPlugins)(pluginContext);
+    const fileRegistry = getVueFileRegistry(getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
     return {
         getLanguageId(scriptId) {
             const fileName = asFileName(scriptId);
@@ -86,10 +64,6 @@ function createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, v
         createVirtualCode(scriptId, languageId, snapshot) {
             const fileName = asFileName(scriptId);
             if (plugins.some(plugin => plugin.isValidFile?.(fileName, languageId))) {
-                if (!pluginContext.globalTypesHolder && isRootFile(fileName)) {
-                    pluginContext.globalTypesHolder = fileName;
-                }
-                const fileRegistry = getFileRegistry(pluginContext.globalTypesHolder === fileName);
                 const code = fileRegistry.get(fileName);
                 if (code) {
                     code.update(snapshot);
@@ -106,30 +80,6 @@ function createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, v
             code.update(snapshot);
             return code;
         },
-        // TODO: when global types holder deleted, move global types to another file
-        // disposeVirtualCode(fileId, code) {
-        // 	const isGlobalTypesHolder = code.fileName === pluginContext.globalTypesHolder;
-        // 	const fileRegistry = getFileRegistry(isGlobalTypesHolder);
-        // 	fileRegistry.delete(fileId);
-        // 	if (isGlobalTypesHolder) {
-        // 		pluginContext.globalTypesHolder = undefined;
-        // 		const fileRegistry2 = getFileRegistry(false);
-        // 		for (const [fileId, code] of fileRegistry2) {
-        // 			if (isValidGlobalTypesHolder(code.fileName)) {
-        // 				pluginContext.globalTypesHolder = code.fileName;
-        // 				fileRegistry2.delete(fileId);
-        // 				// force dirty
-        // 				files?.delete(fileId);
-        // 				files?.set(
-        // 					fileId,
-        // 					code.languageId,
-        // 					code.snapshot,
-        // 				);
-        // 				break;
-        // 			}
-        // 		}
-        // 	}
-        // },
         typescript: {
             extraFileExtensions: getAllExtensions(vueCompilerOptions)
                 .map(ext => ({
@@ -154,9 +104,6 @@ function createVueLanguagePlugin2(ts, asFileName, isRootFile, compilerOptions, v
             },
         },
     };
-    function getFileRegistry(isGlobalTypesHolder) {
-        return getVueFileRegistry(isGlobalTypesHolder, getFileRegistryKey(compilerOptions, vueCompilerOptions, plugins), vueCompilerOptions.plugins);
-    }
 }
 function getAllExtensions(options) {
     const result = new Set();

package/lib/parsers/scriptRanges.d.ts

@@ -10,6 +10,7 @@ export declare function parseScriptRanges(ts: typeof import('typescript'), ast:
         componentsOption: TextRange | undefined;
         componentsOptionNode: ts.ObjectLiteralExpression | undefined;
         nameOption: TextRange | undefined;
+        inheritAttrsOption: string | undefined;
     }) | undefined;
     classBlockEnd: number | undefined;
     bindings: TextRange[];

package/lib/parsers/scriptRanges.js

@@ -25,6 +25,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
             if (obj) {
                 let componentsOptionNode;
                 let nameOptionNode;
+                let inheritAttrsOption;
                 ts.forEachChild(obj, node => {
                     if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name)) {
                         const name = (0, scriptSetupRanges_1.getNodeText)(ts, node.name, ast);
@@ -34,6 +35,9 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                         if (name === 'name') {
                             nameOptionNode = node.initializer;
                         }
+                        if (name === 'inheritAttrs') {
+                            inheritAttrsOption = (0, scriptSetupRanges_1.getNodeText)(ts, node.initializer, ast);
+                        }
                     }
                 });
                 exportDefault = {
@@ -44,6 +48,7 @@ function parseScriptRanges(ts, ast, hasScriptSetup, withNode) {
                     componentsOption: componentsOptionNode ? _getStartEnd(componentsOptionNode) : undefined,
                     componentsOptionNode: withNode ? componentsOptionNode : undefined,
                     nameOption: nameOptionNode ? _getStartEnd(nameOptionNode) : undefined,
+                    inheritAttrsOption,
                 };
             }
         }

package/lib/parsers/scriptSetupRanges.d.ts

@@ -9,6 +9,7 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
     importComponentNames: Set<string>;
     props: {
         name?: string;
+        destructured?: string[];
         define?: ReturnType<(node: ts.CallExpression) => TextRange & {
             arg?: TextRange;
             typeArg?: TextRange;
@@ -43,18 +44,31 @@ export declare function parseScriptSetupRanges(ts: typeof import('typescript'),
             typeArg?: TextRange;
         }>;
     };
+    options: {
+        name?: string;
+        inheritAttrs?: string;
+    };
+    cssModules: {
+        exp: TextRange;
+        arg?: TextRange;
+    }[];
     defineProp: {
+        localName: TextRange | undefined;
         name: TextRange | undefined;
-        nameIsString: boolean;
         type: TextRange | undefined;
         modifierType?: TextRange | undefined;
+        runtimeType: TextRange | undefined;
         defaultValue: TextRange | undefined;
         required: boolean;
         isModel?: boolean;
     }[];
-    options: {
+    templateRefs: {
         name?: string;
-    };
+        define?: ReturnType<(node: ts.CallExpression) => TextRange & {
+            arg?: TextRange;
+            typeArg?: TextRange;
+        }>;
+    }[];
 };
 export declare function parseBindingRanges(ts: typeof import('typescript'), sourceFile: ts.SourceFile): TextRange[];
 export declare function findBindingVars(ts: typeof import('typescript'), left: ts.BindingName, sourceFile: ts.SourceFile): TextRange[];