typescript 5.0.0-dev.20230226 → 5.1.0-dev.20230301

package/lib/typescript.js

@@ -34,8 +34,8 @@ var ts = (() => {
   var init_corePublic = __esm({
     "src/compiler/corePublic.ts"() {
       "use strict";
-      versionMajorMinor = "5.0";
-      version = `${versionMajorMinor}.0-dev.20230226`;
+      versionMajorMinor = "5.1";
+      version = `${versionMajorMinor}.0-dev.20230301`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -1000,9 +1000,6 @@ var ts = (() => {
       }
     }
   }
-  function createUnderscoreEscapedMultiMap() {
-    return createMultiMap();
-  }
   function createQueue(items) {
     const elements = (items == null ? void 0 : items.slice()) || [];
     let headIndex = 0;
@@ -50209,7 +50206,7 @@ ${lanes.join("\n")}
             }
           }
           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) {
@@ -62490,7 +62487,7 @@ ${lanes.join("\n")}
                 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,
@@ -88009,6 +88006,7 @@ ${lanes.join("\n")}
     );
   }
   function createDestructuringPropertyAccess(flattenContext, value, propertyName) {
+    const { factory: factory2 } = flattenContext.context;
     if (isComputedPropertyName(propertyName)) {
       const argumentExpression = ensureIdentifier(
         flattenContext,
@@ -88020,7 +88018,7 @@ ${lanes.join("\n")}
       );
       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));
@@ -88102,28 +88100,29 @@ ${lanes.join("\n")}
     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
         )
@@ -88131,17 +88130,17 @@ ${lanes.join("\n")}
     } 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(
@@ -88153,7 +88152,7 @@ ${lanes.join("\n")}
       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);
   }
   var ProcessLevel;
   var init_taggedTemplate = __esm({
@@ -91628,12 +91627,14 @@ ${lanes.join("\n")}
           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)
               );
@@ -91715,7 +91716,7 @@ ${lanes.join("\n")}
       Debug.assert(weakSetName, "weakSetName should be set in private identifier environment");
       statements.push(
         factory2.createExpressionStatement(
-          createPrivateInstanceMethodInitializer(receiver, weakSetName)
+          createPrivateInstanceMethodInitializer(factory2, receiver, weakSetName)
         )
       );
     }
@@ -92168,25 +92169,25 @@ ${lanes.join("\n")}
       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]
@@ -92208,6 +92209,7 @@ ${lanes.join("\n")}
   // src/compiler/transformers/typeSerializer.ts
   function createRuntimeTypeSerializer(context) {
     const {
+      factory: factory2,
       hoistVariableDeclaration
     } = context;
     const resolver = context.getEmitResolver();
@@ -92247,9 +92249,9 @@ ${lanes.join("\n")}
         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) {
@@ -92270,7 +92272,7 @@ ${lanes.join("\n")}
           }
         }
       }
-      return factory.createArrayLiteralExpression(expressions);
+      return factory2.createArrayLiteralExpression(expressions);
     }
     function getParametersOfDecoratedDeclaration(node, container) {
       if (container && node.kind === 174 /* GetAccessor */) {
@@ -92285,39 +92287,39 @@ ${lanes.join("\n")}
       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 */:
@@ -92369,13 +92371,13 @@ ${lanes.join("\n")}
         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) {
@@ -92387,14 +92389,14 @@ ${lanes.join("\n")}
           }
         }
         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);
       }
@@ -92405,16 +92407,16 @@ ${lanes.join("\n")}
         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;
@@ -92425,13 +92427,13 @@ ${lanes.join("\n")}
         }
         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 (
@@ -92465,48 +92467,48 @@ ${lanes.join("\n")}
       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
       );
     }
@@ -92519,13 +92521,13 @@ ${lanes.join("\n")}
         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) {
@@ -92540,21 +92542,21 @@ ${lanes.join("\n")}
       }
     }
     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);
     }
   }
   var init_typeSerializer = __esm({
@@ -107500,7 +107502,7 @@ ${lanes.join("\n")}
       }
       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,
@@ -108614,8 +108616,8 @@ ${lanes.join("\n")}
     }
     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;
