typescript 4.8.0-dev.20220728 → 4.8.0-dev.20220731

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.20220728";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220731";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1895,6 +1895,10 @@ var ts;
     /** Does nothing. */
     function noop(_) { }
     ts.noop = noop;
+    ts.noopPush = {
+        push: noop,
+        length: 0
+    };
     /** Do nothing and return false */
     function returnFalse() {
         return false;
@@ -5903,10 +5907,8 @@ var ts;
         TransformFlags[TransformFlags["ContainsPossibleTopLevelAwait"] = 67108864] = "ContainsPossibleTopLevelAwait";
         TransformFlags[TransformFlags["ContainsLexicalSuper"] = 134217728] = "ContainsLexicalSuper";
         TransformFlags[TransformFlags["ContainsUpdateExpressionForIdentifier"] = 268435456] = "ContainsUpdateExpressionForIdentifier";
-        // Please leave this as 1 << 29.
-        // It is the maximum bit we can set before we outgrow the size of a v8 small integer (SMI) on an x86 system.
-        // It is a good reminder of how much room we have left
-        TransformFlags[TransformFlags["HasComputedFlags"] = 536870912] = "HasComputedFlags";
+        TransformFlags[TransformFlags["ContainsPrivateIdentifierInExpression"] = 536870912] = "ContainsPrivateIdentifierInExpression";
+        TransformFlags[TransformFlags["HasComputedFlags"] = -2147483648] = "HasComputedFlags";
         // Assertions
         // - Bitmasks that are used to assert facts about the syntax of a node and its subtree.
         TransformFlags[TransformFlags["AssertTypeScript"] = 1] = "AssertTypeScript";
@@ -5925,23 +5927,23 @@ var ts;
         // Scope Exclusions
         // - Bitmasks that exclude flags from propagating out of a specific context
         //   into the subtree flags of their container.
-        TransformFlags[TransformFlags["OuterExpressionExcludes"] = 536870912] = "OuterExpressionExcludes";
-        TransformFlags[TransformFlags["PropertyAccessExcludes"] = 536870912] = "PropertyAccessExcludes";
-        TransformFlags[TransformFlags["NodeExcludes"] = 536870912] = "NodeExcludes";
-        TransformFlags[TransformFlags["ArrowFunctionExcludes"] = 612179968] = "ArrowFunctionExcludes";
-        TransformFlags[TransformFlags["FunctionExcludes"] = 746414080] = "FunctionExcludes";
-        TransformFlags[TransformFlags["ConstructorExcludes"] = 746405888] = "ConstructorExcludes";
-        TransformFlags[TransformFlags["MethodOrAccessorExcludes"] = 679297024] = "MethodOrAccessorExcludes";
-        TransformFlags[TransformFlags["PropertyExcludes"] = 671105024] = "PropertyExcludes";
-        TransformFlags[TransformFlags["ClassExcludes"] = 537010176] = "ClassExcludes";
-        TransformFlags[TransformFlags["ModuleExcludes"] = 742678528] = "ModuleExcludes";
+        TransformFlags[TransformFlags["OuterExpressionExcludes"] = -2147483648] = "OuterExpressionExcludes";
+        TransformFlags[TransformFlags["PropertyAccessExcludes"] = -2147483648] = "PropertyAccessExcludes";
+        TransformFlags[TransformFlags["NodeExcludes"] = -2147483648] = "NodeExcludes";
+        TransformFlags[TransformFlags["ArrowFunctionExcludes"] = -2072174592] = "ArrowFunctionExcludes";
+        TransformFlags[TransformFlags["FunctionExcludes"] = -1937940480] = "FunctionExcludes";
+        TransformFlags[TransformFlags["ConstructorExcludes"] = -1937948672] = "ConstructorExcludes";
+        TransformFlags[TransformFlags["MethodOrAccessorExcludes"] = -2005057536] = "MethodOrAccessorExcludes";
+        TransformFlags[TransformFlags["PropertyExcludes"] = -2013249536] = "PropertyExcludes";
+        TransformFlags[TransformFlags["ClassExcludes"] = -2147344384] = "ClassExcludes";
+        TransformFlags[TransformFlags["ModuleExcludes"] = -1941676032] = "ModuleExcludes";
         TransformFlags[TransformFlags["TypeExcludes"] = -2] = "TypeExcludes";
-        TransformFlags[TransformFlags["ObjectLiteralExcludes"] = 537075712] = "ObjectLiteralExcludes";
-        TransformFlags[TransformFlags["ArrayLiteralOrCallOrNewExcludes"] = 536903680] = "ArrayLiteralOrCallOrNewExcludes";
-        TransformFlags[TransformFlags["VariableDeclarationListExcludes"] = 537460736] = "VariableDeclarationListExcludes";
-        TransformFlags[TransformFlags["ParameterExcludes"] = 536870912] = "ParameterExcludes";
-        TransformFlags[TransformFlags["CatchClauseExcludes"] = 536936448] = "CatchClauseExcludes";
-        TransformFlags[TransformFlags["BindingPatternExcludes"] = 536903680] = "BindingPatternExcludes";
+        TransformFlags[TransformFlags["ObjectLiteralExcludes"] = -2147278848] = "ObjectLiteralExcludes";
+        TransformFlags[TransformFlags["ArrayLiteralOrCallOrNewExcludes"] = -2147450880] = "ArrayLiteralOrCallOrNewExcludes";
+        TransformFlags[TransformFlags["VariableDeclarationListExcludes"] = -2146893824] = "VariableDeclarationListExcludes";
+        TransformFlags[TransformFlags["ParameterExcludes"] = -2147483648] = "ParameterExcludes";
+        TransformFlags[TransformFlags["CatchClauseExcludes"] = -2147418112] = "CatchClauseExcludes";
+        TransformFlags[TransformFlags["BindingPatternExcludes"] = -2147450880] = "BindingPatternExcludes";
         TransformFlags[TransformFlags["ContainsLexicalThisOrSuper"] = 134234112] = "ContainsLexicalThisOrSuper";
         // Propagating flags
         // - Bitmasks for flags that should propagate from a child
@@ -8976,6 +8978,7 @@ var ts;
         Cannot_create_an_instance_of_an_abstract_class: diag(2511, ts.DiagnosticCategory.Error, "Cannot_create_an_instance_of_an_abstract_class_2511", "Cannot create an instance of an abstract class."),
         Overload_signatures_must_all_be_abstract_or_non_abstract: diag(2512, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."),
         Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: diag(2513, ts.DiagnosticCategory.Error, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."),
+        A_tuple_type_cannot_be_indexed_with_a_negative_value: diag(2514, ts.DiagnosticCategory.Error, "A_tuple_type_cannot_be_indexed_with_a_negative_value_2514", "A tuple type cannot be indexed with a negative value."),
         Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, ts.DiagnosticCategory.Error, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'."),
         All_declarations_of_an_abstract_method_must_be_consecutive: diag(2516, ts.DiagnosticCategory.Error, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."),
         Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: diag(2517, ts.DiagnosticCategory.Error, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."),
@@ -24279,7 +24282,7 @@ var ts;
                 propagateChildFlags(node.expression) |
                     (ts.isIdentifier(node.name) ?
                         propagateIdentifierNameFlags(node.name) :
-                        propagateChildFlags(node.name));
+                        propagateChildFlags(node.name) | 536870912 /* ContainsPrivateIdentifierInExpression */);
             if (ts.isSuperKeyword(expression)) {
                 // super method calls require a lexical 'this'
                 // super method calls require 'super' hoisting in ES2017 and ES2018 async functions and async generators
@@ -24312,7 +24315,7 @@ var ts;
                     propagateChildFlags(node.questionDotToken) |
                     (ts.isIdentifier(node.name) ?
                         propagateIdentifierNameFlags(node.name) :
-                        propagateChildFlags(node.name));
+                        propagateChildFlags(node.name) | 536870912 /* ContainsPrivateIdentifierInExpression */);
             return node;
         }
         // @api
@@ -24716,6 +24719,9 @@ var ts;
             else if (ts.isLogicalOrCoalescingAssignmentOperator(operatorKind)) {
                 node.transformFlags |= 16 /* ContainsES2021 */;
             }
+            if (operatorKind === 101 /* InKeyword */ && ts.isPrivateIdentifier(node.left)) {
+                node.transformFlags |= 536870912 /* ContainsPrivateIdentifierInExpression */;
+            }
             return node;
         }
         function propagateAssignmentPatternFlags(node) {
@@ -27670,29 +27676,29 @@ var ts;
             case 208 /* CallExpression */:
             case 209 /* NewExpression */:
             case 204 /* ArrayLiteralExpression */:
-                return 536903680 /* ArrayLiteralOrCallOrNewExcludes */;
+                return -2147450880 /* ArrayLiteralOrCallOrNewExcludes */;
             case 261 /* ModuleDeclaration */:
-                return 742678528 /* ModuleExcludes */;
+                return -1941676032 /* ModuleExcludes */;
             case 164 /* Parameter */:
-                return 536870912 /* ParameterExcludes */;
+                return -2147483648 /* ParameterExcludes */;
             case 214 /* ArrowFunction */:
-                return 612179968 /* ArrowFunctionExcludes */;
+                return -2072174592 /* ArrowFunctionExcludes */;
             case 213 /* FunctionExpression */:
             case 256 /* FunctionDeclaration */:
-                return 746414080 /* FunctionExcludes */;
+                return -1937940480 /* FunctionExcludes */;
             case 255 /* VariableDeclarationList */:
-                return 537460736 /* VariableDeclarationListExcludes */;
+                return -2146893824 /* VariableDeclarationListExcludes */;
             case 257 /* ClassDeclaration */:
             case 226 /* ClassExpression */:
-                return 537010176 /* ClassExcludes */;
+                return -2147344384 /* ClassExcludes */;
             case 171 /* Constructor */:
-                return 746405888 /* ConstructorExcludes */;
+                return -1937948672 /* ConstructorExcludes */;
             case 167 /* PropertyDeclaration */:
-                return 671105024 /* PropertyExcludes */;
+                return -2013249536 /* PropertyExcludes */;
             case 169 /* MethodDeclaration */:
             case 172 /* GetAccessor */:
             case 173 /* SetAccessor */:
-                return 679297024 /* MethodOrAccessorExcludes */;
+                return -2005057536 /* MethodOrAccessorExcludes */;
             case 130 /* AnyKeyword */:
             case 147 /* NumberKeyword */:
             case 158 /* BigIntKeyword */:
@@ -27712,23 +27718,23 @@ var ts;
             case 259 /* TypeAliasDeclaration */:
                 return -2 /* TypeExcludes */;
             case 205 /* ObjectLiteralExpression */:
-                return 537075712 /* ObjectLiteralExcludes */;
+                return -2147278848 /* ObjectLiteralExcludes */;
             case 292 /* CatchClause */:
-                return 536936448 /* CatchClauseExcludes */;
+                return -2147418112 /* CatchClauseExcludes */;
             case 201 /* ObjectBindingPattern */:
             case 202 /* ArrayBindingPattern */:
-                return 536903680 /* BindingPatternExcludes */;
+                return -2147450880 /* BindingPatternExcludes */;
             case 211 /* TypeAssertionExpression */:
             case 229 /* AsExpression */:
             case 350 /* PartiallyEmittedExpression */:
             case 212 /* ParenthesizedExpression */:
             case 106 /* SuperKeyword */:
-                return 536870912 /* OuterExpressionExcludes */;
+                return -2147483648 /* OuterExpressionExcludes */;
             case 206 /* PropertyAccessExpression */:
             case 207 /* ElementAccessExpression */:
-                return 536870912 /* PropertyAccessExcludes */;
+                return -2147483648 /* PropertyAccessExcludes */;
             default:
-                return 536870912 /* NodeExcludes */;
+                return -2147483648 /* NodeExcludes */;
         }
     }
     ts.getTransformFlagsSubtreeExclusions = getTransformFlagsSubtreeExclusions;
@@ -43330,18 +43336,7 @@ var ts;
      * Does not try `@types/${packageName}` - use a second pass if needed.
      */
     function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) {
-        var moduleResolutionState = {
-            compilerOptions: options,
-            host: host,
-            traceEnabled: isTraceEnabled(options, host),
-            failedLookupLocations: [],
-            affectingLocations: [],
-            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
-            conditions: ts.emptyArray,
-            features: NodeResolutionFeatures.None,
-            requestContainingDirectory: containingDirectory,
-            reportDiagnostic: ts.noop
-        };
+        var moduleResolutionState = getTemporaryModuleResolutionState(cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(), host, options);
         return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) {
             if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") {
                 var nodeModulesFolder = ts.combinePaths(ancestorDirectory, "node_modules");
@@ -44301,18 +44296,9 @@ var ts;
         var entrypoints;
         var extensions = resolveJs ? Extensions.JavaScript : Extensions.TypeScript;
         var features = getDefaultNodeResolutionFeatures(options);
-        var requireState = {
-            compilerOptions: options,
-            host: host,
-            traceEnabled: isTraceEnabled(options, host),
-            failedLookupLocations: [],
-            affectingLocations: [],
-            packageJsonInfoCache: cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(),
-            conditions: ["node", "require", "types"],
-            features: features,
-            requestContainingDirectory: packageJsonInfo.packageDirectory,
-            reportDiagnostic: ts.noop
-        };
+        var requireState = getTemporaryModuleResolutionState(cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(), host, options);
+        requireState.conditions = ["node", "require", "types"];
+        requireState.requestContainingDirectory = packageJsonInfo.packageDirectory;
         var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, 
         /*onlyRecordFailures*/ false, requireState, packageJsonInfo.packageJsonContent, packageJsonInfo.versionPaths);
         entrypoints = ts.append(entrypoints, requireResolution === null || requireResolution === void 0 ? void 0 : requireResolution.path);
