Package Diff: typescript @ 3.4.3 .. 3.4.5

var ts;

(function (ts) {

ts.versionMajorMinor = "3.4";

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

(function (ts) {

ts.emptyArray = [];

}

ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol;

function getObjectFlags(type) {

}

ts.getObjectFlags = getObjectFlags;

function typeHasCallOrConstructSignatures(type, checker) {

var wildcardType = createIntrinsicType(1, "any");

var errorType = createIntrinsicType(1, "error");

var unknownType = createIntrinsicType(2, "unknown");

var stringType = createIntrinsicType(4, "string");

var numberType = createIntrinsicType(8, "number");

var bigintType = createIntrinsicType(64, "bigint");

var voidType = createIntrinsicType(16384, "void");

var neverType = createIntrinsicType(131072, "never");

var silentNeverType = createIntrinsicType(131072, "never");

var implicitNeverType = createIntrinsicType(131072, "never");

var nonPrimitiveType = createIntrinsicType(67108864, "object");

var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

result.id = typeCount;

return result;

}

var type = createType(kind);

type.intrinsicName = intrinsicName;

type.objectFlags = objectFlags;

return type;

}

return newResult;

}

function getConditionalTypeWorker(root, mapper, checkType, extendsType, trueType, falseType) {

if (checkType.flags & 1 || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {

return trueType;

}

return neverType;

}

}

if (!(checkType.flags & 1) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) {

return neverType;

}

var stringIndexInfo = getIndexInfoOfType(type, 0);

var numberIndexInfo = getIndexInfoOfType(type, 1);

var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));

return result;

}

function getWidenedType(type) {

return type;

}

function createReverseMappedType(source, target, constraint) {

return undefined;

}

if (isArrayType(source)) {

return createArrayType(inferReverseMappedType(source.typeArguments[0], target, constraint), isReadonlyArrayType(source));

}

return getTypeFromInference(inference);

}

function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {

return __generator(this, function (_a) {

switch (_a.label) {

case 0:

properties = target.flags & 2097152 ? getPropertiesOfUnionOrIntersectionType(target) : getPropertiesOfObjectType(target);

_a.label = 1;

case 1:

if (!(requireOptionalProperties || !(targetProp.flags & 16777216))) return [3, 5];

sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (!!sourceProp) return [3, 3];

inferFromTypes(source, target.falseType);

}

else if (target.flags & 3145728) {

for (var _d = 0, _e = target.types; _d < _e.length; _d++) {

var t = _e[_d];

if (getInferenceInfoForType(t)) {

}

inferFromTypes(source, t);

priority = savePriority;

}

}

else if (source.flags & 1048576) {

var sourceTypes = source.types;

inferFromTypes(sourceType, target);

}

}

}

}

var properties = getPropertiesOfObjectType(target);

var sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (sourceProp) {

inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));

spanArray = ts.createNodeArray(args);

if (hasSpreadArgument && argCount) {

var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;

}

}

else {

checkGrammarArguments(node.arguments);

var signature = getResolvedSignature(node, undefined, checkMode);

if (signature === resolvingSignature) {

}

if (node.expression.kind === 98) {

return voidType;

if (strictNullChecks && properties.length === 0) {

return checkNonNullType(sourceType, node);

}

checkObjectLiteralDestructuringPropertyAssignment(sourceType, p, properties, rightIsThis);

}

return sourceType;

for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {

var base = baseTypes_2[_i];

var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));

var existing = seen.get(prop.escapedName);

if (!existing) {

seen.set(prop.escapedName, { prop: prop, containingType: base });

if (autoArrayType === emptyObjectType) {

autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

}

anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;

globalThisType = getGlobalTypeOrUndefined("ThisType", 1);

if (augmentations) {

function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) {

var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;

if (property === firstAccessor) {

if (getAccessor) {

var getterFunction = ts.createFunctionExpression(getAccessor.modifiers, undefined, undefined, undefined, getAccessor.parameters, undefined, getAccessor.body);

ts.setTextRange(getterFunction, getAccessor);

ts.setOriginalNode(getterFunction, getAccessor);

var getter = ts.createPropertyAssignment("get", getterFunction);

}

if (setAccessor) {

var setterFunction = ts.createFunctionExpression(setAccessor.modifiers, undefined, undefined, undefined, setAccessor.parameters, undefined, setAccessor.body);

ts.setTextRange(setterFunction, setAccessor);

ts.setOriginalNode(setterFunction, setAccessor);

var setter = ts.createPropertyAssignment("set", setterFunction);

}

var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"), undefined, [

receiver,

createExpressionForPropertyName(property.name),

]), firstAccessor);

return ts.aggregateTransformFlags(expression);

}

&& member.initializer !== undefined;

}

function addInitializedPropertyStatements(statements, properties, receiver) {

var statement = ts.createExpressionStatement(transformInitializedProperty(property, receiver));

ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));

ts.setCommentRange(statement, property);

}

function generateInitializedPropertyExpressions(properties, receiver) {

var expressions = [];

var expression = transformInitializedProperty(property, receiver);

ts.startOnNewLine(expression);

ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property));

// If changing the text in this section, be sure to test `configureNightly` too.

ts.versionMajorMinor = "3.4";

/** The version of the TypeScript compiler release */

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

