declare var Map: MapConstructor;

interface WeakMap<K, V> {

delete(key: K): boolean;

get(key: K): V | undefined;

has(key: K): boolean;

interface WeakSet<T> {

add(value: T): this;

delete(value: T): boolean;

has(value: T): boolean;

}

(node.name.kind === 9 || isGlobalScopeAugmentation(node));

}

ts.isAmbientModule = isAmbientModule;

function isShorthandAmbientModule(node) {

return node.kind === 225 && (!node.body);

}

function isBlockScopedContainerTopLevel(node) {

return node.kind === 256 ||

node.kind === 225 ||

var noConstraintType = createAnonymousType(undefined, emptySymbols, emptyArray, emptyArray, undefined, undefined);

var anySignature = createSignature(undefined, undefined, undefined, emptyArray, anyType, undefined, 0, false, false);

var unknownSignature = createSignature(undefined, undefined, undefined, emptyArray, unknownType, undefined, 0, false, false);

var enumNumberIndexInfo = createIndexInfo(stringType, true);

var globals = ts.createMap();

var patternAmbientModules;

var assignableRelation = ts.createMap();

var comparableRelation = ts.createMap();

var identityRelation = ts.createMap();

var _displayBuilder;

var builtinGlobals = ts.createMap();

builtinGlobals[undefinedSymbol.name] = undefinedSymbol;

checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation);

}

}

var decls = result.declarations;

if (decls && decls.length === 1 && decls[0].kind === 228) {

error(errorLocation, ts.Diagnostics.Identifier_0_must_be_imported_from_a_module, name);

function getTargetOfImportClause(node) {

var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier);

if (moduleSymbol) {

moduleSymbol :

moduleSymbol.exports["export="] ?

getPropertyOfType(getTypeOfSymbol(moduleSymbol.exports["export="]), "default") :

if (targetSymbol) {

var name_10 = specifier.propertyName || specifier.name;

if (name_10.text) {

return moduleSymbol;

}

var symbolFromVariable = void 0;

buildSymbolDisplay(type.symbol, writer, enclosingDeclaration, 793064, 0, nextFlags);

}

else if (!(flags & 512) && type.flags & (2097152 | 1572864) && type.aliasSymbol) {

}

else if (type.flags & 1572864) {

writeUnionOrIntersectionType(type, nextFlags);

if (strictNullChecks && declaration.initializer && !(getFalsyFlags(checkExpressionCached(declaration.initializer)) & 2048)) {

type = getTypeWithFacts(type, 131072);

}

}

function getTypeForVariableLikeDeclarationFromJSDocComment(declaration) {

var jsDocType = getJSDocTypeForVariableLikeDeclarationFromJSDocComment(declaration);

function getTypeOfFuncClassEnumModule(symbol) {

var links = getSymbolLinks(symbol);

if (!links.type) {

links.type = anyType;

}

else {

if (source === target) {

return true;

}

}

var targetEnumType = getTypeOfSymbol(target.symbol);

for (var _i = 0, _a = getPropertiesOfType(getTypeOfSymbol(source.symbol)); _i < _a.length; _i++) {

if (errorReporter) {

errorReporter(ts.Diagnostics.Property_0_is_missing_in_type_1, property.name, typeToString(target, undefined, 128));

}

}

}

}

}

function isSimpleTypeRelatedTo(source, target, relation, errorReporter) {

if (target.flags & 8192)

if (relation === assignableRelation || relation === comparableRelation) {

if (source.flags & 1)

return true;

return true;

return true;

}

return false;

}

return type;

}

function narrowTypeByEquality(type, operator, value, assumeTrue) {

if (operator === 31 || operator === 33) {

assumeTrue = !assumeTrue;

}

}

}

var targetType = type.flags & 16384 ? getApparentType(type) : type;

isTypeAssignableTo(type, candidate) ? type :

isTypeAssignableTo(candidate, targetType) ? candidate :

getIntersectionType([type, candidate]);

var isParameter = ts.getRootDeclaration(declaration).kind === 142;

var declarationContainer = getControlFlowContainer(declaration);

var flowContainer = getControlFlowContainer(node);

while (flowContainer !== declarationContainer &&

(flowContainer.kind === 179 || flowContainer.kind === 180) &&

(isReadonlySymbol(localOrExportSymbol) || isParameter && !isParameterAssigned(localOrExportSymbol))) {

flowContainer = getControlFlowContainer(flowContainer);

}

var assumeInitialized = !strictNullChecks || (type.flags & 1) !== 0 || isParameter ||

var flowType = getFlowTypeOfReference(node, type, assumeInitialized, flowContainer);

if (!assumeInitialized && !(getFalsyFlags(type) & 2048) && getFalsyFlags(flowType) & 2048) {

error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol));

function getResolvedSignature(node, candidatesOutArray) {

var links = getNodeLinks(node);

var cached = links.resolvedSignature;

return cached;

}

var result = resolveSignature(node, candidatesOutArray);

links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached;

return result;

}

function getResolvedOrAnySignature(node) {

}

function getInferredClassType(symbol) {

var links = getSymbolLinks(symbol);

return maybeTypeOfKind(contextualType, (64 | 256));

}

if (type.flags & 8) {

}

if (type.flags & 16) {

return typeContainsLiteralFromEnum(contextualType, type);

}

function moduleExportsSomeValue(moduleReferenceExpression) {

var moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression);

return true;

}

var hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol);

}

else {

errorNameNode = declaration.name;

errorNameNode = undefined;

}

}

}

else {

errorNameNode = signature.name;

errorNameNode = undefined;

}

}

write(tempVarName);

write(": ");

writer.getSymbolAccessibilityDiagnostic = getDefaultExportAccessibilityDiagnostic;

write(";");

writeLine();

write(node.isExportEquals ? "export = " : "export default ");

}

else {

writer.getSymbolAccessibilityDiagnostic = getHeritageClauseVisibilityError;

}

function getHeritageClauseVisibilityError(symbolAccessibilityResult) {

var diagnosticMessage;

})(ts || (ts = {}));

var ts;

(function (ts) {

var emptyArray = [];

function findConfigFile(searchPath, fileExists) {

while (true) {

var fileName = ts.combinePaths(searchPath, "tsconfig.json");

else if (host.getCurrentDirectory) {

currentDirectory = host.getCurrentDirectory();

}

}

}

function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host) {

var traceEnabled = isTraceEnabled(options, host);

var moduleResolutionState = {