@@ -44385,23 +44371,27 @@ var ts;
             }
         }
     }
-    /**
-     * A function for locating the package.json scope for a given path
-     */
     /*@internal*/
-    function getPackageScopeForPath(fileName, packageJsonInfoCache, host, options) {
-        var state = {
+    function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options) {
+        return {
             host: host,
             compilerOptions: options,
             traceEnabled: isTraceEnabled(options, host),
-            failedLookupLocations: [],
-            affectingLocations: [],
+            failedLookupLocations: ts.noopPush,
+            affectingLocations: ts.noopPush,
             packageJsonInfoCache: packageJsonInfoCache,
-            features: 0,
-            conditions: [],
+            features: NodeResolutionFeatures.None,
+            conditions: ts.emptyArray,
             requestContainingDirectory: undefined,
             reportDiagnostic: ts.noop
         };
+    }
+    ts.getTemporaryModuleResolutionState = getTemporaryModuleResolutionState;
+    /**
+     * A function for locating the package.json scope for a given path
+     */
+    /*@internal*/
+    function getPackageScopeForPath(fileName, state) {
         var parts = ts.getPathComponents(fileName);
         parts.pop();
         while (parts.length > 0) {
@@ -44572,7 +44562,7 @@ var ts;
         var _a, _b;
         var useCaseSensitiveFileNames = typeof state.host.useCaseSensitiveFileNames === "function" ? state.host.useCaseSensitiveFileNames() : state.host.useCaseSensitiveFileNames;
         var directoryPath = ts.toPath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
-        var scope = getPackageScopeForPath(directoryPath, state.packageJsonInfoCache, state.host, state.compilerOptions);
+        var scope = getPackageScopeForPath(directoryPath, state);
         if (!scope || !scope.packageJsonContent.exports) {
             return undefined;
         }
@@ -44631,7 +44621,7 @@ var ts;
         }
         var useCaseSensitiveFileNames = typeof state.host.useCaseSensitiveFileNames === "function" ? state.host.useCaseSensitiveFileNames() : state.host.useCaseSensitiveFileNames;
         var directoryPath = ts.toPath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a), ts.createGetCanonicalFileName(useCaseSensitiveFileNames === undefined ? true : useCaseSensitiveFileNames));
