isUndefinedSymbol: symbol => symbol === undefinedSymbol,

isArgumentsSymbol: symbol => symbol === argumentsSymbol,

isUnknownSymbol: symbol => symbol === unknownSymbol,

getDiagnostics,

getGlobalDiagnostics,

getTypeOfSymbolAtLocation,

isValidPropertyAccess,

getSignatureFromDeclaration,

isImplementationOfOverload,

getAliasedSymbol: resolveAlias,

getEmitResolver,

getExportsOfModule: getExportsOfModuleAsArray,

return find<Declaration>(symbol.declarations, isAliasSymbolDeclaration);

}

if (node.moduleReference.kind === SyntaxKind.ExternalModuleReference) {

return resolveExternalModuleSymbol(resolveExternalModuleName(node, getExternalModuleImportEqualsDeclarationExpression(node)));

}

}

const moduleSymbol = resolveExternalModuleName(node, (<ImportDeclaration>node.parent).moduleSpecifier);

if (moduleSymbol) {

const exportValue = moduleSymbol.exports.get("export=");

exportDefaultSymbol = exportValue

? getPropertyOfType(getTypeOfSymbol(exportValue), "default")

}

if (!exportDefaultSymbol && !allowSyntheticDefaultImports) {

error(node.name, Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol));

}

else if (!exportDefaultSymbol && allowSyntheticDefaultImports) {

}

return exportDefaultSymbol;

}

}

const moduleSpecifier = (<ImportDeclaration>node.parent.parent).moduleSpecifier;

}

// This function creates a synthetic symbol that combines the value side of one symbol with the

return result;

}

if (symbol.flags & SymbolFlags.Module) {

}

}

}

}

const moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier);

if (targetSymbol) {

const name = specifier.propertyName || specifier.name;

if (name.text) {

symbolFromVariable = getPropertyOfVariable(targetSymbol, name.text);

}

// if symbolFromVariable is export - get its final target

// If the export member we're looking for is default, and there is no real default but allowSyntheticDefaultImports is on, return the entire module as the default

if (!symbolFromModule && allowSyntheticDefaultImports && name.text === "default") {

}

const symbol = symbolFromModule && symbolFromVariable ?

combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) :

}

}

}

}

return (<ExportDeclaration>node.parent.parent).moduleSpecifier ?

}

}

switch (node.kind) {

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.ImportClause:

case SyntaxKind.NamespaceImport:

case SyntaxKind.ImportSpecifier:

case SyntaxKind.ExportSpecifier:

case SyntaxKind.ExportAssignment:

case SyntaxKind.NamespaceExportDeclaration:

}

}

}

function resolveAlias(symbol: Symbol): Symbol {

// An external module with an 'export =' declaration resolves to the target of the 'export =' declaration,

// and an external module with no 'export =' declaration resolves to the module itself.

}

// An external module with an 'export =' declaration may be referenced as an ES6 module provided the 'export ='

// references a symbol that is at least declared as a module or a variable. The target of the 'export =' may

// combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable).

error(moduleReferenceExpression, Diagnostics.Module_0_resolves_to_a_non_module_entity_and_cannot_be_imported_using_this_construct, symbolToString(moduleSymbol));

symbol = undefined;

}

}

/** Shims `Array.from`. */

for (let { value, done } = iterator.next(); !done; { value, done } = iterator.next()) {

}

return result;

}

return Parser.parseIsolatedEntityName(text, languageVersion);

}

export function isExternalModule(file: SourceFile): boolean {

return file.externalModuleIndicator !== undefined;

}

}

export interface ExternalModuleReference extends Node {

kind: SyntaxKind.ExternalModuleReference;

expression?: Expression;

}

export interface ImportDeclaration extends Statement {

kind: SyntaxKind.ImportDeclaration;

importClause?: ImportClause;

moduleSpecifier: Expression;

}

export interface ExportDeclaration extends DeclarationStatement {

kind: SyntaxKind.ExportDeclaration;

exportClause?: NamedExports;

moduleSpecifier?: Expression;

}

}

export interface NamedExports extends Node {

kind: SyntaxKind.NamedExports;

elements: NodeArray<ExportSpecifier>;

}

}

export interface ExportSpecifier extends Declaration {

kind: SyntaxKind.ExportSpecifier;

propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent)

name: Identifier; // Declared name

// Content of this field should never be used directly - use getResolvedModuleFileName/setResolvedModuleFileName functions instead

/* @internal */ resolvedModules: Map<ResolvedModuleFull>;

/* @internal */ resolvedTypeReferenceDirectiveNames: Map<ResolvedTypeReferenceDirective>;

/* @internal */ patternAmbientModules?: PatternAmbientModule[];

/* @internal */ ambientModuleNames: string[];

}

isUndefinedSymbol(symbol: Symbol): boolean;

isArgumentsSymbol(symbol: Symbol): boolean;

isUnknownSymbol(symbol: Symbol): boolean;

getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;

isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;

getAliasedSymbol(symbol: Symbol): Symbol;

getExportsOfModule(moduleSymbol: Symbol): Symbol[];

/** Unlike `getExportsOfModule`, this includes properties of an `export =` value. */

/* @internal */ getExportsAndPropertiesOfModule(moduleSymbol: Symbol): Symbol[];

/* @internal */

export interface SymbolLinks {

target?: Symbol; // Resolved (non-alias) target of an alias

type?: Type; // Type of value symbol

declaredType?: Type; // Type of class, interface, enum, type alias, or type parameter

return isExportDefaultSymbol(symbol) ? symbol.valueDeclaration.localSymbol : undefined;

}

return symbol && symbol.valueDeclaration && hasModifier(symbol.valueDeclaration, ModifierFlags.Default);

}