typescript 5.6.0-dev.20240805 → 5.6.0-dev.20240807

package/lib/lib.webworker.asynciterable.d.ts

@@ -20,14 +20,22 @@ and limitations under the License.
 /// Worker Async Iterable APIs
 /////////////////////////////
 
+interface FileSystemDirectoryHandleAsyncIterator<T> extends AsyncIteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<T>;
+}
+
 interface FileSystemDirectoryHandle {
-    [Symbol.asyncIterator](): BuiltinAsyncIterator<[string, FileSystemHandle], BuiltinIteratorReturn>;
-    entries(): BuiltinAsyncIterator<[string, FileSystemHandle], BuiltinIteratorReturn>;
-    keys(): BuiltinAsyncIterator<string, BuiltinIteratorReturn>;
-    values(): BuiltinAsyncIterator<FileSystemHandle, BuiltinIteratorReturn>;
+    [Symbol.asyncIterator](): FileSystemDirectoryHandleAsyncIterator<[string, FileSystemHandle]>;
+    entries(): FileSystemDirectoryHandleAsyncIterator<[string, FileSystemHandle]>;
+    keys(): FileSystemDirectoryHandleAsyncIterator<string>;
+    values(): FileSystemDirectoryHandleAsyncIterator<FileSystemHandle>;
+}
+
+interface ReadableStreamAsyncIterator<T> extends AsyncIteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.asyncIterator](): ReadableStreamAsyncIterator<T>;
 }
 
 interface ReadableStream<R = any> {
-    [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): BuiltinAsyncIterator<R, BuiltinIteratorReturn>;
-    values(options?: ReadableStreamIteratorOptions): BuiltinAsyncIterator<R, BuiltinIteratorReturn>;
+    [Symbol.asyncIterator](options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
+    values(options?: ReadableStreamIteratorOptions): ReadableStreamAsyncIterator<R>;
 }

package/lib/lib.webworker.iterable.d.ts

@@ -26,24 +26,24 @@ interface AbortSignal {
 }
 
 interface CSSNumericArray {
-    [Symbol.iterator](): BuiltinIterator<CSSNumericValue, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSNumericValue], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSNumericValue, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSNumericValue>;
+    entries(): ArrayIterator<[number, CSSNumericValue]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSNumericValue>;
 }
 
 interface CSSTransformValue {
-    [Symbol.iterator](): BuiltinIterator<CSSTransformComponent, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSTransformComponent], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSTransformComponent, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSTransformComponent>;
+    entries(): ArrayIterator<[number, CSSTransformComponent]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSTransformComponent>;
 }
 
 interface CSSUnparsedValue {
-    [Symbol.iterator](): BuiltinIterator<CSSUnparsedSegment, BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[number, CSSUnparsedSegment], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<number, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<CSSUnparsedSegment, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<CSSUnparsedSegment>;
+    entries(): ArrayIterator<[number, CSSUnparsedSegment]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<CSSUnparsedSegment>;
 }
 
 interface Cache {
@@ -62,34 +62,42 @@ interface CanvasPathDrawingStyles {
 }
 
 interface DOMStringList {
-    [Symbol.iterator](): BuiltinIterator<string, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<string>;
 }
 
 interface FileList {
-    [Symbol.iterator](): BuiltinIterator<File, BuiltinIteratorReturn>;
+    [Symbol.iterator](): ArrayIterator<File>;
 }
 
 interface FontFaceSet extends Set<FontFace> {
 }
 
+interface FormDataIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): FormDataIterator<T>;
+}
+
 interface FormData {
-    [Symbol.iterator](): BuiltinIterator<[string, FormDataEntryValue], BuiltinIteratorReturn>;
+    [Symbol.iterator](): FormDataIterator<[string, FormDataEntryValue]>;
     /** Returns an array of key, value pairs for every entry in the list. */
-    entries(): BuiltinIterator<[string, FormDataEntryValue], BuiltinIteratorReturn>;
+    entries(): FormDataIterator<[string, FormDataEntryValue]>;
     /** Returns a list of keys in the list. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): FormDataIterator<string>;
     /** Returns a list of values in the list. */
-    values(): BuiltinIterator<FormDataEntryValue, BuiltinIteratorReturn>;
+    values(): FormDataIterator<FormDataEntryValue>;
+}
+
+interface HeadersIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): HeadersIterator<T>;
 }
 
 interface Headers {
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): HeadersIterator<[string, string]>;
     /** Returns an iterator allowing to go through all key/value pairs contained in this object. */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): HeadersIterator<[string, string]>;
     /** Returns an iterator allowing to go through all keys of the key/value pairs contained in this object. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): HeadersIterator<string>;
     /** Returns an iterator allowing to go through all values of the key/value pairs contained in this object. */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): HeadersIterator<string>;
 }
 
 interface IDBDatabase {
@@ -117,11 +125,15 @@ interface MessageEvent<T = any> {
     initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: Iterable<MessagePort>): void;
 }
 
+interface StylePropertyMapReadOnlyIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): StylePropertyMapReadOnlyIterator<T>;
+}
+
 interface StylePropertyMapReadOnly {
-    [Symbol.iterator](): BuiltinIterator<[string, Iterable<CSSStyleValue>], BuiltinIteratorReturn>;
-    entries(): BuiltinIterator<[string, Iterable<CSSStyleValue>], BuiltinIteratorReturn>;
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
-    values(): BuiltinIterator<Iterable<CSSStyleValue>, BuiltinIteratorReturn>;
+    [Symbol.iterator](): StylePropertyMapReadOnlyIterator<[string, Iterable<CSSStyleValue>]>;
+    entries(): StylePropertyMapReadOnlyIterator<[string, Iterable<CSSStyleValue>]>;
+    keys(): StylePropertyMapReadOnlyIterator<string>;
+    values(): StylePropertyMapReadOnlyIterator<Iterable<CSSStyleValue>>;
 }
 
 interface SubtleCrypto {
@@ -139,14 +151,18 @@ interface SubtleCrypto {
     unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier | RsaOaepParams | AesCtrParams | AesCbcParams | AesGcmParams, unwrappedKeyAlgorithm: AlgorithmIdentifier | RsaHashedImportParams | EcKeyImportParams | HmacImportParams | AesKeyAlgorithm, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<CryptoKey>;
 }
 
+interface URLSearchParamsIterator<T> extends IteratorObject<T, BuiltinIteratorReturn, unknown> {
+    [Symbol.iterator](): URLSearchParamsIterator<T>;
+}
+
 interface URLSearchParams {
-    [Symbol.iterator](): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    [Symbol.iterator](): URLSearchParamsIterator<[string, string]>;
     /** Returns an array of key, value pairs for every entry in the search params. */
-    entries(): BuiltinIterator<[string, string], BuiltinIteratorReturn>;
+    entries(): URLSearchParamsIterator<[string, string]>;
     /** Returns a list of keys in the search params. */
-    keys(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    keys(): URLSearchParamsIterator<string>;
     /** Returns a list of values in the search params. */
-    values(): BuiltinIterator<string, BuiltinIteratorReturn>;
+    values(): URLSearchParamsIterator<string>;
 }
 
 interface WEBGL_draw_buffers {

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.6";
-var version = `${versionMajorMinor}.0-dev.20240805`;
+var version = `${versionMajorMinor}.0-dev.20240807`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -15313,7 +15313,7 @@ function skipTypeParentheses(node) {
   return node;
 }
 function skipParentheses(node, excludeJSDocTypeAssertions) {
-  const flags = excludeJSDocTypeAssertions ? 1 /* Parentheses */ | 16 /* ExcludeJSDocTypeAssertion */ : 1 /* Parentheses */;
+  const flags = excludeJSDocTypeAssertions ? 1 /* Parentheses */ | -2147483648 /* ExcludeJSDocTypeAssertion */ : 1 /* Parentheses */;
   return skipOuterExpressions(node, flags);
 }
 function isDeleteTarget(node) {
@@ -23897,6 +23897,8 @@ function createNodeFactory(flags, baseFactory2) {
         return updateSatisfiesExpression(outerExpression, expression, outerExpression.type);
       case 235 /* NonNullExpression */:
         return updateNonNullExpression(outerExpression, expression);
+      case 233 /* ExpressionWithTypeArguments */:
+        return updateExpressionWithTypeArguments(outerExpression, expression, outerExpression.typeArguments);
       case 354 /* PartiallyEmittedExpression */:
         return updatePartiallyEmittedExpression(outerExpression, expression);
     }
@@ -23904,7 +23906,7 @@ function createNodeFactory(flags, baseFactory2) {
   function isIgnorableParen(node) {
     return isParenthesizedExpression(node) && nodeIsSynthesized(node) && nodeIsSynthesized(getSourceMapRange(node)) && nodeIsSynthesized(getCommentRange(node)) && !some(getSyntheticLeadingComments(node)) && !some(getSyntheticTrailingComments(node));
   }
-  function restoreOuterExpressions(outerExpression, innerExpression, kinds = 15 /* All */) {
+  function restoreOuterExpressions(outerExpression, innerExpression, kinds = 31 /* All */) {
     if (outerExpression && isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) {
       return updateOuterExpression(
         outerExpression,
@@ -23950,7 +23952,7 @@ function createNodeFactory(flags, baseFactory2) {
     }
   }
   function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers = false) {
-    const callee = skipOuterExpressions(expression, 15 /* All */);
+    const callee = skipOuterExpressions(expression, 31 /* All */);
     let thisArg;
     let target;
     if (isSuperProperty(callee)) {
@@ -26781,18 +26783,19 @@ function getJSDocTypeAssertionType(node) {
   Debug.assertIsDefined(type);
   return type;
 }
-function isOuterExpression(node, kinds = 15 /* All */) {
+function isOuterExpression(node, kinds = 31 /* All */) {
   switch (node.kind) {
     case 217 /* ParenthesizedExpression */:
-      if (kinds & 16 /* ExcludeJSDocTypeAssertion */ && isJSDocTypeAssertion(node)) {
+      if (kinds & -2147483648 /* ExcludeJSDocTypeAssertion */ && isJSDocTypeAssertion(node)) {
         return false;
       }
       return (kinds & 1 /* Parentheses */) !== 0;
     case 216 /* TypeAssertionExpression */:
     case 234 /* AsExpression */:
-    case 233 /* ExpressionWithTypeArguments */:
     case 238 /* SatisfiesExpression */:
       return (kinds & 2 /* TypeAssertions */) !== 0;
+    case 233 /* ExpressionWithTypeArguments */:
+      return (kinds & 16 /* ExpressionsWithTypeArguments */) !== 0;
     case 235 /* NonNullExpression */:
       return (kinds & 4 /* NonNullAssertions */) !== 0;
     case 354 /* PartiallyEmittedExpression */:
@@ -26800,13 +26803,13 @@ function isOuterExpression(node, kinds = 15 /* All */) {
   }
   return false;
 }
-function skipOuterExpressions(node, kinds = 15 /* All */) {
+function skipOuterExpressions(node, kinds = 31 /* All */) {
   while (isOuterExpression(node, kinds)) {
     node = node.expression;
   }
   return node;
 }
-function walkUpOuterExpressions(node, kinds = 15 /* All */) {
+function walkUpOuterExpressions(node, kinds = 31 /* All */) {
   let parent = node.parent;
   while (isOuterExpression(parent, kinds)) {
     parent = parent.parent;
@@ -46161,8 +46164,9 @@ function createTypeChecker(host) {
     getGlobalIteratorType: getGlobalAsyncIteratorType,
     getGlobalIterableType: getGlobalAsyncIterableType,
     getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType,
-    getGlobalBuiltinIteratorType: getGlobalBuiltinAsyncIteratorType,
+    getGlobalIteratorObjectType: getGlobalAsyncIteratorObjectType,
     getGlobalGeneratorType: getGlobalAsyncGeneratorType,
+    getGlobalBuiltinIteratorTypes: getGlobalBuiltinAsyncIteratorTypes,
     resolveIterationType: (type, errorNode) => getAwaitedType(type, errorNode, Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member),
     mustHaveANextMethodDiagnostic: Diagnostics.An_async_iterator_must_have_a_next_method,
     mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method,
@@ -46175,8 +46179,9 @@ function createTypeChecker(host) {
     getGlobalIteratorType,
     getGlobalIterableType,
     getGlobalIterableIteratorType,
-    getGlobalBuiltinIteratorType,
+    getGlobalIteratorObjectType,
     getGlobalGeneratorType,
+    getGlobalBuiltinIteratorTypes,
     resolveIterationType: (type, _errorNode) => type,
     mustHaveANextMethodDiagnostic: Diagnostics.An_iterator_must_have_a_next_method,
     mustBeAMethodDiagnostic: Diagnostics.The_0_property_of_an_iterator_must_be_a_method,
@@ -46214,14 +46219,16 @@ function createTypeChecker(host) {
   var deferredGlobalIterableType;
   var deferredGlobalIteratorType;
   var deferredGlobalIterableIteratorType;
-  var deferredGlobalBuiltinIteratorType;
+  var deferredGlobalIteratorObjectType;
   var deferredGlobalGeneratorType;
   var deferredGlobalIteratorYieldResultType;
   var deferredGlobalIteratorReturnResultType;
   var deferredGlobalAsyncIterableType;
   var deferredGlobalAsyncIteratorType;
   var deferredGlobalAsyncIterableIteratorType;
-  var deferredGlobalBuiltinAsyncIteratorType;
+  var deferredGlobalBuiltinIteratorTypes;
+  var deferredGlobalBuiltinAsyncIteratorTypes;
+  var deferredGlobalAsyncIteratorObjectType;
   var deferredGlobalAsyncGeneratorType;
   var deferredGlobalTemplateStringsArrayType;
   var deferredGlobalImportMetaType;
@@ -55304,6 +55311,17 @@ function createTypeChecker(host) {
   function getNonMissingTypeOfSymbol(symbol) {
     return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & 16777216 /* Optional */));
   }
+  function isReferenceToSomeType(type, targets) {
+    if (type === void 0 || (getObjectFlags(type) & 4 /* Reference */) === 0) {
+      return false;
+    }
+    for (const target of targets) {
+      if (type.target === target) {
+        return true;
+      }
+    }
+    return false;
+  }
   function isReferenceToType(type, target) {
     return type !== void 0 && target !== void 0 && (getObjectFlags(type) & 4 /* Reference */) !== 0 && type.target === target;
   }
@@ -55726,7 +55744,7 @@ function createTypeChecker(host) {
           links.instantiations.set(getTypeListId(typeParameters), type);
         }
         if (type === intrinsicMarkerType && symbol.escapedName === "BuiltinIteratorReturn") {
-          type = strictBuiltinIteratorReturn ? undefinedType : anyType;
+          type = getBuiltinIteratorReturnType();
         }
       } else {
         type = errorType;
@@ -58903,6 +58921,18 @@ function createTypeChecker(host) {
     const symbol = getGlobalTypeSymbol(name, reportErrors2);
     return symbol || reportErrors2 ? getTypeOfGlobalSymbol(symbol, arity) : void 0;
   }
+  function getGlobalBuiltinTypes(typeNames, arity) {
+    let types;
+    for (const typeName of typeNames) {
+      types = append(types, getGlobalType(
+        typeName,
+        arity,
+        /*reportErrors*/
+        false
+      ));
+    }
+    return types ?? emptyArray;
+  }
   function getGlobalTypedPropertyDescriptorType() {
     return deferredGlobalTypedPropertyDescriptorType || (deferredGlobalTypedPropertyDescriptorType = getGlobalType(
       "TypedPropertyDescriptor",
@@ -59025,9 +59055,12 @@ function createTypeChecker(host) {
       reportErrors2
     )) || emptyGenericType;
   }
-  function getGlobalBuiltinAsyncIteratorType(reportErrors2) {
-    return deferredGlobalBuiltinAsyncIteratorType || (deferredGlobalBuiltinAsyncIteratorType = getGlobalType(
-      "BuiltinAsyncIterator",
+  function getGlobalBuiltinAsyncIteratorTypes() {
+    return deferredGlobalBuiltinAsyncIteratorTypes ?? (deferredGlobalBuiltinAsyncIteratorTypes = getGlobalBuiltinTypes(["ReadableStreamAsyncIterator"], 1));
+  }
+  function getGlobalAsyncIteratorObjectType(reportErrors2) {
+    return deferredGlobalAsyncIteratorObjectType || (deferredGlobalAsyncIteratorObjectType = getGlobalType(
+      "AsyncIteratorObject",
       /*arity*/
       3,
       reportErrors2
@@ -59065,9 +59098,15 @@ function createTypeChecker(host) {
       reportErrors2
     )) || emptyGenericType;
   }
-  function getGlobalBuiltinIteratorType(reportErrors2) {
-    return deferredGlobalBuiltinIteratorType || (deferredGlobalBuiltinIteratorType = getGlobalType(
-      "BuiltinIterator",
+  function getBuiltinIteratorReturnType() {
+    return strictBuiltinIteratorReturn ? undefinedType : anyType;
+  }
+  function getGlobalBuiltinIteratorTypes() {
+    return deferredGlobalBuiltinIteratorTypes ?? (deferredGlobalBuiltinIteratorTypes = getGlobalBuiltinTypes(["ArrayIterator", "MapIterator", "SetIterator", "StringIterator"], 1));
+  }
+  function getGlobalIteratorObjectType(reportErrors2) {
+    return deferredGlobalIteratorObjectType || (deferredGlobalIteratorObjectType = getGlobalType(
+      "IteratorObject",
       /*arity*/
       3,
       reportErrors2
@@ -77830,7 +77869,7 @@ function createTypeChecker(host) {
       if (isBinaryExpression(right) && (right.operatorToken.kind === 57 /* BarBarToken */ || right.operatorToken.kind === 56 /* AmpersandAmpersandToken */)) {
         grammarErrorOnNode(right, Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, tokenToString(right.operatorToken.kind), tokenToString(operatorToken.kind));
       }
-      const leftTarget = skipOuterExpressions(left, 15 /* All */);
+      const leftTarget = skipOuterExpressions(left, 31 /* All */);
       const nullishSemantics = getSyntacticNullishnessSemantics(leftTarget);
       if (nullishSemantics !== 3 /* Sometimes */) {
         if (node.parent.kind === 226 /* BinaryExpression */) {
@@ -81934,7 +81973,7 @@ function createTypeChecker(host) {
     if (isReferenceToType(type, resolver.getGlobalIterableType(
       /*reportErrors*/
       false
-    )) || isReferenceToType(type, resolver.getGlobalBuiltinIteratorType(
+    )) || isReferenceToType(type, resolver.getGlobalIteratorObjectType(
       /*reportErrors*/
       false
     )) || isReferenceToType(type, resolver.getGlobalIterableIteratorType(
@@ -81955,6 +81994,20 @@ function createTypeChecker(host) {
         void 0
       ) || returnType, nextType));
     }
+    if (isReferenceToSomeType(type, resolver.getGlobalBuiltinIteratorTypes())) {
+      const [yieldType] = getTypeArguments(type);
+      const returnType = getBuiltinIteratorReturnType();
+      const nextType = unknownType;
+      return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(
+        yieldType,
+        /*errorNode*/
+        void 0
+      ) || yieldType, resolver.resolveIterationType(
+        returnType,
+        /*errorNode*/
+        void 0
+      ) || returnType, nextType));
+    }
   }
   function getPropertyNameForKnownSymbolName(symbolName2) {
     const ctorType = getGlobalESSymbolConstructorSymbol(
@@ -82018,13 +82071,13 @@ function createTypeChecker(host) {
     return getCachedIterationTypes(type, resolver.iteratorCacheKey);
   }
   function getIterationTypesOfIteratorFast(type, resolver) {
-    if (isReferenceToType(type, resolver.getGlobalBuiltinIteratorType(
+    if (isReferenceToType(type, resolver.getGlobalIterableIteratorType(
       /*reportErrors*/
       false
-    )) || isReferenceToType(type, resolver.getGlobalIterableIteratorType(
+    )) || isReferenceToType(type, resolver.getGlobalIteratorType(
       /*reportErrors*/
       false
-    )) || isReferenceToType(type, resolver.getGlobalIteratorType(
+    )) || isReferenceToType(type, resolver.getGlobalIteratorObjectType(
       /*reportErrors*/
       false
     )) || isReferenceToType(type, resolver.getGlobalGeneratorType(
@@ -82034,6 +82087,12 @@ function createTypeChecker(host) {
       const [yieldType, returnType, nextType] = getTypeArguments(type);
       return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
     }
+    if (isReferenceToSomeType(type, resolver.getGlobalBuiltinIteratorTypes())) {
+      const [yieldType] = getTypeArguments(type);
+      const returnType = getBuiltinIteratorReturnType();
+      const nextType = unknownType;
+      return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType));
+    }
   }
   function isIteratorResult(type, kind) {
     const doneType = getTypeOfPropertyOfType(type, "done") || falseType;
@@ -92206,7 +92265,7 @@ function transformTypeScript(context) {
     return updated;
   }
   function visitParenthesizedExpression(node) {
-    const innerExpression = skipOuterExpressions(node.expression, ~6 /* Assertions */);
+    const innerExpression = skipOuterExpressions(node.expression, ~(6 /* Assertions */ | 16 /* ExpressionsWithTypeArguments */));
     if (isAssertionExpression(innerExpression) || isSatisfiesExpression(innerExpression)) {
       const expression = visitNode(node.expression, visitor, isExpression);
       Debug.assert(expression);

package/lib/typescript.d.ts

@@ -7346,9 +7346,10 @@ declare namespace ts {
         TypeAssertions = 2,
         NonNullAssertions = 4,
         PartiallyEmittedExpressions = 8,
+        ExpressionsWithTypeArguments = 16,
         Assertions = 6,
-        All = 15,
-        ExcludeJSDocTypeAssertion = 16,
+        All = 31,
+        ExcludeJSDocTypeAssertion = -2147483648,
     }
     type ImmediatelyInvokedFunctionExpression = CallExpression & {
         readonly expression: FunctionExpression;