typescript 4.6.0-dev.20220204 → 4.6.0-dev.20220208

package/lib/de/diagnosticMessages.generated.json

@@ -435,6 +435,7 @@
   "Convert_function_to_an_ES2015_class_95001": "Funktion in eine ES2015-Klasse konvertieren",
   "Convert_invalid_character_to_its_html_entity_code_95100": "Ungültiges Zeichen in entsprechenden HTML-Entitätscode konvertieren",
   "Convert_named_export_to_default_export_95062": "Benannten Export in Standardexport konvertieren",
+  "Convert_named_imports_to_default_import_95170": "Konvertieren benannter Importe in Standardimporte",
   "Convert_named_imports_to_namespace_import_95057": "Benannte Importe in Namespaceimport konvertieren",
   "Convert_namespace_import_to_named_imports_95056": "Namespaceimport in benannte Importe konvertieren",
   "Convert_overload_list_to_single_signature_95118": "Überladungsliste in einzelne Signatur konvertieren",
@@ -1116,7 +1117,6 @@
   "Property_0_is_protected_in_type_1_but_public_in_type_2_2444": "Die Eigenschaft \"{0}\" ist im Typ \"{1}\" geschützt, im Typ \"{2}\" aber öffentlich.",
   "Property_0_is_used_before_being_assigned_2565": "Die Eigenschaft \"{0}\" wird vor ihrer Zuweisung verwendet.",
   "Property_0_is_used_before_its_initialization_2729": "Die Eigenschaft \"{0}\" wird vor ihrer Initialisierung verwendet.",
-  "Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnex_2810": "Die Eigenschaft \"{0}\" darf nicht im Initialisierer einer statischen Eigenschaft in derselben Klasse verwendet werden, wenn \"target\" auf \"esnext\" und \"useDefineForClassFields\" auf FALSE festgelegt ist.",
   "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568": "Die Eigenschaft \"{0}\" ist für den Typ \"{1}\" möglicherweise nicht vorhanden. Meinten Sie \"{2}\"?",
   "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606": "Die Eigenschaft \"{0}\" des JSX-Verteilungsattributs kann nicht der Zieleigenschaft zugewiesen werden.",
   "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094": "Die Eigenschaft \"{0}\" des exportierten Klassenausdrucks ist unter Umständen nicht privat oder geschützt.",
@@ -1324,7 +1324,6 @@
   "Starting_compilation_in_watch_mode_6031": "Kompilierung im Überwachungsmodus wird gestartet...",
   "Statement_expected_1129": "Eine Anweisung wurde erwartet.",
   "Statements_are_not_allowed_in_ambient_contexts_1036": "Anweisungen sind in Umgebungskontexten unzulässig.",
-  "Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_no_2805": "Statische Felder mit privaten Namen dürfen keine Initialisierer enthalten, wenn das Flag \"--useDefineForClassFields\" nicht mit dem Wert \"esnext\" für \"--target\" angegeben wird. Erwägen Sie, das Flag \"--useDefineForClassFields\" hinzuzufügen.",
   "Static_members_cannot_reference_class_type_parameters_2302": "Statische Member dürfen nicht auf Klassentypparameter verweisen.",
   "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699": "Die statische Eigenschaft \"{0}\" steht in Konflikt mit der integrierten Eigenschaft \"Function.{0}\" der Konstruktorfunktion \"{1}\".",
   "String_literal_expected_1141": "Ein Zeichenfolgenliteral wurde erwartet.",

package/lib/ru/diagnosticMessages.generated.json

@@ -435,6 +435,7 @@
   "Convert_function_to_an_ES2015_class_95001": "Преобразование функции в класс ES2015",
   "Convert_invalid_character_to_its_html_entity_code_95100": "Преобразовать недопустимый знак в его код сущности HTML",
   "Convert_named_export_to_default_export_95062": "Преобразовать именованный экспорт в экспорт по умолчанию",