(function (ts) {

/* @internal */

TypeFlags[TypeFlags["Instantiable"] = 63176704] = "Instantiable";

TypeFlags[TypeFlags["StructuredOrInstantiable"] = 66846720] = "StructuredOrInstantiable";

/* @internal */

// 'Narrowable' types are types where narrowing actually narrows.

// This *should* be every type other than null, undefined, void, and never

TypeFlags[TypeFlags["Narrowable"] = 133970943] = "Narrowable";

/* @internal */

ObjectFlags[ObjectFlags["ContainsObjectLiteral"] = 262144] = "ContainsObjectLiteral";

/* @internal */

ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface";

/* @internal */

ObjectFlags[ObjectFlags["RequiresWidening"] = 393216] = "RequiresWidening";

}

ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol;

function getObjectFlags(type) {

}

ts.getObjectFlags = getObjectFlags;

function typeHasCallOrConstructSignatures(type, checker) {

var wildcardType = createIntrinsicType(1 /* Any */, "any");

var errorType = createIntrinsicType(1 /* Any */, "error");

var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");

var stringType = createIntrinsicType(4 /* String */, "string");

var numberType = createIntrinsicType(8 /* Number */, "number");

var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");

var voidType = createIntrinsicType(16384 /* Void */, "void");

var neverType = createIntrinsicType(131072 /* Never */, "never");

var silentNeverType = createIntrinsicType(131072 /* Never */, "never");

var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");

var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");

var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated

// in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.

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

var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

result.id = typeCount;

return result;

}

var type = createType(kind);

type.intrinsicName = intrinsicName;

type.objectFlags = objectFlags;

return type;

}

}

function getConditionalTypeWorker(root, mapper, checkType, extendsType, trueType, falseType) {

// Simplifications for types of the form `T extends U ? T : never` and `T extends U ? never : T`.

if (checkType.flags & 1 /* Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return trueType;

}

return neverType;

}

}

if (!(checkType.flags & 1 /* Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return neverType;

}

var stringIndexInfo = getIndexInfoOfType(type, 0 /* String */);

var numberIndexInfo = getIndexInfoOfType(type, 1 /* Number */);

var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));

return result;

}

function getWidenedType(type) {

return type;

}

function createReverseMappedType(source, target, constraint) {

// If any property contains context sensitive functions that have been skipped, the source type

// is incomplete and we can't infer a meaningful input type.

return undefined;

}

// For arrays and tuples we infer new arrays and tuples where the reverse mapping has been

// applied to the element type(s).

if (isArrayType(source)) {

return getTypeFromInference(inference);

}

function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {

return __generator(this, function (_a) {

switch (_a.label) {

case 0:

properties = target.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(target) : getPropertiesOfObjectType(target);

_a.label = 1;

case 1:

if (!(requireOptionalProperties || !(targetProp.flags & 16777216 /* Optional */))) return [3 /*break*/, 5];

sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (!!sourceProp) return [3 /*break*/, 3];

// not contain anyFunctionType when we come back to this argument for its second round

// of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard

// when constructing types from type parameters that had no inference candidates).

return;

}

var inference = getInferenceInfoForType(target);

inferFromTypes(source, target.falseType);

}

else if (target.flags & 3145728 /* UnionOrIntersection */) {

for (var _d = 0, _e = target.types; _d < _e.length; _d++) {

var t = _e[_d];

// Inferences directly to naked type variables are given lower priority as they are

// less specific. For example, when inferring from Promise<string> to T | Promise<T>,

priority |= 1 /* NakedTypeVariable */;

inferFromTypes(source, t);

priority = savePriority;

}

}

else if (source.flags & 1048576 /* Union */) {

// Source is a union or intersection type, infer from each constituent type

var sourceTypes = source.types;

inferFromTypes(sourceType, target);

}

}

}

}

var properties = getPropertiesOfObjectType(target);

var sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (sourceProp) {

inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));

var sourceLen = sourceSignatures.length;

var targetLen = targetSignatures.length;

var len = sourceLen < targetLen ? sourceLen : targetLen;

for (var i = 0; i < len; i++) {

inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters);

}

spanArray = ts.createNodeArray(args);

if (hasSpreadArgument && argCount) {

var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;

}

}

else {

// returns a function type, we choose to defer processing. This narrowly permits function composition

// operators to flow inferences through return types, but otherwise processes calls right away. We

// use the resolvingSignature singleton to indicate that we deferred processing. This result will be

// from which we never make inferences).

if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {

skippedGenericFunction(node, checkMode);

var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);

if (signature === resolvingSignature) {

// CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that

}

if (node.expression.kind === 98 /* SuperKeyword */) {

return voidType;

var returnType = getReturnTypeFromBody(node, checkMode);

var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);

var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined);

return links_1.contextFreeType = returnOnlyType;

}

return anyFunctionType;

if (strictNullChecks && properties.length === 0) {

return checkNonNullType(sourceType, node);

}

checkObjectLiteralDestructuringPropertyAssignment(sourceType, p, properties, rightIsThis);

}

return sourceType;

for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {

var base = baseTypes_2[_i];

var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));

var existing = seen.get(prop.escapedName);

if (!existing) {

seen.set(prop.escapedName, { prop: prop, containingType: base });

// autoArrayType is used as a marker, so even if global Array type is not defined, it needs to be a unique type

autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

}

anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;

globalThisType = getGlobalTypeOrUndefined("ThisType", /*arity*/ 1);

if (augmentations) {

function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) {

var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;

if (property === firstAccessor) {

if (getAccessor) {

var getterFunction = ts.createFunctionExpression(getAccessor.modifiers,

/*asteriskToken*/ undefined,

ts.setTextRange(getterFunction, getAccessor);

ts.setOriginalNode(getterFunction, getAccessor);

var getter = ts.createPropertyAssignment("get", getterFunction);

}

if (setAccessor) {

var setterFunction = ts.createFunctionExpression(setAccessor.modifiers,

ts.setTextRange(setterFunction, setAccessor);

ts.setOriginalNode(setterFunction, setAccessor);

var setter = ts.createPropertyAssignment("set", setterFunction);

}

var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"),

/*typeArguments*/ undefined, [

receiver,

createExpressionForPropertyName(property.name),

]),

/*location*/ firstAccessor);

return ts.aggregateTransformFlags(expression);

* @param receiver The receiver on which each property should be assigned.

*/

function addInitializedPropertyStatements(statements, properties, receiver) {

var statement = ts.createExpressionStatement(transformInitializedProperty(property, receiver));

ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));

ts.setCommentRange(statement, property);

*/

function generateInitializedPropertyExpressions(properties, receiver) {

var expressions = [];

var expression = transformInitializedProperty(property, receiver);

ts.startOnNewLine(expression);

ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property));