-        var scope = getPackageScopeForPath(directoryPath, state.packageJsonInfoCache, state.host, state.compilerOptions);
+        var scope = getPackageScopeForPath(directoryPath, state);
         if (!scope) {
             if (state.traceEnabled) {
                 trace(state.host, ts.Diagnostics.Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve, directoryPath);
@@ -53091,6 +53081,12 @@ var ts;
                 return context.truncating = context.approximateLength > ((context.flags & 1 /* NoTruncation */) ? ts.noTruncationMaximumTruncationLength : ts.defaultMaximumTruncationLength);
             }
             function typeToTypeNodeHelper(type, context) {
+                var savedFlags = context.flags;
+                var typeNode = typeToTypeNodeWorker(type, context);
+                context.flags = savedFlags;
+                return typeNode;
+            }
+            function typeToTypeNodeWorker(type, context) {
                 if (cancellationToken && cancellationToken.throwIfCancellationRequested) {
                     cancellationToken.throwIfCancellationRequested();
                 }
@@ -62829,21 +62825,28 @@ var ts;
                         getFlowTypeOfReference(accessExpression, propType) :
                         propType;
                 }
-                if (everyType(objectType, isTupleType) && ts.isNumericLiteralName(propName) && +propName >= 0) {
+                if (everyType(objectType, isTupleType) && ts.isNumericLiteralName(propName)) {
+                    var index = +propName;
                     if (accessNode && everyType(objectType, function (t) { return !t.target.hasRestElement; }) && !(accessFlags & 16 /* NoTupleBoundsCheck */)) {
                         var indexNode = getIndexNodeForAccessExpression(accessNode);
                         if (isTupleType(objectType)) {
+                            if (index < 0) {
+                                error(indexNode, ts.Diagnostics.A_tuple_type_cannot_be_indexed_with_a_negative_value);
+                                return undefinedType;
+                            }
                             error(indexNode, ts.Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2, typeToString(objectType), getTypeReferenceArity(objectType), ts.unescapeLeadingUnderscores(propName));
                         }
                         else {
                             error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType));
                         }
                     }
-                    errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, numberType));
-                    return mapType(objectType, function (t) {
-                        var restType = getRestTypeOfTupleType(t) || undefinedType;
-                        return accessFlags & 1 /* IncludeUndefined */ ? getUnionType([restType, undefinedType]) : restType;
-                    });
+                    if (index >= 0) {
+                        errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, numberType));
+                        return mapType(objectType, function (t) {
+                            var restType = getRestTypeOfTupleType(t) || undefinedType;
+                            return accessFlags & 1 /* IncludeUndefined */ ? getUnionType([restType, undefinedType]) : restType;
+                        });
+                    }
                 }
             }
             if (!(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 402653316 /* StringLike */ | 296 /* NumberLike */ | 12288 /* ESSymbolLike */)) {
@@ -80977,7 +80980,7 @@ var ts;
                     error(node.name, ts.Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name);
                 }
             }
