@putout/bundle 1.8.0 → 1.8.2

package/bundle/putout.js

@@ -230,8 +230,8 @@ generated$3.isExportDefaultSpecifier = isExportDefaultSpecifier$1;
 generated$3.isExportNamedDeclaration = isExportNamedDeclaration$1;
 generated$3.isExportNamespaceSpecifier = isExportNamespaceSpecifier$1;
 generated$3.isExportSpecifier = isExportSpecifier;
-generated$3.isExpression = isExpression$2;
-generated$3.isExpressionStatement = isExpressionStatement$3;
+generated$3.isExpression = isExpression$3;
+generated$3.isExpressionStatement = isExpressionStatement$4;
 generated$3.isExpressionWrapper = isExpressionWrapper;
 generated$3.isFile = isFile$1;
 generated$3.isFlow = isFlow$1;
@@ -308,7 +308,7 @@ generated$3.isNumberTypeAnnotation = isNumberTypeAnnotation$1;
 generated$3.isNumericLiteral = isNumericLiteral;
 generated$3.isObjectExpression = isObjectExpression$2;
 generated$3.isObjectMember = isObjectMember;
-generated$3.isObjectMethod = isObjectMethod$1;
+generated$3.isObjectMethod = isObjectMethod$2;
 generated$3.isObjectPattern = isObjectPattern$2;
 generated$3.isObjectProperty = isObjectProperty$2;
 generated$3.isObjectTypeAnnotation = isObjectTypeAnnotation;
@@ -345,7 +345,7 @@ generated$3.isSequenceExpression = isSequenceExpression$1;
 generated$3.isSpreadElement = isSpreadElement;
 generated$3.isSpreadProperty = isSpreadProperty$1;
 generated$3.isStandardized = isStandardized;
-generated$3.isStatement = isStatement$7;
+generated$3.isStatement = isStatement$8;
 generated$3.isStaticBlock = isStaticBlock;
 generated$3.isStringLiteral = isStringLiteral$6;
 generated$3.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
@@ -638,7 +638,7 @@ function isEmptyStatement(node, opts) {
   }
   return false;
 }