* typingsInstaller will run the command with `${npmLocation} install ...`.

*/

Arguments.NpmLocation = "--npmLocation";

})(Arguments = server.Arguments || (server.Arguments = {}));

function hasArgument(argumentName) {

return ts.sys.args.indexOf(argumentName) >= 0;

return Logger;

}());

var NodeTypingsInstaller = /** @class */ (function () {

this.telemetryEnabled = telemetryEnabled;

this.logger = logger;

this.host = host;

this.typingSafeListLocation = typingSafeListLocation;

this.typesMapLocation = typesMapLocation;

this.npmLocation = npmLocation;

this.event = event;

this.activeRequestCount = 0;

this.requestQueue = [];

if (this.npmLocation) {

args.push(server.Arguments.NpmLocation, this.npmLocation);

}

var execArgv = [];

for (var _i = 0, _a = process.execArgv; _i < _a.length; _i++) {

var arg = _a[_i];

var host = sys;

var typingsInstaller = disableAutomaticTypingAcquisition

? undefined

_this = _super.call(this, {

host: host,

cancellationToken: cancellationToken,

var typingSafeListLocation = server.findArgument(server.Arguments.TypingSafeListLocation); // TODO: GH#18217

var typesMapLocation = server.findArgument(server.Arguments.TypesMapLocation) || ts.combinePaths(ts.getDirectoryPath(sys.getExecutingFilePath()), "typesMap.json");

var npmLocation = server.findArgument(server.Arguments.NpmLocation);

function parseStringArray(argName) {

var arg = server.findArgument(argName);

if (arg === undefined) {

// If changing the text in this section, be sure to test `configureNightly` too.

ts.versionMajorMinor = "3.4";

/** The version of the TypeScript compiler release */

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

(function (ts) {

/* @internal */

TypeFlags[TypeFlags["Instantiable"] = 63176704] = "Instantiable";

TypeFlags[TypeFlags["StructuredOrInstantiable"] = 66846720] = "StructuredOrInstantiable";

/* @internal */

// 'Narrowable' types are types where narrowing actually narrows.

// This *should* be every type other than null, undefined, void, and never

TypeFlags[TypeFlags["Narrowable"] = 133970943] = "Narrowable";

/* @internal */

ObjectFlags[ObjectFlags["ContainsObjectLiteral"] = 262144] = "ContainsObjectLiteral";

/* @internal */

ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface";

/* @internal */

ObjectFlags[ObjectFlags["RequiresWidening"] = 393216] = "RequiresWidening";

}

ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol;

function getObjectFlags(type) {

}

ts.getObjectFlags = getObjectFlags;

function typeHasCallOrConstructSignatures(type, checker) {

var wildcardType = createIntrinsicType(1 /* Any */, "any");

var errorType = createIntrinsicType(1 /* Any */, "error");

var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");

var stringType = createIntrinsicType(4 /* String */, "string");

var numberType = createIntrinsicType(8 /* Number */, "number");

var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");

var voidType = createIntrinsicType(16384 /* Void */, "void");

var neverType = createIntrinsicType(131072 /* Never */, "never");

var silentNeverType = createIntrinsicType(131072 /* Never */, "never");

var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");

var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");

var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated

// in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.

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

var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

result.id = typeCount;

return result;

}

var type = createType(kind);

type.intrinsicName = intrinsicName;

type.objectFlags = objectFlags;

return type;

}

}

function getConditionalTypeWorker(root, mapper, checkType, extendsType, trueType, falseType) {

// Simplifications for types of the form `T extends U ? T : never` and `T extends U ? never : T`.

if (checkType.flags & 1 /* Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return trueType;

}

return neverType;

}

}

if (!(checkType.flags & 1 /* Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return neverType;

}

var stringIndexInfo = getIndexInfoOfType(type, 0 /* String */);

var numberIndexInfo = getIndexInfoOfType(type, 1 /* Number */);

var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));

return result;

}

function getWidenedType(type) {

return type;

}

function createReverseMappedType(source, target, constraint) {

// If any property contains context sensitive functions that have been skipped, the source type

// is incomplete and we can't infer a meaningful input type.

return undefined;

}

// For arrays and tuples we infer new arrays and tuples where the reverse mapping has been

// applied to the element type(s).

if (isArrayType(source)) {

return getTypeFromInference(inference);

}

function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {

return __generator(this, function (_a) {

switch (_a.label) {

case 0:

properties = target.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(target) : getPropertiesOfObjectType(target);

_a.label = 1;

case 1:

if (!(requireOptionalProperties || !(targetProp.flags & 16777216 /* Optional */))) return [3 /*break*/, 5];

sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (!!sourceProp) return [3 /*break*/, 3];

// not contain anyFunctionType when we come back to this argument for its second round

// of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard

// when constructing types from type parameters that had no inference candidates).

return;

}

var inference = getInferenceInfoForType(target);

inferFromTypes(source, target.falseType);

}

else if (target.flags & 3145728 /* UnionOrIntersection */) {

for (var _d = 0, _e = target.types; _d < _e.length; _d++) {

var t = _e[_d];

// Inferences directly to naked type variables are given lower priority as they are

// less specific. For example, when inferring from Promise<string> to T | Promise<T>,

priority |= 1 /* NakedTypeVariable */;

inferFromTypes(source, t);

priority = savePriority;

}

}

else if (source.flags & 1048576 /* Union */) {

// Source is a union or intersection type, infer from each constituent type

var sourceTypes = source.types;

inferFromTypes(sourceType, target);

}

}

}

}

var properties = getPropertiesOfObjectType(target);

var sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (sourceProp) {

inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));

var sourceLen = sourceSignatures.length;

var targetLen = targetSignatures.length;

var len = sourceLen < targetLen ? sourceLen : targetLen;

for (var i = 0; i < len; i++) {

inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters);

}

spanArray = ts.createNodeArray(args);

if (hasSpreadArgument && argCount) {

var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;

}

}

