// The presence of a particular fact means that the given test is true for some (and possibly all) values

// of that kind of type.

BaseStringStrictFacts = TypeofEQString | TypeofNENumber | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | NEUndefined | NENull | NEUndefinedOrNull,

StringStrictFacts = BaseStringStrictFacts | Truthy | Falsy,

StringFacts = BaseStringFacts | Truthy,

EmptyStringStrictFacts = BaseStringStrictFacts | Falsy,

}

}

if (!isRelative && resolvedModule && !extensionIsTypeScript(resolvedModule.extension)) {

if (isForAugmentation) {

const diag = Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented;

type;

}

const jsdocType = getJSDocType(declaration);

if (jsdocType) {

return getTypeFromTypeNode(jsdocType);

function getConstraintOfType(type: TypeVariable | UnionOrIntersectionType): Type {

return type.flags & TypeFlags.TypeParameter ? getConstraintOfTypeParameter(<TypeParameter>type) :

type.flags & TypeFlags.IndexedAccess ? getConstraintOfIndexedAccess(<IndexedAccessType>type) :

}

function getConstraintOfTypeParameter(typeParameter: TypeParameter): Type {

}

return t.flags & TypeFlags.Union && baseTypes.length === types.length ? getUnionType(baseTypes) :

t.flags & TypeFlags.Intersection && baseTypes.length ? getIntersectionType(baseTypes) :

}

if (t.flags & TypeFlags.Index) {

return stringType;

const t = type.flags & TypeFlags.TypeVariable ? getBaseConstraintOfType(type) || emptyObjectType : type;

return t.flags & TypeFlags.Intersection ? getApparentTypeOfIntersectionType(<IntersectionType>t) :

t.flags & TypeFlags.StringLike ? globalStringType :

}

function createUnionOrIntersectionProperty(containingType: UnionOrIntersectionType, name: string): Symbol {

function getIndexType(type: Type): Type {

return maybeTypeOfKind(type, TypeFlags.TypeVariable) ? getIndexTypeForGenericType(<TypeVariable | UnionOrIntersectionType>type) :

getObjectFlags(type) & ObjectFlags.Mapped ? getConstraintTypeFromMappedType(<MappedType>type) :

}

function getIndexTypeOrString(type: Type): Type {

* this function should be called in a left folding style, with left = previous result of getSpreadType

* and right = the new element to be spread.

*/

if (left.flags & TypeFlags.Any || right.flags & TypeFlags.Any) {

return anyType;

}

function createTypeMapper(sources: Type[], targets: Type[]): TypeMapper {

const mapper: TypeMapper = sources.length === 1 ? makeUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) :

sources.length === 2 ? makeBinaryTypeMapper(sources[0], targets ? targets[0] : anyType, sources[1], targets ? targets[1] : anyType) :

mapper.mappedTypes = sources;

return mapper;

}

(globalNumberType === source && numberType === target) ||

(globalBooleanType === source && booleanType === target) ||

(getGlobalESSymbolType(/*reportErrors*/ false) === source && esSymbolType === target)) {

}

}

function isLiteralType(type: Type): boolean {

return type.flags & TypeFlags.Boolean ? true :

type.flags & TypeFlags.Union ? type.flags & TypeFlags.Enum ? true : !forEach((<UnionType>type).types, t => !isUnitType(t)) :

}

function getBaseTypeOfLiteralType(type: Type): Type {

return type.flags & TypeFlags.StringLiteral ? stringType :

type.flags & TypeFlags.NumberLiteral ? numberType :

}

function getWidenedLiteralType(type: Type): Type {

return type.flags & TypeFlags.StringLiteral && type.flags & TypeFlags.FreshLiteral ? stringType :

type.flags & TypeFlags.NumberLiteral && type.flags & TypeFlags.FreshLiteral ? numberType :

}

/**

function getFalsyFlags(type: Type): TypeFlags {

return type.flags & TypeFlags.Union ? getFalsyFlagsOfTypes((<UnionType>type).types) :

type.flags & TypeFlags.StringLiteral ? (<LiteralType>type).text === "" ? TypeFlags.StringLiteral : 0 :

}

function includeFalsyTypes(type: Type, flags: TypeFlags) {

isTypeSubsetOf(numberType, typeWithPrimitives) && maybeTypeOfKind(typeWithLiterals, TypeFlags.NumberLiteral)) {

return mapType(typeWithPrimitives, t =>

t.flags & TypeFlags.String ? extractTypesOfKind(typeWithLiterals, TypeFlags.String | TypeFlags.StringLiteral) :

}

return typeWithPrimitives;

}

const discriminantType = getUnionType(clauseTypes);

const caseType =

discriminantType.flags & TypeFlags.Never ? neverType :

if (!hasDefaultClause) {

return caseType;

}

// two types.

return isTypeSubtypeOf(candidate, type) ? candidate :

isTypeAssignableTo(type, candidate) ? type :

}

function narrowTypeByTypePredicate(type: Type, callExpression: CallExpression, assumeTrue: boolean): Type {

isInAmbientContext(declaration);

const initialType = assumeInitialized ? (isParameter ? removeOptionalityFromDeclaredType(type, getRootDeclaration(declaration) as VariableLikeDeclaration) : type) :

type === autoType || type === autoArrayType ? undefinedType :

const flowType = getFlowTypeOfReference(node, type, initialType, flowContainer, !assumeInitialized);

// A variable is considered uninitialized when it is possible to analyze the entire control flow graph

// from declaration to use, and when the variable's declared type doesn't include undefined but the

func.kind === SyntaxKind.GetAccessor ||

func.kind === SyntaxKind.SetAccessor) && func.parent.kind === SyntaxKind.ObjectLiteralExpression ? <ObjectLiteralExpression>func.parent :

func.kind === SyntaxKind.FunctionExpression && func.parent.kind === SyntaxKind.PropertyAssignment ? <ObjectLiteralExpression>func.parent.parent :

}

function getThisTypeArgument(type: Type): Type {