-            if (node.questionToken && ts.isBindingPattern(node.name) && func.body) {
+            if ((node.questionToken || isJSDocOptionalParameter(node)) && ts.isBindingPattern(node.name) && func.body) {
                 error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature);
             }
             if (node.name && ts.isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) {
@@ -96782,39 +96785,72 @@ var ts;
         function visitClassDeclaration(node) {
             if (!(ts.classOrConstructorParameterIsDecorated(node) || ts.childIsDecorated(node)))
                 return ts.visitEachChild(node, visitor, context);
-            var classStatement = ts.hasDecorators(node) ?
-                createClassDeclarationHeadWithDecorators(node, node.name) :
-                createClassDeclarationHeadWithoutDecorators(node, node.name);
-            var statements = [classStatement];
-            // Write any decorators of the node.
-            addClassElementDecorationStatements(statements, node, /*isStatic*/ false);
-            addClassElementDecorationStatements(statements, node, /*isStatic*/ true);
-            addConstructorDecorationStatement(statements, node);
+            var statements = ts.hasDecorators(node) ?
+                transformClassDeclarationWithClassDecorators(node, node.name) :
+                transformClassDeclarationWithoutClassDecorators(node, node.name);
             if (statements.length > 1) {
                 // Add a DeclarationMarker as a marker for the end of the declaration
                 statements.push(factory.createEndOfDeclarationMarker(node));
-                ts.setEmitFlags(classStatement, ts.getEmitFlags(classStatement) | 4194304 /* HasEndOfDeclarationMarker */);
+                ts.setEmitFlags(statements[0], ts.getEmitFlags(statements[0]) | 4194304 /* HasEndOfDeclarationMarker */);
             }
             return ts.singleOrMany(statements);
         }
+        function decoratorContainsPrivateIdentifierInExpression(decorator) {
+            return !!(decorator.transformFlags & 536870912 /* ContainsPrivateIdentifierInExpression */);
+        }
+        function parameterDecoratorsContainPrivateIdentifierInExpression(parameterDecorators) {
+            return ts.some(parameterDecorators, decoratorContainsPrivateIdentifierInExpression);
+        }
+        function hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node) {
+            for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
+                var member = _a[_i];
+                if (!ts.canHaveDecorators(member))
+                    continue;
+                var allDecorators = ts.getAllDecoratorsOfClassElement(member, node);
+                if (ts.some(allDecorators === null || allDecorators === void 0 ? void 0 : allDecorators.decorators, decoratorContainsPrivateIdentifierInExpression))
+                    return true;
+                if (ts.some(allDecorators === null || allDecorators === void 0 ? void 0 : allDecorators.parameters, parameterDecoratorsContainPrivateIdentifierInExpression))
+                    return true;
+            }
+            return false;
+        }
+        function transformDecoratorsOfClassElements(node, members) {
+            var decorationStatements = [];
+            addClassElementDecorationStatements(decorationStatements, node, /*isStatic*/ false);
+            addClassElementDecorationStatements(decorationStatements, node, /*isStatic*/ true);
+            if (hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node)) {
+                members = ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray([], members, true), [
+                    factory.createClassStaticBlockDeclaration(factory.createBlock(decorationStatements, /*multiLine*/ true))
+                ], false)), members);
+                decorationStatements = undefined;
+            }
+            return { decorationStatements: decorationStatements, members: members };
+        }
         /**
          * Transforms a non-decorated class declaration.
          *
          * @param node A ClassDeclaration node.
          * @param name The name of the class.
          */