+  "Convert_named_imports_to_default_import_95170": "Преобразовать именованные операции импорта в стандартный импорт",
   "Convert_named_imports_to_namespace_import_95057": "Преобразовать операции импорта имен в импорт пространства имен",
   "Convert_namespace_import_to_named_imports_95056": "Преобразовать импорт пространства имен в операции импорта имен",
   "Convert_overload_list_to_single_signature_95118": "Преобразовать список перегрузок в одиночную сигнатуру",
@@ -1116,7 +1117,6 @@
   "Property_0_is_protected_in_type_1_but_public_in_type_2_2444": "Свойство \"{0}\" является защищенным в типе \"{1}\" и общим в типе \"{2}\".",
   "Property_0_is_used_before_being_assigned_2565": "Свойство \"{0}\" используется перед присваиванием значения.",
   "Property_0_is_used_before_its_initialization_2729": "Свойство \"{0}\" используется перед его инициализацией.",
-  "Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnex_2810": "Свойство \"{0}\" не может использоваться в инициализаторе статического свойства в том же классе, если \"target\" имеет значение \"esnext\", а \"useDefineForClassFields\" — \"false\".",
   "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568": "Свойство \"{0}\" может не существовать в типе \"{1}\". Вы имели в виду \"{2}\"?",
   "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606": "Свойство \"{0}\" атрибута расширения JSX не может быть назначено для целевого свойства.",
   "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094": "Свойство \"{0}\" выражения экспортированного класса не может быть частным или защищенным.",
@@ -1324,7 +1324,6 @@
   "Starting_compilation_in_watch_mode_6031": "Запуск компиляции в режиме наблюдения...",
   "Statement_expected_1129": "Ожидался оператор.",
   "Statements_are_not_allowed_in_ambient_contexts_1036": "Операторы не разрешены в окружающих контекстах.",
