@typescript-deploys/pr-build 5.4.0-pr-56805-4 → 5.4.0-pr-56794-34

package/lib/lib.es5.d.ts

@@ -1666,6 +1666,11 @@ type Capitalize<S extends string> = intrinsic;
  */
 type Uncapitalize<S extends string> = intrinsic;
 
+/**
+ * Marker for non-inference type position
+ */
+type NoInfer<T> = intrinsic;
+
 /**
  * Marker for contextual 'this' type
  */

package/lib/lib.esnext.d.ts

@@ -21,5 +21,3 @@ and limitations under the License.
 /// <reference lib="esnext.decorators" />
 /// <reference lib="esnext.disposable" />
 /// <reference lib="esnext.promise" />
-/// <reference lib="esnext.object" />
-/// <reference lib="esnext.collection" />

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-insiders.20231218`;
+var version = `${versionMajorMinor}.0-insiders.20231220`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -34047,7 +34047,7 @@ var libEntries = [
   ["es2023.array", "lib.es2023.array.d.ts"],
   ["es2023.collection", "lib.es2023.collection.d.ts"],
   ["esnext.array", "lib.es2023.array.d.ts"],
-  ["esnext.collection", "lib.esnext.collection.d.ts"],
+  ["esnext.collection", "lib.es2023.collection.d.ts"],
   ["esnext.symbol", "lib.es2019.symbol.d.ts"],
   ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
   ["esnext.intl", "lib.esnext.intl.d.ts"],
@@ -34057,7 +34057,6 @@ var libEntries = [
   ["esnext.promise", "lib.esnext.promise.d.ts"],
   ["esnext.weakref", "lib.es2021.weakref.d.ts"],
   ["esnext.decorators", "lib.esnext.decorators.d.ts"],
-  ["esnext.object", "lib.esnext.object.d.ts"],
   ["decorators", "lib.decorators.d.ts"],
   ["decorators.legacy", "lib.decorators.legacy.d.ts"]
 ];
@@ -42973,10 +42972,10 @@ function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, hos
     return ending !== 0 /* Minimal */ || value === processEnding(relativeToBaseUrl, [ending], compilerOptions, host);
   }
 }
-function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, exports, conditions, mode = 0 /* Exact */) {
-  if (typeof exports === "string") {
+function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, exports2, conditions, mode = 0 /* Exact */) {
+  if (typeof exports2 === "string") {
     const pathOrPattern = getNormalizedAbsolutePath(
-      combinePaths(packageDirectory, exports),
+      combinePaths(packageDirectory, exports2),
       /*currentDirectory*/
       void 0
     );
@@ -42996,7 +42995,7 @@ function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory,
             false
           );
           return { moduleFileToTry: getNormalizedAbsolutePath(
-            combinePaths(combinePaths(packageName, exports), fragment),
+            combinePaths(combinePaths(packageName, exports2), fragment),
             /*currentDirectory*/
             void 0
           ) };
@@ -43016,23 +43015,23 @@ function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory,
         }
         break;
     }
-  } else if (Array.isArray(exports)) {
-    return forEach(exports, (e) => tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, e, conditions));
-  } else if (typeof exports === "object" && exports !== null) {
-    if (allKeysStartWithDot(exports)) {
-      return forEach(getOwnKeys(exports), (k) => {
+  } else if (Array.isArray(exports2)) {
+    return forEach(exports2, (e) => tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, e, conditions));
+  } else if (typeof exports2 === "object" && exports2 !== null) {
+    if (allKeysStartWithDot(exports2)) {
+      return forEach(getOwnKeys(exports2), (k) => {
         const subPackageName = getNormalizedAbsolutePath(
           combinePaths(packageName, k),
           /*currentDirectory*/
           void 0
         );
         const mode2 = endsWith(k, "/") ? 1 /* Directory */ : k.includes("*") ? 2 /* Pattern */ : 0 /* Exact */;
-        return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, subPackageName, exports[k], conditions, mode2);
+        return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, subPackageName, exports2[k], conditions, mode2);
       });
     } else {
-      for (const key of getOwnKeys(exports)) {
+      for (const key of getOwnKeys(exports2)) {
         if (key === "default" || conditions.includes(key) || isApplicableVersionedTypesKey(conditions, key)) {
-          const subTarget = exports[key];
+          const subTarget = exports2[key];
           const result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions, mode);
           if (result) {
             return result;
@@ -43393,7 +43392,8 @@ var intrinsicTypeKinds = new Map(Object.entries({
   Uppercase: 0 /* Uppercase */,
   Lowercase: 1 /* Lowercase */,
   Capitalize: 2 /* Capitalize */,
-  Uncapitalize: 3 /* Uncapitalize */
+  Uncapitalize: 3 /* Uncapitalize */,
+  NoInfer: 4 /* NoInfer */
 }));
 var SymbolLinks = class {
 };
@@ -46124,13 +46124,13 @@ function createTypeChecker(host) {
   function reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName) {
     var _a, _b;
     const localSymbol = (_b = (_a = tryCast(moduleSymbol.valueDeclaration, canHaveLocals)) == null ? void 0 : _a.locals) == null ? void 0 : _b.get(name.escapedText);
-    const exports = moduleSymbol.exports;
+    const exports2 = moduleSymbol.exports;
     if (localSymbol) {
-      const exportedEqualsSymbol = exports == null ? void 0 : exports.get("export=" /* ExportEquals */);
+      const exportedEqualsSymbol = exports2 == null ? void 0 : exports2.get("export=" /* ExportEquals */);
       if (exportedEqualsSymbol) {
         getSymbolIfSameReference(exportedEqualsSymbol, localSymbol) ? reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) : error(name, Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName);
       } else {
-        const exportedSymbol = exports ? find(symbolsToArray(exports), (symbol) => !!getSymbolIfSameReference(symbol, localSymbol)) : void 0;
+        const exportedSymbol = exports2 ? find(symbolsToArray(exports2), (symbol) => !!getSymbolIfSameReference(symbol, localSymbol)) : void 0;
         const diagnostic = exportedSymbol ? error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) : error(name, Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName);
         if (localSymbol.declarations) {
           addRelatedInfo(diagnostic, ...map(localSymbol.declarations, (decl, index) => createDiagnosticForNode(decl, index === 0 ? Diagnostics._0_is_declared_here : Diagnostics.and_here, declarationName)));
@@ -46994,19 +46994,19 @@ function createTypeChecker(host) {
     return symbolsToArray(getExportsOfModule(moduleSymbol));
   }
   function getExportsAndPropertiesOfModule(moduleSymbol) {
-    const exports = getExportsOfModuleAsArray(moduleSymbol);
+    const exports2 = getExportsOfModuleAsArray(moduleSymbol);
     const exportEquals = resolveExternalModuleSymbol(moduleSymbol);
     if (exportEquals !== moduleSymbol) {
       const type = getTypeOfSymbol(exportEquals);
       if (shouldTreatPropertiesOfExternalModuleAsExports(type)) {
-        addRange(exports, getPropertiesOfType(type));
+        addRange(exports2, getPropertiesOfType(type));
       }
     }
-    return exports;
+    return exports2;
   }
   function forEachExportAndPropertyOfModule(moduleSymbol, cb) {
-    const exports = getExportsOfModule(moduleSymbol);
-    exports.forEach((symbol, key) => {
+    const exports2 = getExportsOfModule(moduleSymbol);
+    exports2.forEach((symbol, key) => {
       if (!isReservedMemberName(key)) {
         cb(symbol, key);
       }
@@ -47049,8 +47049,8 @@ function createTypeChecker(host) {
   function getExportsOfModule(moduleSymbol) {
     const links = getSymbolLinks(moduleSymbol);
     if (!links.resolvedExports) {
-      const { exports, typeOnlyExportStarMap } = getExportsOfModuleWorker(moduleSymbol);
-      links.resolvedExports = exports;
+      const { exports: exports2, typeOnlyExportStarMap } = getExportsOfModuleWorker(moduleSymbol);
+      links.resolvedExports = exports2;
       links.typeOnlyExportStarMap = typeOnlyExportStarMap;
     }
     return links.resolvedExports;
@@ -47084,12 +47084,12 @@ function createTypeChecker(host) {
     let typeOnlyExportStarMap;
     const nonTypeOnlyNames = /* @__PURE__ */ new Set();
     moduleSymbol = resolveExternalModuleSymbol(moduleSymbol);
-    const exports = visit(moduleSymbol) || emptySymbols;
+    const exports2 = visit(moduleSymbol) || emptySymbols;
     if (typeOnlyExportStarMap) {
       nonTypeOnlyNames.forEach((name) => typeOnlyExportStarMap.delete(name));
     }
     return {
-      exports,
+      exports: exports2,
       typeOnlyExportStarMap
     };
     function visit(symbol, exportStar, isTypeOnly) {
@@ -47278,12 +47278,12 @@ function createTypeChecker(host) {
     if (exportEquals && getSymbolIfSameReference(exportEquals, symbol)) {
       return container;
     }
-    const exports = getExportsOfSymbol(container);
-    const quick = exports.get(symbol.escapedName);
+    const exports2 = getExportsOfSymbol(container);
+    const quick = exports2.get(symbol.escapedName);
     if (quick && getSymbolIfSameReference(quick, symbol)) {
       return quick;
     }
-    return forEachEntry(exports, (exported) => {
+    return forEachEntry(exports2, (exported) => {
       if (getSymbolIfSameReference(exported, symbol)) {
         return exported;
       }
@@ -48247,7 +48247,13 @@ function createTypeChecker(host) {
         return visitAndTransformType(type, (type2) => conditionalTypeToTypeNode(type2));
       }
       if (type.flags & 33554432 /* Substitution */) {
-        return typeToTypeNodeHelper(type.baseType, context);
+        const typeNode = typeToTypeNodeHelper(type.baseType, context);
+        const noInferSymbol = isNoInferType(type) && getGlobalTypeSymbol(
+          "NoInfer",
+          /*reportErrors*/
+          false
+        );
+        return noInferSymbol ? symbolToTypeNode(noInferSymbol, context, 788968 /* Type */, [typeNode]) : typeNode;
       }
       return Debug.fail("Should be unreachable.");
       function conditionalTypeToTypeNode(type2) {
@@ -49532,8 +49538,8 @@ function createTypeChecker(host) {
           context.flags ^= 16777216 /* InInitialEntityName */;
         } else {
           if (parent && getExportsOfSymbol(parent)) {
-            const exports = getExportsOfSymbol(parent);
-            forEachEntry(exports, (ex, name) => {
+            const exports2 = getExportsOfSymbol(parent);
+            forEachEntry(exports2, (ex, name) => {
               if (getSymbolIfSameReference(ex, symbol2) && !isLateBoundName(name) && name !== "export=" /* ExportEquals */) {
                 symbolName2 = unescapeLeadingUnderscores(name);
                 return true;
@@ -50157,8 +50163,8 @@ function createTypeChecker(host) {
         return statements;
       }
       function mergeExportDeclarations(statements) {
-        const exports = filter(statements, (d) => isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && isNamedExports(d.exportClause));
-        if (length(exports) > 1) {
+        const exports2 = filter(statements, (d) => isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && isNamedExports(d.exportClause));
+        if (length(exports2) > 1) {
           const nonExports = filter(statements, (d) => !isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause);
           statements = [
             ...nonExports,
@@ -50167,7 +50173,7 @@ function createTypeChecker(host) {
               void 0,
               /*isTypeOnly*/
               false,
-              factory.createNamedExports(flatMap(exports, (e) => cast(e.exportClause, isNamedExports).elements)),
+              factory.createNamedExports(flatMap(exports2, (e) => cast(e.exportClause, isNamedExports).elements)),
               /*moduleSpecifier*/
               void 0
             )
@@ -50550,8 +50556,8 @@ function createTypeChecker(host) {
         );
       }
       function getNamespaceMembersForSerialization(symbol) {
-        const exports = getExportsOfSymbol(symbol);
-        return !exports ? [] : filter(arrayFrom(exports.values()), (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
+        const exports2 = getExportsOfSymbol(symbol);
+        return !exports2 ? [] : filter(arrayFrom(exports2.values()), (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
       }
       function isTypeOnlyNamespace(symbol) {
         return every(getNamespaceMembersForSerialization(symbol), (m) => !(getSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
@@ -52353,19 +52359,19 @@ function createTypeChecker(host) {
     if (!isInJSFile(decl) || !init || !isObjectLiteralExpression(init) || init.properties.length) {
       return void 0;
     }
-    const exports = createSymbolTable();
+    const exports2 = createSymbolTable();
     while (isBinaryExpression(decl) || isPropertyAccessExpression(decl)) {
       const s2 = getSymbolOfNode(decl);
       if ((_a = s2 == null ? void 0 : s2.exports) == null ? void 0 : _a.size) {
-        mergeSymbolTable(exports, s2.exports);
+        mergeSymbolTable(exports2, s2.exports);
       }
       decl = isBinaryExpression(decl) ? decl.parent : decl.parent.parent;
     }
     const s = getSymbolOfNode(decl);
     if ((_b = s == null ? void 0 : s.exports) == null ? void 0 : _b.size) {
-      mergeSymbolTable(exports, s.exports);
+      mergeSymbolTable(exports2, s.exports);
     }
-    const type = createAnonymousType(symbol, exports, emptyArray, emptyArray, emptyArray);
+    const type = createAnonymousType(symbol, exports2, emptyArray, emptyArray, emptyArray);
     type.objectFlags |= 4096 /* JSLiteral */;
     return type;
   }
@@ -56151,8 +56157,11 @@ function createTypeChecker(host) {
   }
   function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
     const type = getDeclaredTypeOfSymbol(symbol);
-    if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
-      return getStringMappingType(symbol, typeArguments[0]);
+    if (type === intrinsicMarkerType) {
+      const typeKind = intrinsicTypeKinds.get(symbol.escapedName);
+      if (typeKind !== void 0 && typeArguments && typeArguments.length === 1) {
+        return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]);
+      }
     }
     const links = getSymbolLinks(symbol);
     const typeParameters = links.typeParameters;
@@ -56306,10 +56315,19 @@ function createTypeChecker(host) {
     }
     return links.resolvedJSDocType;
   }
+  function getNoInferType(type) {
+    return isNoInferTargetType(type) ? getOrCreateSubstitutionType(type, unknownType) : type;
+  }
+  function isNoInferTargetType(type) {
+    return !!(type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, isNoInferTargetType) || type.flags & 33554432 /* Substitution */ && !isNoInferType(type) && isNoInferTargetType(type.baseType) || type.flags & 524288 /* Object */ && !isEmptyAnonymousObjectType(type) || type.flags & (465829888 /* Instantiable */ & ~33554432 /* Substitution */) && !isPatternLiteralType(type));
+  }
+  function isNoInferType(type) {
+    return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
+  }
   function getSubstitutionType(baseType, constraint) {
-    if (constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */) {
-      return baseType;
-    }
+    return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
+  }
+  function getOrCreateSubstitutionType(baseType, constraint) {
     const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
     const cached = substitutionTypes.get(id);
     if (cached) {
@@ -56322,7 +56340,7 @@ function createTypeChecker(host) {
     return result;
   }
   function getSubstitutionIntersection(substitutionType) {
-    return getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
+    return isNoInferType(substitutionType) ? substitutionType.baseType : getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
   }
   function isUnaryTupleTypeNode(node) {
     return node.kind === 189 /* TupleType */ && node.elements.length === 1;
@@ -57843,7 +57861,7 @@ function createTypeChecker(host) {
   }
   function getIndexType(type, indexFlags = defaultIndexFlags) {
     type = getReducedType(type);
-    return shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
+    return isNoInferType(type) ? getNoInferType(getIndexType(type.baseType, indexFlags)) : shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
   }
   function getExtractStringType(type) {
     if (keyofStringsOnly) {
@@ -59580,6 +59598,9 @@ function createTypeChecker(host) {
     }
     if (flags & 33554432 /* Substitution */) {
       const newBaseType = instantiateType(type.baseType, mapper);
+      if (isNoInferType(type)) {
+        return getNoInferType(newBaseType);
+      }
       const newConstraint = instantiateType(type.constraint, mapper);
       if (newBaseType.flags & 8650752 /* TypeVariable */ && isGenericType(newConstraint)) {
         return getSubstitutionType(newBaseType, newConstraint);
@@ -64330,7 +64351,7 @@ function createTypeChecker(host) {
     let expandingFlags = 0 /* None */;
     inferFromTypes(originalSource, originalTarget);
     function inferFromTypes(source, target) {
-      if (!couldContainTypeVariables(target)) {
+      if (!couldContainTypeVariables(target) || isNoInferType(target)) {
         return;
       }
       if (source === wildcardType || source === blockedStringType) {
@@ -64379,6 +64400,9 @@ function createTypeChecker(host) {
         }
       }
       if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
+        if (isNoInferType(target)) {
+          return;
+        }
         target = getActualTypeVariable(target);
       }
       if (target.flags & 8650752 /* TypeVariable */) {
@@ -69538,8 +69562,8 @@ function createTypeChecker(host) {
   }
   function getJsxType(name, location) {
     const namespace = getJsxNamespaceAt(location);
-    const exports = namespace && getExportsOfSymbol(namespace);
-    const typeSymbol = exports && getSymbol(exports, name, 788968 /* Type */);
+    const exports2 = namespace && getExportsOfSymbol(namespace);
+    const typeSymbol = exports2 && getSymbol(exports2, name, 788968 /* Type */);
     return typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType;
   }
   function getIntrinsicTagSymbol(node) {
@@ -72369,8 +72393,8 @@ function createTypeChecker(host) {
   }
   function createSignatureForJSXIntrinsic(node, result) {
     const namespace = getJsxNamespaceAt(node);
-    const exports = namespace && getExportsOfSymbol(namespace);
-    const typeSymbol = exports && getSymbol(exports, JsxNames.Element, 788968 /* Type */);
+    const exports2 = namespace && getExportsOfSymbol(namespace);
+    const typeSymbol = exports2 && getSymbol(exports2, JsxNames.Element, 788968 /* Type */);
     const returnNode = typeSymbol && nodeBuilder.symbolToEntityName(typeSymbol, 788968 /* Type */, node);
     const declaration = factory.createFunctionTypeNode(
       /*typeParameters*/
@@ -81123,9 +81147,9 @@ function createTypeChecker(host) {
           error(declaration, Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements);
         }
       }
-      const exports = getExportsOfModule(moduleSymbol);
-      if (exports) {
-        exports.forEach(({ declarations, flags }, id) => {
+      const exports2 = getExportsOfModule(moduleSymbol);
+      if (exports2) {
+        exports2.forEach(({ declarations, flags }, id) => {
           if (id === "__export") {
             return;
           }
@@ -82990,8 +83014,8 @@ function createTypeChecker(host) {
         return false;
       if (importTarget === file)
         return false;
-      const exports = getExportsOfModule(file.symbol);
-      for (const s of arrayFrom(exports.values())) {
+      const exports2 = getExportsOfModule(file.symbol);
+      for (const s of arrayFrom(exports2.values())) {
         if (s.mergeId) {
           const merged = getMergedSymbol(s);
           if (merged.declarations) {
@@ -106287,7 +106311,7 @@ function transformSystemModule(context) {
     const exportStarFunction = factory2.createUniqueName("exportStar");
     const m = factory2.createIdentifier("m");
     const n = factory2.createIdentifier("n");
-    const exports = factory2.createIdentifier("exports");
+    const exports2 = factory2.createIdentifier("exports");
     let condition = factory2.createStrictInequality(n, factory2.createStringLiteral("default"));
     if (localNames) {
       condition = factory2.createLogicalAnd(
@@ -106326,7 +106350,7 @@ function transformSystemModule(context) {
             void 0,
             factory2.createVariableDeclarationList([
               factory2.createVariableDeclaration(
-                exports,
+                exports2,
                 /*exclamationToken*/
                 void 0,
                 /*type*/
@@ -106346,7 +106370,7 @@ function transformSystemModule(context) {
                   condition,
                   factory2.createExpressionStatement(
                     factory2.createAssignment(
-                      factory2.createElementAccessExpression(exports, n),
+                      factory2.createElementAccessExpression(exports2, n),
                       factory2.createElementAccessExpression(m, n)
                     )
                   )
@@ -106360,7 +106384,7 @@ function transformSystemModule(context) {
               exportFunction,
               /*typeArguments*/
               void 0,
-              [exports]
+              [exports2]
             )
           )
         ],