@tilua/parser 2.3.0 → 3.0.0

package/dist/index.d.cts

@@ -212,7 +212,7 @@ interface ExportAllStatement extends BaseNode {
     type: "ExportAllStatement";
     source: StringLiteral;
 }
-type Statement = VariableDeclaration | FunctionDeclaration | FunctionDeclarationStatement | ClassDeclaration | AssignmentStatement | CompoundAssignmentStatement | CallStatement | ExpressionStatement | DoStatement | WhileStatement | RepeatStatement | IfStatement | NumericForStatement | GenericForStatement | ReturnStatement | BreakStatement | ContinueStatement | TypeAliasStatement | ExportTypeAliasStatement | ImportStatement | ExportStatement | ExportDefaultStatement | ExportNamedStatement | ExportAllStatement | DeclareStatement | DeclareClassStatement | ErrorStatement;
+type Statement = VariableDeclaration | FunctionDeclaration | FunctionDeclarationStatement | ClassDeclaration | AssignmentStatement | CompoundAssignmentStatement | CallStatement | ExpressionStatement | DoStatement | WhileStatement | RepeatStatement | IfStatement | NumericForStatement | GenericForStatement | ReturnStatement | BreakStatement | ContinueStatement | TypeAliasStatement | ExportTypeAliasStatement | ImportStatement | ExportStatement | ExportDefaultStatement | ExportNamedStatement | ExportAllStatement | DeclareStatement | DeclareClassStatement | DeclareMetatableStatement | ErrorStatement;
 /** `declare game: DataModel` / `declare function require(m: string): unknown`
  *  — an ambient value/function declaration for a definitions file (`.d.tilua`).
  *  Contributes a global type; emits no runtime code. */
@@ -236,6 +236,25 @@ interface DeclareClassStatement extends BaseNode {
     superclass?: TypeReference;
     body: TableTypeNode;
 }
+/** `declare metatable string: { __index: StringLibrary }` — the metatable
+ *  every value of `target` has, as far as types go. A method call reads
+ *  through its `__index`: `text:upper()` is `upper` there.
+ *
+ *  A library may declare one a value does not really have — Lua gives an
+ *  array none — and ship a lowering that turns a call through it into a
+ *  call of its own (`names:filter(f)` becomes `array.filter(names, f)`).
+ *  The compiler asks the library that declared the metatable, and only it.
+ *
+ *  `target` may use the declaration's type parameters: `<T> T[]` is every
+ *  array, `T` its elements; `<T extends {}> T` every plain table, `T` the
+ *  table itself. The most specific target a value matches is its metatable,
+ *  and declaring one target again adds to it. */
+interface DeclareMetatableStatement extends BaseNode {
+    type: "DeclareMetatableStatement";
+    generics: GenericTypeParameter[];
+    target: TypeNode;
+    metatable: TypeNode;
+}
 /** A statement position that could not be parsed. Only produced when parsing
  *  in recovery mode (`parseWithRecovery`); its span covers the skipped tokens
  *  so tools can still map a cursor there. */
@@ -254,7 +273,9 @@ interface VariableDeclaration extends BaseNode {
     /** Absent only on `let x`. */
     init?: Expression;
 }
