@tilua/parser 4.0.0 → 5.0.0

package/dist/index.d.ts

@@ -36,7 +36,7 @@ type LiteralToken = (BaseToken & {
     kind: "boolean";
     value: boolean;
 });
-declare const Operators: readonly ["+=", "-=", "*=", "/=", "//=", "%=", "^=", "..=", "==", "~=", "<=", ">=", "//", "..", "...", "+", "-", "*", "/", "%", "^", "#", "<", ">", "="];
+declare const Operators: readonly ["+=", "-=", "*=", "/=", "//=", "%=", "^=", "..=", "==", "~=", "<=", ">=", "//", "..", "...", "??", "++", "--", "+", "-", "*", "/", "%", "^", "#", "<", ">", "="];
 interface OperatorToken extends BaseToken {
     type: "Operator";
     value: typeof Operators[number];
@@ -205,6 +205,9 @@ interface ExportNamedStatement extends BaseNode {
     type: "ExportNamedStatement";
     specifiers: ExportSpecifier[];
     source?: StringLiteral;
+    /** `export type { A }`: the names are types, and only types are
+     *  exported — compiled code keeps no trace of it. */
+    typeOnly?: boolean;
 }
 /** `export * from "./x"` — every named export of another module (not its
  *  default), except names this module exports itself. */
@@ -483,6 +486,9 @@ interface CompoundAssignmentStatement extends BaseNode {
     operator: "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "^=" | "..=";
     target: Expression;
     value: Expression;
+    /** Written `n++` / `n--`: the same statement as `n += 1` / `n -= 1`,
+     *  whose `value` is then a `1` spanning the operator. */
+    postfix?: "++" | "--";
 }
 interface CallStatement extends BaseNode {
     type: "CallStatement";
@@ -559,6 +565,16 @@ interface TypeAliasStatement extends BaseNode {
     name: Identifier;
     generics: GenericTypeParameter[];
     definition: TypeNode;
+    /** Written `interface Name extends A, B { ... }`. The alias is then the
+     *  bases and the body together — `definition` is `A & B & { ... }` — and
+     *  two interfaces of one name are one, their members merged. */
+    interface?: InterfaceParts;
+}
+/** What an `interface` was written as: the shapes it extends, and its own
+ *  members. */
+interface InterfaceParts {
+    extends: TypeReference[];
+    body: TableTypeNode;
 }
 interface ExportTypeAliasStatement extends BaseNode {
     type: "ExportTypeAliasStatement";
@@ -575,8 +591,12 @@ interface GenericTypeParameter extends BaseNode {
     /** `<T extends C>` upper bound (TS style). */
     constraint?: TypeNode;
     default?: TypeNode;
+    /** `<out T>`, `<in T>`, `<in out T>`: how the type compares by `T` —
+     *  `out` as `T` does, `in` the other way round, both only when equal.
+     *  Checked against how the body uses `T`. */
+    variance?: "in" | "out" | "in out";
 }
-type Expression = Identifier | NilLiteral | BooleanLiteral | NumberLiteral | StringLiteral | InterpolatedStringExpression | FunctionExpression | TableExpression | ArrayExpression | BinaryExpression | UnaryExpression | MemberExpression | IndexExpression | CallExpression | MethodCallExpression | SuperExpression | ClassExpression | SpreadElement | ParenthesizedExpression | TypeAssertionExpression | SatisfiesExpression | AsConstExpression | IfElseExpression | ErrorExpression;
+type Expression = Identifier | NilLiteral | BooleanLiteral | NumberLiteral | StringLiteral | InterpolatedStringExpression | FunctionExpression | TableExpression | ArrayExpression | BinaryExpression | UnaryExpression | MemberExpression | IndexExpression | CallExpression | MethodCallExpression | SuperExpression | ClassExpression | SpreadElement | ParenthesizedExpression | ImportExpression | TypeAssertionExpression | SatisfiesExpression | AsConstExpression | IfElseExpression | ErrorExpression;
 /** An expression that could not be parsed. Only produced in recovery mode
  *  (`parseWithRecovery`), where a broken initializer, condition, field value or
  *  argument keeps its place in the tree; its span covers the skipped tokens
@@ -690,7 +710,16 @@ type TableField =
  | {
     type: "TableFieldSpread";
     argument: Expression;
-};
+}
+/** `{ get name() { ... } }` / `{ set name(v) { ... } }` — read as a
+ *  property, run as a function. `func` takes the object as `this`, an
+ *  implicit first parameter, as a class method does. */
+ | {
+    type: "TableFieldAccessor";
+    kind: "get" | "set";
+    key: Identifier | StringLiteral;
+    func: FunctionBody;
+} & BaseNode;
 /** `{ a: 1, [k]: v }` — object literal (Luau `{}` narrowed to objects only). */
 interface TableExpression extends BaseNode {
     type: "TableExpression";
@@ -712,7 +741,7 @@ interface SpreadElement extends BaseNode {
     type: "SpreadElement";
     argument: Expression;
 }
-declare const BinaryOperators: readonly ["+", "-", "*", "/", "//", "%", "^", "..", "==", "~=", "<", ">", "<=", ">=", "and", "or"];
+declare const BinaryOperators: readonly ["+", "-", "*", "/", "//", "%", "^", "..", "==", "~=", "<", ">", "<=", ">=", "and", "or", "??", "in", "instanceof"];
 interface BinaryExpression extends BaseNode {
     type: "BinaryExpression";
     operator: typeof BinaryOperators[number];
@@ -773,6 +802,15 @@ interface MethodCallExpression extends BaseNode {
      *  arguments are not evaluated when `object` is nil. */
     optional?: boolean;
 }
+/** `import("./module")` — the module's exports as one value, the one
+ *  `import * as M from "./module"` would name `M`, read where the expression
+ *  runs instead of before the file does. The module is loaded the first time
+ *  anything asks for it. `source` has to be a string literal: which module it
+ *  is must be known when the project is built. */
+interface ImportExpression extends BaseNode {
+    type: "ImportExpression";
+    source: Expression;
+}
 interface ParenthesizedExpression extends BaseNode {
     type: "ParenthesizedExpression";
     expression: Expression;
@@ -807,19 +845,7 @@ interface IfElseExpression extends BaseNode {
     }[];
     alternate: Expression;
 }
-type TypeNode = TypeReference | TypeLiteralString | TypeLiteralBoolean | TypeLiteralNumber | TableTypeNode | ArrayTypeNode | TupleTypeNode | FunctionTypeNode | UnionTypeNode | IntersectionTypeNode | ParenthesizedTypeNode | TypeofTypeNode | KeyofTypeNode | IndexedAccessTypeNode | ConditionalTypeNode | InferTypeNode | MappedTypeNode | TemplateLiteralTypeNode | DifferenceTypeNode;
-/** `A - B` — every value of `A` that is not a `B`. Binds tighter than `|`
- *  and looser than `&`, so `A | B - C` is `A | (B - C)`.
- *
- *  Mostly it simplifies away (a union drops members; `string - "a"` is just
- *  `string`), but over an opaque type it is retained — which is what lets the
- *  `else` of `if a == 1` on an `unknown` say `unknown - 1` instead of
- *  forgetting the test. `Exclude<T, U>` is defined as `T - U`. */
-interface DifferenceTypeNode extends BaseNode {
-    type: "DifferenceTypeNode";
-    base: TypeNode;
-    excluded: TypeNode;
-}
+type TypeNode = TypeReference | TypeLiteralString | TypeLiteralBoolean | TypeLiteralNumber | TableTypeNode | ArrayTypeNode | TupleTypeNode | FunctionTypeNode | UnionTypeNode | IntersectionTypeNode | ParenthesizedTypeNode | TypeofTypeNode | KeyofTypeNode | IndexedAccessTypeNode | ConditionalTypeNode | InferTypeNode | MappedTypeNode | TemplateLiteralTypeNode | RestTypeNode;
 /** A template literal type: `` `on${string}` ``, `` `get${K}` ``.
  *  `quasis` are the literal chunks and `types` the interpolated types;
  *  `quasis.length === types.length + 1`, exactly as in an ECMAScript template.
@@ -860,6 +886,14 @@ interface InferTypeNode extends BaseNode {
     name: string;
     /** The bound name as a node. */
     id?: Identifier;
+    /** `infer N extends number`: what matched only counts if it is one — and
+     *  out of a template literal, `"42"` read as a `number` is `42`. */
+    constraint?: TypeNode;
+}
+/** `...T` inside a tuple type: the elements of `T`, in its place. */
+interface RestTypeNode extends BaseNode {
+    type: "RestTypeNode";
+    typeAnnotation: TypeNode;
 }
 /** `{ [K in C]: V }` — a mapped type. `optional` / `readonly` carry the
  *  modifier as written: `true` adds it (`?`), `false` removes it (`-?`),
@@ -931,10 +965,20 @@ type TableTypeProperty = ({
     valueType: TypeNode;
     optional: boolean;
     readonly?: boolean;
+    /** Written as a method, `name(x: T): R`: `valueType` is the function,
+     *  its receiver first — `(self: this, x: T) => R`. */
+    method?: boolean;
+    /** Written as `get name(): T` / `set name(v: T)`: what the property
+     *  holds. A getter without a setter is read-only. */
+    accessor?: "get" | "set" | "both";
 } & BaseNode);
 interface TableTypeNode extends BaseNode {
     type: "TableTypeNode";
     properties: TableTypeProperty[];
+    /** `{ (x: number): string }` — what calling a value of this type does.
+     *  Several are overloads. The type is then these functions together
+     *  with the properties. */
+    callSignatures?: FunctionTypeNode[];
 }
 /** `T[]` — array type. Replaces Luau's `{T}` array-table notation. */
 interface ArrayTypeNode extends BaseNode {
@@ -944,14 +988,22 @@ interface ArrayTypeNode extends BaseNode {
     isReadonly?: boolean;
 }
 /** `[number, string]` — a tuple type; `[string, ...number[]]` ends in a rest
- *  of as many more as there are. */
+ *  of as many more as there are. A spread of anything else — `[...T, U]`, a
+ *  type parameter or another tuple — stays among `elements` as a
+ *  `RestTypeNode`, and is laid out once what it spreads is known. */
 interface TupleTypeNode extends BaseNode {
     type: "TupleTypeNode";
     elements: TypeNode[];
+    /** `[x: number, y: number]` — the name each element was written with,
+     *  where it was. Display only. */
+    labels?: (string | undefined)[];
     /** `...number[]` at the end: the array type the rest of it is. */
     rest?: TypeNode;
     /** `readonly [A, B]` — see `ArrayTypeNode.isReadonly`. */
     isReadonly?: boolean;
+    /** `[A, B?]`, `[a: A, b?: B]`: which elements may be left out — each
+     *  then read as `T | nil`, which in Lua is the same thing. */
+    optional?: boolean[];
 }
 interface FunctionTypeParameter extends BaseNode {
     type: "FunctionTypeParameter";
@@ -1101,11 +1153,14 @@ interface AnalyzeScopesOptions {
      *  one of these does not count as "defining" it, so `declarationNode`
      *  is left unset even though the binding exists up front. */
     builtinGlobals?: readonly string[];
+    /** Leave out the standard library's globals (`print`, `pairs`, ...),
+     *  which are otherwise there for every file. The config's `"noLib"`. */
+    noLib?: boolean;
     /** Report each read of a name nothing declares — not a local, not one of
      *  `builtinGlobals`, not `declare`d in the file, never assigned as a
      *  global: "Cannot find name 'x'", as TypeScript says. Only meaningful
      *  when `builtinGlobals` lists everything the file's type libraries
-     *  declare, so it is off unless asked for. */
+     *  declare beyond the standard library, so it is off unless asked for. */
     reportUndeclared?: boolean;
 }
 declare function getBinding(analysis: ScopeAnalysis, id: Identifier | IdentifierPattern): Binding | undefined;
@@ -1121,7 +1176,7 @@ declare function isUnassignedGlobal(binding: Binding): boolean;
 declare const LANGUAGE_GLOBALS: readonly string[];
 declare function analyzeScopes(program: Program, options?: AnalyzeScopesOptions): ScopeAnalysis;
 
-type Type = AnyType | UnknownType | NeverType | PrimitiveType | LiteralType | ArrayType | TupleType | ObjectType | FunctionType | UnionType | IntersectionType | TypeParamType | GenericRefType | KeyofType | IndexedAccessType | ConditionalType | InferType | MappedType | TemplateLiteralType | DifferenceType;
+type Type = AnyType | UnknownType | NeverType | PrimitiveType | LiteralType | ArrayType | TupleType | ObjectType | FunctionType | UnionType | IntersectionType | TypeParamType | GenericRefType | KeyofType | IndexedAccessType | ConditionalType | InferType | MappedType | TemplateLiteralType | DifferenceType | SpreadType;
 /** `any` — opts out of checking. Assignable to and from everything. */
 interface AnyType {
     kind: "any";
@@ -1142,7 +1197,9 @@ interface NeverType {
     kind: "never";
     alias?: string;
 }
-type PrimitiveName = "nil" | "boolean" | "number" | "string" | "thread" | "buffer";
+/** `object` is TypeScript's: any value that is not one of the others — a
+ *  table, a list, a function, a class instance. */
+type PrimitiveName = "nil" | "boolean" | "number" | "string" | "thread" | "buffer" | "object";
 interface PrimitiveType {
     kind: "primitive";
     name: PrimitiveName;
@@ -1171,7 +1228,32 @@ interface TupleType {
     rest?: Type;
     alias?: string;
     readonly?: boolean;
+    /** `[number, string?]`: how many of the elements have to be there — the
+     *  ones from here on may be left out, and hold `nil` when they are. All
+     *  of them when absent. */
+    minLength?: number;
+    /** `[x: number, y?: number]`: the name each element was written with,
+     *  where it was. Display only. */
+    names?: readonly (string | undefined)[];
+}
+/** `made`, rebuilt from `from`, keeping what `tuple` does not carry: that
+ *  it is read-only, which of its places may be left out, and their names —
+ *  so long as it has as many places as `from` had. */
+declare function tupleMeta(made: TupleType, from: TupleType): TupleType;
+/** How many places a tuple has to have. */
+declare function minLengthOf(t: TupleType): number;
+/** What a tuple's `length` is: one number, or each it may be. */
+declare function tupleLength(t: TupleType): Type;
+/** `...T` among a tuple's elements, where `T` is not known yet — a type
+ *  parameter, an `infer`, a type-level operator still waiting on one. It only
+ *  ever stands inside a `TupleType`'s `elements`: `tuple` lays out a spread of
+ *  anything known (a tuple's elements in its place, an array's as the rest),
+ *  so once its type parameters are filled in none is left. */
+interface SpreadType {
+    kind: "spread";
+    type: Type;
 }
+declare function spread(type: Type): SpreadType;
 interface ObjectProperty {
     type: Type;
     optional: boolean;
@@ -1226,6 +1308,10 @@ interface ClassInfo {
      *  `Box<string>`. A class with no type parameters anywhere carries
      *  nothing, and costs nothing. */
     typeArguments?: ReadonlyMap<string, readonly Type[]>;
+    /** A `class` the program writes, whose instances are Lua tables — as
+     *  opposed to a `declare class`, a value the host made (a Roblox
+     *  `Instance`, a `Vector3`), which knows how to print itself. */
+    runtime?: boolean;
 }
 declare function isClassType(t: Type): t is ObjectType & {
     class: ClassInfo;
@@ -1279,6 +1365,9 @@ interface TypeParamType {
     /** Declared `<const T>`: the call site infers the argument at its
      *  narrowest rather than widening it. */
     isConst?: boolean;
+    /** Written inside `NoInfer<...>`: an argument there is checked against
+     *  the parameter, never read to work out what it is. */
+    noInfer?: boolean;
 }
 declare function typeParam(name: string, constraint?: Type, isConst?: boolean): TypeParamType;
 interface UnionType {
@@ -1309,6 +1398,9 @@ interface GenericRefType {
 /** A module's own alias resolution, handed out on the refs it creates. */
 interface TypeOrigin {
     expand(t: GenericRefType): Type;
+    /** How the alias `name` compares by each of its parameters, where it
+     *  says (`<out T>`, `<in T>`, `<in out T>`). */
+    variances?(name: string): readonly (string | undefined)[] | undefined;
 }
 /** `keyof T`. */
 interface KeyofType {
@@ -1320,6 +1412,7 @@ interface IndexedAccessType {
     kind: "indexedAccess";
     objectType: Type;
     indexType: Type;
+    alias?: string;
 }
 /** `C extends E ? A : B`. */
 interface ConditionalType {
@@ -1335,26 +1428,29 @@ interface ConditionalType {
      *  branch the parameter denotes the single member being tested — the
      *  property `Exclude<T, U>` relies on. */
     distributeParam?: string;
+    alias?: string;
 }
 /** `infer U`, valid only inside a conditional's `extends` clause. */
 interface InferType {
     kind: "infer";
     name: string;
+    /** `infer N extends number` — see `InferTypeNode.constraint`. */
+    constraint?: Type;
 }
-/** `A - B` — every value of `A` that is not a `B`.
+/** `Exclude<A, B>` — every value of `A` that is not a `B`.
  *
- *  Only kept when `A` is *opaque*: `unknown`, or a type parameter or nominal
- *  reference not yet resolved. For a union the subtraction is performed by
- *  dropping members, and for a concrete type such as `string` it is discarded
- *  (`string - "a"` supports exactly the same operations as `string`, and
- *  TypeScript likewise does not track it). For `unknown`, though, the
- *  subtraction is the *only* thing known about the value, so throwing it away
- *  loses the whole result of the test:
+ *  Only kept when `A` is *opaque*: `unknown`, `any`, or a type parameter or
+ *  nominal reference not yet resolved. For a union the subtraction is
+ *  performed by dropping members, and for a concrete type such as `string` it
+ *  is discarded (`Exclude<string, "a">` supports exactly the same operations
+ *  as `string`). For `unknown`, though, the subtraction is the *only* thing
+ *  known about the value, so throwing it away — as TypeScript's `Exclude`
+ *  does — loses the whole result of the test:
  *
  *      let a: unknown
- *      if a == 1 then  -- a: 1
- *      else            -- a: unknown - 1
- *      end
+ *      if (a == 1) {   -- a: 1
+ *      } else {        -- a: Exclude<unknown, 1>
+ *      }
  */
 interface DifferenceType {
     kind: "difference";
@@ -1391,6 +1487,7 @@ interface MappedType {
     /** The `T` of `[K in keyof T]`, kept so a homomorphic mapped type can carry
      *  each source property's own `?` / `readonly` across. */
     source?: Type;
+    alias?: string;
 }
 declare const anyType: AnyType;
 declare const unknownType: UnknownType;
@@ -1402,10 +1499,13 @@ declare const numberType: PrimitiveType;
 declare const stringType: PrimitiveType;
 declare const threadType: PrimitiveType;
 declare const bufferType: PrimitiveType;
+declare const objectKeywordType: PrimitiveType;
 declare function primitive(name: PrimitiveName): PrimitiveType;
 declare function literal(value: string | number | boolean): LiteralType;
 declare function arrayOf(element: Type): ArrayType;
 declare function tuple(elements: Type[], rest?: Type): TupleType;
+/** Does this tuple still have a spread to lay out? */
+declare function hasSpread(t: TupleType): boolean;
 /** Every element type a tuple can hold, the rest's included. */
 declare function tupleMembers(t: TupleType): Type[];
 declare function objectType(entries: Iterable<[string, ObjectProperty]>, indexer?: ObjectType["indexer"], frozen?: boolean): ObjectType;
@@ -1422,8 +1522,13 @@ type Unification = "union" | "first";
 declare function unify(param: Type, arg: Type, vars: Set<string>, out: Map<string, Type>, how?: Unification): void;
 declare function union(types: Type[]): Type;
 declare function intersection(types: Type[]): Type;
-/** `base - excluded`, simplified as far as the base allows. */
+/** `Exclude<base, excluded>`, simplified as far as the base allows. */
 declare function difference(base: Type, excluded: Type): Type;
+/** A method's type with its receiver left out: what it takes after `this`
+ *  (or a definitions file's `self`) — what `text.upper` is, the receiver
+ *  being `text`. A guard on a later parameter moves with it. Anything else is
+ *  returned as it is. */
+declare function withoutReceiver(t: Type): Type;
 /** `T | nil` — the type of an optional property or parameter. */
 declare function optional(t: Type): Type;
 /** Widens literal types to their primitive base (the default for a plain
@@ -1432,7 +1537,15 @@ declare function optional(t: Type): Type;
 declare function widen(t: Type): Type;
 declare function setAliasExpander(fn: ((t: GenericRefType) => Type) | undefined): void;
 declare function setDeferredBound(fn: ((t: Type) => Type | undefined) | undefined): void;
+declare function setBuiltinMember(fn: ((t: Type, name: string) => Type | undefined) | undefined): void;
 declare function isAssignable(rawA: Type, rawB: Type): boolean;
+/** A tuple's places as the parameters they are, with their names, and the
+ *  ones that may be left out optional: `[a: number, b?: string]` is
+ *  `(a: number, b?: string)`. */
+declare function tupleParams(t: TupleType): FunctionParam[];
+/** Parameters as the tuple they are: `(a: number, b?: string)` is
+ *  `[a: number, b?: string]`. */
+declare function paramsAsTuple(params: readonly FunctionParam[], rest?: Type): TupleType;
 declare function equalTypes(a: Type, b: Type): boolean;
 /** Keep the parts of `t` compatible with `filter` — TypeScript's
  *  `getNarrowedType`. Per union member: a member already assignable to the
@@ -1458,11 +1571,26 @@ declare function narrowTruthy(t: Type): Type;
 /** Keep only what can be falsy — `nil` and `false`. */
 declare function narrowFalsy(t: Type): Type;
 declare function containsTypeParam(t: Type, seen?: Set<Type>, bound?: Set<string>): boolean;
+/** The name of TypeScript's polymorphic `this` type: the value a member is
+ *  read from. It is a type parameter filled in where a member is read (see
+ *  `withThis`), so it never keeps a type waiting the way a generic's own
+ *  parameters do — `keyof` an interface whose methods take `self: this` is
+ *  as known as any other. */
+declare const THIS_TYPE = "this";
+/** Does `t` mention the polymorphic `this` — outside a class, whose members
+ *  are read one at a time? */
+declare function mentionsThis(t: Type): boolean;
+/** `t` with `this` standing for `receiver`. */
+declare function withThis(t: Type, receiver: Type): Type;
 /** Structurally match `arg` against `pattern`, binding every `infer` name it
  *  contains into `out`. This is what turns `T extends (...unknown) -> infer R`
  *  into `R = <the return type>`. Returns false when the shapes cannot match at
- *  all; a `true` result still needs the usual assignability check. */
-declare function matchInfer(arg: Type, pattern: Type, out: Map<string, Type>): boolean;
+ *  all; a `true` result still needs the usual assignability check.
+ *
+ *  `contra` is set below a function's parameter: a name inferred from several
+ *  places there is what all of them take — their intersection, which is how
+ *  `UnionToIntersection` works — where anywhere else it is their union. */
+declare function matchInfer(arg: Type, pattern: Type, out: Map<string, Type>, contra?: boolean): boolean;
 /** Does a concrete string match a template literal *pattern*? Each
  *  interpolation is matched against the widest thing it could stand for:
  *  `string` swallows any run, `number` a numeric run, and a literal union only
@@ -1522,6 +1650,15 @@ interface TypeAnalysis {
      *  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>;
+    /** Each `value.method` read with `.` that reaches a method the value's
+     *  metatable gives it — `names.filter`, `text.trim` — and which library
+     *  declared that. The method is a function like any other: called with
+     *  `.` it is handed its `self` the way any function is handed its first
+     *  argument, `names.filter(names, f)`. No Lua array has a `filter` to
+     *  read, so the compiler writes the read as what the method really is. */
+    readonly methodReads: ReadonlyMap<MemberExpression, MethodSource>;
+    /** Each `.length` read of a string or a list: Luau's `#`. */
+    readonly lengths: ReadonlySet<MemberExpression>;
     /** Each `typeof v` whose `v`, where it is a table at all, is known by its
      *  type to be an array or to be an object. One missing here has to be
      *  told apart as the program runs. */
@@ -1572,6 +1709,9 @@ interface AnalyzeTypesOptions {
      *  types. A project lists them under `types` in `tilua.config.json`; see
      *  `resolveTypeLibraries`. */
     libs?: readonly Program[];
+    /** Leave the standard library out: no `print`, no `string`, nothing but
+     *  what `libs` declare. The config's `"noLib": true`. */
+    noLib?: boolean;
     /** Resolve an `import`'s module path to what that module exports. Called
      *  once per distinct path. Return `undefined` when there is no such module:
      *  the import is reported and its names are `any`. Without this option
@@ -1597,8 +1737,8 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * or without a type library — as TypeScript's `Partial` and `ReturnType` are.
  *
  * They are written in tilua on top of `keyof`, `T[K]`, conditional types with
- * `infer`, mapped types and set difference; the analyzer knows none of these
- * names. A type library or the file itself may declare one of them again, and
+ * `infer`, mapped types and `Exclude`; the analyzer knows none of these
+ * names but `Exclude`. A type library or the file itself may declare one of them again, and
  * that declaration wins.
  *
  * What a runtime provides — `print`, `string`, `game` — is not here: that is a
@@ -1616,7 +1756,28 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * `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\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.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\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: (<S extends T>(self: T[], test: (value: T, index: number) => value is S) => S[])\n            & ((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.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\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        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\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> = Exclude<T, Falsy>\n\n-- `Exclude<T, U>` is the analyzer's own: what of `T` is not a `U`. Over a\n-- union it drops the members it takes whole; over `unknown`, `any`, a\n-- primitive or an unresolved parameter it is kept \u2014 `Exclude<string, \"a\">` is\n-- a string that is not `\"a\"` \u2014 unlike TypeScript's.\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = Exclude<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\n-- A class table builds with `new`: `InstanceType<typeof Dog>` is a `Dog`.\ntype InstanceType<T> = T extends { new: (...args: any[]) => infer R } ? R : never\ntype ConstructorParameters<T> = T extends { new: (...args: infer P) => any } ? P : never\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.\n-- The ones that only read take a `readonly T[]` too \u2014 `as const` lists, and\n-- what a function promised not to change \u2014 as TypeScript's `ReadonlyArray`.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: readonly T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: readonly T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: readonly T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: readonly T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: readonly T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: readonly T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: readonly T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        -- Asking is not adding: any value may be looked for, and finding it\n        -- says it is one of the array's \u2014 `if (names:includes(s))` narrows `s`.\n        includes: (self: readonly T[], value: unknown) => value is T,\n        indexOf: (self: readonly T[], value: unknown, start?: number) => number | nil,\n        join: (self: readonly T[], separator?: string) => string,\n        concat: <U>(self: readonly T[], ...others: (readonly U[])[]) => (T | U)[],\n        slice: (self: readonly T[], start?: number, stop?: number) => T[],\n        flat: (self: readonly 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.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\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        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\n";
+
+/**
+ * The Lua 5.1 standard library, always there — as TypeScript always has
+ * JavaScript's. `print`, `pairs`, `string`, `math`, `table`, `pcall`,
+ * `console`: every file can name them with no type library listed in
+ * `tilua.config.json`. A project that wants none of it says `"noLib": true`.
+ *
+ * It is a type library like any other, loaded before the ones a project
+ * lists — so `@tilua-types/roblox` adds Luau's and Roblox's on top of it —
+ * and what it declares runs as Lua's own, except where Lua answers several
+ * values: the compiler lowers those (`pcall`, `string.find`, ...) and the
+ * console, in its `standard` lowering.
+ *
+ * `@tilua-types/lua`, where this used to live, is not loaded when a project
+ * still names it: it would declare everything twice.
+ */
+declare const STANDARD_LIBRARY_SOURCE = "\n-- The Lua 5.1 standard library, written in tilua.\n--\n-- This is the floor every tilua project stands on, the way TypeScript stands\n-- on JavaScript's: the functions and libraries Lua itself defines, there in\n-- every file without being asked for. Nothing here is Luau's or Roblox's \u2014\n-- `buffer`, `table.create` and the rest live one layer up in\n-- `@tilua-types/roblox`, which adds to it.\n--\n-- Lua's `type()` is not here: what a value is, is asked with the language's\n-- own `typeof v`, which also tells an array from an object.\n--\n-- Adding to it is literal: a name declared again in a later file keeps what\n-- earlier files gave it. `declare table: { find: ... }` in `@tilua-types/roblox` does\n-- not replace this `table`, it extends it, and overloads of a function\n-- accumulate the same way. So the layers really are layers.\n\n-- ============================================================\n-- Base library\n-- ============================================================\n\ndeclare _G: { [string]: unknown }\ndeclare _VERSION: string\n\ndeclare function require(module: unknown): unknown\ndeclare function tostring(value: unknown): string\ndeclare function tonumber(value: unknown, base?: number): number | nil\ndeclare function print(...args: unknown[]): nil\n-- `error` never returns, which is what lets\n-- `if v == nil then error(\"...\") end` narrow the rest of the block.\ndeclare function error(message: unknown, level?: number): never\n\n-- `asserts value` \u2014 narrows the *rest of the enclosing block*, the way\n-- TypeScript's assertion signatures do:\n--\n--     const part = workspace:FindFirstChild(\"Part\")  -- Instance | nil\n--     assert(part)\n--     part.Name                                      -- Instance, no `?`\n\ndeclare function assert<T>(value: T, message?: string): asserts value\n\n-- `pcall` and `xpcall` answer the way a JavaScript result object does:\n--\n--     const { success, data, error } = pcall(load, \"config\")\n--     if (success) { use(data) } else { warn(error) }\n--\n-- `data` is what the function returned. These are not Luau's own `pcall`:\n-- where Luau answers several values, tilua has one, and the compiler puts its\n-- own functions in place of those globals (runtime/result.luau) \u2014 for calls,\n-- and for the global read as a value alike. The same goes for `string.find`,\n-- `string.match`, `string.gsub`, `string.byte`, `math.modf`, `math.frexp`,\n-- `next`, `select`, `unpack`, `loadstring`, `pairs`, `ipairs` and\n-- `string.gmatch` below.\ntype PcallResult<T> = { success: true, data: T, error: nil } | { success: false, data: nil, error: unknown }\n\ndeclare function pcall<A extends unknown[], T>(fn: (...args: A) => T, ...args: A): PcallResult<T>\ndeclare function xpcall<A extends unknown[], T>(fn: (...args: A) => T, handler: (err: unknown) => unknown, ...args: A): PcallResult<T>\n-- `select(\"#\", ...args)` counts; `select(n, ...args)` is what follows the\n-- n-th, as an array.\ndeclare function select(n: \"#\", ...args: unknown[]): number\ndeclare function select<T>(n: number, ...args: T[]): T[]\n-- A copy of the list, or of part of it.\ndeclare function unpack<V>(list: V[], i?: number, j?: number): V[]\ndeclare function rawget(t: unknown, key: unknown): unknown\ndeclare function rawset<T>(t: T, key: unknown, value: unknown): T\ndeclare function rawequal(a: unknown, b: unknown): boolean\ndeclare function setmetatable<T>(t: T, mt: unknown): T\ndeclare function getmetatable(t: unknown): unknown\ndeclare function newproxy(addMeta?: boolean): unknown\n-- The entry after `key` \u2014 or nil, past the last one.\ndeclare function next<K, V>(t: { [K]: V }, key?: K): [K, V] | nil\n\n-- What `for (const item in source)` walks: `step` is called with the state\n-- and the item before it \u2014 `first` the first time \u2014 until it answers nil.\n-- An array, a table and an iterator function are walked too, so this is only\n-- what a source such as `pairs(t)` hands over.\ntype Iteration<S, T> = [(state: S, previous: T | nil) => T | nil, S, T | nil]\n\n-- `for (const [k, v] in pairs(t))` / `ipairs(t)`: each item is one `[key,\n-- value]` \u2014 a table, as every array is. The analyzer types it from `t` itself\n-- (a record's keys as literals, an array's elements); these declare the\n-- names, and their shape for any other use.\ndeclare function pairs<V>(t: V[]): Iteration<V[], [number, V]>\ndeclare function pairs<K, V>(t: { [K]: V }): Iteration<{ [K]: V }, [K, V]>\ndeclare function ipairs<V>(t: V[]): Iteration<V[], [number, V]>\n\ndeclare function collectgarbage(option: \"count\"): number\ndeclare function gcinfo(): number\ndeclare function getfenv(target?: unknown): { [string]: unknown }\ndeclare function setfenv<T>(target: T, env: { [string]: unknown }): T\ndeclare function loadstring(source: string, chunkname?: string): [((...args: unknown[]) => unknown) | nil, string | nil]\n\ndeclare debug: {\n    traceback: (message?: string, level?: number) => string,\n}\n\ndeclare string: {\n    format: (fmt: string, ...args: unknown[]) => string,\n    sub: (s: string, i: number, j?: number) => string,\n    len: (s: string) => number,\n    upper: (s: string) => string,\n    lower: (s: string) => string,\n    rep: (s: string, n: number, sep?: string) => string,\n    reverse: (s: string) => string,\n    -- Where the pattern is, then what it captured \u2014 or nil.\n    find: (s: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n    -- What it captured (the whole match when there are no captures), as\n    -- JavaScript's `match` answers \u2014 or nil.\n    match: (s: string, pattern: string, init?: number) => [...string[]] | nil,\n    -- Each match's captures (the whole match when there are none), one\n    -- array at a time: `for (const [word] in s:gmatch(\"%a+\"))`.\n    gmatch: (s: string, pattern: string) => () => [string, ...string[]] | nil,\n    -- The new string, as JavaScript's `replace` answers; Luau's count of\n    -- replacements is left behind.\n    gsub: (s: string, pattern: string, repl: unknown, n?: number) => string,\n    -- One code for one position; an array of them for a range.\n    byte: ((s: string, i?: number) => number) & ((s: string, i: number, j: number) => number[]),\n    char: (...args: number[]) => string,\n}\n\ndeclare math: {\n    abs: (x: number) => number,\n    floor: (x: number) => number,\n    ceil: (x: number) => number,\n    fmod: (x: number, y: number) => number,\n    modf: (x: number) => [number, number],\n    sqrt: (x: number) => number,\n    pow: (x: number, y: number) => number,\n    exp: (x: number) => number,\n    log: (x: number, base?: number) => number,\n    log10: (x: number) => number,\n    frexp: (x: number) => [number, number],\n    ldexp: (m: number, e: number) => number,\n    min: (...args: number[]) => number,\n    max: (...args: number[]) => number, \n    sin: (x: number) => number,\n    cos: (x: number) => number,\n    tan: (x: number) => number,\n    asin: (x: number) => number,\n    acos: (x: number) => number,\n    atan: (x: number) => number,\n    atan2: (y: number, x: number) => number,\n    sinh: (x: number) => number,\n    cosh: (x: number) => number,\n    tanh: (x: number) => number,\n    rad: (deg: number) => number,\n    deg: (rad: number) => number,\n    random: (m?: number, n?: number) => number,\n    randomseed: (x: number) => nil,\n    huge: number,\n    pi: number,\n}\n\n\ndeclare table: {\n    -- `insert(t, v)` appends; `insert(t, pos, v)` puts it there.\n    insert: (<T>(t: T[], value: T) => nil) & (<T>(t: T[], pos: number, value: T) => nil),\n    remove: <T>(t: T[], pos?: number) => T | nil,\n    concat: (t: (string | number)[], sep?: string, i?: number, j?: number) => string,\n    sort: <T>(t: T[], compare?: (a: T, b: T) => boolean) => nil,\n    -- Lua 5.1's originals. Deprecated there and gone from 5.2 on, but Luau\n    -- still answers to them, so code being ported still type-checks.\n    getn: <T>(t: T[]) => number,\n    maxn: <T>(t: T[]) => number,\n    foreach: <K, V, R>(t: { [K]: V }, f: (key: K, value: V) => R) => R | nil,\n    foreachi: <V, R>(t: V[], f: (index: number, value: V) => R) => R | nil,\n}\n\ndeclare os: {\n    time: (t?: unknown) => number,\n    clock: () => number,\n    date: (format?: string, time?: number) => unknown,\n    difftime: (a: number, b: number) => number,\n}\n\ndeclare coroutine: {\n    create: (fn: (...args: unknown[]) => unknown) => thread,\n    -- Answers like `pcall`: `{ success, data, error }`, `data` what the\n    -- coroutine yielded or returned.\n    resume: (co: thread, ...args: unknown[]) => PcallResult<unknown>,\n    yield: (...args: unknown[]) => unknown,\n    wrap: (fn: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown,\n    status: (co: thread) => string,\n    running: () => thread,\n}\n\n-- A string's, an array's and a table's methods \u2014 `text:trim()`,\n-- `names:filter(f)`, `point:keys()` \u2014 are the language's: their metatables\n-- are declared in @tilua/parser's prelude, and the compiler runs them. A\n-- library adds to one with `declare metatable` of the same target, as\n-- `@tilua-types/roblox` gives a string Luau's `split`.\n\n-- The console. Written with `:` \u2014 `console:log(value)` \u2014 and lowered by the\n-- compiler (standard.ts) into runtime/console.luau, not into `print`.\n--\n-- Every line starts with the place that called it: `[src/main:12]: ...`.\n-- `print` and `warn` are left as written; `error` puts `src/main.tilua:12:` in\n-- its message, as Lua does.\n--\n-- `log` expands what it is given the way a browser console does: a table is\n-- printed as its contents, not as an address. A function prints as the type it\n-- was inferred to have *and* the code it was written as, both of which the\n-- compiler passes along, since neither exists once the code is running.\n--\n-- `error` reports in the project's own files: a bundle is one Luau file, so\n-- Luau's own line numbers name a file nobody wrote. It does not raise on the\n-- calling thread \u2014 the error goes to `task.spawn`, so reporting a problem\n-- never becomes one.\ntype Console = {\n    log: (self: Console, ...args: unknown[]) => nil,\n    warn: (self: Console, ...args: unknown[]) => nil,\n    error: (self: Console, ...args: unknown[]) => nil,\n}\n\ndeclare console: Console\n";
+/** The standard library, parsed once. */
+declare function standardLibrary(): Program;
+/** The globals the standard library declares: `print`, `string`, ... */
+declare function standardGlobals(): readonly string[];
 
 interface ProjectHost {
     /** A file's text, or `undefined` when there is no such file. */
@@ -1649,9 +1810,22 @@ interface TiluaConfig {
      *  syntax for. The parser does not care — it is the compiler's to act on,
      *  and lives here because it belongs to the project. */
     readonly target: BuildTarget;
+    /** How many files the compiler writes. `"single"` (the default) is one
+     *  file holding every module. `"chunks"` keeps what the entry imports in
+     *  the entry's file and writes what only an `import()` reaches to files of
+     *  their own, loaded when first asked for. `"modules"` writes one file per
+     *  module. Like `target`, it is the compiler's to act on. */
+    readonly output: OutputMode;
+    /** Leave out Lua's standard library, which every file otherwise has the
+     *  way every TypeScript file has JavaScript's: `print`, `string`, `pcall`.
+     *  For a host that offers none of it, or a library of one's own in its
+     *  place. `false` unless set. */
+    readonly noLib: boolean;
 }
 /** `"luau"` is Roblox's Lua. `"lua51"` is stock Lua 5.1. */
 type BuildTarget = "luau" | "lua51";
+/** See `TiluaConfig.output`. */
+type OutputMode = "single" | "chunks" | "modules";
 interface ConfigProblem {
     /** The file the problem is about: a config file, or a sourcemap it names. */
     readonly file: string;
@@ -1857,6 +2031,10 @@ interface MethodLowering extends CallLowering {
 declare function moduleCandidates(fromFile: string, specifier: string, config?: TiluaConfig): string[];
 /** The file `specifier` names from `fromFile`, if it exists. */
 declare function resolveModulePath(fromFile: string, specifier: string, config?: TiluaConfig, host?: ProjectHost): string | undefined;
+/** Every `import("...")` in `program`, wherever it is written — in the order
+ *  they are written. A module they name belongs to the project as much as one
+ *  an `import` statement names, though nothing says so at the top of the file. */
+declare function importExpressions(program: Program): ImportExpression[];
 
 interface SourceMapNode {
     name: string;
@@ -1957,4 +2135,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 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, LUAU_KEYWORDS, 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, escapeLuauString, falsyType, findConfig, fn, formatType, getBinding, hasMembers, intersection, isAssignable, isClassType, isFunctionType, isGlobal, isIdentifier, isInstanceOf, isLuauName, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, luauString, matchInfer, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectType, optional, overlaps, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, returnsTuple, setAliasExpander, setDeferredBound, sourceMapTypes, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleMembers, typeParam, unify, union, unknownType, widen, withAliasName, withoutAliasName, withoutNil };
+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 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 ImportExpression, type ImportSpecifier, type ImportStatement, type IndexExpression, type IndexedAccessType, type IndexedAccessTypeNode, type InferType, type InferTypeNode, type InterfaceParts, 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, LUAU_KEYWORDS, 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, type OutputMode, 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 RestTypeNode, type ReturnStatement, STANDARD_LIBRARY_SOURCE, type SatisfiesExpression, type ScopeAnalysis, type ScopeDiagnostic, type SourceComment, type SourceMapNode, type SourceMapOptions, type SourceMapTypes, type SpreadElement, type SpreadType, type Statement, type StringLiteral, type SuperExpression, THIS_TYPE, 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, escapeLuauString, falsyType, findConfig, fn, formatType, getBinding, hasMembers, hasSpread, importExpressions, intersection, isAssignable, isClassType, isFunctionType, isGlobal, isIdentifier, isInstanceOf, isLuauName, isPossiblyFalsy, isPossiblyTruthy, isUnassignedGlobal, literal, loadConfig, luauString, matchInfer, mentionsThis, minLengthOf, moduleCandidates, moduleExports, narrowExclude, narrowFalsy, narrowTo, narrowTruthy, neverType, nilType, nodeHost, numberType, objectKeywordType, objectType, optional, overlaps, paramsAsTuple, parse, parseExpressionFromSource, parseTokens, parseWithRecovery, primitive, readDirectives, resolveModulePath, resolveTypeLibraries, returnsTuple, setAliasExpander, setBuiltinMember, setDeferredBound, sourceMapTypes, spread, standardGlobals, standardLibrary, stringType, stripJsonComments, substitute, templateMatches, threadType, tilua, tokenize, tuple, tupleLength, tupleMembers, tupleMeta, tupleParams, typeParam, unify, union, unknownType, widen, withAliasName, withThis, withoutAliasName, withoutNil, withoutReceiver };