typescript 5.1.0-dev.20230227 → 5.1.0-dev.20230301

package/README.md

@@ -5,6 +5,8 @@
 [![Devops Build Status](https://dev.azure.com/typescript/TypeScript/_apis/build/status/Typescript/node10)](https://dev.azure.com/typescript/TypeScript/_build?definitionId=7)
 [![npm version](https://badge.fury.io/js/typescript.svg)](https://www.npmjs.com/package/typescript)
 [![Downloads](https://img.shields.io/npm/dm/typescript.svg)](https://www.npmjs.com/package/typescript)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/microsoft/TypeScript/badge)](https://api.securityscorecards.dev/projects/github.com/microsoft/TypeScript)
+
 
 [TypeScript](https://www.typescriptlang.org/) is a language for application-scale JavaScript. TypeScript adds optional types to JavaScript that support tools for large-scale JavaScript applications for any browser, for any host, on any OS. TypeScript compiles to readable, standards-based JavaScript. Try it out at the [playground](https://www.typescriptlang.org/play/), and stay up to date via [our blog](https://blogs.msdn.microsoft.com/typescript) and [Twitter account](https://twitter.com/typescript).
 

package/lib/lib.es2015.collection.d.ts

@@ -82,7 +82,7 @@ interface WeakMap<K extends object, V> {
 }
 
 interface WeakMapConstructor {
-    new <K extends object = object, V = any>(entries?: readonly [K, V][] | null): WeakMap<K, V>;
+    new <K extends object = object, V = any>(entries?: readonly (readonly [K, V])[] | null): WeakMap<K, V>;
     readonly prototype: WeakMap<object, any>;
 }
 declare var WeakMap: WeakMapConstructor;

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230227`;
+var version = `${versionMajorMinor}.0-dev.20230301`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -842,9 +842,6 @@ function multiMapRemove(key, value) {
     }
   }
 }
-function createUnderscoreEscapedMultiMap() {
-  return createMultiMap();
-}
 function createQueue(items) {
   const elements = (items == null ? void 0 : items.slice()) || [];
   let headIndex = 0;
@@ -47794,7 +47791,7 @@ function createTypeChecker(host) {
           }
         }
         const mayHaveNameCollisions = !(context.flags & 64 /* UseFullyQualifiedType */);
-        const seenNames = mayHaveNameCollisions ? createUnderscoreEscapedMultiMap() : void 0;
+        const seenNames = mayHaveNameCollisions ? createMultiMap() : void 0;
         const result = [];
         let i = 0;
         for (const type of types) {
@@ -60075,7 +60072,7 @@ function createTypeChecker(host) {
               0 /* None */
             );
           }
-        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
+        } else if (result2 && isNonGenericObjectType(target2) && !isArrayOrTupleType(target2) && source2.flags & 2097152 /* Intersection */ && getApparentType(source2).flags & 3670016 /* StructuredType */ && !some(source2.types, (t) => t === target2 || !!(getObjectFlags(t) & 262144 /* NonInferrableType */))) {
           result2 &= propertiesRelatedTo(
             source2,
             target2,
@@ -85279,6 +85276,7 @@ function createDefaultValueCheck(flattenContext, value, defaultValue, location)
   );
 }
 function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
+  const { factory: factory2 } = flattenContext.context;
   if (isComputedPropertyName(propertyName)) {
     const argumentExpression = ensureIdentifier(
       flattenContext,
@@ -85290,7 +85288,7 @@ function createDestructuringPropertyAccess(flattenContext, value, propertyName)
     );
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
   } else if (isStringOrNumericLiteralLike(propertyName)) {
-    const argumentExpression = factory.cloneNode(propertyName);
+    const argumentExpression = factory2.cloneNode(propertyName);
     return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression);
   } else {
     const name = flattenContext.context.factory.createIdentifier(idText(propertyName));
@@ -85360,28 +85358,29 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   if (level === 0 /* LiftRestriction */ && !hasInvalidEscape(template)) {
     return visitEachChild(node, visitor, context);
   }
+  const { factory: factory2 } = context;
   if (isNoSubstitutionTemplateLiteral(template)) {
-    cookedStrings.push(createTemplateCooked(template));
-    rawStrings.push(getRawLiteral(template, currentSourceFile));
+    cookedStrings.push(createTemplateCooked(factory2, template));
+    rawStrings.push(getRawLiteral(factory2, template, currentSourceFile));
   } else {
-    cookedStrings.push(createTemplateCooked(template.head));
-    rawStrings.push(getRawLiteral(template.head, currentSourceFile));
+    cookedStrings.push(createTemplateCooked(factory2, template.head));
+    rawStrings.push(getRawLiteral(factory2, template.head, currentSourceFile));
     for (const templateSpan of template.templateSpans) {
-      cookedStrings.push(createTemplateCooked(templateSpan.literal));
-      rawStrings.push(getRawLiteral(templateSpan.literal, currentSourceFile));
+      cookedStrings.push(createTemplateCooked(factory2, templateSpan.literal));
+      rawStrings.push(getRawLiteral(factory2, templateSpan.literal, currentSourceFile));
       templateArguments.push(Debug.checkDefined(visitNode(templateSpan.expression, visitor, isExpression)));
     }
   }
   const helperCall = context.getEmitHelperFactory().createTemplateObjectHelper(
-    factory.createArrayLiteralExpression(cookedStrings),
-    factory.createArrayLiteralExpression(rawStrings)
+    factory2.createArrayLiteralExpression(cookedStrings),
+    factory2.createArrayLiteralExpression(rawStrings)
   );
   if (isExternalModule(currentSourceFile)) {
-    const tempVar = factory.createUniqueName("templateObject");
+    const tempVar = factory2.createUniqueName("templateObject");
     recordTaggedTemplateString(tempVar);
-    templateArguments[0] = factory.createLogicalOr(
+    templateArguments[0] = factory2.createLogicalOr(
       tempVar,
-      factory.createAssignment(
+      factory2.createAssignment(
         tempVar,
         helperCall
       )
@@ -85389,17 +85388,17 @@ function processTaggedTemplateExpression(context, node, visitor, currentSourceFi
   } else {
     templateArguments[0] = helperCall;
   }
-  return factory.createCallExpression(
+  return factory2.createCallExpression(
     tag,
     /*typeArguments*/
     void 0,
     templateArguments
   );
 }
-function createTemplateCooked(template) {
-  return template.templateFlags ? factory.createVoidZero() : factory.createStringLiteral(template.text);
+function createTemplateCooked(factory2, template) {
+  return template.templateFlags ? factory2.createVoidZero() : factory2.createStringLiteral(template.text);
 }
-function getRawLiteral(node, currentSourceFile) {
+function getRawLiteral(factory2, node, currentSourceFile) {
   let text = node.rawText;
   if (text === void 0) {
     Debug.assertIsDefined(
@@ -85411,7 +85410,7 @@ function getRawLiteral(node, currentSourceFile) {
     text = text.substring(1, text.length - (isLast ? 1 : 2));
   }
   text = text.replace(/\r\n?/g, "\n");
-  return setTextRange(factory.createStringLiteral(text), node);
+  return setTextRange(factory2.createStringLiteral(text), node);
 }
 
 // src/compiler/transformers/ts.ts
@@ -88867,12 +88866,14 @@ function transformClassFields(context) {
         if (privateIdentifierInfo.kind === "f" /* Field */) {
           if (!privateIdentifierInfo.isStatic) {
             return createPrivateInstanceFieldInitializer(
+              factory2,
               receiver,
               visitNode(property.initializer, initializerVisitor, isExpression),
               privateIdentifierInfo.brandCheckIdentifier
             );
           } else {
             return createPrivateStaticFieldInitializer(
+              factory2,
               privateIdentifierInfo.variableName,
               visitNode(property.initializer, initializerVisitor, isExpression)
             );
@@ -88954,7 +88955,7 @@ function transformClassFields(context) {
     Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
     statements.push(
       factory2.createExpressionStatement(
-        createPrivateInstanceMethodInitializer(receiver, weakSetName)
+        createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName)
       )
     );
   }
@@ -89407,25 +89408,25 @@ function transformClassFields(context) {
     return void 0;
   }
 }
-function createPrivateStaticFieldInitializer(variableName, initializer) {
-  return factory.createAssignment(
+function createPrivateStaticFieldInitializer(factory2, variableName, initializer) {
+  return factory2.createAssignment(
     variableName,
-    factory.createObjectLiteralExpression([
-      factory.createPropertyAssignment("value", initializer || factory.createVoidZero())
+    factory2.createObjectLiteralExpression([
+      factory2.createPropertyAssignment("value", initializer || factory2.createVoidZero())
     ])
   );
 }
-function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) {
-  return factory.createCallExpression(
-    factory.createPropertyAccessExpression(weakMapName, "set"),
+function createPrivateInstanceFieldInitializer(factory2, receiver, initializer, weakMapName) {
+  return factory2.createCallExpression(
+    factory2.createPropertyAccessExpression(weakMapName, "set"),
     /*typeArguments*/
     void 0,
-    [receiver, initializer || factory.createVoidZero()]
+    [receiver, initializer || factory2.createVoidZero()]
   );
 }
-function createPrivateInstanceMethodInitializer(receiver, weakSetName) {
-  return factory.createCallExpression(
-    factory.createPropertyAccessExpression(weakSetName, "add"),
+function createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName) {
+  return factory2.createCallExpression(
+    factory2.createPropertyAccessExpression(weakSetName, "add"),
     /*typeArguments*/
     void 0,
     [receiver]
@@ -89441,6 +89442,7 @@ function isPrivateIdentifierInExpression(node) {
 // src/compiler/transformers/typeSerializer.ts
 function createRuntimeTypeSerializer(context) {
   const {
+    factory: factory2,
     hoistVariableDeclaration
   } = context;
   const resolver = context.getEmitResolver();
@@ -89480,9 +89482,9 @@ function createRuntimeTypeSerializer(context) {
       case 260 /* ClassDeclaration */:
       case 228 /* ClassExpression */:
       case 171 /* MethodDeclaration */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       default:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
     }
   }
   function serializeParameterTypesOfNode(node, container) {
@@ -89503,7 +89505,7 @@ function createRuntimeTypeSerializer(context) {
         }
       }
     }
-    return factory.createArrayLiteralExpression(expressions);
+    return factory2.createArrayLiteralExpression(expressions);
   }
   function getParametersOfDecoratedDeclaration(node, container) {
     if (container && node.kind === 174 /* GetAccessor */) {
@@ -89518,39 +89520,39 @@ function createRuntimeTypeSerializer(context) {
     if (isFunctionLike(node) && node.type) {
       return serializeTypeNode(node.type);
     } else if (isAsyncFunction(node)) {
-      return factory.createIdentifier("Promise");
+      return factory2.createIdentifier("Promise");
     }
-    return factory.createVoidZero();
+    return factory2.createVoidZero();
   }
   function serializeTypeNode(node) {
     if (node === void 0) {
-      return factory.createIdentifier("Object");
+      return factory2.createIdentifier("Object");
     }
     node = skipTypeParentheses(node);
     switch (node.kind) {
       case 114 /* VoidKeyword */:
       case 155 /* UndefinedKeyword */:
       case 144 /* NeverKeyword */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       case 181 /* FunctionType */:
       case 182 /* ConstructorType */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       case 185 /* ArrayType */:
       case 186 /* TupleType */:
-        return factory.createIdentifier("Array");
+        return factory2.createIdentifier("Array");
       case 179 /* TypePredicate */:
-        return node.assertsModifier ? factory.createVoidZero() : factory.createIdentifier("Boolean");
+        return node.assertsModifier ? factory2.createVoidZero() : factory2.createIdentifier("Boolean");
       case 134 /* BooleanKeyword */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 200 /* TemplateLiteralType */:
       case 152 /* StringKeyword */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 149 /* ObjectKeyword */:
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       case 198 /* LiteralType */:
         return serializeLiteralOfLiteralTypeNode(node.literal);
       case 148 /* NumberKeyword */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 160 /* BigIntKeyword */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 153 /* SymbolKeyword */:
@@ -89602,13 +89604,13 @@ function createRuntimeTypeSerializer(context) {
       default:
         return Debug.failBadSyntaxKind(node);
     }
-    return factory.createIdentifier("Object");
+    return factory2.createIdentifier("Object");
   }
   function serializeLiteralOfLiteralTypeNode(node) {
     switch (node.kind) {
       case 10 /* StringLiteral */:
       case 14 /* NoSubstitutionTemplateLiteral */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 221 /* PrefixUnaryExpression */: {
         const operand = node.operand;
         switch (operand.kind) {
@@ -89620,14 +89622,14 @@ function createRuntimeTypeSerializer(context) {
         }
       }
       case 8 /* NumericLiteral */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 9 /* BigIntLiteral */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 110 /* TrueKeyword */:
       case 95 /* FalseKeyword */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 104 /* NullKeyword */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       default:
         return Debug.failBadSyntaxKind(node);
     }
@@ -89638,16 +89640,16 @@ function createRuntimeTypeSerializer(context) {
       typeNode = skipTypeParentheses(typeNode);
       if (typeNode.kind === 144 /* NeverKeyword */) {
         if (isIntersection)
-          return factory.createVoidZero();
+          return factory2.createVoidZero();
         continue;
       }
       if (typeNode.kind === 157 /* UnknownKeyword */) {
         if (!isIntersection)
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         continue;
       }
       if (typeNode.kind === 131 /* AnyKeyword */) {
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       }
       if (!strictNullChecks && (isLiteralTypeNode(typeNode) && typeNode.literal.kind === 104 /* NullKeyword */ || typeNode.kind === 155 /* UndefinedKeyword */)) {
         continue;
@@ -89658,13 +89660,13 @@ function createRuntimeTypeSerializer(context) {
       }
       if (serializedType) {
         if (!equateSerializedTypeNodes(serializedType, serializedConstituent)) {
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         }
       } else {
         serializedType = serializedConstituent;
       }
     }
-    return serializedType != null ? serializedType : factory.createVoidZero();
+    return serializedType != null ? serializedType : factory2.createVoidZero();
   }
   function equateSerializedTypeNodes(left, right) {
     return (
@@ -89698,48 +89700,48 @@ function createRuntimeTypeSerializer(context) {
     switch (kind) {
       case 0 /* Unknown */:
         if (findAncestor(node, (n) => n.parent && isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n))) {
-          return factory.createIdentifier("Object");
+          return factory2.createIdentifier("Object");
         }
         const serialized = serializeEntityNameAsExpressionFallback(node.typeName);
-        const temp = factory.createTempVariable(hoistVariableDeclaration);
-        return factory.createConditionalExpression(
-          factory.createTypeCheck(factory.createAssignment(temp, serialized), "function"),
+        const temp = factory2.createTempVariable(hoistVariableDeclaration);
+        return factory2.createConditionalExpression(
+          factory2.createTypeCheck(factory2.createAssignment(temp, serialized), "function"),
           /*questionToken*/
           void 0,
           temp,
           /*colonToken*/
           void 0,
-          factory.createIdentifier("Object")
+          factory2.createIdentifier("Object")
         );
       case 1 /* TypeWithConstructSignatureAndValue */:
         return serializeEntityNameAsExpression(node.typeName);
       case 2 /* VoidNullableOrNeverType */:
-        return factory.createVoidZero();
+        return factory2.createVoidZero();
       case 4 /* BigIntLikeType */:
         return getGlobalConstructor("BigInt", 7 /* ES2020 */);
       case 6 /* BooleanType */:
-        return factory.createIdentifier("Boolean");
+        return factory2.createIdentifier("Boolean");
       case 3 /* NumberLikeType */:
-        return factory.createIdentifier("Number");
+        return factory2.createIdentifier("Number");
       case 5 /* StringLikeType */:
-        return factory.createIdentifier("String");
+        return factory2.createIdentifier("String");
       case 7 /* ArrayLikeType */:
-        return factory.createIdentifier("Array");
+        return factory2.createIdentifier("Array");
       case 8 /* ESSymbolType */:
         return getGlobalConstructor("Symbol", 2 /* ES2015 */);
       case 10 /* TypeWithCallSignature */:
-        return factory.createIdentifier("Function");
+        return factory2.createIdentifier("Function");
       case 9 /* Promise */:
-        return factory.createIdentifier("Promise");
+        return factory2.createIdentifier("Promise");
       case 11 /* ObjectType */:
-        return factory.createIdentifier("Object");
+        return factory2.createIdentifier("Object");
       default:
         return Debug.assertNever(kind);
     }
   }
   function createCheckedValue(left, right) {
-    return factory.createLogicalAnd(
-      factory.createStrictInequality(factory.createTypeOfExpression(left), factory.createStringLiteral("undefined")),
+    return factory2.createLogicalAnd(
+      factory2.createStrictInequality(factory2.createTypeOfExpression(left), factory2.createStringLiteral("undefined")),
       right
     );
   }
@@ -89752,13 +89754,13 @@ function createRuntimeTypeSerializer(context) {
       return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node));
     }
     const left = serializeEntityNameAsExpressionFallback(node.left);
-    const temp = factory.createTempVariable(hoistVariableDeclaration);
-    return factory.createLogicalAnd(
-      factory.createLogicalAnd(
+    const temp = factory2.createTempVariable(hoistVariableDeclaration);
+    return factory2.createLogicalAnd(
+      factory2.createLogicalAnd(
         left.left,
-        factory.createStrictInequality(factory.createAssignment(temp, left.right), factory.createVoidZero())
+        factory2.createStrictInequality(factory2.createAssignment(temp, left.right), factory2.createVoidZero())
       ),
-      factory.createPropertyAccessExpression(temp, node.right)
+      factory2.createPropertyAccessExpression(temp, node.right)
     );
   }
   function serializeEntityNameAsExpression(node) {
@@ -89773,21 +89775,21 @@ function createRuntimeTypeSerializer(context) {
     }
   }
   function serializeQualifiedNameAsExpression(node) {
-    return factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
+    return factory2.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right);
   }
   function getGlobalConstructorWithFallback(name) {
-    return factory.createConditionalExpression(
-      factory.createTypeCheck(factory.createIdentifier(name), "function"),
+    return factory2.createConditionalExpression(
+      factory2.createTypeCheck(factory2.createIdentifier(name), "function"),
       /*questionToken*/
       void 0,
-      factory.createIdentifier(name),
+      factory2.createIdentifier(name),
       /*colonToken*/
       void 0,
-      factory.createIdentifier("Object")
+      factory2.createIdentifier("Object")
     );
   }
   function getGlobalConstructor(name, minLanguageVersion) {
-    return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory.createIdentifier(name);
+    return languageVersion < minLanguageVersion ? getGlobalConstructorWithFallback(name) : factory2.createIdentifier(name);
   }
 }
 
@@ -104618,7 +104620,7 @@ function transformDeclarations(context) {
     }
     const newParam = factory2.updateParameterDeclaration(
       p,
-      maskModifiers(p, modifierMask),
+      maskModifiers(factory2, p, modifierMask),
       p.dotDotDotToken,
       filterBindingPatternInitializersAndRenamings(p.name),
       resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(57 /* QuestionToken */) : void 0,
@@ -105732,8 +105734,8 @@ function isAlwaysType(node) {
   }
   return false;
 }
-function maskModifiers(node, modifierMask, modifierAdditions) {
-  return factory.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
+function maskModifiers(factory2, node, modifierMask, modifierAdditions) {
+  return factory2.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions));
 }
 function maskModifierFlags(node, modifierMask = 258047 /* All */ ^ 4 /* Public */, modifierAdditions = 0 /* None */) {
   let flags = getEffectiveModifierFlags(node) & modifierMask | modifierAdditions;