-type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern;
+/** A member or an index (`t.a`, `t[i]`) is a leaf only in a destructuring
+ *  assignment (`[t[i], t[j]] = [t[j], t[i]]`): a declaration binds names. */
+type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern | MemberExpression | IndexExpression;
 interface IdentifierPattern extends BaseNode {
     type: "IdentifierPattern";
     name: string;
@@ -1486,8 +1507,27 @@ interface TypeAnalysis {
     /** How each `for (const item in source)` walks its source; see
      *  `LoopForm`. A loop missing here walks values. */
     readonly loops: ReadonlyMap<GenericForStatement, LoopForm>;
+    /** Each `receiver:method(...)` whose method the receiver's metatable
+     *  gave it (`declare metatable`), and which library declared that. A call
+     *  missing here reached a member of the receiver's own. */
+    readonly methodSources: ReadonlyMap<MethodCallExpression, MethodSource>;
+    /** The members a value's metatable `__index` gives it — what an editor
+     *  offers after `:`. Empty for a value no metatable matches. */
+    readonly metatableMembers: (type: Type) => ReadonlyMap<string, Type>;
     readonly diagnostics: TypeDiagnostic[];
 }
+/** Where a metatable reached by a method call was declared: by the language
+ *  itself (the prelude's metatables for strings, arrays and tables), by a
+ *  library (its index in `libs`), or by the program. The compiler lowers a
+ *  language method itself, and asks a library about its own. */
+type MethodSource = {
+    readonly origin: "language";
+} | {
+    readonly origin: "library";
+    readonly library: number;
+} | {
+    readonly origin: "program";
+};
 /** A type a module exports: the resolved type, plus the parameter names of a
  *  generic alias so an importer can instantiate it (`Box<number>`). */
 interface ExportedType {
@@ -1549,14 +1589,19 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * What a runtime provides — `print`, `string`, `game` — is not here: that is a
  * type library's job (`@tilua-types/lua`, `@tilua-types/roblox`).
  *
- * The methods an array and a string answer to — `names:filter(f)`,
- * `text:trim()` — are a library's too. `propertyType` reads them from types
- * named `ArrayMethods<T>` and `StringMethods`, whichever library declares
- * those; the library also says which of them the compiler must emit code for
- * (`tilua.methods` in its package.json). Nothing about `filter` is written
- * into the analyzer.
+ * Strings, arrays and tables are the language's own, so the metatables they
+ * answer to are declared here too — `declare metatable`, in tilua, the way a
+ * library declares one. A string's is Lua's (`upper`, `sub`) with tilua's
+ * answers where Lua's are several values (`find` is an array); the rest —
+ * `names:filter(f)`, `text:trim()`, `point:keys()` — no Lua value really
+ * has, and the compiler lowers each call to a function of its own runtime.
+ * A library adds to any of them by declaring the same target again.
+ *
+ * The analyzer supplies only what no type can compute: `ObjectKeys<T>`,
+ * `ObjectValues<T>` and `ObjectEntries<T>`, an object's members as tuples in
+ * the order they were written.
  */
-declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n";
+declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (self: T[], test: (value: T, index: number) => boolean) => T[],\n        map: <U>(self: T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        includes: (self: T[], value: T) => boolean,\n        indexOf: (self: T[], value: T, start?: number) => number | nil,\n        join: (self: T[], separator?: string) => string,\n        concat: (self: T[], ...others: T[][]) => T[],\n        slice: (self: T[], start?: number, stop?: number) => T[],\n        flat: (self: T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n    },\n}\n";
 
 interface ProjectHost {
     /** A file's text, or `undefined` when there is no such file. */
@@ -1632,9 +1677,9 @@ interface TypeLibraries {
  *  call written against this library's types should become.
  *
  *  The library declares the *types* in its definitions file; this is the other
- *  half. `names:filter(f)` is a call to a function only because `@tilua-types/lua`
- *  says so and ships the Luau behind it — the compiler knows how to ask, and
- *  nothing about `filter`.
+ *  half. `names:first()` is a call to a function only because the library that
+ *  put `first` in an array's metatable says so and ships the Luau behind it —
+ *  the compiler knows how to ask, and nothing about `first`.
  *
  *  `tilua.lowering` in the package.json names the module; what it must export
  *  is the compiler's business (see @tilua/compiler's `LoweringPlugin`). */
@@ -1643,6 +1688,10 @@ interface LoweringModule {
     readonly file: string;
     /** The package it came from, for reporting. */
     readonly from: string;
+    /** The package's definitions file, as its index in `files` — what the
+     *  analyzer names when a method comes from a metatable the package
+     *  declared (`MethodSource`), so the compiler asks this lowering. */
+    readonly library: number;
 }
 declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost): TypeLibraries;
 
@@ -1651,10 +1700,11 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
  *
  * A library's definitions file says what a value *is*; when what it gives is
  * not something the value already answers to, the library must also say how
- * it runs. `names:filter(f)` is a call to a function because `@tilua-types/lua`
- * declares the method and ships the Luau behind it — the compiler lowers the
- * language (`import`, `export`, `?.`, `a ? b : c`, destructuring, spreads)
- * and asks a library about everything else.
+ * it runs. `names:first()` is a call to a function when a library declares
+ * `first` in an array's metatable and ships the Luau behind it — the compiler
+ * lowers the language (`import`, `export`, `?.`, `a ? b : c`, destructuring,
+ * spreads, and the methods of the language's own metatables, such as
+ * `names:filter(f)`) and asks a library about what the library declared.
  *
  * These types are declarations only: nothing here runs, and the parser never
  * loads a lowering module. They live here so a library can be checked against
@@ -1666,10 +1716,8 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
  *     /** @type {import("@tilua/parser").LoweringPlugin} *\/
  *     const plugin = {
  *         runtime: { array: "local __NAME__ = {}\n..." },
- *         methodCall({ method, receiver, use }) {
- *             if (receiver?.kind === "array" && method === "filter") {
- *                 return { callee: `${use("array")}.filter` }
- *             }
+ *         methodCall({ method, use }) {
+ *             if (method === "first") return { callee: `${use("array")}.first` }
  *             return undefined
  *         },
  *     }
@@ -1694,10 +1742,12 @@ interface LoweringPlugin {
      *     that callback's errors the same way.
      *
      *      local __NAME__ = {}
-     *      function __NAME__.filter(t, test) ... end
+     *      function __NAME__.first(t) return t[1] end
      */
     readonly runtime?: Readonly<Record<string, string>>;
-    /** What `receiver:method(...)` becomes. `undefined` leaves a plain Luau
+    /** What `receiver:method(...)` becomes. Asked about a method a metatable
+     *  gave the receiver only when this library declared that metatable, and
+     *  about a method of the receiver's own always. `undefined` leaves a plain Luau
      *  method call, which is what a value that answers to the method itself
      *  wants — `text:upper()` reaches Lua's own. */
     methodCall?(call: MethodCall): MethodLowering | undefined;
@@ -1828,4 +1878,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareMetatableStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };

package/dist/index.d.ts

@@ -212,7 +212,7 @@ interface ExportAllStatement extends BaseNode {
     type: "ExportAllStatement";
     source: StringLiteral;
 }
-type Statement = VariableDeclaration | FunctionDeclaration | FunctionDeclarationStatement | ClassDeclaration | AssignmentStatement | CompoundAssignmentStatement | CallStatement | ExpressionStatement | DoStatement | WhileStatement | RepeatStatement | IfStatement | NumericForStatement | GenericForStatement | ReturnStatement | BreakStatement | ContinueStatement | TypeAliasStatement | ExportTypeAliasStatement | ImportStatement | ExportStatement | ExportDefaultStatement | ExportNamedStatement | ExportAllStatement | DeclareStatement | DeclareClassStatement | ErrorStatement;
+type Statement = VariableDeclaration | FunctionDeclaration | FunctionDeclarationStatement | ClassDeclaration | AssignmentStatement | CompoundAssignmentStatement | CallStatement | ExpressionStatement | DoStatement | WhileStatement | RepeatStatement | IfStatement | NumericForStatement | GenericForStatement | ReturnStatement | BreakStatement | ContinueStatement | TypeAliasStatement | ExportTypeAliasStatement | ImportStatement | ExportStatement | ExportDefaultStatement | ExportNamedStatement | ExportAllStatement | DeclareStatement | DeclareClassStatement | DeclareMetatableStatement | ErrorStatement;
 /** `declare game: DataModel` / `declare function require(m: string): unknown`
  *  — an ambient value/function declaration for a definitions file (`.d.tilua`).
  *  Contributes a global type; emits no runtime code. */
@@ -236,6 +236,25 @@ interface DeclareClassStatement extends BaseNode {
     superclass?: TypeReference;
     body: TableTypeNode;
 }
+/** `declare metatable string: { __index: StringLibrary }` — the metatable
+ *  every value of `target` has, as far as types go. A method call reads
+ *  through its `__index`: `text:upper()` is `upper` there.
+ *
+ *  A library may declare one a value does not really have — Lua gives an
+ *  array none — and ship a lowering that turns a call through it into a
+ *  call of its own (`names:filter(f)` becomes `array.filter(names, f)`).
+ *  The compiler asks the library that declared the metatable, and only it.
+ *
+ *  `target` may use the declaration's type parameters: `<T> T[]` is every
+ *  array, `T` its elements; `<T extends {}> T` every plain table, `T` the
+ *  table itself. The most specific target a value matches is its metatable,
+ *  and declaring one target again adds to it. */
+interface DeclareMetatableStatement extends BaseNode {
+    type: "DeclareMetatableStatement";
+    generics: GenericTypeParameter[];
+    target: TypeNode;
+    metatable: TypeNode;
+}
 /** A statement position that could not be parsed. Only produced when parsing
  *  in recovery mode (`parseWithRecovery`); its span covers the skipped tokens
  *  so tools can still map a cursor there. */
@@ -254,7 +273,9 @@ interface VariableDeclaration extends BaseNode {
     /** Absent only on `let x`. */
     init?: Expression;
 }
-type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern;
+/** A member or an index (`t.a`, `t[i]`) is a leaf only in a destructuring
+ *  assignment (`[t[i], t[j]] = [t[j], t[i]]`): a declaration binds names. */
+type BindingTarget = IdentifierPattern | ObjectPattern | ArrayPattern | MemberExpression | IndexExpression;
 interface IdentifierPattern extends BaseNode {
     type: "IdentifierPattern";
     name: string;
@@ -1486,8 +1507,27 @@ interface TypeAnalysis {
     /** How each `for (const item in source)` walks its source; see
      *  `LoopForm`. A loop missing here walks values. */
     readonly loops: ReadonlyMap<GenericForStatement, LoopForm>;
+    /** Each `receiver:method(...)` whose method the receiver's metatable
+     *  gave it (`declare metatable`), and which library declared that. A call
+     *  missing here reached a member of the receiver's own. */
+    readonly methodSources: ReadonlyMap<MethodCallExpression, MethodSource>;
+    /** The members a value's metatable `__index` gives it — what an editor
+     *  offers after `:`. Empty for a value no metatable matches. */
+    readonly metatableMembers: (type: Type) => ReadonlyMap<string, Type>;
     readonly diagnostics: TypeDiagnostic[];
 }
+/** Where a metatable reached by a method call was declared: by the language
+ *  itself (the prelude's metatables for strings, arrays and tables), by a
+ *  library (its index in `libs`), or by the program. The compiler lowers a
+ *  language method itself, and asks a library about its own. */
+type MethodSource = {
+    readonly origin: "language";
+} | {
+    readonly origin: "library";
+    readonly library: number;
+} | {
+    readonly origin: "program";
+};
 /** A type a module exports: the resolved type, plus the parameter names of a
  *  generic alias so an importer can instantiate it (`Box<number>`). */
 interface ExportedType {
@@ -1549,14 +1589,19 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * What a runtime provides — `print`, `string`, `game` — is not here: that is a
  * type library's job (`@tilua-types/lua`, `@tilua-types/roblox`).
  *
- * The methods an array and a string answer to — `names:filter(f)`,
- * `text:trim()` — are a library's too. `propertyType` reads them from types
- * named `ArrayMethods<T>` and `StringMethods`, whichever library declares
- * those; the library also says which of them the compiler must emit code for
- * (`tilua.methods` in its package.json). Nothing about `filter` is written
- * into the analyzer.
+ * Strings, arrays and tables are the language's own, so the metatables they
+ * answer to are declared here too — `declare metatable`, in tilua, the way a
+ * library declares one. A string's is Lua's (`upper`, `sub`) with tilua's
+ * answers where Lua's are several values (`find` is an array); the rest —
+ * `names:filter(f)`, `text:trim()`, `point:keys()` — no Lua value really
+ * has, and the compiler lowers each call to a function of its own runtime.
+ * A library adds to any of them by declaring the same target again.
+ *
+ * The analyzer supplies only what no type can compute: `ObjectKeys<T>`,
+ * `ObjectValues<T>` and `ObjectEntries<T>`, an object's members as tuples in
+ * the order they were written.
  */
-declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n";
+declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = T - Falsy\n\n-- `-` is set difference. Over a union it drops members; over a concrete type\n-- it simplifies away; over an opaque type (`unknown`, an unresolved parameter)\n-- it is kept, so `Exclude<unknown, 1>` stays `unknown - 1`.\ntype Exclude<T, U> = T - U\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = T - nil\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (self: T[], test: (value: T, index: number) => boolean) => T[],\n        map: <U>(self: T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        includes: (self: T[], value: T) => boolean,\n        indexOf: (self: T[], value: T, start?: number) => number | nil,\n        join: (self: T[], separator?: string) => string,\n        concat: (self: T[], ...others: T[][]) => T[],\n        slice: (self: T[], start?: number, stop?: number) => T[],\n        flat: (self: T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n    },\n}\n";
 
 interface ProjectHost {
     /** A file's text, or `undefined` when there is no such file. */
@@ -1632,9 +1677,9 @@ interface TypeLibraries {
  *  call written against this library's types should become.
  *
  *  The library declares the *types* in its definitions file; this is the other
- *  half. `names:filter(f)` is a call to a function only because `@tilua-types/lua`
- *  says so and ships the Luau behind it — the compiler knows how to ask, and
- *  nothing about `filter`.
+ *  half. `names:first()` is a call to a function only because the library that
+ *  put `first` in an array's metatable says so and ships the Luau behind it —
+ *  the compiler knows how to ask, and nothing about `first`.
  *
  *  `tilua.lowering` in the package.json names the module; what it must export
  *  is the compiler's business (see @tilua/compiler's `LoweringPlugin`). */
@@ -1643,6 +1688,10 @@ interface LoweringModule {
     readonly file: string;
     /** The package it came from, for reporting. */
     readonly from: string;
+    /** The package's definitions file, as its index in `files` — what the
+     *  analyzer names when a method comes from a metatable the package
+     *  declared (`MethodSource`), so the compiler asks this lowering. */
+    readonly library: number;
 }
 declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost): TypeLibraries;
 
@@ -1651,10 +1700,11 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
  *
  * A library's definitions file says what a value *is*; when what it gives is
  * not something the value already answers to, the library must also say how
- * it runs. `names:filter(f)` is a call to a function because `@tilua-types/lua`
- * declares the method and ships the Luau behind it — the compiler lowers the
- * language (`import`, `export`, `?.`, `a ? b : c`, destructuring, spreads)
- * and asks a library about everything else.
+ * it runs. `names:first()` is a call to a function when a library declares
+ * `first` in an array's metatable and ships the Luau behind it — the compiler
+ * lowers the language (`import`, `export`, `?.`, `a ? b : c`, destructuring,
+ * spreads, and the methods of the language's own metatables, such as
+ * `names:filter(f)`) and asks a library about what the library declared.
  *
  * These types are declarations only: nothing here runs, and the parser never
  * loads a lowering module. They live here so a library can be checked against
@@ -1666,10 +1716,8 @@ declare function resolveTypeLibraries(config: TiluaConfig, host?: ProjectHost):
  *     /** @type {import("@tilua/parser").LoweringPlugin} *\/
  *     const plugin = {
  *         runtime: { array: "local __NAME__ = {}\n..." },
- *         methodCall({ method, receiver, use }) {
- *             if (receiver?.kind === "array" && method === "filter") {
- *                 return { callee: `${use("array")}.filter` }
- *             }
+ *         methodCall({ method, use }) {
+ *             if (method === "first") return { callee: `${use("array")}.first` }
  *             return undefined
  *         },
  *     }
@@ -1694,10 +1742,12 @@ interface LoweringPlugin {
      *     that callback's errors the same way.
      *
      *      local __NAME__ = {}
-     *      function __NAME__.filter(t, test) ... end
+     *      function __NAME__.first(t) return t[1] end
      */
     readonly runtime?: Readonly<Record<string, string>>;
-    /** What `receiver:method(...)` becomes. `undefined` leaves a plain Luau
+    /** What `receiver:method(...)` becomes. Asked about a method a metatable
+     *  gave the receiver only when this library declared that metatable, and
+     *  about a method of the receiver's own always. `undefined` leaves a plain Luau
      *  method call, which is what a value that answers to the method itself
      *  wants — `text:upper()` reaches Lua's own. */
     methodCall?(call: MethodCall): MethodLowering | undefined;
@@ -1828,4 +1878,4 @@ declare const tilua: {
     readonly analyzeTypes: typeof analyzeTypes;
 };
 
-export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };
+export { type AnalyzeTypesOptions, type AnyType, type ArgumentInfo, type ArrayExpression, type ArrayPattern, type ArrayPatternElement, type ArrayType, type ArrayTypeNode, type AsConstExpression, type AssignmentStatement, type BaseNode, type BaseToken, type BinaryExpression, BinaryOperators, type Binding, type BindingId, type BindingKind, type BindingTarget, type Block, type BooleanLiteral, type BreakStatement, type BuildTarget, CONFIG_FILE_NAMES, type CallExpression, type CallLowering, type CallSite, type CallStatement, type ClassAccessibility, type ClassAccessor, type ClassConstructor, type ClassDeclaration, type ClassExpression, type ClassField, type ClassInfo, type ClassLike, type ClassMember, type ClassMethod, type CompoundAssignmentStatement, type ConditionalType, type ConditionalTypeNode, type ConfigLookup, type ConfigProblem, type ContinueStatement, type DeclareClassStatement, type DeclareMetatableStatement, type DeclareStatement, type DifferenceType, type DifferenceTypeNode, type Directive, type DirectiveKind, type DirectiveOutcome, type Directives, type DoStatement, type EOFToken, type ErrorExpression, type ErrorStatement, type ExportAllStatement, type ExportDefaultStatement, type ExportNamedStatement, type ExportSpecifier, type ExportStatement, type ExportTypeAliasStatement, type ExportedType, type Expression, type ExpressionStatement, type FunctionBody, type FunctionDeclaration, type FunctionDeclarationStatement, type FunctionExpression, type FunctionName, type FunctionParam, type FunctionParameter, type FunctionSignature, type FunctionType, type FunctionTypeNode, type FunctionTypeParameter, type GenericForStatement, type GenericRefType, type GenericTypeParameter, type GlobalCall, type GlobalValue, type Identifier, type IdentifierPattern, type IdentifierToken, type IfClause, type IfElseExpression, type IfStatement, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterpolatedStringExpression, type InterpolatedStringPart, type InterpolatedStringPart_Expression, type InterpolatedStringPart_String, type InterpolatedStringToken, type IntersectionType, type IntersectionTypeNode, type KeyofType, type KeyofTypeNode, type KeywordToken, Keywords, LANGUAGE_GLOBALS, LexError, type LiteralToken, type LiteralType, type LoweringModule, type LoweringPlugin, type MappedType, type MappedTypeNode, type MemberExpression, type MethodCall, type MethodCallExpression, type MethodLowering, type ModuleExports, type NeverType, type NilLiteral, type Node, type NumberLiteral, type NumericForStatement, type ObjectPattern, type ObjectPatternProperty, type ObjectProperty, type ObjectType, type OperatorToken, Operators, PRELUDE_SOURCE, type ParenthesizedExpression, type ParenthesizedTypeNode, ParseError, type ParserOptions, type PrimitiveName, type PrimitiveType, type Program, type ProjectHost, type PunctuatorToken, Punctuators, type RecoverResult, type RepeatStatement, type ReturnStatement, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type Statement, type StringLiteral, type SuperExpression, type TableExpression, type TableField, type TableTypeNode, type TableTypeProperty, type TemplateLiteralType, type TemplateLiteralTypeNode, type TiluaConfig, type Token, type TokenizeOptions, type TupleType, type TupleTypeNode, type Type, type TypeAliasStatement, type TypeAnalysis, type TypeAssertionExpression, type TypeDiagnostic, type TypeLibraries, type TypeLiteralBoolean, type TypeLiteralNumber, type TypeLiteralString, type TypeNode, type TypeOrigin, type TypeParamType, type TypePredicate, type TypePredicateNode, type TypeReference, type TypedIdentifier, type TypeofTypeNode, UNUSED_EXPECT_ERROR, type UnaryExpression, UnaryOperators, type Unification, type UnionType, type UnionTypeNode, type UnknownType, type VariableDeclaration, type WhileStatement, aliasNameOf, analyzeScopes, analyzeTypes, anyType, applyDirectives, arrayOf, booleanType, bufferType, containsTypeParam, declaredUnknownType, tilua as default, difference, directivesOf, equalTypes, falsyType, findConfig, fn, formatType, getBinding, intersection, isAssignable, isClassType, isGlobal, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName };