@typescript-deploys/pr-build 4.8.0-pr-49387-9 → 4.8.0-pr-49422-8

package/lib/lib.es2022.d.ts

@@ -23,4 +23,5 @@ and limitations under the License.
 /// <reference lib="es2022.error" />
 /// <reference lib="es2022.intl" />
 /// <reference lib="es2022.object" />
+/// <reference lib="es2022.sharedmemory" />
 /// <reference lib="es2022.string" />

package/lib/lib.es2022.sharedmemory.d.ts

@@ -0,0 +1,27 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+
+/// <reference no-default-lib="true"/>
+
+
+interface Atomics {
+    /**
+     * A non-blocking, asynchronous version of wait which is usable on the main thread.
+     * Waits asynchronously on a shared memory location and returns a Promise
+     */
+    waitAsync(typedArray: BigInt64Array | Int32Array, index: number, value: bigint, timeout?: number): { async: false, value: "ok" | "not-equal" | "timed-out" } | { async: true, value: Promise<"ok" | "not-equal" | "timed-out"> };
+}

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.8";
-    ts.version = ts.versionMajorMinor + ".0-insiders.20220604";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220607";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -31542,6 +31542,7 @@ var ts;
         ["es2022.error", "lib.es2022.error.d.ts"],
         ["es2022.intl", "lib.es2022.intl.d.ts"],
         ["es2022.object", "lib.es2022.object.d.ts"],
+        ["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"],
         ["es2022.string", "lib.es2022.string.d.ts"],
         ["esnext.array", "lib.es2022.array.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
@@ -39263,16 +39264,6 @@ var ts;
     var nextNodeId = 1;
     var nextMergeId = 1;
     var nextFlowId = 1;
-    var typeofEQFacts = new ts.Map(ts.getEntries({
-        string: 1,
-        number: 2,
-        bigint: 4,
-        boolean: 8,
-        symbol: 16,
-        undefined: 65536,
-        object: 32,
-        function: 64
-    }));
     var typeofNEFacts = new ts.Map(ts.getEntries({
         string: 256,
         number: 512,
@@ -39932,14 +39923,6 @@ var ts;
         var awaitedTypeStack = [];
         var diagnostics = ts.createDiagnosticCollection();
         var suggestionDiagnostics = ts.createDiagnosticCollection();
-        var typeofTypesByName = new ts.Map(ts.getEntries({
-            string: stringType,
-            number: numberType,
-            bigint: bigintType,
-            boolean: booleanType,
-            symbol: esSymbolType,
-            undefined: undefinedType
-        }));
         var typeofType = createTypeofType();
         var _jsxNamespace;
         var _jsxFactoryEntity;
@@ -42439,7 +42422,7 @@ var ts;
             return type;
         }
         function createTypeofType() {
-            return getUnionType(ts.arrayFrom(typeofEQFacts.keys(), getStringLiteralType));
+            return getUnionType(ts.arrayFrom(typeofNEFacts.keys(), getStringLiteralType));
         }
         function createTypeParameter(symbol) {
             var type = createType(262144);
@@ -58293,19 +58276,15 @@ var ts;
             }
             return links.switchTypes;
         }
-        function getSwitchClauseTypeOfWitnesses(switchStatement, retainDefault) {
+        function getSwitchClauseTypeOfWitnesses(switchStatement) {
+            if (ts.some(switchStatement.caseBlock.clauses, function (clause) { return clause.kind === 289 && !ts.isStringLiteralLike(clause.expression); })) {
+                return undefined;
+            }
             var witnesses = [];
             for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) {
                 var clause = _a[_i];
-                if (clause.kind === 289) {
-                    if (ts.isStringLiteralLike(clause.expression)) {
-                        witnesses.push(clause.expression.text);
-                        continue;
-                    }
-                    return ts.emptyArray;
-                }
-                if (retainDefault)
-                    witnesses.push(undefined);
+                var text = clause.kind === 289 ? clause.expression.text : undefined;
+                witnesses.push(text && !ts.contains(witnesses, text) ? text : undefined);
             }
             return witnesses;
         }
@@ -59361,14 +59340,9 @@ var ts;
                     }
                     return type;
                 }
