typescript 5.4.0-dev.20231128 → 5.4.0-dev.20231130

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20231128`;
+      version = `${versionMajorMinor}.0-dev.20231130`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -35191,18 +35191,7 @@ ${lanes.join("\n")}
               }
               nextTokenJSDoc();
               skipWhitespace();
-              const p2 = getNodePos();
-              let name = tokenIsIdentifierOrKeyword(token()) ? parseEntityName(
-                /*allowReservedWords*/
-                true
-              ) : void 0;
-              if (name) {
-                while (token() === 81 /* PrivateIdentifier */) {
-                  reScanHashToken();
-                  nextTokenJSDoc();
-                  name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), p2);
-                }
-              }
+              const name = parseJSDocLinkName();
               const text = [];
               while (token() !== 20 /* CloseBraceToken */ && token() !== 4 /* NewLineTrivia */ && token() !== 1 /* EndOfFileToken */) {
                 text.push(scanner2.getTokenText());
@@ -35211,6 +35200,26 @@ ${lanes.join("\n")}
               const create = linkType === "link" ? factory2.createJSDocLink : linkType === "linkcode" ? factory2.createJSDocLinkCode : factory2.createJSDocLinkPlain;
               return finishNode(create(name, text.join("")), start2, scanner2.getTokenEnd());
             }
+            function parseJSDocLinkName() {
+              if (tokenIsIdentifierOrKeyword(token())) {
+                const pos = getNodePos();
+                let name = parseIdentifierName();
+                while (parseOptional(25 /* DotToken */)) {
+                  name = finishNode(factory2.createQualifiedName(name, token() === 81 /* PrivateIdentifier */ ? createMissingNode(
+                    80 /* Identifier */,
+                    /*reportAtCurrentPosition*/
+                    false
+                  ) : parseIdentifier()), pos);
+                }
+                while (token() === 81 /* PrivateIdentifier */) {
+                  reScanHashToken();
+                  nextTokenJSDoc();
+                  name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), pos);
+                }
+                return name;
+              }
+              return void 0;
+            }
             function parseJSDocLinkPrefix() {
               skipWhitespaceOrAsterisk();
               if (token() === 19 /* OpenBraceToken */ && nextTokenJSDoc() === 60 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc())) {
@@ -37805,7 +37814,7 @@ ${lanes.join("\n")}
         ["esnext.disposable", "lib.esnext.disposable.d.ts"],
         ["esnext.bigint", "lib.es2020.bigint.d.ts"],
         ["esnext.string", "lib.es2022.string.d.ts"],
-        ["esnext.promise", "lib.es2021.promise.d.ts"],
+        ["esnext.promise", "lib.esnext.promise.d.ts"],
         ["esnext.weakref", "lib.es2021.weakref.d.ts"],
         ["esnext.decorators", "lib.esnext.decorators.d.ts"],
         ["decorators", "lib.decorators.d.ts"],
@@ -44301,7 +44310,7 @@ ${lanes.join("\n")}
     }
     function bindSpecialPropertyAssignment(node) {
       var _a;
-      const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, container) || lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer);
+      const parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer) || lookupSymbolForPropertyAccess(node.left.expression, container);
       if (!isInJSFile(node) && !isFunctionSymbol(parentSymbol)) {
         return;
       }
@@ -44399,7 +44408,7 @@ ${lanes.join("\n")}
       return isBinaryExpression(propertyAccess.parent) ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 312 /* SourceFile */ : propertyAccess.parent.parent.kind === 312 /* SourceFile */;
     }
     function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) {
-      let namespaceSymbol = lookupSymbolForPropertyAccess(name, container) || lookupSymbolForPropertyAccess(name, blockScopeContainer);
+      let namespaceSymbol = lookupSymbolForPropertyAccess(name, blockScopeContainer) || lookupSymbolForPropertyAccess(name, container);
       const isToplevel = isTopLevelNamespaceAssignment(propertyAccess);
       namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass);
       bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty);
@@ -56952,7 +56961,12 @@ ${lanes.join("\n")}
         for (const current of type.types) {
           for (const prop of getPropertiesOfType(current)) {
             if (!members.has(prop.escapedName)) {
-              const combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName);
+              const combinedProp = getPropertyOfUnionOrIntersectionType(
+                type,
+                prop.escapedName,
+                /*skipObjectFunctionPropertyAugment*/
+                !!(type.flags & 2097152 /* Intersection */)
+              );
               if (combinedProp) {
                 members.set(prop.escapedName, combinedProp);
               }
@@ -57442,13 +57456,17 @@ ${lanes.join("\n")}
       return result;
     }
     function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) {
-      var _a, _b;
+      var _a, _b, _c;
       let property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) == null ? void 0 : _a.get(name)) || !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) == null ? void 0 : _b.get(name) : void 0;
       if (!property) {
         property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment);
         if (property) {
           const properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = createSymbolTable()) : type.propertyCache || (type.propertyCache = createSymbolTable());
           properties.set(name, property);
+          if (skipObjectFunctionPropertyAugment && !((_c = type.propertyCache) == null ? void 0 : _c.get(name))) {
+            const properties2 = type.propertyCache || (type.propertyCache = createSymbolTable());
+            properties2.set(name, property);
+          }
         }
       }
       return property;
@@ -57558,7 +57576,22 @@ ${lanes.join("\n")}
         }
         return getPropertyOfObjectType(globalObjectType, name);
       }
-      if (type.flags & 3145728 /* UnionOrIntersection */) {
+      if (type.flags & 2097152 /* Intersection */) {
+        const prop = getPropertyOfUnionOrIntersectionType(
+          type,
+          name,
+          /*skipObjectFunctionPropertyAugment*/
+          true
+        );
+        if (prop) {
+          return prop;
+        }
+        if (!skipObjectFunctionPropertyAugment) {
+          return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
+        }
+        return void 0;
+      }
+      if (type.flags & 1048576 /* Union */) {
         return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment);
       }
       return void 0;
@@ -66411,12 +66444,12 @@ ${lanes.join("\n")}
       return false;
     }
     function isValidTypeForTemplateLiteralPlaceholder(source, target) {
-      if (source === target || target.flags & (1 /* Any */ | 4 /* String */)) {
-        return true;
-      }
       if (target.flags & 2097152 /* Intersection */) {
         return every(target.types, (t) => t === emptyTypeLiteralType || isValidTypeForTemplateLiteralPlaceholder(source, t));
       }
+      if (target.flags & 4 /* String */ || isTypeAssignableTo(source, target)) {
+        return true;
+      }
       if (source.flags & 128 /* StringLiteral */) {
         const value = source.value;
         return !!(target.flags & 8 /* Number */ && isValidNumberString(
@@ -66433,7 +66466,7 @@ ${lanes.join("\n")}
         const texts = source.texts;
         return texts.length === 2 && texts[0] === "" && texts[1] === "" && isTypeAssignableTo(source.types[0], target);
       }
-      return isTypeAssignableTo(source, target);
+      return false;
     }
     function inferTypesFromTemplateLiteralType(source, target) {
       return source.flags & 128 /* StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], emptyArray, target) : source.flags & 134217728 /* TemplateLiteral */ ? arraysEqual(source.texts, target.texts) ? map(source.types, getStringLikeTypeForType) : inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : void 0;
@@ -69391,14 +69424,15 @@ ${lanes.join("\n")}
       if (declaration) {
         if (isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
           const parent2 = declaration.parent.parent;
-          if (parent2.kind === 260 /* VariableDeclaration */ && getCombinedNodeFlagsCached(declaration) & 6 /* Constant */ || parent2.kind === 169 /* Parameter */) {
+          const rootDeclaration = getRootDeclaration(parent2);
+          if (rootDeclaration.kind === 260 /* VariableDeclaration */ && getCombinedNodeFlagsCached(rootDeclaration) & 6 /* Constant */ || rootDeclaration.kind === 169 /* Parameter */) {
             const links = getNodeLinks(parent2);
             if (!(links.flags & 4194304 /* InCheckIdentifier */)) {
               links.flags |= 4194304 /* InCheckIdentifier */;
               const parentType = getTypeForBindingElementParent(parent2, 0 /* Normal */);
               const parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType);
               links.flags &= ~4194304 /* InCheckIdentifier */;
-              if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(parent2.kind === 169 /* Parameter */ && isSymbolAssigned(symbol))) {
+              if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* Union */ && !(rootDeclaration.kind === 169 /* Parameter */ && isSymbolAssigned(symbol))) {
                 const pattern = declaration.parent;
                 const narrowedType = getFlowTypeOfReference(
                   pattern,
@@ -73571,19 +73605,9 @@ ${lanes.join("\n")}
           return Debug.fail();
       }
     }
-    function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) {
-      let start;
-      let length2;
+    function getDiagnosticSpanForCallNode(node) {
       const sourceFile = getSourceFileOfNode(node);
-      if (isPropertyAccessExpression(node.expression)) {
-        const nameSpan = getErrorSpanForNode(sourceFile, node.expression.name);
-        start = nameSpan.start;
-        length2 = doNotIncludeArguments ? nameSpan.length : node.end - start;
-      } else {
-        const expressionSpan = getErrorSpanForNode(sourceFile, node.expression);
-        start = expressionSpan.start;
-        length2 = doNotIncludeArguments ? expressionSpan.length : node.end - start;
-      }
+      const { start, length: length2 } = getErrorSpanForNode(sourceFile, isPropertyAccessExpression(node.expression) ? node.expression.name : node.expression);
       return { start, length: length2, sourceFile };
     }
     function getDiagnosticForCallNode(node, message, ...args) {
@@ -73600,6 +73624,18 @@ ${lanes.join("\n")}
         return createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, message);
       }
     }
+    function getErrorNodeForCallNode(callLike) {
+      if (isCallOrNewExpression(callLike)) {
+        return isPropertyAccessExpression(callLike.expression) ? callLike.expression.name : callLike.expression;
+      }
+      if (isTaggedTemplateExpression(callLike)) {
+        return isPropertyAccessExpression(callLike.tag) ? callLike.tag.name : callLike.tag;
+      }
+      if (isJsxOpeningLikeElement(callLike)) {
+        return callLike.tagName;
+      }
+      return callLike;
+    }
     function isPromiseResolveArityError(node) {
       if (!isCallExpression(node) || !isIdentifier(node.expression))
         return false;
@@ -73901,7 +73937,7 @@ ${lanes.join("\n")}
               const { file, start, length: length2 } = diags[0];
               diag2 = { file, start, length: length2, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related };
             } else {
-              diag2 = createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, chain, related);
+              diag2 = createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), getErrorNodeForCallNode(node), chain, related);
             }
             addImplementationSuccessElaboration(candidatesForArgumentError[0], diag2);
             diagnostics.add(diag2);
@@ -74429,11 +74465,7 @@ ${lanes.join("\n")}
         addRelatedInfo(diagnostic, createDiagnosticForNode(errorTarget, relatedInfo));
       }
       if (isCallExpression(errorTarget.parent)) {
-        const { start, length: length2 } = getDiagnosticSpanForCallNode(
-          errorTarget.parent,
-          /*doNotIncludeArguments*/
-          true
-        );
+        const { start, length: length2 } = getDiagnosticSpanForCallNode(errorTarget.parent);
         diagnostic.start = start;
         diagnostic.length = length2;
       }
@@ -77803,16 +77835,19 @@ ${lanes.join("\n")}
         }
       }
     }
-    function getReturnTypeOfSingleNonGenericCallSignature(funcType) {
+    function getNonGenericReturnTypeOfSingleCallSignature(funcType) {
       const signature = getSingleCallSignature(funcType);
-      if (signature && !signature.typeParameters) {
-        return getReturnTypeOfSignature(signature);
+      if (signature) {
+        const returnType = getReturnTypeOfSignature(signature);
+        if (!signature.typeParameters || !couldContainTypeVariables(returnType)) {
+          return returnType;
+        }
       }
     }
     function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) {
       const funcType = checkExpression(expr.expression);
       const nonOptionalType = getOptionalExpressionType(funcType, expr.expression);
-      const returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType);
+      const returnType = getNonGenericReturnTypeOfSingleCallSignature(funcType);
       return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType);
     }
     function getTypeOfExpression(node) {
@@ -77857,7 +77892,7 @@ ${lanes.join("\n")}
         /*requireStringLiteralLikeArgument*/
         true
       ) && !isSymbolOrSymbolForCall(expr)) {
-        return isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression));
+        return isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : getNonGenericReturnTypeOfSingleCallSignature(checkNonNullExpression(expr.expression));
       } else if (isAssertionExpression(expr) && !isConstTypeReference(expr.type)) {
         return getTypeFromTypeNode(expr.type);
       } else if (isLiteralExpression(node) || isBooleanLiteral(node)) {
@@ -165137,6 +165172,17 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               visitForDisplayParts(node.type);
             }
             break;
+          case 181 /* IndexSignature */:
+            Debug.assertNode(node, isIndexSignatureDeclaration);
+            Debug.assertEqual(node.parameters.length, 1);
+            parts.push({ text: "[" });
+            visitForDisplayParts(node.parameters[0]);
+            parts.push({ text: "]" });
+            if (node.type) {
+              parts.push({ text: ": " });
+              visitForDisplayParts(node.type);
+            }
+            break;
           case 173 /* MethodSignature */:
             Debug.assertNode(node, isMethodSignature);
             if ((_b = node.modifiers) == null ? void 0 : _b.length) {
@@ -165186,6 +165232,28 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             parts.push({ text: tokenToString(node.operator) });
             visitForDisplayParts(node.operand);
             break;
+          case 203 /* TemplateLiteralType */:
+            Debug.assertNode(node, isTemplateLiteralTypeNode);
+            visitForDisplayParts(node.head);
+            node.templateSpans.forEach(visitForDisplayParts);
+            break;
+          case 16 /* TemplateHead */:
+            Debug.assertNode(node, isTemplateHead);
+            parts.push({ text: getLiteralText2(node) });
+            break;
+          case 204 /* TemplateLiteralTypeSpan */:
+            Debug.assertNode(node, isTemplateLiteralTypeSpan);
+            visitForDisplayParts(node.type);
+            visitForDisplayParts(node.literal);
+            break;
+          case 17 /* TemplateMiddle */:
+            Debug.assertNode(node, isTemplateMiddle);
+            parts.push({ text: getLiteralText2(node) });
+            break;
+          case 18 /* TemplateTail */:
+            Debug.assertNode(node, isTemplateTail);
+            parts.push({ text: getLiteralText2(node) });
+            break;
           case 197 /* ThisType */:
             Debug.assertNode(node, isThisTypeNode);
             parts.push({ text: "this" });
@@ -165213,8 +165281,22 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         });
       }
       function getLiteralText2(node) {
-        if (isStringLiteral(node)) {
-          return quotePreference === 0 /* Single */ ? `'${escapeString(node.text, 39 /* singleQuote */)}'` : `"${escapeString(node.text, 34 /* doubleQuote */)}"`;
+        switch (node.kind) {
+          case 11 /* StringLiteral */:
+            return quotePreference === 0 /* Single */ ? `'${escapeString(node.text, 39 /* singleQuote */)}'` : `"${escapeString(node.text, 34 /* doubleQuote */)}"`;
+          case 16 /* TemplateHead */:
+          case 17 /* TemplateMiddle */:
+          case 18 /* TemplateTail */: {
+            const rawText = node.rawText ?? escapeTemplateSubstitution(escapeString(node.text, 96 /* backtick */));
+            switch (node.kind) {
+              case 16 /* TemplateHead */:
+                return "`" + rawText + "${";
+              case 17 /* TemplateMiddle */:
+                return "}" + rawText + "${";
+              case 18 /* TemplateTail */:
+                return "}" + rawText + "`";
+            }
+          }
         }
         return node.text;
       }