@@ -118200,7 +118202,7 @@ ${lanes.join("\n")}
       const version2 = typeScriptVersion3 || versionMajorMinor;
       const ignoreDeprecations = options.ignoreDeprecations;
       if (ignoreDeprecations) {
-        if (ignoreDeprecations === "5.0" /* v5_0 */ && (version2 === "5.0" /* v5_0 */ || version2 === "5.5" /* v5_5 */)) {
+        if (ignoreDeprecations === "5.0" /* v5_0 */ && version2.startsWith("5.")) {
           return;
         } else if (reportInvalidIgnoreDeprecations) {
           createOptionValueDiagnostic("ignoreDeprecations", Diagnostics.Invalid_value_for_ignoreDeprecations);
@@ -145045,7 +145047,7 @@ ${lanes.join("\n")}
       const props = createMultiMap();
       for (const anon2 of anons) {
         for (const p of checker.getPropertiesOfType(anon2)) {
-          props.add(p.name, p.valueDeclaration ? checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration) : checker.getAnyType());
+          props.add(p.escapedName, p.valueDeclaration ? checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration) : checker.getAnyType());
         }
         calls.push(...checker.getSignaturesOfType(anon2, 0 /* Call */));
         constructs.push(...checker.getSignaturesOfType(anon2, 1 /* Construct */));
@@ -149167,7 +149169,8 @@ ${lanes.join("\n")}
     }
     log("getCompletionData: Semantic work: " + (timestamp() - semanticStart));
     const contextualType = previousToken && getContextualType(previousToken, position, sourceFile, typeChecker);
-    const literals = mapDefined(
+    const isLiteralExpected = !tryCast(previousToken, isStringLiteralLike) && !isJsxIdentifierExpected;
+    const literals = !isLiteralExpected ? [] : mapDefined(
       contextualType && (contextualType.isUnion() ? contextualType.types : [contextualType]),
       (t) => t.isLiteral() && !(t.flags & 1024 /* EnumLiteral */) ? t.value : void 0
     );
@@ -155779,8 +155782,7 @@ ${lanes.join("\n")}
   function compareModuleSpecifiersWorker(m1, m2, comparer) {
     const name1 = m1 === void 0 ? void 0 : getExternalModuleName2(m1);
     const name2 = m2 === void 0 ? void 0 : getExternalModuleName2(m2);
-    return compareBooleans(name1 === void 0, name2 === void 0) || compareBooleans(isExternalModuleNameRelative(name1), isExternalModuleNameRelative(name2)) || // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-    comparer(name1, name2);
+    return compareBooleans(name1 === void 0, name2 === void 0) || compareBooleans(isExternalModuleNameRelative(name1), isExternalModuleNameRelative(name2)) || comparer(name1, name2);
   }
   function getModuleSpecifierExpression(declaration) {
     var _a2;
@@ -167869,7 +167871,6 @@ ${options.prefix}` : "\n" : options.prefix
     createTypeChecker: () => createTypeChecker,
     createTypeReferenceDirectiveResolutionCache: () => createTypeReferenceDirectiveResolutionCache,
     createTypeReferenceResolutionLoader: () => createTypeReferenceResolutionLoader,
-    createUnderscoreEscapedMultiMap: () => createUnderscoreEscapedMultiMap,
     createUnparsedSourceFile: () => createUnparsedSourceFile,
     createWatchCompilerHost: () => createWatchCompilerHost2,
     createWatchCompilerHostOfConfigFile: () => createWatchCompilerHostOfConfigFile,

package/lib/typingsInstaller.js

@@ -53,8 +53,8 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-dev.20230226`;
+var versionMajorMinor = "5.1";
+var version = `${versionMajorMinor}.0-dev.20230301`;
 
 // src/compiler/core.ts
 var emptyArray = [];

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.0.0-dev.20230226",
+    "version": "5.1.0-dev.20230301",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -41,21 +41,21 @@
     "devDependencies": {
         "@esfx/canceltoken": "^1.0.0",
         "@octokit/rest": "latest",
-        "@types/chai": "latest",
+        "@types/chai": "^4.3.4",
         "@types/fs-extra": "^9.0.13",
-        "@types/glob": "latest",
-        "@types/microsoft__typescript-etw": "latest",
-        "@types/minimist": "latest",
-        "@types/mocha": "latest",
-        "@types/ms": "latest",
+        "@types/glob": "^8.1.0",
+        "@types/microsoft__typescript-etw": "^0.1.1",
+        "@types/minimist": "^1.2.2",
+        "@types/mocha": "^10.0.1",
+        "@types/ms": "^0.7.31",
         "@types/node": "latest",
-        "@types/source-map-support": "latest",
+        "@types/source-map-support": "^0.5.6",
         "@types/which": "^2.0.1",
         "@typescript-eslint/eslint-plugin": "^5.33.1",
         "@typescript-eslint/parser": "^5.33.1",
         "@typescript-eslint/utils": "^5.33.1",
         "azure-devops-node-api": "^11.2.0",
-        "chai": "latest",
+        "chai": "^4.3.7",
         "chalk": "^4.1.2",
         "chokidar": "^3.5.3",
         "del": "^6.1.1",
@@ -69,15 +69,15 @@
         "eslint-plugin-simple-import-sort": "^10.0.0",
         "fast-xml-parser": "^4.0.11",
         "fs-extra": "^9.1.0",
-        "glob": "latest",
+        "glob": "^8.1.0",
         "hereby": "^1.6.4",
         "jsonc-parser": "^3.2.0",
-        "minimist": "latest",
-        "mocha": "latest",
-        "mocha-fivemat-progress-reporter": "latest",
+        "minimist": "^1.2.8",
+        "mocha": "^10.2.0",
+        "mocha-fivemat-progress-reporter": "^0.1.0",
         "ms": "^2.1.3",
         "node-fetch": "^3.2.10",
-        "source-map-support": "latest",
+        "source-map-support": "^0.5.21",
         "typescript": "5.0.0-dev.20230112",
         "which": "^2.0.2"
     },