typescript 4.6.0-dev.20211202 → 4.6.0-dev.20211203

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.6";
-    ts.version = ts.versionMajorMinor + ".0-dev.20211202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211203";
     var NativeCollections;
     (function (NativeCollections) {
         function tryGetNativeMap() {
@@ -72858,11 +72858,13 @@ var ts;
             return false;
         }
         function checkNumericLiteralValueSize(node) {
-            if (node.numericLiteralFlags & 16 || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+            var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1;
+            var isScientific = node.numericLiteralFlags & 16;
+            if (isFractional || isScientific) {
                 return;
             }
-            var apparentValue = +ts.getTextOfNode(node);
-            if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+            var value = +node.text;
+            if (value <= Math.pow(2, 53) - 1) {
                 return;
             }
             addErrorOrSuggestion(false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
@@ -75556,7 +75558,7 @@ var ts;
                 return undefined;
             }
             var prefix = getClassMemberPrefix(node, member);
-            var memberName = getExpressionForPropertyName(member, true);
+            var memberName = getExpressionForPropertyName(member, !ts.hasSyntacticModifier(member, 2));
             var descriptor = languageVersion > 0
                 ? member.kind === 166
                     ? factory.createVoidZero()

package/lib/tsserver.js

@@ -100,7 +100,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211203";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -86634,18 +86634,22 @@ var ts;
             return false;
         }
         function checkNumericLiteralValueSize(node) {
+            // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "."
+            // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`.
+            var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1;
+            var isScientific = node.numericLiteralFlags & 16 /* Scientific */;
             // Scientific notation (e.g. 2e54 and 1e00000000010) can't be converted to bigint
-            // Literals with 15 or fewer characters aren't long enough to reach past 2^53 - 1
             // Fractional numbers (e.g. 9000000000000000.001) are inherently imprecise anyway
-            if (node.numericLiteralFlags & 16 /* Scientific */ || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+            if (isFractional || isScientific) {
                 return;
             }
-            // We can't rely on the runtime to accurately store and compare extremely large numeric values
-            // Even for internal use, we use getTextOfNode: https://github.com/microsoft/TypeScript/issues/33298
-            // Thus, if the runtime claims a too-large number is lower than Number.MAX_SAFE_INTEGER,
-            // it's likely addition operations on it will fail too
-            var apparentValue = +ts.getTextOfNode(node);
-            if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+            // Here `node` is guaranteed to be a numeric literal representing an integer.
+            // We need to judge whether the integer `node` represents is <= 2 ** 53 - 1, which can be accomplished by comparing to `value` defined below because:
+            // 1) when `node` represents an integer <= 2 ** 53 - 1, `node.text` is its exact string representation and thus `value` precisely represents the integer.
+            // 2) otherwise, although `node.text` may be imprecise string representation, its mathematical value and consequently `value` cannot be less than 2 ** 53,
+            //    thus the result of the predicate won't be affected.
+            var value = +node.text;
+            if (value <= Math.pow(2, 53) - 1) {
                 return;
             }
             addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
@@ -90107,7 +90111,7 @@ var ts;
             //   ], C.prototype, "prop");
             //
             var prefix = getClassMemberPrefix(node, member);
-            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ true);
+            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !ts.hasSyntacticModifier(member, 2 /* Ambient */));
             var descriptor = languageVersion > 0 /* ES3 */
                 ? member.kind === 166 /* PropertyDeclaration */
                     // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it

package/lib/tsserverlibrary.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211203";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -86828,18 +86828,22 @@ var ts;
             return false;
         }
         function checkNumericLiteralValueSize(node) {
+            // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "."
+            // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`.
+            var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1;
+            var isScientific = node.numericLiteralFlags & 16 /* Scientific */;
             // Scientific notation (e.g. 2e54 and 1e00000000010) can't be converted to bigint
-            // Literals with 15 or fewer characters aren't long enough to reach past 2^53 - 1
             // Fractional numbers (e.g. 9000000000000000.001) are inherently imprecise anyway
-            if (node.numericLiteralFlags & 16 /* Scientific */ || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+            if (isFractional || isScientific) {
                 return;
             }
-            // We can't rely on the runtime to accurately store and compare extremely large numeric values
-            // Even for internal use, we use getTextOfNode: https://github.com/microsoft/TypeScript/issues/33298
-            // Thus, if the runtime claims a too-large number is lower than Number.MAX_SAFE_INTEGER,
-            // it's likely addition operations on it will fail too
-            var apparentValue = +ts.getTextOfNode(node);
-            if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+            // Here `node` is guaranteed to be a numeric literal representing an integer.
+            // We need to judge whether the integer `node` represents is <= 2 ** 53 - 1, which can be accomplished by comparing to `value` defined below because:
+            // 1) when `node` represents an integer <= 2 ** 53 - 1, `node.text` is its exact string representation and thus `value` precisely represents the integer.
+            // 2) otherwise, although `node.text` may be imprecise string representation, its mathematical value and consequently `value` cannot be less than 2 ** 53,
+            //    thus the result of the predicate won't be affected.
+            var value = +node.text;
+            if (value <= Math.pow(2, 53) - 1) {
                 return;
             }
             addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
@@ -90301,7 +90305,7 @@ var ts;
             //   ], C.prototype, "prop");
             //
             var prefix = getClassMemberPrefix(node, member);
-            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ true);
+            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !ts.hasSyntacticModifier(member, 2 /* Ambient */));
             var descriptor = languageVersion > 0 /* ES3 */
                 ? member.kind === 166 /* PropertyDeclaration */
                     // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it

package/lib/typescript.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211203";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -86828,18 +86828,22 @@ var ts;
             return false;
         }
         function checkNumericLiteralValueSize(node) {
+            // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "."
+            // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`.
+            var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1;
+            var isScientific = node.numericLiteralFlags & 16 /* Scientific */;
             // Scientific notation (e.g. 2e54 and 1e00000000010) can't be converted to bigint
-            // Literals with 15 or fewer characters aren't long enough to reach past 2^53 - 1
             // Fractional numbers (e.g. 9000000000000000.001) are inherently imprecise anyway
-            if (node.numericLiteralFlags & 16 /* Scientific */ || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+            if (isFractional || isScientific) {
                 return;
             }
-            // We can't rely on the runtime to accurately store and compare extremely large numeric values
-            // Even for internal use, we use getTextOfNode: https://github.com/microsoft/TypeScript/issues/33298
-            // Thus, if the runtime claims a too-large number is lower than Number.MAX_SAFE_INTEGER,
-            // it's likely addition operations on it will fail too
-            var apparentValue = +ts.getTextOfNode(node);
-            if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+            // Here `node` is guaranteed to be a numeric literal representing an integer.
+            // We need to judge whether the integer `node` represents is <= 2 ** 53 - 1, which can be accomplished by comparing to `value` defined below because:
+            // 1) when `node` represents an integer <= 2 ** 53 - 1, `node.text` is its exact string representation and thus `value` precisely represents the integer.
+            // 2) otherwise, although `node.text` may be imprecise string representation, its mathematical value and consequently `value` cannot be less than 2 ** 53,
+            //    thus the result of the predicate won't be affected.
+            var value = +node.text;
+            if (value <= Math.pow(2, 53) - 1) {
                 return;
             }
             addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
@@ -90301,7 +90305,7 @@ var ts;
             //   ], C.prototype, "prop");
             //
             var prefix = getClassMemberPrefix(node, member);
-            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ true);
+            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !ts.hasSyntacticModifier(member, 2 /* Ambient */));
             var descriptor = languageVersion > 0 /* ES3 */
                 ? member.kind === 166 /* PropertyDeclaration */
                     // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211203";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -86828,18 +86828,22 @@ var ts;
             return false;
         }
         function checkNumericLiteralValueSize(node) {
+            // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "."
+            // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`.
+            var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1;
+            var isScientific = node.numericLiteralFlags & 16 /* Scientific */;
             // Scientific notation (e.g. 2e54 and 1e00000000010) can't be converted to bigint
-            // Literals with 15 or fewer characters aren't long enough to reach past 2^53 - 1
             // Fractional numbers (e.g. 9000000000000000.001) are inherently imprecise anyway
-            if (node.numericLiteralFlags & 16 /* Scientific */ || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+            if (isFractional || isScientific) {
                 return;
             }
-            // We can't rely on the runtime to accurately store and compare extremely large numeric values
-            // Even for internal use, we use getTextOfNode: https://github.com/microsoft/TypeScript/issues/33298
-            // Thus, if the runtime claims a too-large number is lower than Number.MAX_SAFE_INTEGER,
-            // it's likely addition operations on it will fail too
-            var apparentValue = +ts.getTextOfNode(node);
-            if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+            // Here `node` is guaranteed to be a numeric literal representing an integer.
+            // We need to judge whether the integer `node` represents is <= 2 ** 53 - 1, which can be accomplished by comparing to `value` defined below because:
+            // 1) when `node` represents an integer <= 2 ** 53 - 1, `node.text` is its exact string representation and thus `value` precisely represents the integer.
+            // 2) otherwise, although `node.text` may be imprecise string representation, its mathematical value and consequently `value` cannot be less than 2 ** 53,
+            //    thus the result of the predicate won't be affected.
+            var value = +node.text;
+            if (value <= Math.pow(2, 53) - 1) {
                 return;
             }
             addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
@@ -90301,7 +90305,7 @@ var ts;
             //   ], C.prototype, "prop");
             //
             var prefix = getClassMemberPrefix(node, member);
-            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ true);
+            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !ts.hasSyntacticModifier(member, 2 /* Ambient */));
             var descriptor = languageVersion > 0 /* ES3 */
                 ? member.kind === 166 /* PropertyDeclaration */
                     // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20211202";