-        function createClassDeclarationHeadWithoutDecorators(node, name) {
+        function transformClassDeclarationWithoutClassDecorators(node, name) {
             //  ${modifiers} class ${name} ${heritageClauses} {
             //      ${members}
             //  }
-            return factory.updateClassDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), name, 
-            /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), ts.visitNodes(node.members, visitor, ts.isClassElement));
+            var _a;
+            var modifiers = ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier);
+            var heritageClauses = ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause);
+            var members = ts.visitNodes(node.members, visitor, ts.isClassElement);
+            var decorationStatements = [];
+            (_a = transformDecoratorsOfClassElements(node, members), members = _a.members, decorationStatements = _a.decorationStatements);
+            var updated = factory.updateClassDeclaration(node, modifiers, name, 
+            /*typeParameters*/ undefined, heritageClauses, members);
+            return ts.addRange([updated], decorationStatements);
         }
         /**
          * Transforms a decorated class declaration and appends the resulting statements. If
          * the class requires an alias to avoid issues with double-binding, the alias is returned.
          */
-        function createClassDeclarationHeadWithDecorators(node, name) {
+        function transformClassDeclarationWithClassDecorators(node, name) {
             // When we emit an ES6 class that has a class decorator, we must tailor the
             // emit to certain specific cases.
             //
@@ -96900,6 +96936,7 @@ var ts;
             //                                  | var C_1;
             //  ---------------------------------------------------------------------
             //
+            var _a;
             var location = ts.moveRangePastModifiers(node);
             var classAlias = getClassAliasIfNeeded(node);
             // When we transform to ES5/3 this will be moved inside an IIFE and should reference the name
@@ -96912,7 +96949,11 @@ var ts;
             //  }
             var heritageClauses = ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause);
             var members = ts.visitNodes(node.members, visitor, ts.isClassElement);
-            var classExpression = factory.createClassExpression(/*modifiers*/ undefined, name, /*typeParameters*/ undefined, heritageClauses, members);
+            var decorationStatements = [];
+            (_a = transformDecoratorsOfClassElements(node, members), members = _a.members, decorationStatements = _a.decorationStatements);
+            var classExpression = factory.createClassExpression(
+            /*modifiers*/ undefined, name, 
+            /*typeParameters*/ undefined, heritageClauses, members);
             ts.setOriginalNode(classExpression, node);
             ts.setTextRange(classExpression, location);
             //  let ${name} = ${classExpression} where name is either declaredName if the class doesn't contain self-reference
@@ -96926,7 +96967,10 @@ var ts;
             ts.setOriginalNode(statement, node);
             ts.setTextRange(statement, location);
             ts.setCommentRange(statement, node);
-            return statement;
+            var statements = [statement];
+            ts.addRange(statements, decorationStatements);
+            addConstructorDecorationStatement(statements, node);
+            return statements;
         }
         function visitClassExpression(node) {
             // Legacy decorators were not supported on class expressions
@@ -117854,7 +117898,7 @@ var ts;
                 return undefined;
         }
         function lookupFromPackageJson() {
-            var scope = ts.getPackageScopeForPath(fileName, packageJsonInfoCache, host, options);
+            var scope = ts.getPackageScopeForPath(fileName, ts.getTemporaryModuleResolutionState(packageJsonInfoCache, host, options));
             return (scope === null || scope === void 0 ? void 0 : scope.packageJsonContent.type) === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS;
         }
     }