-function isExpressionStatement$3(node, opts) {
+function isExpressionStatement$4(node, opts) {
   if (!node) return false;
   const nodeType = node.type;
   if (nodeType === "ExpressionStatement") {
@@ -866,7 +866,7 @@ function isObjectExpression$2(node, opts) {
   }
   return false;
 }
-function isObjectMethod$1(node, opts) {
+function isObjectMethod$2(node, opts) {
   if (!node) return false;
   const nodeType = node.type;
   if (nodeType === "ObjectMethod") {
@@ -3458,7 +3458,7 @@ function isStandardized(node, opts) {
   }
   return false;
 }
-function isExpression$2(node, opts) {
+function isExpression$3(node, opts) {
   if (!node) return false;
   const nodeType = node.type;
   if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "BindExpression" === nodeType || "DoExpression" === nodeType || "RecordExpression" === nodeType || "TupleExpression" === nodeType || "DecimalLiteral" === nodeType || "ModuleExpression" === nodeType || "TopicReference" === nodeType || "PipelineTopicExpression" === nodeType || "PipelineBareFunction" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "TSInstantiationExpression" === nodeType || "TSAsExpression" === nodeType || "TSSatisfiesExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Expression" === node.expectedNode || "Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode)) {
@@ -3518,7 +3518,7 @@ function isBlock(node, opts) {
   }
   return false;
 }
-function isStatement$7(node, opts) {
+function isStatement$8(node, opts) {
   if (!node) return false;
   const nodeType = node.type;
   if ("BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || nodeType === "Placeholder" && ("Statement" === node.expectedNode || "Declaration" === node.expectedNode || "BlockStatement" === node.expectedNode)) {
@@ -23374,7 +23374,7 @@ parentheses.BinaryExpression = BinaryExpression$2;
 parentheses.ClassExpression = ClassExpression$1;
 parentheses.ConditionalExpression = ConditionalExpression$2;
 parentheses.DoExpression = DoExpression$1;
-parentheses.FunctionExpression = FunctionExpression$1;
+parentheses.FunctionExpression = FunctionExpression$2;
 parentheses.FunctionTypeAnnotation = FunctionTypeAnnotation;
 parentheses.Identifier = Identifier$3;
 parentheses.LogicalExpression = LogicalExpression$1;
@@ -23407,7 +23407,7 @@ const {
   isConditionalExpression,
   isExportDeclaration: isExportDeclaration$3,
   isExportDefaultDeclaration: isExportDefaultDeclaration$1,
-  isExpressionStatement: isExpressionStatement$2,
+  isExpressionStatement: isExpressionStatement$3,
   isFor: isFor$1,
   isForInStatement,
   isForOfStatement: isForOfStatement$2,
@@ -23542,7 +23542,7 @@ function BinaryExpression$2(node, parent) {
   return node.operator === "in" && (isVariableDeclarator$1(parent) || isFor$1(parent));
 }
 function SequenceExpression$2(node, parent) {
-  if (isForStatement$2(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement$3(parent) && parent.test === node || isWhileStatement(parent) && parent.test === node || isForInStatement(parent) && parent.right === node || isSwitchStatement(parent) && parent.discriminant === node || isExpressionStatement$2(parent) && parent.expression === node) {
+  if (isForStatement$2(parent) || isThrowStatement(parent) || isReturnStatement(parent) || isIfStatement$3(parent) && parent.test === node || isWhileStatement(parent) && parent.test === node || isForInStatement(parent) && parent.right === node || isSwitchStatement(parent) && parent.discriminant === node || isExpressionStatement$3(parent) && parent.expression === node) {
     return false;
   }
   return true;
@@ -23559,7 +23559,7 @@ function UnaryLike(node, parent) {
     left: node
   }) || isClassExtendsClause(node, parent);
 }
-function FunctionExpression$1(node, parent, printStack) {
+function FunctionExpression$2(node, parent, printStack) {
   return isFirstInContext(printStack, 1 | 4);
 }
 function ArrowFunctionExpression$2(node, parent) {
@@ -23634,7 +23634,7 @@ function isFirstInContext(printStack, checkParam) {
   i--;
   let parent = printStack[i];
   while (i >= 0) {
-    if (expressionStatement && isExpressionStatement$2(parent, {
+    if (expressionStatement && isExpressionStatement$3(parent, {
       expression: node
     }) || exportDefault && isExportDefaultDeclaration$1(parent, {
       declaration: node
@@ -23679,7 +23679,7 @@ var _t$o = requireLib$a();
 const {
   FLIPPED_ALIAS_KEYS,
   isCallExpression: isCallExpression$3,
-  isExpressionStatement: isExpressionStatement$1,
+  isExpressionStatement: isExpressionStatement$2,
   isMemberExpression: isMemberExpression$2,
   isNewExpression: isNewExpression$2
 } = _t$o;
@@ -23718,7 +23718,7 @@ function isOrHasCallExpression(node) {
 }
 function needsWhitespace(node, parent, type) {
   if (!node) return false;
-  if (isExpressionStatement$1(node)) {
+  if (isExpressionStatement$2(node)) {
     node = node.expression;
   }
   const flag = find$1(expandedWhitespaceNodes, node, parent);
@@ -24100,7 +24100,7 @@ const {
   isFor,
   isForStatement: isForStatement$1,
   isIfStatement: isIfStatement$2,
-  isStatement: isStatement$6
+  isStatement: isStatement$7
 } = _t$m;
 function WithStatement(node) {
   this.word("with");
@@ -24140,7 +24140,7 @@ function getLastStatement(statement) {
   const {
     body
   } = statement;
-  if (isStatement$6(body) === false) {
+  if (isStatement$7(body) === false) {
     return statement;
   }
   return getLastStatement(body);
@@ -24532,7 +24532,7 @@ Object.defineProperty(methods, "__esModule", {
   value: true
 });
 methods.ArrowFunctionExpression = ArrowFunctionExpression$1;
-methods.FunctionDeclaration = methods.FunctionExpression = FunctionExpression;
+methods.FunctionDeclaration = methods.FunctionExpression = FunctionExpression$1;
 methods._functionHead = _functionHead;
 methods._methodHead = _methodHead;
 methods._param = _param;
@@ -24631,7 +24631,7 @@ function _functionHead(node, parent) {
     this._predicate(node);
   }
 }
-function FunctionExpression(node, parent) {
+function FunctionExpression$1(node, parent) {
   this._functionHead(node, parent);
   this.space();
   this.print(node.body, node);
@@ -24722,7 +24722,7 @@ const {
   isExportNamespaceSpecifier,
   isImportDefaultSpecifier,
   isImportNamespaceSpecifier,
-  isStatement: isStatement$5
+  isStatement: isStatement$6
 } = _t$j;
 function ImportSpecifier(node) {
   if (node.importKind === "type" || node.importKind === "typeof") {
@@ -24805,7 +24805,7 @@ function ExportNamedDeclaration(node) {
   if (node.declaration) {
     const declar = node.declaration;
     this.print(declar, node);
-    if (!isStatement$5(declar)) this.semicolon();
+    if (!isStatement$6(declar)) this.semicolon();
   } else {
     if (node.exportKind === "type") {
       this.word("type");
@@ -24860,7 +24860,7 @@ function ExportDefaultDeclaration$1(node) {
   this.space();
   const declar = node.declaration;
   this.print(declar, node);
-  if (!isStatement$5(declar)) this.semicolon();
+  if (!isStatement$6(declar)) this.semicolon();
 }
 function ImportDeclaration(node) {
   var _node$assertions3;
@@ -25279,7 +25279,7 @@ types$5.Identifier = Identifier$2;
 types$5.NullLiteral = NullLiteral;
 types$5.NumericLiteral = NumericLiteral;
 types$5.ObjectPattern = types$5.ObjectExpression = ObjectExpression$1;
-types$5.ObjectMethod = ObjectMethod$1;
+types$5.ObjectMethod = ObjectMethod$2;
 types$5.ObjectProperty = ObjectProperty$1;
 types$5.PipelineBareFunction = PipelineBareFunction;
 types$5.PipelinePrimaryTopicReference = PipelinePrimaryTopicReference;
@@ -25322,7 +25322,7 @@ function ObjectExpression$1(node) {
   this.sourceWithOffset("end", node.loc, 0, -1);
   this.tokenChar(125);
 }
-function ObjectMethod$1(node) {
+function ObjectMethod$2(node) {
   this.printJoin(node.decorators, node);
   this._methodHead(node);
   this.space();
@@ -27202,7 +27202,7 @@ var generatorFunctions = generators;
 
 const {
   isFunction: isFunction$4,
-  isStatement: isStatement$4,
+  isStatement: isStatement$5,
   isClassBody,
   isTSInterfaceBody,
   isTSEnumDeclaration
@@ -27794,7 +27794,7 @@ class Printer {
         }
         if (len === 1) {
           const singleLine = comment.loc ? comment.loc.start.line === comment.loc.end.line : !HAS_NEWLINE.test(comment.value);
-          const shouldSkipNewline = singleLine && !isStatement$4(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumDeclaration(parent);
+          const shouldSkipNewline = singleLine && !isStatement$5(node) && !isClassBody(parent) && !isTSInterfaceBody(parent) && !isTSEnumDeclaration(parent);
           if (type === 0) {
             this._printComment(comment, shouldSkipNewline && node.type !== "ObjectExpression" || singleLine && isFunction$4(parent, {
               body: node
@@ -44027,13 +44027,13 @@ var _parser$2 = lib$c;
 var _codeFrame$2 = requireLib$8();
 const {
   isCallExpression: isCallExpression$1,
-  isExpressionStatement,
+  isExpressionStatement: isExpressionStatement$1,
   isFunction: isFunction$3,
   isIdentifier: isIdentifier$8,
   isJSXIdentifier: isJSXIdentifier$1,
   isNewExpression,
   isPlaceholder,
-  isStatement: isStatement$3,
+  isStatement: isStatement$4,
   isStringLiteral: isStringLiteral$4,
   removePropertiesDeep,
   traverse: traverse$7
@@ -44114,10 +44114,10 @@ function placeholderVisitorHandler(node, ancestors, state) {
     type = "string";
   } else if (isNewExpression(parent) && key === "arguments" || isCallExpression$1(parent) && key === "arguments" || isFunction$3(parent) && key === "params") {
     type = "param";
-  } else if (isExpressionStatement(parent) && !isPlaceholder(node)) {
+  } else if (isExpressionStatement$1(parent) && !isPlaceholder(node)) {
     type = "statement";
     ancestors = ancestors.slice(0, -1);
-  } else if (isStatement$3(node) && isPlaceholder(node)) {
+  } else if (isStatement$4(node) && isPlaceholder(node)) {
     type = "statement";
   } else {
     type = "other";
@@ -44196,7 +44196,7 @@ const {
   emptyStatement,
   expressionStatement: expressionStatement$3,
   identifier: identifier$3,
-  isStatement: isStatement$2,
+  isStatement: isStatement$3,
   isStringLiteral: isStringLiteral$3,
   stringLiteral: stringLiteral$2,
   validate: validate$2
@@ -44258,7 +44258,7 @@ function applyReplacement(placeholder, ast, replacement) {
         replacement = blockStatement$3(replacement);
       } else if (typeof replacement === "string") {
         replacement = expressionStatement$3(identifier$3(replacement));
-      } else if (!isStatement$2(replacement)) {
+      } else if (!isStatement$3(replacement)) {
         replacement = expressionStatement$3(replacement);
       }
     } else {
@@ -44266,7 +44266,7 @@ function applyReplacement(placeholder, ast, replacement) {
         if (typeof replacement === "string") {
           replacement = identifier$3(replacement);
         }
-        if (!isStatement$2(replacement)) {
+        if (!isStatement$3(replacement)) {
           replacement = expressionStatement$3(replacement);
         }
       }
@@ -44499,7 +44499,7 @@ const {
   isIdentifier: isIdentifier$7,
   isLiteral: isLiteral$1,
   isNullLiteral,
-  isObjectMethod,
+  isObjectMethod: isObjectMethod$1,
   isObjectProperty: isObjectProperty$1,
   isRegExpLiteral,
   isRestElement,
@@ -44610,7 +44610,7 @@ function _default$3({
   id
 }, localBinding = false, supportUnicodeId = false) {
   if (node.id) return;
-  if ((isObjectProperty$1(parent) || isObjectMethod(parent, {
+  if ((isObjectProperty$1(parent) || isObjectMethod$1(parent, {
     kind: "method"
   })) && (!parent.computed || isLiteral$1(parent.key))) {
     id = parent.key;
@@ -45144,7 +45144,7 @@ const {
   STATEMENT_OR_BLOCK_KEYS,
   VISITOR_KEYS,
   isBlockStatement,
-  isExpression: isExpression$1,
+  isExpression: isExpression$2,
   isIdentifier: isIdentifier$5,
   isLiteral,
   isStringLiteral: isStringLiteral$2,
@@ -45186,7 +45186,7 @@ function canSwapBetweenExpressionAndStatement(replacement) {
   if (this.isExpression()) {
     return isBlockStatement(replacement);
   } else if (this.isBlockStatement()) {
-    return isExpression$1(replacement);
+    return isExpression$2(replacement);
   }
   return false;
 }
@@ -46638,7 +46638,7 @@ Object.defineProperty(virtualTypesValidator, "__esModule", {
 virtualTypesValidator.isBindingIdentifier = isBindingIdentifier;
 virtualTypesValidator.isBlockScoped = isBlockScoped;
 virtualTypesValidator.isExistentialTypeParam = isExistentialTypeParam;
-virtualTypesValidator.isExpression = isExpression;
+virtualTypesValidator.isExpression = isExpression$1;
 virtualTypesValidator.isFlow = isFlow;
 virtualTypesValidator.isForAwaitStatement = isForAwaitStatement;
 virtualTypesValidator.isGenerated = isGenerated;
@@ -46650,7 +46650,7 @@ virtualTypesValidator.isReferencedMemberExpression = isReferencedMemberExpressio
 virtualTypesValidator.isRestProperty = isRestProperty;
 virtualTypesValidator.isScope = isScope;
 virtualTypesValidator.isSpreadProperty = isSpreadProperty;
-virtualTypesValidator.isStatement = isStatement$1;
+virtualTypesValidator.isStatement = isStatement$2;
 virtualTypesValidator.isUser = isUser;
 virtualTypesValidator.isVar = isVar;
 var _t$3 = requireLib$a();
@@ -46709,7 +46709,7 @@ function isBindingIdentifier() {
   const grandparent = this.parentPath.parent;
   return isIdentifier$4(node) && isBinding(node, parent, grandparent);
 }
-function isStatement$1() {
+function isStatement$2() {
   const {
     node,
     parent
@@ -46728,7 +46728,7 @@ function isStatement$1() {
     return false;
   }
 }
-function isExpression() {
+function isExpression$1() {
   if (this.isIdentifier()) {
     return this.isReferencedIdentifier();
   } else {
@@ -69080,7 +69080,7 @@ main$1.default;
 
 const {
     isFunctionExpression,
-    ObjectMethod,
+    ObjectMethod: ObjectMethod$1,
 } = requireLib$a();
 
 const {assign: assign$8} = Object;
@@ -69094,7 +69094,7 @@ var traverseObjectExpression$1 = (propertiesPaths) => {
         } = propPath.node;
         
         if (isFunctionExpression(value)) {
-            propPath.replaceWith(ObjectMethod('method', key, value.params, value.body, computed));
+            propPath.replaceWith(ObjectMethod$1('method', key, value.params, value.body, computed));
             
             assign$8(propPath.node, {
                 id: null,
@@ -100423,7 +100423,7 @@ const {
   exportNamedDeclaration,
   exportSpecifier,
   expressionStatement: expressionStatement$1,
-  functionExpression,
+  functionExpression: functionExpression$1,
   identifier,
   memberExpression,
   objectExpression: objectExpression$1,
@@ -100449,7 +100449,7 @@ const buildUmdWrapper = replacements => _template().default.statement`
 function buildGlobal(allowlist) {
   const namespace = identifier("babelHelpers");
   const body = [];
-  const container = functionExpression(null, [identifier("global")], blockStatement$1(body));
+  const container = functionExpression$1(null, [identifier("global")], blockStatement$1(body));
   const tree = program([expressionStatement$1(callExpression$1(container, [conditionalExpression$1(binaryExpression$1("===", unaryExpression$1("typeof", identifier("global")), stringLiteral("undefined")), identifier("self"), identifier("global"))]))]);
   body.push(variableDeclaration$1("var", [variableDeclarator(namespace, assignmentExpression$1("=", memberExpression(identifier("global"), namespace), objectExpression$1([])))]));
   buildHelpers(body, namespace, allowlist);
@@ -115597,16 +115597,24 @@ var watermarkExports = watermark$1.exports;
 
 const {template: template$4} = requireParser$1();
 
+const {
+    isExpression,
+    isStatement: isStatement$1,
+    isExpressionStatement,
+} = requireLib$a();
+
 const {
     remove,
     replaceWith,
 } = requireOperate();
+
 const {
     compare: compare$1,
     findVarsWays,
     getValues,
     setValues,
 } = requireCompare();
+
 const debug$2 = browserExports('putout:runner:replace');
 const maybeArray = maybeArray_1;
 
@@ -115689,6 +115697,8 @@ const fix = (from, to, path) => {
         return remove(path);
     }
     
+    checkExpressionStatement(nodeFrom, nodeTo, path);
+    
     const waysTo = findVarsWays(nodeTo);
     const newPath = replaceWith(path, nodeTo);
     
@@ -115764,6 +115774,19 @@ const validateTemplateValues = (a, b) => {
     }
 };
 
+function checkExpressionStatement(nodeFrom, nodeTo, path) {
+    if (!isExpression(nodeFrom))
+        return;
+    
+    if (!isStatement$1(nodeTo) || isExpressionStatement(nodeTo))
+        return;
+    
+    if (isExpressionStatement(path) || isExpressionStatement(path.parentPath))
+        return;
+    
+    throw Error(`☝️ Looks like try to put Statement in place of Expression, use 'match' to filter out such cases`);
+}
+
 var replaceExports = replace$1.exports;
 
 var declare$2 = {};
@@ -116459,7 +116482,9 @@ is.satisfy = (conditions) => (path) => {
     return false;
 };
 
-const {exists: exists$4} = is;
+is.noTrailingComment = (path) => !path.node.trailingComments;
+
+const {exists: exists$5} = is;
 
 arrowFunctionExpression.ArrowFunctionExpression = {
     condition({parentPath}) {
@@ -116488,7 +116513,7 @@ arrowFunctionExpression.ArrowFunctionExpression = {
         
         const returnType = path.get('returnType');
         
-        if (exists$4(returnType)) {
+        if (exists$5(returnType)) {
             write(':');
             write.space();
             traverse(returnType);
@@ -116592,15 +116617,34 @@ classMethod.ClassMethod = {
     },
 };
 
-const {ArrowFunctionExpression} = arrowFunctionExpression;
-const {FunctionDeclaration} = functionDeclaration;
-const {ClassMethod} = classMethod;
+var objectMethod = {};
 
-functions$1.ArrowFunctionExpression = ArrowFunctionExpression;
-functions$1.FunctionDeclaration = FunctionDeclaration;
-functions$1.ClassMethod = ClassMethod;
+objectMethod.ObjectMethod = (path, {print}) => {
+    const {kind} = path.node;
+    
+    if (kind !== 'method')
+        print(`${kind} `);
+    
+    print('__key');
+    print('(');
+    
+    const params = path.get('params');
+    const n = params.length - 1;
+    
+    for (let i = 0; i <= n; i++) {
+        print(params[i]);
+        
+        if (i < n)
+            print(', ');
+    }
+    
+    print(') ');
+    print('__body');
+};
 
-functions$1.FunctionExpression = (path, {print, maybe, write, traverse}) => {
+var functionExpression = {};
+
+functionExpression.FunctionExpression = (path, {print, maybe, write, traverse}) => {
     const {node} = path;
     
     const {
@@ -116635,28 +116679,17 @@ functions$1.FunctionExpression = (path, {print, maybe, write, traverse}) => {
     print('__body');
 };
 
-functions$1.ObjectMethod = (path, {print}) => {
-    const {kind} = path.node;
-    
-    if (kind !== 'method')
-        print(`${kind} `);
-    
-    print('__key');
-    print('(');
-    
-    const params = path.get('params');
-    const n = params.length - 1;
-    
-    for (let i = 0; i <= n; i++) {
-        print(params[i]);
-        
-        if (i < n)
-            print(', ');
-    }
-    
-    print(') ');
-    print('__body');
-};
+const {ArrowFunctionExpression} = arrowFunctionExpression;
+const {FunctionDeclaration} = functionDeclaration;
+const {ClassMethod} = classMethod;
+const {ObjectMethod} = objectMethod;
+const {FunctionExpression} = functionExpression;
+
+functions$1.FunctionDeclaration = FunctionDeclaration;
+functions$1.FunctionExpression = FunctionExpression;
+functions$1.ArrowFunctionExpression = ArrowFunctionExpression;
+functions$1.ClassMethod = ClassMethod;
+functions$1.ObjectMethod = ObjectMethod;
 
 var unaryExpressions$1 = {};
 
@@ -116887,7 +116920,7 @@ function classVisitor(path, {print, indent, maybe}) {
 
 var callExpression = {};
 
-const {exists: exists$3} = is;
+const {exists: exists$4} = is;
 
 function CallExpression$1(path, {indent, print, maybe, traverse}) {
     const isParentCall = toLong(path) && path.parentPath.isCallExpression();
@@ -116898,7 +116931,7 @@ function CallExpression$1(path, {indent, print, maybe, traverse}) {
     maybe.write(isFn, '(');
     traverse(callee);
     
-    if (exists$3(typeParameters))
+    if (exists$4(typeParameters))
         traverse(typeParameters);
     
     maybe.write(isFn, ')');
@@ -116979,6 +117012,7 @@ const {
     isCoupleLines: isCoupleLines$5,
     isForOf: isForOf$3,
     isIf,
+    noTrailingComment: noTrailingComment$1,
 } = is;
 
 const {isFunction} = requireLib$a();
@@ -117021,7 +117055,7 @@ objectExpression.ObjectExpression = (path, {print, maybe, indent}) => {
         }
         
         print(property);
-        maybe.print.newline(manyLines);
+        maybe.print.newline(manyLines && noTrailingComment$1(property));
     }
     
     indent.dec();
@@ -117885,6 +117919,7 @@ const isNextAssign = (path) => {
 var ifStatement = {};
 
 const {markAfter: markAfter$3} = mark;
+const {exists: exists$3} = is;
 
 const isEmptyConsequent = (path) => path.get('consequent').isEmptyStatement();
 
@@ -117917,7 +117952,7 @@ ifStatement.IfStatement = {
             write('else');
             write.space();
             traverse(alternate);
-        } else if (alternate.node) {
+        } else if (exists$3(alternate)) {
             write('else');
             print.newline();
             indent.inc();
@@ -117937,8 +117972,7 @@ ifStatement.IfStatement = {
         return true;
     },
     after: (path, {print}) => {
-        print.indent();
-        print.newline();
+        print.linebreak();
         markAfter$3(path);
     },
 };
@@ -118006,6 +118040,7 @@ const {
     isLast: isLast$4,
     exists: exists$2,
 } = is;
+const {isObjectMethod} = requireLib$a();
 
 const isFirstStatement = (path) => path.get('body.0')?.isStatement();
 
@@ -118048,6 +118083,9 @@ function shouldAddNewlineAfter$1(path) {
     if (!isNext$5(path) && !isNext$5(path.parentPath) && isParentProgram(path.parentPath))
         return false;
     
+    if (path.find(isObjectMethod))
+        return true;
+    
     if (parentPath.isStatement() && !path.node.body.length && !isNext$5(parentPath))
         return false;
     
@@ -118089,28 +118127,41 @@ function isTry({parentPath}) {
 
 var returnStatement = {};
 
-const {isPrevBody} = is;
+const {
+    isPrevBody,
+    noTrailingComment,
+} = is;
+
 const {hasPrevNewline} = mark;
 const isBodyLength = ({parentPath}) => parentPath.node?.body?.length > 2;
 
-returnStatement.ReturnStatement = (path, {indent, traverse, print}) => {
-    if (!hasPrevNewline(path) && isBodyLength(path) || isPrevBody(path)) {
+returnStatement.ReturnStatement = {
+    beforeIf(path) {
+        return !hasPrevNewline(path) && isBodyLength(path) || isPrevBody(path);
+    },
+    before(path, {print}) {
         print.indent();
         print.newline();
-    }
-    
-    indent();
-    print('return');
-    
-    const argPath = path.get('argument');
-    
-    if (argPath.node) {
-        print(' ');
-        traverse(argPath);
-    }
-    
-    print(';');
-    print.newline();
+    },
+    print(path, {indent, traverse, print}) {
+        indent();
+        print('return');
+        
+        const argPath = path.get('argument');
+        
+        if (argPath.node) {
+            print(' ');
+            traverse(argPath);
+        }
+        
+        print(';');
+    },
+    afterSatisfy: () => [
+        noTrailingComment,
+    ],
+    after(path, {print}) {
+        print.newline();
+    },
 };
 
 var tryStatements = {};
@@ -119259,7 +119310,9 @@ maybe.maybeThrow = (a, path, b) => {
     }));
 };
 
-const maybeProgram = (ast) => isProgram(ast) ? ast : Program([ExpressionStatement$1(ast)]);
+const maybeProgram = (ast) => isProgram(ast) ? ast : Program([
+    ExpressionStatement$1(ast),
+]);
 
 maybe.maybeFile = (ast) => isFile(ast) ? ast : File(maybeProgram(ast));
 
@@ -119460,10 +119513,11 @@ comments.parseTrailingComments = (path, {write, maybe}) => {
     for (const {type, value, loc} of trailingComments) {
         if (type === 'CommentLine') {
             const sameLine = isSameLine(path, loc);
+            
             maybe.write.space(sameLine);
             maybe.indent(!sameLine);
             write(`//${value}`);
-            maybe.write.newline(!sameLine);
+            write.newline();
         }
     }
 };