-  "Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_no_2805": "Статические поля с частными именами не могут иметь инициализаторы, если не указан флаг \"--useDefineForClassFields\" с параметром \"--target\", имеющим значение \"esnext\". Рекомендуется добавить флаг \"--useDefineForClassFields\".",
   "Static_members_cannot_reference_class_type_parameters_2302": "Статические элементы не могут ссылаться на параметры типов класса.",
   "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699": "Статическое свойство \"{0}\" конфликтует со встроенным свойством \"Function.{0}\" функции-конструктора \"{1}\".",
   "String_literal_expected_1141": "Ожидался строковый литерал.",

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.20220204";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220208";
     var NativeCollections;
     (function (NativeCollections) {
         var globals = typeof globalThis !== "undefined" ? globalThis :
@@ -1087,11 +1087,11 @@ var ts;
         return result;
     }
     ts.getAllKeys = getAllKeys;
-    function getOwnValues(sparseArray) {
+    function getOwnValues(collection) {
         var values = [];
-        for (var key in sparseArray) {
-            if (hasOwnProperty.call(sparseArray, key)) {
-                values.push(sparseArray[key]);
+        for (var key in collection) {
+            if (hasOwnProperty.call(collection, key)) {
+                values.push(collection[key]);
             }
         }
         return values;
@@ -5895,12 +5895,10 @@ var ts;
         Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher: diag(2802, ts.DiagnosticCategory.Error, "Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es201_2802", "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher."),
         Cannot_assign_to_private_method_0_Private_methods_are_not_writable: diag(2803, ts.DiagnosticCategory.Error, "Cannot_assign_to_private_method_0_Private_methods_are_not_writable_2803", "Cannot assign to private method '{0}'. Private methods are not writable."),
         Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name: diag(2804, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name_2804", "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name."),
-        Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_not_specified_with_a_target_of_esnext_Consider_adding_the_useDefineForClassFields_flag: diag(2805, ts.DiagnosticCategory.Error, "Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_no_2805", "Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag."),
         Private_accessor_was_defined_without_a_getter: diag(2806, ts.DiagnosticCategory.Error, "Private_accessor_was_defined_without_a_getter_2806", "Private accessor was defined without a getter."),
         This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0: diag(2807, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807", "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'."),
         A_get_accessor_must_be_at_least_as_accessible_as_the_setter: diag(2808, ts.DiagnosticCategory.Error, "A_get_accessor_must_be_at_least_as_accessible_as_the_setter_2808", "A get accessor must be at least as accessible as the setter"),
         Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses: diag(2809, ts.DiagnosticCategory.Error, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the the whole assignment in parentheses."),
-        Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnext_and_useDefineForClassFields_is_false: diag(2810, ts.DiagnosticCategory.Error, "Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnex_2810", "Property '{0}' may not be used in a static property's initializer in the same class when 'target' is 'esnext' and 'useDefineForClassFields' is 'false'."),
         Initializer_for_property_0: diag(2811, ts.DiagnosticCategory.Error, "Initializer_for_property_0_2811", "Initializer for property '{0}'"),
         Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom: diag(2812, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom_2812", "Property '{0}' does not exist on type '{1}'. Try changing the 'lib' compiler option to include 'dom'."),
         Class_declaration_cannot_implement_overload_list_for_0: diag(2813, ts.DiagnosticCategory.Error, "Class_declaration_cannot_implement_overload_list_for_0_2813", "Class declaration cannot implement overload list for '{0}'."),
@@ -6851,6 +6849,7 @@ var ts;
         Add_missing_attributes: diag(95167, ts.DiagnosticCategory.Message, "Add_missing_attributes_95167", "Add missing attributes"),
         Add_all_missing_attributes: diag(95168, ts.DiagnosticCategory.Message, "Add_all_missing_attributes_95168", "Add all missing attributes"),
         Add_undefined_to_optional_property_type: diag(95169, ts.DiagnosticCategory.Message, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"),
+        Convert_named_imports_to_default_import: diag(95170, ts.DiagnosticCategory.Message, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"),
         No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
         Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
         JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -48921,7 +48920,7 @@ var ts;
         }
         function getImpliedConstraint(type, checkNode, extendsNode) {
             return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, checkNode.elements[0], extendsNode.elements[0]) :
-                getActualTypeVariable(getTypeFromTypeNode(checkNode)) === type ? getTypeFromTypeNode(extendsNode) :
+                getActualTypeVariable(getTypeFromTypeNode(checkNode)) === getActualTypeVariable(type) ? getTypeFromTypeNode(extendsNode) :
                     undefined;
         }
         function getConditionalFlowTypeOfType(type, node) {
@@ -60938,23 +60937,6 @@ var ts;
                 if (assignmentKind && lexicallyScopedSymbol && lexicallyScopedSymbol.valueDeclaration && ts.isMethodDeclaration(lexicallyScopedSymbol.valueDeclaration)) {
                     grammarErrorOnNode(right, ts.Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, ts.idText(right));
                 }
-                if ((lexicallyScopedSymbol === null || lexicallyScopedSymbol === void 0 ? void 0 : lexicallyScopedSymbol.valueDeclaration) && (ts.getEmitScriptTarget(compilerOptions) === 99 && !useDefineForClassFields)) {
-                    var lexicalClass_1 = ts.getContainingClass(lexicallyScopedSymbol.valueDeclaration);
-                    var parentStaticFieldInitializer = ts.findAncestor(node, function (n) {
-                        if (n === lexicalClass_1)
-                            return "quit";
-                        if (ts.isPropertyDeclaration(n.parent) && ts.hasStaticModifier(n.parent) && n.parent.initializer === n && n.parent.parent === lexicalClass_1) {
-                            return true;
-                        }
-                        return false;
-                    });
-                    if (parentStaticFieldInitializer) {
-                        var parentStaticFieldInitializerSymbol = getSymbolOfNode(parentStaticFieldInitializer.parent);
-                        ts.Debug.assert(parentStaticFieldInitializerSymbol, "Initializer without declaration symbol");
-                        var diagnostic = error(node, ts.Diagnostics.Property_0_may_not_be_used_in_a_static_property_s_initializer_in_the_same_class_when_target_is_esnext_and_useDefineForClassFields_is_false, ts.symbolName(lexicallyScopedSymbol));
-                        ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(parentStaticFieldInitializer.parent, ts.Diagnostics.Initializer_for_property_0, ts.symbolName(parentStaticFieldInitializerSymbol)));
-                    }
-                }
                 if (isAnyLike) {
                     if (lexicallyScopedSymbol) {
                         return isErrorType(apparentType) ? errorType : apparentType;
@@ -65881,9 +65863,6 @@ var ts;
                 checkGrammarComputedPropertyName(node.name);
             checkVariableLikeDeclaration(node);
             setNodeLinksForPrivateIdentifierScope(node);
-            if (ts.isPrivateIdentifier(node.name) && ts.hasStaticModifier(node) && node.initializer && languageVersion === 99 && !compilerOptions.useDefineForClassFields) {
-                error(node.initializer, ts.Diagnostics.Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_not_specified_with_a_target_of_esnext_Consider_adding_the_useDefineForClassFields_flag);
-            }
             if (ts.hasSyntacticModifier(node, 128) && node.kind === 166 && node.initializer) {
                 error(node, ts.Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, ts.declarationNameToString(node.name));
             }
@@ -77054,8 +77033,8 @@ var ts;
         var languageVersion = ts.getEmitScriptTarget(compilerOptions);
         var useDefineForClassFields = ts.getUseDefineForClassFields(compilerOptions);
         var shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9;
-        var shouldTransformSuperInStaticInitializers = (languageVersion <= 8 || !useDefineForClassFields) && languageVersion >= 2;
-        var shouldTransformThisInStaticInitializers = languageVersion <= 8 || !useDefineForClassFields;
+        var shouldTransformThisInStaticInitializers = languageVersion < 9;
+        var shouldTransformSuperInStaticInitializers = shouldTransformThisInStaticInitializers && languageVersion >= 2;
         var previousOnSubstituteNode = context.onSubstituteNode;
         context.onSubstituteNode = onSubstituteNode;
         var previousOnEmitNode = context.onEmitNode;
@@ -77255,6 +77234,9 @@ var ts;
             ts.Debug.assert(!ts.some(node.decorators));
             if (ts.isPrivateIdentifier(node.name)) {
                 if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
+                    if (ts.isStatic(node)) {
+                        return ts.visitEachChild(node, visitor, context);
+                    }
                     return factory.updatePropertyDeclaration(node, undefined, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.name, undefined, undefined, undefined);
                 }
                 var info = accessPrivateIdentifier(node.name);
@@ -77267,6 +77249,18 @@ var ts;
             if (expr && !ts.isSimpleInlineableExpression(expr)) {
                 getPendingExpressions().push(expr);
             }
+            if (ts.isStatic(node) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
+                var initializerStatement = transformPropertyOrClassStaticBlock(node, factory.createThis());
+                if (initializerStatement) {
+                    var staticBlock = factory.createClassStaticBlockDeclaration(undefined, undefined, factory.createBlock([initializerStatement]));
+                    ts.setOriginalNode(staticBlock, node);
+                    ts.setCommentRange(staticBlock, node);
+                    ts.setCommentRange(initializerStatement, { pos: -1, end: -1 });
+                    ts.setSyntheticLeadingComments(initializerStatement, undefined);
+                    ts.setSyntheticTrailingComments(initializerStatement, undefined);
+                    return staticBlock;
+                }
+            }
             return undefined;
         }
         function createPrivateIdentifierAccess(info, receiver) {
@@ -77625,7 +77619,6 @@ var ts;
             if (facts & 8) {
                 enableSubstitutionForClassStaticThisOrSuperReference();
             }
-            var staticProperties = ts.getStaticPropertiesAndClassStaticBlock(node);
             var pendingClassReferenceAssignment;
             if (facts & 2) {
                 var temp = factory.createTempVariable(hoistVariableDeclaration, true);
@@ -77643,6 +77636,7 @@ var ts;
             if (ts.some(pendingExpressions)) {
                 statements.push(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions)));
             }
+            var staticProperties = ts.getStaticPropertiesAndClassStaticBlock(node);
             if (ts.some(staticProperties)) {
                 addPropertyOrClassStaticBlockStatements(statements, staticProperties, factory.getInternalName(node));
             }
@@ -77673,7 +77667,7 @@ var ts;
                 getClassLexicalEnvironment().classConstructor = factory.cloneNode(temp);
             }
             var classExpression = factory.updateClassExpression(node, ts.visitNodes(node.decorators, visitor, ts.isDecorator), node.modifiers, node.name, undefined, ts.visitNodes(node.heritageClauses, heritageClauseVisitor, ts.isHeritageClause), transformClassMembers(node, isDerivedClass));
-            var hasTransformableStatics = ts.some(staticPropertiesOrClassStaticBlocks, function (p) { return ts.isClassStaticBlockDeclaration(p) || !!p.initializer || (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifier(p.name)); });
+            var hasTransformableStatics = shouldTransformPrivateElementsOrClassStaticBlocks && ts.some(staticPropertiesOrClassStaticBlocks, function (p) { return ts.isClassStaticBlockDeclaration(p) || !!p.initializer || ts.isPrivateIdentifier(p.name); });
             if (hasTransformableStatics || ts.some(pendingExpressions)) {
                 if (isDecoratedClassDeclaration) {
                     ts.Debug.assertIsDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration.");
@@ -77714,6 +77708,7 @@ var ts;
             return undefined;
         }
         function transformClassMembers(node, isDerivedClass) {
+            var members = [];
             if (shouldTransformPrivateElementsOrClassStaticBlocks) {
                 for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                     var member = _a[_i];
@@ -77725,12 +77720,18 @@ var ts;
                     createBrandCheckWeakSetForPrivateMethods();
                 }
             }
-            var members = [];
             var constructor = transformConstructor(node, isDerivedClass);
+            var visitedMembers = ts.visitNodes(node.members, classElementVisitor, ts.isClassElement);
             if (constructor) {
                 members.push(constructor);
             }
-            ts.addRange(members, ts.visitNodes(node.members, classElementVisitor, ts.isClassElement));
+            if (!shouldTransformPrivateElementsOrClassStaticBlocks && ts.some(pendingExpressions)) {
+                members.push(factory.createClassStaticBlockDeclaration(undefined, undefined, factory.createBlock([
+                    factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))
+                ])));
+                pendingExpressions = undefined;
+            }
+            ts.addRange(members, visitedMembers);
             return ts.setTextRange(factory.createNodeArray(members), node.members);
         }
         function createBrandCheckWeakSetForPrivateMethods() {
@@ -77835,21 +77836,31 @@ var ts;
         function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) {
             for (var _i = 0, properties_7 = properties; _i < properties_7.length; _i++) {
                 var property = properties_7[_i];
-                var expression = ts.isClassStaticBlockDeclaration(property) ?
-                    transformClassStaticBlockDeclaration(property) :
-                    transformProperty(property, receiver);
-                if (!expression) {
+                if (ts.isStatic(property) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) {
+                    continue;
+                }
+                var statement = transformPropertyOrClassStaticBlock(property, receiver);
+                if (!statement) {
                     continue;
                 }
-                var statement = factory.createExpressionStatement(expression);
-                ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
-                ts.setCommentRange(statement, property);
-                ts.setOriginalNode(statement, property);
-                ts.setSyntheticLeadingComments(expression, undefined);
-                ts.setSyntheticTrailingComments(expression, undefined);
                 statements.push(statement);
             }
         }
+        function transformPropertyOrClassStaticBlock(property, receiver) {
+            var expression = ts.isClassStaticBlockDeclaration(property) ?
+                transformClassStaticBlockDeclaration(property) :
+                transformProperty(property, receiver);
+            if (!expression) {
+                return undefined;
+            }
+            var statement = factory.createExpressionStatement(expression);
+            ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property));
+            ts.setCommentRange(statement, property);
+            ts.setOriginalNode(statement, property);
+            ts.setSyntheticLeadingComments(expression, undefined);
+            ts.setSyntheticTrailingComments(expression, undefined);
+            return statement;
+        }
         function generateInitializedPropertyExpressionsOrClassStaticBlock(propertiesOrClassStaticBlocks, receiver) {
             var expressions = [];
             for (var _i = 0, propertiesOrClassStaticBlocks_1 = propertiesOrClassStaticBlocks; _i < propertiesOrClassStaticBlocks_1.length; _i++) {