-                if (type.flags & 1 && literal.text === "function") {
-                    return type;
-                }
-                var facts = assumeTrue ?
-                    typeofEQFacts.get(literal.text) || 128 :
-                    typeofNEFacts.get(literal.text) || 32768;
-                var impliedType = getImpliedTypeFromTypeofGuard(type, literal.text);
-                return getTypeWithFacts(assumeTrue && impliedType ? narrowTypeByImpliedType(type, impliedType) : type, facts);
+                return assumeTrue ?
+                    narrowTypeByTypeName(type, literal.text) :
+                    getTypeWithFacts(type, typeofNEFacts.get(literal.text) || 32768);
             }
             function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) {
                 var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck);
@@ -59411,63 +59385,40 @@ var ts;
                 var defaultType = filterType(type, function (t) { return !(isUnitLikeType(t) && ts.contains(switchTypes, getRegularTypeOfLiteralType(extractUnitType(t)))); });
                 return caseType.flags & 131072 ? defaultType : getUnionType([caseType, defaultType]);
             }
-            function getImpliedTypeFromTypeofGuard(type, text) {
-                switch (text) {
-                    case "object":
-                        return type.flags & 1 ? type : getUnionType([nullType, nonPrimitiveType]);
-                    case "function":
-                        return type.flags & 1 ? type : globalFunctionType;
-                    default:
-                        return typeofTypesByName.get(text);
+            function narrowTypeByTypeName(type, typeName) {
+                switch (typeName) {
+                    case "string": return narrowTypeByTypeFacts(type, stringType, 1);
+                    case "number": return narrowTypeByTypeFacts(type, numberType, 2);
+                    case "bigint": return narrowTypeByTypeFacts(type, bigintType, 4);
+                    case "boolean": return narrowTypeByTypeFacts(type, booleanType, 8);
+                    case "symbol": return narrowTypeByTypeFacts(type, esSymbolType, 16);
+                    case "object": return type.flags & 1 ? type : getUnionType([narrowTypeByTypeFacts(type, nonPrimitiveType, 32), narrowTypeByTypeFacts(type, nullType, 131072)]);
+                    case "function": return type.flags & 1 ? type : narrowTypeByTypeFacts(type, globalFunctionType, 64);
+                    case "undefined": return narrowTypeByTypeFacts(type, undefinedType, 65536);
                 }
+                return narrowTypeByTypeFacts(type, nonPrimitiveType, 128);
             }
-            function narrowTypeByImpliedType(type, candidate) {
-                if (type.flags & 3) {
-                    return candidate;
-                }
+            function narrowTypeByTypeFacts(type, impliedType, facts) {
                 return mapType(type, function (t) {
-                    if (isTypeRelatedTo(t, candidate, strictSubtypeRelation)) {
-                        return t;
-                    }
-                    return mapType(candidate, function (c) {
-                        if (!areTypesComparable(t, c)) {
-                            return neverType;
-                        }
-                        if (c.flags & 131068 && t.flags & 524288 && !isEmptyAnonymousObjectType(t)) {
-                            return isTypeSubtypeOf(c, t) ? c : neverType;
-                        }
-                        if (c === globalFunctionType && isTypeSubtypeOf(c, t)) {
-                            return c;
-                        }
-                        return getIntersectionType([t, c]);
-                    });
+                    return isTypeSubtypeOf(impliedType, t) ? impliedType :
+                        !(getTypeFacts(t) & facts) ? neverType :
+                            isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? t :
+                                getIntersectionType([t, impliedType]);
                 });
             }
             function narrowBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) {
-                var switchWitnesses = getSwitchClauseTypeOfWitnesses(switchStatement, true);
-                if (!switchWitnesses.length) {
+                var witnesses = getSwitchClauseTypeOfWitnesses(switchStatement);
+                if (!witnesses) {
                     return type;
                 }
-                var defaultCaseLocation = ts.findIndex(switchWitnesses, function (elem) { return elem === undefined; });
-                var hasDefaultClause = clauseStart === clauseEnd || (defaultCaseLocation >= clauseStart && defaultCaseLocation < clauseEnd);
-                var clauseWitnesses;
-                var switchFacts;
-                if (defaultCaseLocation > -1) {
-                    var witnesses = switchWitnesses.filter(function (witness) { return witness !== undefined; });
-                    var fixedClauseStart = defaultCaseLocation < clauseStart ? clauseStart - 1 : clauseStart;
-                    var fixedClauseEnd = defaultCaseLocation < clauseEnd ? clauseEnd - 1 : clauseEnd;
-                    clauseWitnesses = witnesses.slice(fixedClauseStart, fixedClauseEnd);
-                    switchFacts = getFactsFromTypeofSwitch(fixedClauseStart, fixedClauseEnd, witnesses, hasDefaultClause);
-                }
-                else {
-                    clauseWitnesses = switchWitnesses.slice(clauseStart, clauseEnd);
-                    switchFacts = getFactsFromTypeofSwitch(clauseStart, clauseEnd, switchWitnesses, hasDefaultClause);
-                }
+                var defaultIndex = ts.findIndex(switchStatement.caseBlock.clauses, function (clause) { return clause.kind === 290; });
+                var hasDefaultClause = clauseStart === clauseEnd || (defaultIndex >= clauseStart && defaultIndex < clauseEnd);
                 if (hasDefaultClause) {
-                    return filterType(type, function (t) { return (getTypeFacts(t) & switchFacts) === switchFacts; });
+                    var notEqualFacts_1 = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses);
+                    return filterType(type, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; });
                 }
-                var impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(function (text) { return getImpliedTypeFromTypeofGuard(type, text) || type; })), switchFacts);
-                return getTypeWithFacts(narrowTypeByImpliedType(type, impliedType), switchFacts);
+                var clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
+                return getUnionType(ts.map(clauseWitnesses, function (text) { return text ? narrowTypeByTypeName(type, text) : neverType; }));
             }
             function isMatchingConstructorReference(expr) {
                 return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" ||
@@ -65255,26 +65206,11 @@ var ts;
                 ? ts.Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member
                 : ts.Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member);
         }