else {

// returns a function type, we choose to defer processing. This narrowly permits function composition

// operators to flow inferences through return types, but otherwise processes calls right away. We

// use the resolvingSignature singleton to indicate that we deferred processing. This result will be

// from which we never make inferences).

if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {

skippedGenericFunction(node, checkMode);

var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);

if (signature === resolvingSignature) {

// CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that

}

if (node.expression.kind === 98 /* SuperKeyword */) {

return voidType;

var returnType = getReturnTypeFromBody(node, checkMode);

var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);

var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined);

return links_1.contextFreeType = returnOnlyType;

}

return anyFunctionType;

if (strictNullChecks && properties.length === 0) {

return checkNonNullType(sourceType, node);

}

checkObjectLiteralDestructuringPropertyAssignment(sourceType, p, properties, rightIsThis);

}

return sourceType;

for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {

var base = baseTypes_2[_i];

var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));

var existing = seen.get(prop.escapedName);

if (!existing) {

seen.set(prop.escapedName, { prop: prop, containingType: base });

// autoArrayType is used as a marker, so even if global Array type is not defined, it needs to be a unique type

autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

}

anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;

globalThisType = getGlobalTypeOrUndefined("ThisType", /*arity*/ 1);

if (augmentations) {

function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) {

var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;

if (property === firstAccessor) {

if (getAccessor) {

var getterFunction = ts.createFunctionExpression(getAccessor.modifiers,

/*asteriskToken*/ undefined,

ts.setTextRange(getterFunction, getAccessor);

ts.setOriginalNode(getterFunction, getAccessor);

var getter = ts.createPropertyAssignment("get", getterFunction);

}

if (setAccessor) {

var setterFunction = ts.createFunctionExpression(setAccessor.modifiers,

ts.setTextRange(setterFunction, setAccessor);

ts.setOriginalNode(setterFunction, setAccessor);

var setter = ts.createPropertyAssignment("set", setterFunction);

}

var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"),

/*typeArguments*/ undefined, [

receiver,

createExpressionForPropertyName(property.name),

]),

/*location*/ firstAccessor);

return ts.aggregateTransformFlags(expression);

* @param receiver The receiver on which each property should be assigned.

*/

function addInitializedPropertyStatements(statements, properties, receiver) {

var statement = ts.createExpressionStatement(transformInitializedProperty(property, receiver));

ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));

ts.setCommentRange(statement, property);

*/

function generateInitializedPropertyExpressions(properties, receiver) {

var expressions = [];

var expression = transformInitializedProperty(property, receiver);

ts.startOnNewLine(expression);

ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property));

* typingsInstaller will run the command with `${npmLocation} install ...`.

*/

Arguments.NpmLocation = "--npmLocation";

})(Arguments = server.Arguments || (server.Arguments = {}));

function hasArgument(argumentName) {

return ts.sys.args.indexOf(argumentName) >= 0;

// If changing the text in this section, be sure to test `configureNightly` too.

ts.versionMajorMinor = "3.4";

/** The version of the TypeScript compiler release */

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

(function (ts) {

/* @internal */

TypeFlags[TypeFlags["Instantiable"] = 63176704] = "Instantiable";

TypeFlags[TypeFlags["StructuredOrInstantiable"] = 66846720] = "StructuredOrInstantiable";

/* @internal */

// 'Narrowable' types are types where narrowing actually narrows.

// This *should* be every type other than null, undefined, void, and never

TypeFlags[TypeFlags["Narrowable"] = 133970943] = "Narrowable";

/* @internal */

ObjectFlags[ObjectFlags["ContainsObjectLiteral"] = 262144] = "ContainsObjectLiteral";

/* @internal */

ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface";

/* @internal */

ObjectFlags[ObjectFlags["RequiresWidening"] = 393216] = "RequiresWidening";

}

ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol;

function getObjectFlags(type) {

}

ts.getObjectFlags = getObjectFlags;

function typeHasCallOrConstructSignatures(type, checker) {

var wildcardType = createIntrinsicType(1 /* Any */, "any");

var errorType = createIntrinsicType(1 /* Any */, "error");

var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");

var stringType = createIntrinsicType(4 /* String */, "string");

var numberType = createIntrinsicType(8 /* Number */, "number");

var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");

var voidType = createIntrinsicType(16384 /* Void */, "void");

var neverType = createIntrinsicType(131072 /* Never */, "never");

var silentNeverType = createIntrinsicType(131072 /* Never */, "never");

var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");

var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");

var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated

// in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.

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

var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

result.id = typeCount;

return result;

}

var type = createType(kind);

type.intrinsicName = intrinsicName;

type.objectFlags = objectFlags;

return type;

}

}

function getConditionalTypeWorker(root, mapper, checkType, extendsType, trueType, falseType) {

// Simplifications for types of the form `T extends U ? T : never` and `T extends U ? never : T`.

if (checkType.flags & 1 /* Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return trueType;

}

return neverType;

}

}

if (!(checkType.flags & 1 /* Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return neverType;

}

var stringIndexInfo = getIndexInfoOfType(type, 0 /* String */);

var numberIndexInfo = getIndexInfoOfType(type, 1 /* Number */);

var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));

return result;

}

function getWidenedType(type) {

return type;

}

function createReverseMappedType(source, target, constraint) {

// If any property contains context sensitive functions that have been skipped, the source type

// is incomplete and we can't infer a meaningful input type.

return undefined;

}

// For arrays and tuples we infer new arrays and tuples where the reverse mapping has been

// applied to the element type(s).

if (isArrayType(source)) {

return getTypeFromInference(inference);

}

function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {

return __generator(this, function (_a) {

switch (_a.label) {

case 0:

properties = target.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(target) : getPropertiesOfObjectType(target);

_a.label = 1;

case 1:

if (!(requireOptionalProperties || !(targetProp.flags & 16777216 /* Optional */))) return [3 /*break*/, 5];

sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (!!sourceProp) return [3 /*break*/, 3];

// not contain anyFunctionType when we come back to this argument for its second round

// of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard

// when constructing types from type parameters that had no inference candidates).

return;

}

var inference = getInferenceInfoForType(target);

inferFromTypes(source, target.falseType);

}

else if (target.flags & 3145728 /* UnionOrIntersection */) {

for (var _d = 0, _e = target.types; _d < _e.length; _d++) {

var t = _e[_d];

// Inferences directly to naked type variables are given lower priority as they are

// less specific. For example, when inferring from Promise<string> to T | Promise<T>,

priority |= 1 /* NakedTypeVariable */;

inferFromTypes(source, t);

priority = savePriority;

}

}

else if (source.flags & 1048576 /* Union */) {

// Source is a union or intersection type, infer from each constituent type

var sourceTypes = source.types;

inferFromTypes(sourceType, target);

}

}

}

}

var properties = getPropertiesOfObjectType(target);

var sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (sourceProp) {

inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));

var sourceLen = sourceSignatures.length;

var targetLen = targetSignatures.length;

var len = sourceLen < targetLen ? sourceLen : targetLen;

for (var i = 0; i < len; i++) {

inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters);

}

spanArray = ts.createNodeArray(args);

if (hasSpreadArgument && argCount) {

var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;

}

}

else {

// returns a function type, we choose to defer processing. This narrowly permits function composition

// operators to flow inferences through return types, but otherwise processes calls right away. We

// use the resolvingSignature singleton to indicate that we deferred processing. This result will be

// from which we never make inferences).

if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {

skippedGenericFunction(node, checkMode);

var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);

if (signature === resolvingSignature) {

// CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that

}

if (node.expression.kind === 98 /* SuperKeyword */) {

return voidType;

var returnType = getReturnTypeFromBody(node, checkMode);

var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);

var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined);

return links_1.contextFreeType = returnOnlyType;

}

return anyFunctionType;

if (strictNullChecks && properties.length === 0) {

return checkNonNullType(sourceType, node);

}

checkObjectLiteralDestructuringPropertyAssignment(sourceType, p, properties, rightIsThis);

}

return sourceType;

for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {

var base = baseTypes_2[_i];

var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));

var existing = seen.get(prop.escapedName);

if (!existing) {

seen.set(prop.escapedName, { prop: prop, containingType: base });

// autoArrayType is used as a marker, so even if global Array type is not defined, it needs to be a unique type

autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

}

anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;

globalThisType = getGlobalTypeOrUndefined("ThisType", /*arity*/ 1);

if (augmentations) {

function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) {

var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;

if (property === firstAccessor) {

if (getAccessor) {

var getterFunction = ts.createFunctionExpression(getAccessor.modifiers,

/*asteriskToken*/ undefined,

ts.setTextRange(getterFunction, getAccessor);

ts.setOriginalNode(getterFunction, getAccessor);

var getter = ts.createPropertyAssignment("get", getterFunction);

}

if (setAccessor) {

var setterFunction = ts.createFunctionExpression(setAccessor.modifiers,

ts.setTextRange(setterFunction, setAccessor);

ts.setOriginalNode(setterFunction, setAccessor);

var setter = ts.createPropertyAssignment("set", setterFunction);

}

var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"),

/*typeArguments*/ undefined, [

receiver,

createExpressionForPropertyName(property.name),

]),

/*location*/ firstAccessor);

return ts.aggregateTransformFlags(expression);

* @param receiver The receiver on which each property should be assigned.

*/

function addInitializedPropertyStatements(statements, properties, receiver) {

var statement = ts.createExpressionStatement(transformInitializedProperty(property, receiver));

ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));

ts.setCommentRange(statement, property);

*/

function generateInitializedPropertyExpressions(properties, receiver) {

var expressions = [];

var expression = transformInitializedProperty(property, receiver);

ts.startOnNewLine(expression);

ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property));

* typingsInstaller will run the command with `${npmLocation} install ...`.

*/

Arguments.NpmLocation = "--npmLocation";

})(Arguments = server.Arguments || (server.Arguments = {}));

