Whether a reference is called where it's written: `f(…)`, `new f(…)`, `` f`…` ``, or `class C extends f` (making a `C` calls it). Calling a function runs its body, so what that uses is needed then too (see `initOrder`); a reference that's only read (`const alias = f`) doesn't run it.
A reference is deferred when it is only evaluated later (inside a function body or instance field initializer). A function called where it's written (`(() => { … })()`) runs now: what it uses isn't deferred.
Identifiers whose text becomes a runtime name: declared function/class names, and bindings that name an anonymous function or class (`const f = () => {}`, `(cb = () => {}) =>`, `f = function () {}`). Renaming these is observable through `.name`, so their text is hashed; every other local stays alpha-renamable.
Text between JSX tags as React sees it: each line trimmed, blank lines dropped, lines joined with a space. So reformatting markup hashes the same, and whitespace React keeps (`a <b/>`) still counts.
Stable names for syntax kinds. `ts.SyntaxKind` numbers shift between TypeScript releases, names don't. The enum has aliases (FirstToken, LastKeyword, ...); the first declared name for each value wins.
Which meaning of a name an identifier uses. Usually that's its position, except that `typeof x` names a value even though it sits in a type, and so does a computed key (`readonly [evaluate]: …`, `evaluate` a unique symbol beside a type of that name).