@typescript-deploys/pr-build 5.1.0-pr-53134-21 → 5.1.0-pr-53098-13

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

@@ -20,6 +20,27 @@ and limitations under the License.
 /// Worker Iterable APIs
 /////////////////////////////
 
+interface CSSNumericArray {
+    [Symbol.iterator](): IterableIterator<CSSNumericValue>;
+    entries(): IterableIterator<[number, CSSNumericValue]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<CSSNumericValue>;
+}
+
+interface CSSTransformValue {
+    [Symbol.iterator](): IterableIterator<CSSTransformComponent>;
+    entries(): IterableIterator<[number, CSSTransformComponent]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<CSSTransformComponent>;
+}
+
+interface CSSUnparsedValue {
+    [Symbol.iterator](): IterableIterator<CSSUnparsedSegment>;
+    entries(): IterableIterator<[number, CSSUnparsedSegment]>;
+    keys(): IterableIterator<number>;
+    values(): IterableIterator<CSSUnparsedSegment>;
+}
+
 interface Cache {
     addAll(requests: Iterable<RequestInfo>): Promise<void>;
 }
@@ -82,6 +103,13 @@ 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 StylePropertyMapReadOnly {
+    [Symbol.iterator](): IterableIterator<[string, Iterable<CSSStyleValue>]>;
+    entries(): IterableIterator<[string, Iterable<CSSStyleValue>]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<Iterable<CSSStyleValue>>;
+}
+
 interface SubtleCrypto {
     deriveKey(algorithm: AlgorithmIdentifier | EcdhKeyDeriveParams | HkdfParams | Pbkdf2Params, baseKey: CryptoKey, derivedKeyType: AlgorithmIdentifier | AesDerivedKeyParams | HmacImportParams | HkdfParams | Pbkdf2Params, extractable: boolean, keyUsages: Iterable<KeyUsage>): Promise<CryptoKey>;
     generateKey(algorithm: RsaHashedKeyGenParams | EcKeyGenParams, extractable: boolean, keyUsages: ReadonlyArray<KeyUsage>): Promise<CryptoKeyPair>;

package/lib/tsc.js

@@ -23,7 +23,7 @@ var __export = (target, all) => {
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230308`;
+var version = `${versionMajorMinor}.0-insiders.20230310`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4876,20 +4876,6 @@ function patchWriteFileEnsuringDirectory(sys2) {
     (path2) => sys2.directoryExists(path2)
   );
 }
-function getNodeMajorVersion() {
-  if (typeof process === "undefined") {
-    return void 0;
-  }
-  const version2 = process.version;
-  if (!version2) {
-    return void 0;
-  }
-  const dot = version2.indexOf(".");
-  if (dot === -1) {
-    return void 0;
-  }
-  return parseInt(version2.substring(1, dot));
-}
 var sys = (() => {
   const byteOrderMarkIndicator = "\uFEFF";
   function getNodeSystem() {
@@ -4906,14 +4892,12 @@ var sys = (() => {
     let activeSession;
     let profilePath = "./profile.cpuprofile";
     const Buffer2 = require("buffer").Buffer;
-    const nodeVersion = getNodeMajorVersion();
-    const isNode4OrLater = nodeVersion >= 4;
     const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
     const platform = _os.platform();
     const useCaseSensitiveFileNames = isFileSystemCaseSensitive();
     const fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync;
     const executingFilePath = __filename.endsWith("sys.js") ? _path.join(_path.dirname(__dirname), "__fake__.js") : __filename;
-    const fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin");
+    const fsSupportsRecursiveFsWatch = process.platform === "win32" || process.platform === "darwin";
     const getCurrentDirectory = memoize(() => process.cwd());
     const { watchFile: watchFile2, watchDirectory } = createSystemWatchFunctions({
       pollingWatchFileWorker: fsWatchFileWorker,
@@ -42691,6 +42675,7 @@ function createTypeChecker(host) {
   var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
   var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
   var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
+  var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
   var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
   var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
   var checkBinaryExpression = createCheckBinaryExpression();
@@ -52679,10 +52664,9 @@ function createTypeChecker(host) {
     return [sig.parameters];
     function expandSignatureParametersWithTupleMembers(restType, restIndex) {
       const elementTypes = getTypeArguments(restType);
-      const associatedNames = restType.target.labeledElementDeclarations;
+      const associatedNames = getUniqAssociatedNamesFromTupleType(restType);
       const restParams = map(elementTypes, (t, i) => {
-        const tupleLabelName = !!associatedNames && getTupleElementLabel(associatedNames[i]);
-        const name = tupleLabelName || getParameterNameAtPosition(sig, restIndex + i, restType);
+        const name = associatedNames && associatedNames[i] ? associatedNames[i] : getParameterNameAtPosition(sig, restIndex + i, restType);
         const flags = restType.target.elementFlags[i];
         const checkFlags = flags & 12 /* Variable */ ? 32768 /* RestParameter */ : flags & 2 /* Optional */ ? 16384 /* OptionalParameter */ : 0;
         const symbol = createSymbol(1 /* FunctionScopedVariable */, name, checkFlags);
@@ -52691,6 +52675,20 @@ function createTypeChecker(host) {
       });
       return concatenate(sig.parameters.slice(0, restIndex), restParams);
     }
+    function getUniqAssociatedNamesFromTupleType(type) {
+      const associatedNamesMap = /* @__PURE__ */ new Map();
+      return map(type.target.labeledElementDeclarations, (labeledElement) => {
+        const name = getTupleElementLabel(labeledElement);
+        const prevCounter = associatedNamesMap.get(name);
+        if (prevCounter === void 0) {
+          associatedNamesMap.set(name, 1);
+          return name;
+        } else {
+          associatedNamesMap.set(name, prevCounter + 1);
+          return `${name}_${prevCounter}`;
+        }
+      });
+    }
   }
   function getDefaultConstructSignatures(classType) {
     const baseConstructorType = getBaseConstructorTypeOfClass(classType);
@@ -53946,6 +53944,13 @@ function createTypeChecker(host) {
   function isConflictingPrivateProperty(prop) {
     return !prop.valueDeclaration && !!(getCheckFlags(prop) & 1024 /* ContainsPrivate */);
   }
+  function isGenericReducibleType(type) {
+    return !!(type.flags & 1048576 /* Union */ && type.objectFlags & 16777216 /* ContainsIntersections */ && some(type.types, isGenericReducibleType) || type.flags & 2097152 /* Intersection */ && isReducibleIntersection(type));
+  }
+  function isReducibleIntersection(type) {
+    const uniqueFilled = type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
+    return getReducedType(uniqueFilled) !== uniqueFilled;
+  }
   function elaborateNeverIntersection(errorInfo, type) {
     if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 33554432 /* IsNeverIntersection */) {
       const neverProp = find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
@@ -55388,7 +55393,7 @@ function createTypeChecker(host) {
   }
   function getGlobalOmitSymbol() {
     deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalTypeAliasSymbol(
-      "MappedOmit",
+      "Omit",
       /*arity*/
       2,
       /*reportErrors*/
@@ -56315,10 +56320,10 @@ function createTypeChecker(host) {
     }
     return links.resolvedType;
   }
-  function createIndexType(type, stringsOnly) {
+  function createIndexType(type, indexFlags) {
     const result = createType(4194304 /* Index */);
     result.type = type;
-    result.stringsOnly = stringsOnly;
+    result.indexFlags = indexFlags;
     return result;
   }
   function createOriginIndexType(type) {
@@ -56326,31 +56331,23 @@ function createTypeChecker(host) {
     result.type = type;
     return result;
   }
-  function getIndexTypeForGenericType(type, stringsOnly) {
-    return stringsOnly ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(
-      type,
-      /*stringsOnly*/
-      true
-    )) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(
-      type,
-      /*stringsOnly*/
-      false
-    ));
+  function getIndexTypeForGenericType(type, indexFlags) {
+    return indexFlags & 1 /* StringsOnly */ ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, 1 /* StringsOnly */)) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, 0 /* None */));
   }
-  function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
+  function getIndexTypeForMappedType(type, indexFlags) {
     const typeParameter = getTypeParameterFromMappedType(type);
     const constraintType = getConstraintTypeFromMappedType(type);
     const nameType = getNameTypeFromMappedType(type.target || type);
-    if (!nameType && !noIndexSignatures) {
+    if (!nameType && !(indexFlags & 2 /* NoIndexSignatures */)) {
       return constraintType;
     }
     const keyTypes = [];
     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
       if (!isGenericIndexType(constraintType)) {
         const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
-        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
+        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
       } else {
-        return getIndexTypeForGenericType(type, stringsOnly);
+        return getIndexTypeForGenericType(type, indexFlags);
       }
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
@@ -56358,7 +56355,7 @@ function createTypeChecker(host) {
     if (isGenericIndexType(constraintType)) {
       forEachType(constraintType, addMemberForKeyType);
     }
-    const result = noIndexSignatures ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
+    const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
     if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
       return constraintType;
     }
@@ -56411,19 +56408,15 @@ function createTypeChecker(host) {
       origin
     );
   }
-  function isPossiblyReducibleByInstantiation(type) {
-    const uniqueFilled = getUniqueLiteralFilledInstantiation(type);
-    return getReducedType(uniqueFilled) !== uniqueFilled;
-  }
-  function shouldDeferIndexType(type) {
-    return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && some(type.types, isPossiblyReducibleByInstantiation) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
+  function shouldDeferIndexType(type, indexFlags = 0 /* None */) {
+    return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && !(indexFlags & 4 /* NoReducibleCheck */) && isGenericReducibleType(type) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
   }
-  function getIndexType(type, stringsOnly = keyofStringsOnly, noIndexSignatures) {
+  function getIndexType(type, indexFlags = defaultIndexFlags) {
     type = getReducedType(type);
-    return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(
+    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,
-      (noIndexSignatures ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (stringsOnly ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
-      stringsOnly === keyofStringsOnly && !noIndexSignatures
+      (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
+      indexFlags === defaultIndexFlags
     );
   }
   function getExtractStringType(type) {
@@ -56963,12 +56956,13 @@ function createTypeChecker(host) {
     if (objectType === wildcardType || indexType === wildcardType) {
       return wildcardType;
     }
+    objectType = getReducedType(objectType);
     if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
       indexType = stringType;
     }
     if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* ExpressionPosition */)
       accessFlags |= 1 /* IncludeUndefined */;
-    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 197 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)))) {
+    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 197 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)) || isGenericReducibleType(objectType))) {
       if (objectType.flags & 3 /* AnyOrUnknown */) {
         return objectType;
       }
@@ -58154,9 +58148,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function getUniqueLiteralFilledInstantiation(type) {
-    return type.flags & (402784252 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
-  }
   function getPermissiveInstantiation(type) {
     return type.flags & (402784252 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
   }
@@ -60351,7 +60342,7 @@ function createTypeChecker(host) {
         } else {
           const constraint = getSimplifiedTypeOrConstraint(targetType);
           if (constraint) {
-            if (isRelatedTo(source2, getIndexType(constraint, target2.stringsOnly), 2 /* Target */, reportErrors2) === -1 /* True */) {
+            if (isRelatedTo(source2, getIndexType(constraint, target2.indexFlags | 4 /* NoReducibleCheck */), 2 /* Target */, reportErrors2) === -1 /* True */) {
               return -1 /* True */;
             }
           } else if (isGenericMappedType(targetType)) {
@@ -60432,13 +60423,7 @@ function createTypeChecker(host) {
           }
           if (!isGenericMappedType(source2)) {
             const targetKeys = keysRemapped ? getNameTypeFromMappedType(target2) : getConstraintTypeFromMappedType(target2);
-            const sourceKeys = getIndexType(
-              source2,
-              /*stringsOnly*/
-              void 0,
-              /*noIndexSignatures*/
-              true
-            );
+            const sourceKeys = getIndexType(source2, 2 /* NoIndexSignatures */);
             const includeOptional = modifiers & 4 /* IncludeOptional */;
             const filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : void 0;
             if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
@@ -67270,13 +67255,14 @@ function createTypeChecker(host) {
     const elementFlags = [];
     pushCachedContextualType(node);
     const inDestructuringPattern = isAssignmentTarget(node);
-    const inConstContext = isConstContext(node);
+    const isSpreadIntoCallOrNew = isSpreadElement(node.parent) && isCallOrNewExpression(node.parent.parent);
+    const inConstContext = isSpreadIntoCallOrNew || isConstContext(node);
     const contextualType = getApparentTypeOfContextualType(
       node,
       /*contextFlags*/
       void 0
     );
-    const inTupleContext = !!contextualType && someType(contextualType, isTupleLikeType);
+    const inTupleContext = isSpreadIntoCallOrNew || !!contextualType && someType(contextualType, isTupleLikeType);
     let hasOmittedExpression = false;
     for (let i = 0; i < elementCount; i++) {
       const e = elements[i];
@@ -74670,11 +74656,7 @@ function createTypeChecker(host) {
     }
     const objectType = type.objectType;
     const indexType = type.indexType;
-    if (isTypeAssignableTo(indexType, getIndexType(
-      objectType,
-      /*stringsOnly*/
-      false
-    ))) {
+    if (isTypeAssignableTo(indexType, getIndexType(objectType, 0 /* None */))) {
       if (accessNode.kind === 210 /* ElementAccessExpression */ && isAssignmentTarget(accessNode) && getObjectFlags(objectType) & 32 /* Mapped */ && getMappedTypeModifiers(objectType) & 1 /* IncludeReadonly */) {
         error(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
       }