function hasArgument(argumentName) {

return ts.sys.args.indexOf(argumentName) >= 0;

// If changing the text in this section, be sure to test `configureNightly` too.

ts.versionMajorMinor = "3.4";

/** The version of the TypeScript compiler release */

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

(function (ts) {

/* @internal */

TypeFlags[TypeFlags["Instantiable"] = 63176704] = "Instantiable";

TypeFlags[TypeFlags["StructuredOrInstantiable"] = 66846720] = "StructuredOrInstantiable";

/* @internal */

// 'Narrowable' types are types where narrowing actually narrows.

// This *should* be every type other than null, undefined, void, and never

TypeFlags[TypeFlags["Narrowable"] = 133970943] = "Narrowable";

/* @internal */

ObjectFlags[ObjectFlags["ContainsObjectLiteral"] = 262144] = "ContainsObjectLiteral";

/* @internal */

ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface";

/* @internal */

ObjectFlags[ObjectFlags["RequiresWidening"] = 393216] = "RequiresWidening";

}

ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol;

function getObjectFlags(type) {

}

ts.getObjectFlags = getObjectFlags;

function typeHasCallOrConstructSignatures(type, checker) {

var wildcardType = createIntrinsicType(1 /* Any */, "any");

var errorType = createIntrinsicType(1 /* Any */, "error");

var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");

var stringType = createIntrinsicType(4 /* String */, "string");

var numberType = createIntrinsicType(8 /* Number */, "number");

var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");

var voidType = createIntrinsicType(16384 /* Void */, "void");

var neverType = createIntrinsicType(131072 /* Never */, "never");

var silentNeverType = createIntrinsicType(131072 /* Never */, "never");

var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");

var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");

var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated

// in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.

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

var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

result.id = typeCount;

return result;

}

var type = createType(kind);

type.intrinsicName = intrinsicName;

type.objectFlags = objectFlags;

return type;

}

}

function getConditionalTypeWorker(root, mapper, checkType, extendsType, trueType, falseType) {

// Simplifications for types of the form `T extends U ? T : never` and `T extends U ? never : T`.

if (checkType.flags & 1 /* Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return trueType;

}

return neverType;

}

}

if (!(checkType.flags & 1 /* Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return neverType;

}

var stringIndexInfo = getIndexInfoOfType(type, 0 /* String */);

var numberIndexInfo = getIndexInfoOfType(type, 1 /* Number */);

var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));

return result;

}

function getWidenedType(type) {

return type;

}

function createReverseMappedType(source, target, constraint) {

// If any property contains context sensitive functions that have been skipped, the source type

// is incomplete and we can't infer a meaningful input type.

return undefined;

}

// For arrays and tuples we infer new arrays and tuples where the reverse mapping has been

// applied to the element type(s).

if (isArrayType(source)) {

return getTypeFromInference(inference);

}

function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {

return __generator(this, function (_a) {

switch (_a.label) {

case 0:

properties = target.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(target) : getPropertiesOfObjectType(target);

_a.label = 1;

case 1:

if (!(requireOptionalProperties || !(targetProp.flags & 16777216 /* Optional */))) return [3 /*break*/, 5];

sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (!!sourceProp) return [3 /*break*/, 3];

// not contain anyFunctionType when we come back to this argument for its second round

// of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard

// when constructing types from type parameters that had no inference candidates).

return;

}

var inference = getInferenceInfoForType(target);

inferFromTypes(source, target.falseType);

}

else if (target.flags & 3145728 /* UnionOrIntersection */) {

for (var _d = 0, _e = target.types; _d < _e.length; _d++) {

var t = _e[_d];

// Inferences directly to naked type variables are given lower priority as they are

// less specific. For example, when inferring from Promise<string> to T | Promise<T>,

priority |= 1 /* NakedTypeVariable */;

inferFromTypes(source, t);

priority = savePriority;

}

}

else if (source.flags & 1048576 /* Union */) {

// Source is a union or intersection type, infer from each constituent type

var sourceTypes = source.types;

inferFromTypes(sourceType, target);

}

}

}

}

var properties = getPropertiesOfObjectType(target);

var sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (sourceProp) {

inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));

var sourceLen = sourceSignatures.length;

var targetLen = targetSignatures.length;

var len = sourceLen < targetLen ? sourceLen : targetLen;

for (var i = 0; i < len; i++) {

inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters);

}

spanArray = ts.createNodeArray(args);

if (hasSpreadArgument && argCount) {

var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;

}

}

else {

// returns a function type, we choose to defer processing. This narrowly permits function composition

// operators to flow inferences through return types, but otherwise processes calls right away. We

// use the resolvingSignature singleton to indicate that we deferred processing. This result will be

// from which we never make inferences).

if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {

skippedGenericFunction(node, checkMode);

var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);

if (signature === resolvingSignature) {

// CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that

}

if (node.expression.kind === 98 /* SuperKeyword */) {

return voidType;

var returnType = getReturnTypeFromBody(node, checkMode);

var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);

var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined);

return links_1.contextFreeType = returnOnlyType;

}

return anyFunctionType;

if (strictNullChecks && properties.length === 0) {

return checkNonNullType(sourceType, node);

}

checkObjectLiteralDestructuringPropertyAssignment(sourceType, p, properties, rightIsThis);

}

return sourceType;

for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {

var base = baseTypes_2[_i];

var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));

var existing = seen.get(prop.escapedName);

if (!existing) {

seen.set(prop.escapedName, { prop: prop, containingType: base });

// autoArrayType is used as a marker, so even if global Array type is not defined, it needs to be a unique type

autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

}

anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;

globalThisType = getGlobalTypeOrUndefined("ThisType", /*arity*/ 1);

if (augmentations) {

function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) {

var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;

if (property === firstAccessor) {

if (getAccessor) {

var getterFunction = ts.createFunctionExpression(getAccessor.modifiers,

/*asteriskToken*/ undefined,

ts.setTextRange(getterFunction, getAccessor);

ts.setOriginalNode(getterFunction, getAccessor);

var getter = ts.createPropertyAssignment("get", getterFunction);

}

if (setAccessor) {

var setterFunction = ts.createFunctionExpression(setAccessor.modifiers,

ts.setTextRange(setterFunction, setAccessor);

ts.setOriginalNode(setterFunction, setAccessor);

var setter = ts.createPropertyAssignment("set", setterFunction);

}

var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"),

/*typeArguments*/ undefined, [

receiver,

createExpressionForPropertyName(property.name),

]),

/*location*/ firstAccessor);

return ts.aggregateTransformFlags(expression);

* @param receiver The receiver on which each property should be assigned.

*/

function addInitializedPropertyStatements(statements, properties, receiver) {

var statement = ts.createExpressionStatement(transformInitializedProperty(property, receiver));

ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));

ts.setCommentRange(statement, property);

*/

function generateInitializedPropertyExpressions(properties, receiver) {

var expressions = [];

var expression = transformInitializedProperty(property, receiver);

ts.startOnNewLine(expression);

ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property));

