@typescript-deploys/pr-build 5.0.0-pr-49226-5 → 5.1.0-pr-53034-6

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

@@ -22,8 +22,8 @@ var __export = (target, all) => {
 };
 
 // src/compiler/corePublic.ts
-var versionMajorMinor = "5.0";
-var version = `${versionMajorMinor}.0-insiders.20230225`;
+var versionMajorMinor = "5.1";
+var version = `${versionMajorMinor}.0-insiders.20230228`;
 
 // 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;
@@ -45908,6 +45905,10 @@ function createTypeChecker(host) {
         return;
       merged.exports.set(name, merged.exports.has(name) ? mergeSymbol(merged.exports.get(name), s) : s);
     });
+    if (merged === exported) {
+      getSymbolLinks(merged).resolvedExports = void 0;
+      getSymbolLinks(merged).resolvedMembers = void 0;
+    }
     getSymbolLinks(merged).cjsExportMerged = merged;
     return links.cjsExportMerged = merged;
   }
@@ -47794,7 +47795,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) {
@@ -49361,7 +49362,8 @@ function createTypeChecker(host) {
         ), modifierFlags);
       }
       function getNamespaceMembersForSerialization(symbol) {
-        return !symbol.exports ? [] : filter(arrayFrom(symbol.exports.values()), isNamespaceMember);
+        const exports = getExportsOfSymbol(symbol);
+        return !exports ? [] : filter(arrayFrom(exports.values()), (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
       }
       function isTypeOnlyNamespace(symbol) {
         return every(getNamespaceMembersForSerialization(symbol), (m) => !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
@@ -60075,7 +60077,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,
@@ -61657,7 +61659,7 @@ function createTypeChecker(host) {
         return type.symbol;
       }
       if (isTupleType(type)) {
-        return type;
+        return type.target;
       }
     }
     if (type.flags & 262144 /* TypeParameter */) {
@@ -85279,6 +85281,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 +85293,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 +85363,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 +85393,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 +85415,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 +88871,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 +88960,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 +89413,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 +89447,7 @@ function isPrivateIdentifierInExpression(node) {
 // src/compiler/transformers/typeSerializer.ts
 function createRuntimeTypeSerializer(context) {
   const {
+    factory: factory2,
     hoistVariableDeclaration
   } = context;
   const resolver = context.getEmitResolver();
@@ -89480,9 +89487,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 +89510,7 @@ function createRuntimeTypeSerializer(context) {
         }
       }
     }
-    return factory.createArrayLiteralExpression(expressions);
+    return factory2.createArrayLiteralExpression(expressions);
   }
   function getParametersOfDecoratedDeclaration(node, container) {
     if (container && node.kind === 174 /* GetAccessor */) {
@@ -89518,39 +89525,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 +89609,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 +89627,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 +89645,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 +89665,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 +89705,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 +89759,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 +89780,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);
   }
 }
 
@@ -103832,7 +103839,7 @@ function transformNodeModule(context) {
 
 // src/compiler/transformers/declarations/diagnostics.ts
 function canProduceDiagnostics(node) {
-  return isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isBindingElement(node) || isSetAccessor(node) || isGetAccessor(node) || isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isParameter(node) || isTypeParameterDeclaration(node) || isExpressionWithTypeArguments(node) || isImportEqualsDeclaration(node) || isTypeAliasDeclaration(node) || isConstructorDeclaration(node) || isIndexSignatureDeclaration(node) || isPropertyAccessExpression(node) || isJSDocTypeAlias(node);
+  return isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isBindingElement(node) || isSetAccessor(node) || isGetAccessor(node) || isConstructSignatureDeclaration(node) || isCallSignatureDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isFunctionDeclaration(node) || isParameter(node) || isTypeParameterDeclaration(node) || isExpressionWithTypeArguments(node) || isImportEqualsDeclaration(node) || isTypeAliasDeclaration(node) || isConstructorDeclaration(node) || isIndexSignatureDeclaration(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node) || isBinaryExpression(node) || isJSDocTypeAlias(node);
 }
 function createGetSymbolAccessibilityDiagnosticForNodeName(node) {
   if (isSetAccessor(node) || isGetAccessor(node)) {
@@ -103878,7 +103885,7 @@ function createGetSymbolAccessibilityDiagnosticForNodeName(node) {
   }
 }
 function createGetSymbolAccessibilityDiagnosticForNode(node) {
-  if (isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isPropertyAccessExpression(node) || isBindingElement(node) || isConstructorDeclaration(node)) {
+  if (isVariableDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node) || isBinaryExpression(node) || isBindingElement(node) || isConstructorDeclaration(node)) {
     return getVariableDeclarationTypeVisibilityError;
   } else if (isSetAccessor(node) || isGetAccessor(node)) {
     return getAccessorDeclarationTypeVisibilityError;
@@ -103903,7 +103910,7 @@ function createGetSymbolAccessibilityDiagnosticForNode(node) {
   function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) {
     if (node.kind === 257 /* VariableDeclaration */ || node.kind === 205 /* BindingElement */) {
       return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Exported_variable_0_has_or_is_using_private_name_1;
-    } else if (node.kind === 169 /* PropertyDeclaration */ || node.kind === 208 /* PropertyAccessExpression */ || node.kind === 168 /* PropertySignature */ || node.kind === 166 /* Parameter */ && hasSyntacticModifier(node.parent, 8 /* Private */)) {
+    } else if (node.kind === 169 /* PropertyDeclaration */ || node.kind === 208 /* PropertyAccessExpression */ || node.kind === 209 /* ElementAccessExpression */ || node.kind === 223 /* BinaryExpression */ || node.kind === 168 /* PropertySignature */ || node.kind === 166 /* Parameter */ && hasSyntacticModifier(node.parent, 8 /* Private */)) {
       if (isStatic(node)) {
         return symbolAccessibilityResult.errorModuleName ? symbolAccessibilityResult.accessibility === 2 /* CannotBeNamed */ ? Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1;
       } else if (node.parent.kind === 260 /* ClassDeclaration */ || node.kind === 166 /* Parameter */) {
@@ -104618,7 +104625,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,
@@ -105356,13 +105363,16 @@ function transformDeclarations(context) {
           fakespace.symbol = props[0].parent;
           const exportMappings = [];
           let declarations = mapDefined(props, (p) => {
-            if (!p.valueDeclaration || !isPropertyAccessExpression(p.valueDeclaration)) {
+            if (!p.valueDeclaration || !(isPropertyAccessExpression(p.valueDeclaration) || isElementAccessExpression(p.valueDeclaration) || isBinaryExpression(p.valueDeclaration))) {
+              return void 0;
+            }
+            const nameStr = unescapeLeadingUnderscores(p.escapedName);
+            if (!isIdentifierText(nameStr, 99 /* ESNext */)) {
               return void 0;
             }
             getSymbolAccessibilityDiagnostic = createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration);
             const type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace, declarationEmitNodeBuilderFlags, symbolTracker);
             getSymbolAccessibilityDiagnostic = oldDiag;
-            const nameStr = unescapeLeadingUnderscores(p.escapedName);
             const isNonContextualKeywordName = isStringANonContextualKeyword(nameStr);
             const name = isNonContextualKeywordName ? factory2.getGeneratedNameForNode(p.valueDeclaration) : factory2.createIdentifier(nameStr);
             if (isNonContextualKeywordName) {
@@ -105732,8 +105742,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;
@@ -115341,7 +115351,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     const version2 = typeScriptVersion2 || 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);