-        function getFactsFromTypeofSwitch(start, end, witnesses, hasDefault) {
+        function getNotEqualFactsFromTypeofSwitch(start, end, witnesses) {
             var facts = 0;
-            if (hasDefault) {
-                for (var i = end; i < witnesses.length; i++) {
-                    facts |= typeofNEFacts.get(witnesses[i]) || 32768;
-                }
-                for (var i = start; i < end; i++) {
-                    facts &= ~(typeofNEFacts.get(witnesses[i]) || 0);
-                }
-                for (var i = 0; i < start; i++) {
-                    facts |= typeofNEFacts.get(witnesses[i]) || 32768;
-                }
-            }
-            else {
-                for (var i = start; i < end; i++) {
-                    facts |= typeofEQFacts.get(witnesses[i]) || 128;
-                }
-                for (var i = 0; i < start; i++) {
-                    facts &= ~(typeofEQFacts.get(witnesses[i]) || 0);
-                }
+            for (var i = 0; i < witnesses.length; i++) {
+                var witness = i < start || i >= end ? witnesses[i] : undefined;
+                facts |= witness !== undefined ? typeofNEFacts.get(witness) || 32768 : 0;
             }
             return facts;
         }
@@ -65284,14 +65220,16 @@ var ts;
         }
         function computeExhaustiveSwitchStatement(node) {
             if (node.expression.kind === 216) {
-                var operandType = getTypeOfExpression(node.expression.expression);
-                var witnesses = getSwitchClauseTypeOfWitnesses(node, false);
-                var notEqualFacts_1 = getFactsFromTypeofSwitch(0, 0, witnesses, true);
-                var type_6 = getBaseConstraintOfType(operandType) || operandType;
-                if (type_6.flags & 3) {
-                    return (556800 & notEqualFacts_1) === 556800;
+                var witnesses = getSwitchClauseTypeOfWitnesses(node);
+                if (!witnesses) {
+                    return false;
                 }
-                return !!(filterType(type_6, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }).flags & 131072);
+                var operandConstraint = getBaseConstraintOrType(getTypeOfExpression(node.expression.expression));
+                var notEqualFacts_2 = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses);
+                if (operandConstraint.flags & 3) {
+                    return (556800 & notEqualFacts_2) === 556800;
+                }
+                return !someType(operandConstraint, function (t) { return (getTypeFacts(t) & notEqualFacts_2) === notEqualFacts_2; });
             }
             var type = getTypeOfExpression(node.expression);
             if (!isLiteralType(type)) {
@@ -68593,6 +68531,11 @@ var ts;
         function checkJSDocTypeTag(node) {
             checkSourceElement(node.typeExpression);
         }
+        function checkJSDocLinkLikeTag(node) {
+            if (node.name) {
+                resolveJSDocMemberName(node.name, true);
+            }
+        }
         function checkJSDocParameterTag(node) {
             checkSourceElement(node.typeExpression);
         }
@@ -71842,12 +71785,16 @@ var ts;
             }
         }
         function checkSourceElementWorker(node) {
-            if (ts.isInJSFile(node)) {
-                ts.forEach(node.jsDoc, function (_a) {
-                    var tags = _a.tags;
-                    return ts.forEach(tags, checkSourceElement);
+            ts.forEach(node.jsDoc, function (_a) {
+                var comment = _a.comment, tags = _a.tags;
+                checkJSDocCommentWorker(comment);
+                ts.forEach(tags, function (tag) {
+                    checkJSDocCommentWorker(tag.comment);
+                    if (ts.isInJSFile(node)) {
+                        checkSourceElement(tag);
+                    }
                 });
-            }
+            });
             var kind = node.kind;
             if (cancellationToken) {
                 switch (kind) {
@@ -71931,6 +71878,10 @@ var ts;
                     return checkJSDocTemplateTag(node);
                 case 343:
                     return checkJSDocTypeTag(node);
+                case 324:
+                case 325:
+                case 326:
+                    return checkJSDocLinkLikeTag(node);
                 case 340:
                     return checkJSDocParameterTag(node);
                 case 347:
@@ -72024,6 +71975,15 @@ var ts;
                     return checkMissingDeclaration(node);
             }
         }
+        function checkJSDocCommentWorker(node) {
+            if (ts.isArray(node)) {
+                ts.forEach(node, function (tag) {
+                    if (ts.isJSDocLinkLike(tag)) {
+                        checkSourceElement(tag);
+                    }
+                });
+            }
+        }
         function checkJSDocTypeIsInJsFile(node) {
             if (!ts.isInJSFile(node)) {
                 grammarErrorOnNode(node, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments);
@@ -72507,7 +72467,7 @@ var ts;
                     if (!result && isJSDoc_1) {
                         var container = ts.findAncestor(name, ts.or(ts.isClassLike, ts.isInterfaceDeclaration));
                         if (container) {
-                            return resolveJSDocMemberName(name, getSymbolOfNode(container));
+                            return resolveJSDocMemberName(name, false, getSymbolOfNode(container));
                         }
                     }
                     return result;
@@ -72545,10 +72505,10 @@ var ts;
             }
             return undefined;
         }
-        function resolveJSDocMemberName(name, container) {
+        function resolveJSDocMemberName(name, ignoreErrors, container) {
             if (ts.isEntityName(name)) {
                 var meaning = 788968 | 1920 | 111551;
-                var symbol = resolveEntityName(name, meaning, false, true, ts.getHostSignatureFromJSDoc(name));
+                var symbol = resolveEntityName(name, meaning, ignoreErrors, true, ts.getHostSignatureFromJSDoc(name));
                 if (!symbol && ts.isIdentifier(name) && container) {
                     symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(container), name.escapedText, meaning));
                 }
@@ -72556,7 +72516,7 @@ var ts;
                     return symbol;
                 }
             }
-            var left = ts.isIdentifier(name) ? container : resolveJSDocMemberName(name.left);
+            var left = ts.isIdentifier(name) ? container : resolveJSDocMemberName(name.left, ignoreErrors, container);
             var right = ts.isIdentifier(name) ? name.escapedText : name.right.escapedText;
             if (left) {
                 var proto = left.flags & 111551 && getPropertyOfType(getTypeOfSymbol(left), "prototype");