* typingsInstaller will run the command with `${npmLocation} install ...`.

*/

Arguments.NpmLocation = "--npmLocation";

})(Arguments = server.Arguments || (server.Arguments = {}));

function hasArgument(argumentName) {

return ts.sys.args.indexOf(argumentName) >= 0;

// If changing the text in this section, be sure to test `configureNightly` too.

ts.versionMajorMinor = "3.4";

/** The version of the TypeScript compiler release */

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

(function (ts) {

/* @internal */

TypeFlags[TypeFlags["Instantiable"] = 63176704] = "Instantiable";

TypeFlags[TypeFlags["StructuredOrInstantiable"] = 66846720] = "StructuredOrInstantiable";

/* @internal */

// 'Narrowable' types are types where narrowing actually narrows.

// This *should* be every type other than null, undefined, void, and never

TypeFlags[TypeFlags["Narrowable"] = 133970943] = "Narrowable";

/* @internal */

ObjectFlags[ObjectFlags["ContainsObjectLiteral"] = 262144] = "ContainsObjectLiteral";

/* @internal */

ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface";

/* @internal */

ObjectFlags[ObjectFlags["RequiresWidening"] = 393216] = "RequiresWidening";

}

ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol;

function getObjectFlags(type) {

}

ts.getObjectFlags = getObjectFlags;

function typeHasCallOrConstructSignatures(type, checker) {

var wildcardType = createIntrinsicType(1 /* Any */, "any");

var errorType = createIntrinsicType(1 /* Any */, "error");

var unknownType = createIntrinsicType(2 /* Unknown */, "unknown");

var stringType = createIntrinsicType(4 /* String */, "string");

var numberType = createIntrinsicType(8 /* Number */, "number");

var bigintType = createIntrinsicType(64 /* BigInt */, "bigint");

var voidType = createIntrinsicType(16384 /* Void */, "void");

var neverType = createIntrinsicType(131072 /* Never */, "never");

var silentNeverType = createIntrinsicType(131072 /* Never */, "never");

var implicitNeverType = createIntrinsicType(131072 /* Never */, "never");

var nonPrimitiveType = createIntrinsicType(67108864 /* NonPrimitive */, "object");

var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]);

var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

// The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated

// in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes.

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

var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

result.id = typeCount;

return result;

}

var type = createType(kind);

type.intrinsicName = intrinsicName;

type.objectFlags = objectFlags;

return type;

}

}

function getConditionalTypeWorker(root, mapper, checkType, extendsType, trueType, falseType) {

// Simplifications for types of the form `T extends U ? T : never` and `T extends U ? never : T`.

if (checkType.flags & 1 /* Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return trueType;

}

return neverType;

}

}

if (!(checkType.flags & 1 /* Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true

return neverType;

}

var stringIndexInfo = getIndexInfoOfType(type, 0 /* String */);

var numberIndexInfo = getIndexInfoOfType(type, 1 /* Number */);

var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, stringIndexInfo && createIndexInfo(getWidenedType(stringIndexInfo.type), stringIndexInfo.isReadonly), numberIndexInfo && createIndexInfo(getWidenedType(numberIndexInfo.type), numberIndexInfo.isReadonly));

return result;

}

function getWidenedType(type) {

return type;

}

function createReverseMappedType(source, target, constraint) {

// If any property contains context sensitive functions that have been skipped, the source type

// is incomplete and we can't infer a meaningful input type.

return undefined;

}

// For arrays and tuples we infer new arrays and tuples where the reverse mapping has been

// applied to the element type(s).

if (isArrayType(source)) {

return getTypeFromInference(inference);

}

function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) {

return __generator(this, function (_a) {

switch (_a.label) {

case 0:

properties = target.flags & 2097152 /* Intersection */ ? getPropertiesOfUnionOrIntersectionType(target) : getPropertiesOfObjectType(target);

_a.label = 1;

case 1:

if (!(requireOptionalProperties || !(targetProp.flags & 16777216 /* Optional */))) return [3 /*break*/, 5];

sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (!!sourceProp) return [3 /*break*/, 3];

// not contain anyFunctionType when we come back to this argument for its second round

// of inference. Also, we exclude inferences for silentNeverType (which is used as a wildcard

// when constructing types from type parameters that had no inference candidates).

return;

}

var inference = getInferenceInfoForType(target);

inferFromTypes(source, target.falseType);

}

else if (target.flags & 3145728 /* UnionOrIntersection */) {

for (var _d = 0, _e = target.types; _d < _e.length; _d++) {

var t = _e[_d];

// Inferences directly to naked type variables are given lower priority as they are

// less specific. For example, when inferring from Promise<string> to T | Promise<T>,

priority |= 1 /* NakedTypeVariable */;

inferFromTypes(source, t);

priority = savePriority;

}

}

else if (source.flags & 1048576 /* Union */) {

// Source is a union or intersection type, infer from each constituent type

var sourceTypes = source.types;

inferFromTypes(sourceType, target);

}

}

}

}

var properties = getPropertiesOfObjectType(target);

var sourceProp = getPropertyOfType(source, targetProp.escapedName);

if (sourceProp) {

inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp));

var sourceLen = sourceSignatures.length;

var targetLen = targetSignatures.length;