@@ -184995,6 +185077,7 @@ ${e.message}`;
     escapeNonAsciiString: () => escapeNonAsciiString,
     escapeSnippetText: () => escapeSnippetText,
     escapeString: () => escapeString,
+    escapeTemplateSubstitution: () => escapeTemplateSubstitution,
     every: () => every,
     expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
     explainFiles: () => explainFiles,
@@ -187407,6 +187490,7 @@ ${e.message}`;
     escapeNonAsciiString: () => escapeNonAsciiString,
     escapeSnippetText: () => escapeSnippetText,
     escapeString: () => escapeString,
+    escapeTemplateSubstitution: () => escapeTemplateSubstitution,
     every: () => every,
     expandPreOrPostfixIncrementOrDecrementExpression: () => expandPreOrPostfixIncrementOrDecrementExpression,
     explainFiles: () => explainFiles,

package/lib/typingsInstaller.js

@@ -54,7 +54,7 @@ var path = __toESM(require("path"));
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231128`;
+var version = `${versionMajorMinor}.0-dev.20231130`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -24510,18 +24510,7 @@ var Parser;
         }
         nextTokenJSDoc();
         skipWhitespace();
-        const p2 = getNodePos();
-        let name = tokenIsIdentifierOrKeyword(token()) ? parseEntityName(
-          /*allowReservedWords*/
-          true
-        ) : void 0;
-        if (name) {
-          while (token() === 81 /* PrivateIdentifier */) {
-            reScanHashToken();
-            nextTokenJSDoc();
-            name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), p2);
-          }
-        }
+        const name = parseJSDocLinkName();
         const text = [];
         while (token() !== 20 /* CloseBraceToken */ && token() !== 4 /* NewLineTrivia */ && token() !== 1 /* EndOfFileToken */) {
           text.push(scanner.getTokenText());
@@ -24530,6 +24519,26 @@ var Parser;
         const create = linkType === "link" ? factory2.createJSDocLink : linkType === "linkcode" ? factory2.createJSDocLinkCode : factory2.createJSDocLinkPlain;
         return finishNode(create(name, text.join("")), start2, scanner.getTokenEnd());
       }
+      function parseJSDocLinkName() {
+        if (tokenIsIdentifierOrKeyword(token())) {
+          const pos = getNodePos();
+          let name = parseIdentifierName();
+          while (parseOptional(25 /* DotToken */)) {
+            name = finishNode(factory2.createQualifiedName(name, token() === 81 /* PrivateIdentifier */ ? createMissingNode(
+              80 /* Identifier */,
+              /*reportAtCurrentPosition*/
+              false
+            ) : parseIdentifier()), pos);
+          }
+          while (token() === 81 /* PrivateIdentifier */) {
+            reScanHashToken();
+            nextTokenJSDoc();
+            name = finishNode(factory2.createJSDocMemberName(name, parseIdentifier()), pos);
+          }
+          return name;
+        }
+        return void 0;
+      }
       function parseJSDocLinkPrefix() {
         skipWhitespaceOrAsterisk();
         if (token() === 19 /* OpenBraceToken */ && nextTokenJSDoc() === 60 /* AtToken */ && tokenIsIdentifierOrKeyword(nextTokenJSDoc())) {
@@ -25697,7 +25706,7 @@ var libEntries = [
   ["esnext.disposable", "lib.esnext.disposable.d.ts"],
   ["esnext.bigint", "lib.es2020.bigint.d.ts"],
   ["esnext.string", "lib.es2022.string.d.ts"],
-  ["esnext.promise", "lib.es2021.promise.d.ts"],
+  ["esnext.promise", "lib.esnext.promise.d.ts"],
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
   ["decorators", "lib.decorators.d.ts"],

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "5.4.0-dev.20231128",
+    "version": "5.4.0-dev.20231130",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -114,5 +114,5 @@
         "node": "20.1.0",
         "npm": "8.19.4"
     },
-    "gitHead": "b6121e400cf8636760aa8a7da6b7fac14e2e70c7"
+    "gitHead": "7216ee0bb821b4b565d54c52dcbf788a3fdf7062"
 }