+    ts.version = ts.versionMajorMinor + ".0-dev.20211203";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -86623,18 +86623,22 @@ var ts;
             return false;
         }
         function checkNumericLiteralValueSize(node) {
+            // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "."
+            // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`.
+            var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1;
+            var isScientific = node.numericLiteralFlags & 16 /* Scientific */;
             // Scientific notation (e.g. 2e54 and 1e00000000010) can't be converted to bigint
-            // Literals with 15 or fewer characters aren't long enough to reach past 2^53 - 1
             // Fractional numbers (e.g. 9000000000000000.001) are inherently imprecise anyway
-            if (node.numericLiteralFlags & 16 /* Scientific */ || node.text.length <= 15 || node.text.indexOf(".") !== -1) {
+            if (isFractional || isScientific) {
                 return;
             }
-            // We can't rely on the runtime to accurately store and compare extremely large numeric values
-            // Even for internal use, we use getTextOfNode: https://github.com/microsoft/TypeScript/issues/33298
-            // Thus, if the runtime claims a too-large number is lower than Number.MAX_SAFE_INTEGER,
-            // it's likely addition operations on it will fail too
-            var apparentValue = +ts.getTextOfNode(node);
-            if (apparentValue <= Math.pow(2, 53) - 1 && apparentValue + 1 > apparentValue) {
+            // Here `node` is guaranteed to be a numeric literal representing an integer.
+            // We need to judge whether the integer `node` represents is <= 2 ** 53 - 1, which can be accomplished by comparing to `value` defined below because:
+            // 1) when `node` represents an integer <= 2 ** 53 - 1, `node.text` is its exact string representation and thus `value` precisely represents the integer.
+            // 2) otherwise, although `node.text` may be imprecise string representation, its mathematical value and consequently `value` cannot be less than 2 ** 53,
+            //    thus the result of the predicate won't be affected.
+            var value = +node.text;
+            if (value <= Math.pow(2, 53) - 1) {
                 return;
             }
             addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers));
@@ -90096,7 +90100,7 @@ var ts;
             //   ], C.prototype, "prop");
             //
             var prefix = getClassMemberPrefix(node, member);
-            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ true);
+            var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !ts.hasSyntacticModifier(member, 2 /* Ambient */));
             var descriptor = languageVersion > 0 /* ES3 */
                 ? member.kind === 166 /* PropertyDeclaration */
                     // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.6.0-dev.20211202",
+    "version": "4.6.0-dev.20211203",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [
@@ -61,7 +61,7 @@
         "browser-resolve": "^1.11.2",
         "browserify": "latest",
         "chai": "latest",
-        "chalk": "latest",
+        "chalk": "^4.1.2",
         "convert-source-map": "latest",
         "del": "5.1.0",
         "diff": "^4.0.2",