var len = sourceLen < targetLen ? sourceLen : targetLen;

for (var i = 0; i < len; i++) {

inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getBaseSignature(targetSignatures[targetLen - len + i]), skipParameters);

}

spanArray = ts.createNodeArray(args);

if (hasSpreadArgument && argCount) {

var nextArg = ts.elementAt(args, getSpreadArgumentIndex(args) + 1) || undefined;

}

}

else {

// returns a function type, we choose to defer processing. This narrowly permits function composition

// operators to flow inferences through return types, but otherwise processes calls right away. We

// use the resolvingSignature singleton to indicate that we deferred processing. This result will be

// from which we never make inferences).

if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {

skippedGenericFunction(node, checkMode);

var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);

if (signature === resolvingSignature) {

// CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that

}

if (node.expression.kind === 98 /* SuperKeyword */) {

return voidType;

var returnType = getReturnTypeFromBody(node, checkMode);

var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, /*hasRestParameter*/ false, /*hasLiteralTypes*/ false);

var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, undefined, undefined);

return links_1.contextFreeType = returnOnlyType;

}

return anyFunctionType;

if (strictNullChecks && properties.length === 0) {

return checkNonNullType(sourceType, node);

}

checkObjectLiteralDestructuringPropertyAssignment(sourceType, p, properties, rightIsThis);

}

return sourceType;

for (var _i = 0, baseTypes_2 = baseTypes; _i < baseTypes_2.length; _i++) {

var base = baseTypes_2[_i];

var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType));

var existing = seen.get(prop.escapedName);

if (!existing) {

seen.set(prop.escapedName, { prop: prop, containingType: base });

// autoArrayType is used as a marker, so even if global Array type is not defined, it needs to be a unique type

autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, undefined, undefined);

}

anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType;

globalThisType = getGlobalTypeOrUndefined("ThisType", /*arity*/ 1);

if (augmentations) {

function createExpressionForAccessorDeclaration(properties, property, receiver, multiLine) {

var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor;

if (property === firstAccessor) {

if (getAccessor) {

var getterFunction = ts.createFunctionExpression(getAccessor.modifiers,

/*asteriskToken*/ undefined,

ts.setTextRange(getterFunction, getAccessor);

ts.setOriginalNode(getterFunction, getAccessor);

var getter = ts.createPropertyAssignment("get", getterFunction);

}

if (setAccessor) {

var setterFunction = ts.createFunctionExpression(setAccessor.modifiers,

ts.setTextRange(setterFunction, setAccessor);

ts.setOriginalNode(setterFunction, setAccessor);

var setter = ts.createPropertyAssignment("set", setterFunction);

}

var expression = ts.setTextRange(ts.createCall(ts.createPropertyAccess(ts.createIdentifier("Object"), "defineProperty"),

/*typeArguments*/ undefined, [

receiver,

createExpressionForPropertyName(property.name),

]),

/*location*/ firstAccessor);

return ts.aggregateTransformFlags(expression);

* @param receiver The receiver on which each property should be assigned.

*/

function addInitializedPropertyStatements(statements, properties, receiver) {

var statement = ts.createExpressionStatement(transformInitializedProperty(property, receiver));

ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));

ts.setCommentRange(statement, property);

*/

function generateInitializedPropertyExpressions(properties, receiver) {

var expressions = [];

var expression = transformInitializedProperty(property, receiver);

ts.startOnNewLine(expression);

ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property));

* typingsInstaller will run the command with `${npmLocation} install ...`.

*/

Arguments.NpmLocation = "--npmLocation";

})(Arguments = server.Arguments || (server.Arguments = {}));

function hasArgument(argumentName) {

return ts.sys.args.indexOf(argumentName) >= 0;

}

return FileLog;

}());

if (path.basename(processName).indexOf("node") === 0) {

}

}

}

function loadTypesRegistryFile(typesRegistryFilePath, host, log) {

if (!host.fileExists(typesRegistryFilePath)) {

}

var NodeTypingsInstaller = (function (_super) {

__extends(NodeTypingsInstaller, _super);

var _this = _super.call(this, ts.sys, globalTypingsCacheLocation, typingSafeListLocation ? ts.toPath(typingSafeListLocation, "", ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)) : ts.toPath("typingSafeList.json", __dirname, ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)), typesMapLocation ? ts.toPath(typesMapLocation, "", ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)) : ts.toPath("typesMap.json", __dirname, ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames)), throttleLimit, log) || this;

if (ts.stringContains(_this.npmPath, " ") && _this.npmPath[0] !== "\"") {

_this.npmPath = "\"" + _this.npmPath + "\"";

}

if (_this.log.isEnabled()) {

_this.log.writeLine("Process id: " + process.pid);

_this.log.writeLine("NPM location: " + _this.npmPath + " (explicit '" + server.Arguments.NpmLocation + "' " + (npmLocation === undefined ? "not " : "") + " provided)");

}

(_this.nodeExecSync = require("child_process").execSync);

_this.ensurePackageDirectoryExists(globalTypingsCacheLocation);

var typingSafeListLocation = server.findArgument(server.Arguments.TypingSafeListLocation);

var typesMapLocation = server.findArgument(server.Arguments.TypesMapLocation);

var npmLocation = server.findArgument(server.Arguments.NpmLocation);

var log = new FileLog(logFilePath);

if (log.isEnabled()) {

process.on("uncaughtException", function (e) {

}

process.exit(0);

});

installer.listen();

function indent(newline, str) {

return newline + " " + str.replace(/\r?\n/, newline + " ");

"name": "typescript",

"author": "Microsoft Corp.",

"homepage": "https://www.typescriptlang.org/",

"license": "Apache-2.0",

"description": "TypeScript is a language for application scale JavaScript development",

"keywords": [