TypeScript

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.ts, .tsx, .mts, .cts

Registry names

typescripttsx

Recorded symbols

functions · classes · interfaces · enums

Relationship types this analyzer constructs

14 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

14 constructed, 0 not constructed. The register explains what each label means.

What this analyzer does not resolve

• Runtime globals are excluded from construction: new Promise() and new Map() record no instantiation edge, because those build the platform's runtime rather than a type declared in the repository.
• A computed call names no callee, so handlers[key]() records nothing, and a decorator's argument list is walked for names but not for calls.
• Override matching abstains instead of pairing: when a name is overloaded on either side, or the base type is not in the indexed set, the member is left unmatched rather than attached to a candidate.

Every line above was written against TypeScript’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .ts, .tsx, .mts, .cts. Everything below is about where those files actually sit in a working repository.

• .ts and .tsx are separate registry languages, so a JSX component is indexed under tsx rather than folded into .ts.
• Declaration files (.d.ts) carry types with no bodies: the symbols are recorded and there is nothing to walk into.
• Path aliases (@/lib/…) resolve through tsconfig, so a barrel index.ts sits between the import and the file that declares the symbol.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. Which functions and components import this one?
2. What breaks downstream if I rename this export?
3. Which classes implement this interface, and which member implements which?
4. Which class does this method override?

What the analyzer sees in code like this

export interface Cacheable {                  // bb records: interface Cacheable
  drop(id: string): void                   // bb records: method drop
}

export class TokenStore implements Cacheable {
  private cache = new Map<string, Token>()   // bb records: property cache
  drop(id: string): void {                   // bb records: an override of drop
    this.cache.delete(id)
  }
}

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Application & systems — the count beside each name is how many relationship types that family’s analyzer constructs.

• JavaScript12 types
• Python11 types
• Rust14 types
• Go12 types
• Java10 types
• C++11 types
• C9 types
• C#11 types
• Swift11 types
• Kotlin11 types
• Dart13 types
• Zig8 types
• Objective-C11 types
• Visual Basic11 types
• VBA9 types