Function narrowTypeByTypeof

test/fixtures/snapshot/typescript.js:71032–71058

(type, typeOfExpr, operator, literal, assumeTrue)

                return type;
            }
            function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) {
                // We have '==', '!=', '===', or !==' operator with 'typeof xxx' and string literal operands
                if (operator === 35 /* SyntaxKind.ExclamationEqualsToken */ || operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */) {
                    assumeTrue = !assumeTrue;
                }
                var target = getReferenceCandidate(typeOfExpr.expression);
                if (!isMatchingReference(reference, target)) {
                    if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
                        return getTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */);
                    }
                    return type;
                }
                if (type.flags & 1 /* TypeFlags.Any */ && literal.text === "function") {
                    return type;
                }
                if (assumeTrue && type.flags & 2 /* TypeFlags.Unknown */ && literal.text === "object") {
                    // The non-null unknown type is used to track whether a previous narrowing operation has removed the null type
                    // from the unknown type. For example, the expression `x && typeof x === 'object'` first narrows x to the non-null
                    // unknown type, and then narrows that to the non-primitive type.
                    return type === nonNullUnknownType ? nonPrimitiveType : getUnionType([nonPrimitiveType, nullType]);
                }
                var facts = assumeTrue ?
                    typeofEQFacts.get(literal.text) || 128 /* TypeFacts.TypeofEQHostObject */ :
                    typeofNEFacts.get(literal.text) || 32768 /* TypeFacts.TypeofNEHostObject */;
                var impliedType = getImpliedTypeFromTypeofGuard(type, literal.text);
                return getTypeWithFacts(assumeTrue && impliedType ? mapType(type, narrowUnionMemberByTypeof(impliedType)) : type, facts);
            }
            function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
                var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
                return everyClauseChecks ? getTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */) : type;