@putout/bundle 3.19.2 → 3.20.0

package/bundle/putout.js

@@ -9008,7 +9008,7 @@ __export(lib_exports, {
         return labeledStatement;
     },
     LogicalExpression: function() {
-        return logicalExpression;
+        return logicalExpression$1;
     },
     METHOD_TYPES: function() {
         return METHOD_TYPES;
@@ -11393,7 +11393,7 @@ __export(lib_exports, {
         return isRestProperty;
     },
     isReturnStatement: function() {
-        return isReturnStatement;
+        return isReturnStatement$1;
     },
     isScopable: function() {
         return isScopable;
@@ -11744,7 +11744,7 @@ __export(lib_exports, {
         return isVariableDeclaration$2;
     },
     isVariableDeclarator: function() {
-        return isVariableDeclarator$3;
+        return isVariableDeclarator$4;
     },
     isVariance: function() {
         return isVariance;
@@ -11813,7 +11813,7 @@ __export(lib_exports, {
         return labeledStatement;
     },
     logicalExpression: function() {
-        return logicalExpression;
+        return logicalExpression$1;
     },
     matchesPattern: function() {
         return matchesPattern$1;
@@ -13838,7 +13838,7 @@ function isRestElement(node, opts) {
     if (node.type !== "RestElement") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isReturnStatement(node, opts) {
+function isReturnStatement$1(node, opts) {
     if (!node) return false;
     if (node.type !== "ReturnStatement") return false;
     return opts == null || shallowEqual(node, opts);
@@ -13893,7 +13893,7 @@ function isVariableDeclaration$2(node, opts) {
     if (node.type !== "VariableDeclaration") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isVariableDeclarator$3(node, opts) {
+function isVariableDeclarator$4(node, opts) {
     if (!node) return false;
     if (node.type !== "VariableDeclarator") return false;
     return opts == null || shallowEqual(node, opts);
@@ -16319,7 +16319,7 @@ function validateOptionalType() {
     };
 }
 function arrayOf(elementType) {
-    return chain$2(assertValueType("array"), assertEach(elementType));
+    return chain$4(assertValueType("array"), assertEach(elementType));
 }
 function arrayOfType() {
     for(var _len = arguments.length, typeNames = new Array(_len), _key = 0; _key < _len; _key++){
@@ -16494,7 +16494,7 @@ function assertOptionalChainStart() {
     }
     return validate4;
 }
-function chain$2() {
+function chain$4() {
     for(var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++){
         fns[_key] = arguments[_key];
     }
@@ -16735,7 +16735,7 @@ var utils$1 = /* @__PURE__ */ Object.freeze({
     assertOptionalChainStart: assertOptionalChainStart,
     assertShape: assertShape,
     assertValueType: assertValueType,
-    chain: chain$2,
+    chain: chain$4,
     default: defineType$5,
     defineAliasedType: defineAliasedType,
     validate: validate$2$1,
@@ -17253,7 +17253,7 @@ defineType$4("Identifier", {
     ],
     fields: Object.assign({}, patternLikeCommon(), {
         name: {
-            validate: chain$2(assertValueType("string"), Object.assign(function(node, key, val) {
+            validate: chain$4(assertValueType("string"), Object.assign(function(node, key, val) {
                 if (!isValidIdentifier(val, false)) {
                     throw new TypeError('"'.concat(val, '" is not a valid identifier name'));
                 }
@@ -17354,7 +17354,7 @@ defineType$4("NumericLiteral", {
     deprecatedAlias: "NumberLiteral",
     fields: {
         value: {
-            validate: chain$2(assertValueType("number"), Object.assign(function(node, key, val) {
+            validate: chain$4(assertValueType("number"), Object.assign(function(node, key, val) {
                 if (1 / val < 0 || !Number.isFinite(val)) {
                     var error = new Error("NumericLiterals must be non-negative finite numbers. You can use t.valueToNode(".concat(val, ") instead."));
                     {
@@ -17417,7 +17417,7 @@ defineType$4("RegExpLiteral", {
             validate: assertValueType("string")
         },
         flags: {
-            validate: chain$2(assertValueType("string"), Object.assign(function(node, key, val) {
+            validate: chain$4(assertValueType("string"), Object.assign(function(node, key, val) {
                 var invalid = /[^gimsuy]/.exec(val);
                 if (invalid) {
                     throw new TypeError('"'.concat(invalid[0], '" is not a valid RegExp flag'));
@@ -17637,7 +17637,7 @@ defineType$4("ObjectProperty", {
             validate: assertNodeType("Expression", "PatternLike")
         },
         shorthand: {
-            validate: chain$2(assertValueType("boolean"), Object.assign(function(node, key, shorthand) {
+            validate: chain$4(assertValueType("boolean"), Object.assign(function(node, key, shorthand) {
                 if (!shorthand) return;
                 if (node.computed) {
                     throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
@@ -17803,7 +17803,7 @@ defineType$4("TryStatement", {
     ],
     fields: {
         block: {
-            validate: chain$2(assertNodeType("BlockStatement"), Object.assign(function(node) {
+            validate: chain$4(assertNodeType("BlockStatement"), Object.assign(function(node) {
                 if (!node.handler && !node.finalizer) {
                     throw new TypeError("TryStatement expects either a handler or finalizer, or both");
                 }
@@ -18011,7 +18011,7 @@ defineType$4("ArrayPattern", {
     ],
     fields: Object.assign({}, patternLikeCommon(), {
         elements: {
-            validate: chain$2(assertValueType("array"), assertEach(assertNodeOrValueType("null", "PatternLike", "LVal")))
+            validate: chain$4(assertValueType("array"), assertEach(assertNodeOrValueType("null", "PatternLike", "LVal")))
         }
     })
 });
@@ -18237,7 +18237,7 @@ defineType$4("ExportNamedDeclaration", {
     fields: Object.assign({
         declaration: {
             optional: true,
-            validate: chain$2(assertNodeType("Declaration"), Object.assign(function(node, key, val) {
+            validate: chain$4(assertNodeType("Declaration"), Object.assign(function(node, key, val) {
                 if (val && node.specifiers.length) {
                     throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
                 }
@@ -18470,7 +18470,7 @@ defineType$4("MetaProperty", {
     ],
     fields: {
         meta: {
-            validate: chain$2(assertNodeType("Identifier"), Object.assign(function(node, key, val) {
+            validate: chain$4(assertNodeType("Identifier"), Object.assign(function(node, key, val) {
                 var property;
                 switch(val.name){
                     case "function":
@@ -18523,7 +18523,7 @@ var classMethodOrPropertyCommon = function() {
             optional: true
         },
         key: {
-            validate: chain$2(function() {
+            validate: chain$4(function() {
                 var normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral");
                 var computed = assertNodeType("Expression");
                 return function(node, key, val) {
@@ -18542,7 +18542,7 @@ var classMethodOrDeclareMethodCommon = function() {
             default: "method"
         },
         access: {
-            validate: chain$2(assertValueType("string"), assertOneOf("public", "private", "protected")),
+            validate: chain$4(assertValueType("string"), assertOneOf("public", "private", "protected")),
             optional: true
         },
         decorators: {
@@ -18649,7 +18649,7 @@ defineType$4("TemplateElement", {
     ],
     fields: {
         value: {
-            validate: chain$2(assertShape({
+            validate: chain$4(assertShape({
                 raw: {
                     validate: assertValueType("string")
                 },
@@ -18695,7 +18695,7 @@ defineType$4("TemplateLiteral", {
     fields: {
         quasis: validateArrayOfType("TemplateElement"),
         expressions: {
-            validate: chain$2(assertValueType("array"), assertEach(assertNodeType("Expression", "TSType")), function(node, key, val) {
+            validate: chain$4(assertValueType("array"), assertEach(assertNodeType("Expression", "TSType")), function(node, key, val) {
                 if (node.quasis.length !== val.length + 1) {
                     throw new TypeError("Number of ".concat(node.type, " quasis should be exactly one more than the number of expressions.\nExpected ").concat(val.length + 1, " quasis but got ").concat(node.quasis.length));
                 }
@@ -18717,7 +18717,7 @@ defineType$4("YieldExpression", {
     ],
     fields: {
         delegate: {
-            validate: chain$2(assertValueType("boolean"), Object.assign(function(node, key, val) {
+            validate: chain$4(assertValueType("boolean"), Object.assign(function(node, key, val) {
                 if (val && !node.argument) {
                     throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
                 }
@@ -18821,7 +18821,7 @@ defineType$4("OptionalMemberExpression", {
             default: false
         },
         optional: {
-            validate: chain$2(assertValueType("boolean"), assertOptionalChainStart())
+            validate: chain$4(assertValueType("boolean"), assertOptionalChainStart())
         }
     }
 });
@@ -18846,7 +18846,7 @@ defineType$4("OptionalCallExpression", {
         },
         arguments: validateArrayOfType("Expression", "SpreadElement", "ArgumentPlaceholder"),
         optional: {
-            validate: chain$2(assertValueType("boolean"), assertOptionalChainStart())
+            validate: chain$4(assertValueType("boolean"), assertOptionalChainStart())
         },
         typeArguments: {
             validate: assertNodeType("TypeParameterInstantiation"),
@@ -18928,7 +18928,7 @@ defineType$4("ClassAccessorProperty", {
     ],
     fields: Object.assign({}, classMethodOrPropertyCommon(), {
         key: {
-            validate: chain$2(function() {
+            validate: chain$4(function() {
                 var normal = assertNodeType("Identifier", "StringLiteral", "NumericLiteral", "BigIntLiteral", "PrivateName");
                 var computed = assertNodeType("Expression");
                 return function(node, key, val) {
@@ -21474,7 +21474,7 @@ function regExpLiteral(pattern) {
     validate$4(defs.flags, node, "flags", flags);
     return node;
 }
-function logicalExpression(operator, left, right) {
+function logicalExpression$1(operator, left, right) {
     var node = {
         type: "LogicalExpression",
         operator: operator,
@@ -25944,7 +25944,7 @@ function getFunctionName(node, parent) {
         id = getObjectMemberKey(node);
         if (node.kind === "get") prefix2 = "get ";
         else if (node.kind === "set") prefix2 = "set ";
-    } else if (isVariableDeclarator$3(parent, {
+    } else if (isVariableDeclarator$4(parent, {
         init: node
     })) {
         id = parent.id;
@@ -29368,7 +29368,7 @@ var CommentsParser = /*#__PURE__*/ function(BaseParser) {
 }(BaseParser);
 var lineBreak = /\r\n|[\r\n\u2028\u2029]/;
 var lineBreakG = new RegExp(lineBreak.source, "g");
-function isNewLine(code2) {
+function isNewLine$1(code2) {
     switch(code2){
         case 10:
         case 13:
@@ -29381,7 +29381,7 @@ function isNewLine(code2) {
 }
 function hasNewLine(input, start, end) {
     for(var i = start; i < end; i++){
-        if (isNewLine(input.charCodeAt(i))) {
+        if (isNewLine$1(input.charCodeAt(i))) {
             return true;
         }
     }
@@ -30186,7 +30186,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                 if (!this.isLookahead) startLoc = this.state.curPosition();
                 var ch = this.input.charCodeAt(this.state.pos += startSkip);
                 if (this.state.pos < this.length) {
-                    while(!isNewLine(ch) && ++this.state.pos < this.length){
+                    while(!isNewLine$1(ch) && ++this.state.pos < this.length){
                         ch = this.input.charCodeAt(this.state.pos);
                     }
                 }
@@ -30382,7 +30382,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                 if (ch !== 33) return false;
                 var start = this.state.pos;
                 this.state.pos += 1;
-                while(!isNewLine(ch) && ++this.state.pos < this.length){
+                while(!isNewLine$1(ch) && ++this.state.pos < this.length){
                     ch = this.input.charCodeAt(this.state.pos);
                 }
                 var value1 = this.input.slice(start + 2, this.state.pos);
@@ -30724,7 +30724,7 @@ var Tokenizer = /*#__PURE__*/ function(CommentsParser) {
                         throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
                     }
                     var ch = this.input.charCodeAt(pos);
-                    if (isNewLine(ch)) {
+                    if (isNewLine$1(ch)) {
                         throw this.raise(Errors.UnterminatedRegExp, createPositionWithColumnOffset(startLoc, 1));
                     }
                     if (escaped) {
@@ -35054,7 +35054,7 @@ var jsx$3 = function(superClass) {
                                     });
                                 }
                             default:
-                                if (isNewLine(ch)) {
+                                if (isNewLine$1(ch)) {
                                     out += this.input.slice(chunkStart, this.state.pos);
                                     out += this.jsxReadNewLine(true);
                                     chunkStart = this.state.pos;
@@ -35097,7 +35097,7 @@ var jsx$3 = function(superClass) {
                             out += this.input.slice(chunkStart, this.state.pos);
                             out += this.jsxReadEntity();
                             chunkStart = this.state.pos;
-                        } else if (isNewLine(ch)) {
+                        } else if (isNewLine$1(ch)) {
                             out += this.input.slice(chunkStart, this.state.pos);
                             out += this.jsxReadNewLine(false);
                             chunkStart = this.state.pos;
@@ -46897,7 +46897,7 @@ function TSInstantiationExpression$1(node, parent) {
     var parentType = parent.type;
     return (parentType === "CallExpression" || parentType === "OptionalCallExpression" || parentType === "NewExpression" || parentType === "TSInstantiationExpression") && !!parent.typeParameters;
 }
-function BinaryExpression$2(node, parent, tokenContext, inForStatementInit) {
+function BinaryExpression$1(node, parent, tokenContext, inForStatementInit) {
     return node.operator === "in" && inForStatementInit;
 }
 function SequenceExpression$1(node, parent) {
@@ -46996,7 +46996,7 @@ var parens = /* @__PURE__ */ Object.freeze({
     AssignmentExpression: AssignmentExpression$1,
     AwaitExpression: YieldExpression$1,
     Binary: Binary,
-    BinaryExpression: BinaryExpression$2,
+    BinaryExpression: BinaryExpression$1,
     ClassExpression: ClassExpression$1,
     ConditionalExpression: ConditionalExpression$1,
     DoExpression: DoExpression$1,
@@ -78646,7 +78646,7 @@ const {maybeInsideFn} = maybeInsideFn$1;
 
 const {
     isObjectProperty: isObjectProperty$1,
-    isVariableDeclarator: isVariableDeclarator$2,
+    isVariableDeclarator: isVariableDeclarator$3,
     isClassProperty,
     isTSPropertySignature,
     isSpreadElement: isSpreadElement$2,
@@ -78654,17 +78654,17 @@ const {
 
 const isProperty = satisfy$4([
     isObjectProperty$1,
-    isVariableDeclarator$2,
+    isVariableDeclarator$3,
     isClassProperty,
     isTSPropertySignature,
     isSpreadElement$2,
 ]);
 
 const isInsideVar = ({parentPath}) => {
-    if (isVariableDeclarator$2(parentPath))
+    if (isVariableDeclarator$3(parentPath))
         return true;
     
-    return isVariableDeclarator$2(parentPath.parentPath);
+    return isVariableDeclarator$3(parentPath.parentPath);
 };
 
 const hasDecorators = (path) => {
@@ -79031,13 +79031,21 @@ function isOneArgArrow(path) {
     return param.type === 'Identifier';
 }
 
-var maybeParens$c = {};
+var maybeParens$e = {};
+
+const isFn$6 = (a) => typeof a === 'function';
+const isParens$3 = (path) => path.node.extra?.parenthesized;
 
-const isParens$4 = (path) => path.node.extra?.parenthesized;
+maybeParens$e.isParens = isParens$3;
+maybeParens$e.maybeParens = (print) => {
+    if (isFn$6(print))
+        return maybeParensPrint(print);
+    
+    return maybeParensCondition(print);
+};
 
-maybeParens$c.isParens = isParens$4;
-maybeParens$c.maybeParens = (print) => ({
-    condition: isParens$4,
+const maybeParensPrint = (print) => ({
+    condition: isParens$3,
     before(path, {write}) {
         write('(');
     },
@@ -79047,11 +79055,16 @@ maybeParens$c.maybeParens = (print) => ({
     },
 });
 
+const maybeParensCondition = ({print, condition}) => ({
+    ...maybeParensPrint(print),
+    condition: (path) => condition(path) || isParens$3(path),
+});
+
 const {exists: exists$e} = is$3;
 const {printParams: printParams$c} = params;
-const {maybeParens: maybeParens$b} = maybeParens$c;
+const {maybeParens: maybeParens$d} = maybeParens$e;
 
-arrowFunctionExpression.ArrowFunctionExpression = maybeParens$b((path, printer, semantics) => {
+arrowFunctionExpression.ArrowFunctionExpression = maybeParens$d((path, printer, semantics) => {
     const {
         print,
         maybe,
@@ -79307,9 +79320,9 @@ var functionExpression = {};
 
 const {exists: exists$d} = is$3;
 const {printParams: printParams$8} = params;
-const {maybeParens: maybeParens$a} = maybeParens$c;
+const {maybeParens: maybeParens$c} = maybeParens$e;
 
-functionExpression.FunctionExpression = maybeParens$a((path, printer, semantics) => {
+functionExpression.FunctionExpression = maybeParens$c((path, printer, semantics) => {
     const {
         print,
         maybe,
@@ -79359,11 +79372,11 @@ var unaryExpressions$1 = {};
 
 const {isLast: isLast$b, isNext: isNext$m} = is$3;
 
-const {maybeParens: maybeParens$9} = maybeParens$c;
+const {maybeParens: maybeParens$b} = maybeParens$e;
 
 const isWord = (a) => /^(delete|typeof|void|throw)$/.test(a);
 
-const unaryExpression = maybeParens$9((path, printer) => {
+const unaryExpression = maybeParens$b((path, printer) => {
     const {maybe, traverse} = printer;
     const {prefix, operator} = path.node;
     const argPath = path.get('argument');
@@ -79383,7 +79396,7 @@ unaryExpressions$1.AwaitExpression = (path, {print}) => {
     });
 };
 
-unaryExpressions$1.YieldExpression = maybeParens$9((path, {print, maybe}) => {
+unaryExpressions$1.YieldExpression = maybeParens$b((path, {print, maybe}) => {
     const {delegate} = path.node;
     
     print(`yield`);
@@ -79411,14 +79424,14 @@ function printUnary(path, name, {print}) {
 
 var memberExpressions$1 = {};
 
-var chain$1 = {};
+var chain$3 = {};
 
 const {assign: assign$c} = Object;
 
-chain$1.chain = (path) => {
+chain$3.chain = (path) => {
     const all = [
-        ...down(path),
-        ...up(path),
+        ...down$1(path),
+        ...up$1(path),
     ];
     
     const properties = all.slice(0, -1);
@@ -79427,7 +79440,7 @@ chain$1.chain = (path) => {
     return [root, properties];
 };
 
-function down(path) {
+function down$1(path) {
     const properties = [];
     
     let current = path.get('object');
@@ -79450,7 +79463,7 @@ function down(path) {
     return properties;
 }
 
-function up(current) {
+function up$1(current) {
     const properties = [];
     
     while (current.isMemberExpression()) {
@@ -79492,11 +79505,11 @@ const {
     isIfStatement,
 } = bundle.types;
 
-const {chain} = chain$1;
+const {chain: chain$2} = chain$3;
 const {satisfy: satisfy$3} = is$3;
 
 const {maybePrintComputed} = maybePrintComputed$2;
-const {maybeParens: maybeParens$8} = maybeParens$c;
+const {maybeParens: maybeParens$a} = maybeParens$e;
 
 const isArgOfCall = (path) => path.parentPath.isCallExpression() && path.parentPath.get('arguments.0') === path;
 
@@ -79531,7 +79544,7 @@ memberExpressions$1.MemberExpression = (path, printer) => {
     maybe.indent.dec(isChain);
 };
 
-memberExpressions$1.OptionalMemberExpression = maybeParens$8((path, {print, maybe}) => {
+memberExpressions$1.OptionalMemberExpression = maybeParens$a((path, {print, maybe}) => {
     const {computed, optional} = path.node;
     
     print('__object');
@@ -79581,7 +79594,7 @@ const isIfUp = (path) => {
 
 memberExpressions$1.likeChain = likeChain$1;
 function likeChain$1(path) {
-    const [root, properties] = chain(path);
+    const [root, properties] = chain$2(path);
     
     if (isExcludedFromChain(root))
         return false;
@@ -79712,7 +79725,7 @@ _class.ClassDeclaration = {
 var callExpression = {};
 
 const {exists: exists$c} = is$3;
-const {maybeParens: maybeParens$7} = maybeParens$c;
+const {maybeParens: maybeParens$9} = maybeParens$e;
 const {isArray: isArray$e} = Array;
 
 const parseArgs = (path) => {
@@ -79724,7 +79737,7 @@ const parseArgs = (path) => {
     return argsPath;
 };
 
-const CallExpression$1 = maybeParens$7((path, {indent, print, maybe, traverse}) => {
+const CallExpression$1 = maybeParens$9((path, {indent, print, maybe, traverse}) => {
     const args = parseArgs(path);
     const isParentCall = tooLong$1(args) && path.parentPath.isCallExpression();
     
@@ -79927,7 +79940,7 @@ objectExpression.ObjectExpression = (path, printer, semantics) => {
     
     const properties = path.get('properties');
     const {length} = properties;
-    const parens = isParens$3(path);
+    const parens = isParens$2(path);
     const manyLines = !isOneLine$1(path);
     
     maybe.print(parens, '(');
@@ -80032,7 +80045,7 @@ function isOneLine$1(path) {
     return !isValue(path);
 }
 
-function isParens$3(path) {
+function isParens$2(path) {
     if (isBodyOfArrow(path))
         return true;
     
@@ -80060,6 +80073,9 @@ concatenate$1.isConcatenation = (path) => {
     const {parentPath} = path;
     const {operator} = path.node;
     
+    if (operator !== '+')
+        return false;
+    
     const startLine = path.node.loc?.start.line;
     const endLine = path.node.loc?.end.line;
     
@@ -80069,9 +80085,6 @@ concatenate$1.isConcatenation = (path) => {
     const left = path.get('left');
     const right = path.get('right');
     
-    if (operator !== '+')
-        return false;
-    
     if (isStringLike(left) && isStringLike(right) && isBinaryExpression(parentPath))
         return true;
     
@@ -80209,7 +80222,7 @@ const {
     isIdentifier: isIdentifier$a,
     isObjectPattern: isObjectPattern$2,
     isAssignmentPattern,
-    isVariableDeclarator: isVariableDeclarator$1,
+    isVariableDeclarator: isVariableDeclarator$2,
 } = bundle.types;
 
 const {wrongShorthand} = wrongShortand;
@@ -80391,7 +80404,7 @@ function shouldAddNewline(path, semantics) {
     if (hasObjectPattern(properties))
         return COUPLE_LINES;
     
-    if (moreCount && !moreLength && isVariableDeclarator$1(path.parentPath))
+    if (moreCount && !moreLength && isVariableDeclarator$2(path.parentPath))
         return ONE_LINE$1;
     
     if (!fnParam && n && !isForOf$2(path) && checkLength(properties))
@@ -80476,7 +80489,8 @@ var assignmentExpression = {};
 
 var maybeWriteBrace$3 = {};
 
-const {isParens: isParens$2} = maybeParens$c;
+const {isParens: isParens$1} = maybeParens$e;
+
 maybeWriteBrace$3.maybePrintLeftBrace = (path, printer, semantics) => {
     maybeWriteBrace$2(path, printer, semantics, {
         brace: '(',
@@ -80513,7 +80527,7 @@ function maybeWriteBrace$2(path, printer, semantics, {brace}) {
     if (!roundBraces.assign)
         return;
     
-    if (!isParens$2(path))
+    if (!isParens$1(path))
         return;
     
     write(brace);
@@ -82145,63 +82159,134 @@ const {
 } = concatenate$1;
 
 const {maybeSpace} = maybeSpace$1;
-const {isParens: isParens$1} = maybeParens$c;
+const {maybeParens: maybeParens$8} = maybeParens$e;
 
-const BinaryExpression$1 = {
+binaryExpression.BinaryExpression = maybeParens$8((path, {print, indent, maybe}) => {
+    const {operator} = path.node;
+    
+    if (operator === 'in' || operator === 'instanceof') {
+        print('__left');
+        print(' ');
+        print(operator);
+        print(' ');
+        print('__right');
+        
+        return;
+    }
+    
+    if (isConcatenation$1(path))
+        return concatenate(path, {
+            print,
+            indent,
+            maybe,
+        });
+    
+    print('__left');
+    print.space();
+    print(path.node.operator);
+    maybeSpace(path, {
+        print,
+    });
+    print('__right');
+});
+
+var logicalExpression = {};
+
+var chain$1 = {};
+
+const {
+    isReturnStatement,
+    isVariableDeclarator: isVariableDeclarator$1,
+} = bundle.types;
+
+chain$1.isRootOk = (path) => {
+    return isReturnStatement(path) || isVariableDeclarator$1(path);
+};
+
+chain$1.chain = (path) => {
+    const [downCount] = down(path);
+    const [upCount, root] = up(path);
+    
+    return [
+        root,
+        downCount + upCount,
+        downCount,
+        upCount,
+    ];
+};
+
+function down(current) {
+    let count = 0;
+    
+    do {
+        ++count;
+        current = current.get('left');
+        const {operator} = current.node;
+        
+        if (operator !== '||' && operator !== '&&')
+            break;
+    } while (current.isLogicalExpression());
+    
+    return [count];
+}
+
+function up(current) {
+    let count = 0;
+    
+    do {
+        ++count;
+        current = current.parentPath;
+    } while (current.isLogicalExpression());
+    
+    return [
+        count, {
+            type: current.type,
+        },
+    ];
+}
+
+const {maybeParens: maybeParens$7} = maybeParens$e;
+const {chain, isRootOk} = chain$1;
+
+logicalExpression.LogicalExpression = maybeParens$7({
     condition(path) {
-        if (isParens$1(path))
+        if (path.parentPath.isUnaryExpression())
             return true;
         
         return path.parentPath.isAwaitExpression();
     },
-    before(path, {print}) {
-        print('(');
-    },
-    print(path, {print, indent, maybe}) {
-        const {operator} = path.node;
-        
-        if (operator === 'instanceof') {
-            print('__left');
-            print(' instanceof ');
-            print('__right');
-            
-            return;
-        }
+    print(path, {print, maybe}, semantics) {
+        print('__left');
         
-        if (operator === 'in') {
-            print('__left');
-            print(' in ');
-            print('__right');
-            
-            return;
-        }
+        const needNewLine = isNewLine(path, semantics);
         
-        if (isConcatenation$1(path))
-            return concatenate(path, {
-                print,
-                indent,
-                maybe,
-            });
+        maybe.indent.inc(needNewLine);
+        needNewLine ? print.breakline() : print.space();
+        maybe.indent.dec(needNewLine);
         
-        print('__left');
-        print.space();
         print(path.node.operator);
-        maybeSpace(path, {
-            print,
-        });
+        print.space();
         print('__right');
     },
-    after(path, {print}) {
-        print(')');
-    },
-};
+});
 
-binaryExpression.BinaryExpression = BinaryExpression$1;
-binaryExpression.LogicalExpression = BinaryExpression$1;
+function isNewLine(path, semantics) {
+    const [root, count] = chain(path);
+    
+    if (!isRootOk(root))
+        return false;
+    
+    if (count <= semantics.maxElementsInOneLine)
+        return false;
+    
+    const {operator} = path.node;
+    
+    return operator === '||' || operator === '&&';
+}
 
 var conditionalExpression = {};
 
-const {maybeParens: maybeParens$6} = maybeParens$c;
+const {maybeParens: maybeParens$6} = maybeParens$e;
 
 conditionalExpression.ConditionalExpression = maybeParens$6((path, {print}) => {
     print('__test');
@@ -82451,12 +82536,8 @@ const {RestElement} = restElement;
 const {SpreadElement} = spreadElement;
 const {SequenceExpression} = sequenceExpression;
 const {TaggedTemplateExpression} = taggedTemplateExpression;
-
-const {
-    BinaryExpression,
-    LogicalExpression,
-} = binaryExpression;
-
+const {BinaryExpression} = binaryExpression;
+const {LogicalExpression} = logicalExpression;
 const {ConditionalExpression} = conditionalExpression;
 const {StaticBlock} = staticBlock;
 const {RecordExpression} = recordExpression;
@@ -84120,7 +84201,7 @@ maybeGet.maybeDecorators = (path) => {
 };
 
 const {maybeDecorators} = maybeGet;
-const {maybeParens: maybeParens$5} = maybeParens$c;
+const {maybeParens: maybeParens$5} = maybeParens$e;
 const {maybeTypeAnnotation} = maybeTypeAnnotation$4;
 
 identifier.Identifier = maybeParens$5(maybeTypeAnnotation((path, printer) => {
@@ -84600,7 +84681,7 @@ tsInterfaceDeclaration.TSInterfaceDeclaration = {
 
 var tsAsExpression = {};
 
-const {maybeParens: maybeParens$4} = maybeParens$c;
+const {maybeParens: maybeParens$4} = maybeParens$e;
 const {
     isVariableDeclarator,
     isObjectExpression: isObjectExpression$1,
@@ -84734,7 +84815,7 @@ printReturnType$5.printReturnType = (path, {traverse}) => {
 const {printParams: printParams$5} = params;
 const {printReturnType: printReturnType$4} = printReturnType$5;
 
-const {maybeParens: maybeParens$3} = maybeParens$c;
+const {maybeParens: maybeParens$3} = maybeParens$e;
 
 tsFunctionType.TSFunctionType = maybeParens$3((path, printer, semantics) => {
     const {print} = printer;
@@ -84931,7 +85012,7 @@ tsMethodSignature.TSMethodSignature = (path, printer, semantics) => {
 
 var tsUnionType = {};
 
-const {maybeParens: maybeParens$2} = maybeParens$c;
+const {maybeParens: maybeParens$2} = maybeParens$e;
 const insideTypeDeclaration = ({parentPath}) => parentPath.isTSTypeAliasDeclaration();
 
 tsUnionType.TSUnionType = maybeParens$2((path, printer, {maxTypesInOneLine}) => {
@@ -85006,7 +85087,7 @@ tsTypeReference.TSTypeReference = (path, {print}) => {
 
 var tsInferType = {};
 
-const {maybeParens: maybeParens$1} = maybeParens$c;
+const {maybeParens: maybeParens$1} = maybeParens$e;
 
 tsInferType.TSInferType = maybeParens$1((path, {print}) => {
     print('infer ');
@@ -85052,7 +85133,7 @@ tsParameterProperty.TSParameterProperty = (path, {print, maybe}) => {
 
 var tsTypeQuery = {};
 
-const {maybeParens} = maybeParens$c;
+const {maybeParens} = maybeParens$e;
 
 tsTypeQuery.TSTypeQuery = maybeParens((path, {print}) => {
     print('typeof ');