@@ -149236,6 +149280,7 @@ var ts;
             var options = _a.options, getRules = _a.getRules, host = _a.host;
             // formatting context is used by rules provider
             var formattingContext = new formatting.FormattingContext(sourceFile, requestKind, options);
+            var previousRangeTriviaEnd;
             var previousRange;
             var previousParent;
             var previousRangeStartLine;
@@ -149264,10 +149309,30 @@ var ts;
                 }
             }
             if (previousRange && formattingScanner.getStartPos() >= originalRange.end) {
+                // Formatting edits happen by looking at pairs of contiguous tokens (see `processPair`),
+                // typically inserting or deleting whitespace between them. The recursive `processNode`
+                // logic above bails out as soon as it encounters a token that is beyond the end of the
+                // range we're supposed to format (or if we reach the end of the file). But this potentially
+                // leaves out an edit that would occur *inside* the requested range but cannot be discovered
+                // without looking at one token *beyond* the end of the range: consider the line `x = { }`
+                // with a selection from the beginning of the line to the space inside the curly braces,
+                // inclusive. We would expect a format-selection would delete the space (if rules apply),
+                // but in order to do that, we need to process the pair ["{", "}"], but we stopped processing
+                // just before getting there. This block handles this trailing edit.
                 var tokenInfo = formattingScanner.isOnEOF() ? formattingScanner.readEOFTokenRange() :
                     formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(enclosingNode).token :
                         undefined;
-                if (tokenInfo) {
+                if (tokenInfo && tokenInfo.pos === previousRangeTriviaEnd) {
+                    // We need to check that tokenInfo and previousRange are contiguous: the `originalRange`
+                    // may have ended in the middle of a token, which means we will have stopped formatting
+                    // on that token, leaving `previousRange` pointing to the token before it, but already
+                    // having moved the formatting scanner (where we just got `tokenInfo`) to the next token.
+                    // If this happens, our supposed pair [previousRange, tokenInfo] actually straddles the
+                    // token that intersects the end of the range we're supposed to format, so the pair will
+                    // produce bogus edits if we try to `processPair`. Recall that the point of this logic is
+                    // to perform a trailing edit at the end of the selection range: but there can be no valid
+                    // edit in the middle of a token where the range ended, so if we have a non-contiguous
+                    // pair here, we're already done and we can ignore it.
                     var parent = ((_b = ts.findPrecedingToken(tokenInfo.end, sourceFile, enclosingNode)) === null || _b === void 0 ? void 0 : _b.parent) || previousParent;
                     processPair(tokenInfo, sourceFile.getLineAndCharacterOfPosition(tokenInfo.pos).line, parent, previousRange, previousRangeStartLine, previousParent, parent, 
                     /*dynamicIndentation*/ undefined);
@@ -149625,6 +149690,7 @@ var ts;
                         }
                     }
                     if (currentTokenInfo.trailingTrivia) {
+                        previousRangeTriviaEnd = ts.last(currentTokenInfo.trailingTrivia).end;
                         processTrivia(currentTokenInfo.trailingTrivia, parent, childContextNode, dynamicIndentation);
                     }
                     if (indentToken) {
@@ -149695,6 +149761,7 @@ var ts;
                     }
                 }
                 previousRange = range;
+                previousRangeTriviaEnd = range.end;
                 previousParent = parent;
                 previousRangeStartLine = rangeStart.line;
                 return lineAction;