@putout/printer 18.0.15 → 18.1.0

package/ChangeLog

@@ -1,3 +1,34 @@
+2026.03.06, v18.1.0
+
+feature:
+- 604e849 @putout/printer: ArrayExpression: long identifier: improve support
+- bdd07e7 @putout/printer: isMultiLine: siplify
+- 945a833 @putout/printer: ArrayExpression: newline: isCoupleLines
+- 2ca2751 @putout/printer: ArrayExpression: newline: isStringsInsideArray
+- 488eb71 @putout/printer: ArrayExpression: newline: isSimpleAndObject
+- 246f9df @putout/printer: ArrayExpression: newline: isIdentifierAndString
+- 56637d1 @putout/printer: ArrayExpression: newline: isStringAndIdentifier
+- caa4682 @putout/printer: ArrayExpression: newline: isStringAndIdentifier
+- 0e9dc1d @putout/printer: ArrayExpression: newline: isMultiline: simplify
+- 103ad2e @putout/printer: ExpressionStatement: isBreakline
+- 04c19c3 @putout/printer: ExpressionStatement: isNextToAssignmentCall: simplify
+- 4bcbd61 @putout/printer: ExpressionStatement: isNextStatementWithBlockComment: simplify
+
+2026.03.06, v18.0.16
+
+feature:
+- 2a81cf2 @putout/printer: ExpressionStatement: rm is-inside-assign-next-assign-function
+- 17d19f2 @putout/printer: ExpressionStatement: rm not
+- 1c07e30 @putout/printer: ExpressionStatement: isBreakline: add
+- 15f67f0 @putout/printer: ExpressionStatement: afterIf: move out
+- c6783ee @putout/printer: ExpressionStatement: hasTrailingCommentNotCoupleLines
+- 8e08572 @putout/printer: ExpressionStatement: isTopParentLast: simplify
+- fe1b0ca @putout/printer: ExpressionStatement: isTopParentLast
+- b84b9a6 @putout/printer: ExpressionStatement: isIndent
+- d4d0106 @putout/printer: ExpressionStatement: beforeIf: simplify
+- 9a4721a @putout/printer: ExpressionStatement: afterIf: simplify
+- a9d2cf8 @putout/printer: ExpressionStatement: isBeforeElse: simplify
+
 2026.03.06, v18.0.15
 
 feature:

package/lib/tokenize/expressions/array-expression/array-expression.js

@@ -77,7 +77,6 @@ const isInsideOneElementArray = ({parentPath}) => parentPath.node.elements.lengt
 export const ArrayExpression = {
     beforeIf(path) {
         const {parentPath} = path;
-        const {elements} = path.node;
         
         if (!parentPath.isArrayExpression())
             return false;
@@ -85,10 +84,10 @@ export const ArrayExpression = {
         if (isCoupleLines(parentPath))
             return false;
         
-        if (isStringAndIdentifier(elements) && isInsideOneElementArray(path))
+        if (isStringAndIdentifier(path) && isInsideOneElementArray(path))
             return true;
         
-        return isIdentifierAndIdentifier(elements);
+        return isIdentifierAndIdentifier(path);
     },
     before(path, {print}) {
         print.breakline();
@@ -110,7 +109,6 @@ export const ArrayExpression = {
         maybe.indent.inc(indented && shouldIncreaseIndent);
         
         const isNewLine = isMultiLine(path, {
-            elements,
             maxElementsInOneLine,
             maxElementLengthInOneLine,
         });
@@ -148,7 +146,7 @@ export const ArrayExpression = {
         
         const parentElements = path.parentPath.get('elements');
         
-        if (isInsideArray(path) && isStringAndArray(parentElements)) {
+        if (isInsideArray(path) && isStringAndArray(path.parentPath)) {
             const parentCountTwo = parentElements.length === 2;
             const isHideIdent = !isAroundStrings(path) || parentCountTwo;
             
@@ -159,7 +157,7 @@ export const ArrayExpression = {
             maybe.indent(elements.length && isNewLine);
         }
         
-        if (isSimpleAndNotEmptyObject(elements) && !isSpreadElement(elements.at(-1)) && !isCallExpression(elements.at(-1))) {
+        if (isSimpleAndNotEmptyObject(path) && !isSpreadElement(elements.at(-1)) && !isCallExpression(elements.at(-1))) {
             print(',');
             print.breakline();
         }
@@ -168,7 +166,6 @@ export const ArrayExpression = {
     },
     afterIf(path) {
         const {parentPath} = path;
-        const {elements} = path.node;
         
         if (!parentPath.isArrayExpression())
             return false;
@@ -176,10 +173,10 @@ export const ArrayExpression = {
         if (isCoupleLines(parentPath))
             return false;
         
-        if (isStringAndIdentifier(elements) && isInsideOneElementArray(path))
+        if (isStringAndIdentifier(path) && isInsideOneElementArray(path))
             return true;
         
-        return isIdentifierAndIdentifier(elements);
+        return isIdentifierAndIdentifier(path);
     },
     after(path, {print, indent}) {
         indent.dec();

package/lib/tokenize/expressions/array-expression/newline.js

@@ -11,10 +11,69 @@ import {
     isSimpleAndNotEmptyObject,
     isInsideCall,
 } from '#is';
+import {isInsideArray} from './indent.js';
+import {isInsideForOf} from '../object-pattern/is.js';
+
+const isLastArg = ({parentPath}) => !parentPath.isCallExpression();
+const isParentProperty = (path) => path.find(isObjectProperty);
+
+const isNumbersArray = createTypeChecker([
+    ['-: node.elements', isNumbers],
+    ['-', isInsideForOf],
+    ['-: -> !', isLastArg],
+    ['+: -> !', isParentProperty],
+]);
+
+const isStringAndString = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isStringLiteral(a) && isStringLiteral(b);
+};
+
+const isStringsInsideArray = createTypeChecker([
+    ['-: -> !', isStringAndString],
+    ['-: -> !', isInsideArray],
+    '+: parentPath.node.elements.0 -> ArrayExpression',
+]);
+
+const isTwoSimplesInsideObjectProperty = (path) => {
+    const {node, parentPath} = path;
+    
+    const {elements} = node;
+    const {length} = elements;
+    const [a, b] = elements;
+    
+    if (length > 2)
+        return false;
+    
+    if (!parentPath.isObjectProperty())
+        return false;
+    
+    if (!isStringLiteral(a) || !isStringLiteral(b))
+        return false;
+    
+    return !isCoupleLines(path);
+};
+
+const isShortTwoSimplesInsideCall = (path, {maxElementsInOneLine}) => {
+    const {node, parentPath} = path;
+    
+    const {elements} = node;
+    const {length} = elements;
+    const [a, b] = elements;
+    
+    if (!parentPath.isCallExpression())
+        return false;
+    
+    if (!isStringLiteral(a) || !isStringLiteral(b))
+        return false;
+    
+    return length < maxElementsInOneLine;
+};
 
 const {
     isObjectExpression,
-    isArrayExpression,
     isObjectProperty,
     isCallExpression,
     isAwaitExpression,
@@ -23,11 +82,14 @@ const {
     isStringLiteral,
     isSpreadElement,
     isIdentifier,
+    isNumericLiteral,
 } = types;
 
 const {round} = Math;
 
-const isOneSpread = (elements) => {
+const isOneSpread = (path) => {
+    const {elements} = path.node;
+    
     if (elements.length > 1)
         return false;
     
@@ -36,19 +98,38 @@ const isOneSpread = (elements) => {
     return isSpreadElement(first);
 };
 
-const isSimpleAndCall = ([a, b]) => {
+const isSimpleAndCall = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
     if (!isSimple(a))
         return;
     
     return isCallExpression(b) || isAwaitExpression(b);
 };
 
-const isBooleanAndSimple = ([a, b]) => isBooleanLiteral(a) && isSimple(b);
+const isBooleanAndSimple = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isBooleanLiteral(a) && isSimple(b);
+};
+
 const isBooleanAndObject = ([a, b]) => isBooleanLiteral(a) && isObjectExpression(b);
-const isNullAndSimple = ([a, b]) => isNullLiteral(a) && isSimple(b);
-const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression(b);
-const ONE_LINE = false;
-const MULTI_LINE = true;
+
+const isNullAndSimple = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isNullLiteral(a) && isSimple(b);
+};
+
+const isSimpleAndObject = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isSimple(a) && isObjectExpression(b);
+};
 
 const isSiblingIsArray = (path) => {
     if (path.getNextSibling().isArrayExpression())
@@ -70,13 +151,22 @@ const isMoreThenMaxLiteralLength = (path, {maxElementLengthInOneLine}) => {
     return first.value.length > maxElementLengthInOneLine;
 };
 
+const isMoreThenMaxIdentifierLength = (path) => {
+    const [first] = path.node.elements;
+    
+    return isIdentifier(first);
+};
+
 const isMoreThenMaxElementLengthInOneLine = createTypeChecker([
     ['-', isEmptyArray],
     ['-: -> !', isInsideCall],
     ['+', isMoreThenMaxLiteralLength],
+    ['+', isMoreThenMaxIdentifierLength],
 ]);
 
-function isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine) {
+function isMaxElementLengthInOneLine(path, {maxElementLengthInOneLine}) {
+    const elements = path.get('elements');
+    
     if (elements.length > 1)
         return false;
     
@@ -88,125 +178,55 @@ function isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine) {
     return first.node.name.length < maxElementLengthInOneLine;
 }
 
-export const isMultiLine = (path, {elements, maxElementsInOneLine, maxElementLengthInOneLine}) => {
-    const [first] = elements;
-    
-    if (isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine))
-        return ONE_LINE;
-    
-    if (isMoreThenMaxElementLengthInOneLine(path, {elements, maxElementLengthInOneLine}))
-        return MULTI_LINE;
-    
-    if (elements.length > maxElementsInOneLine && isStringLiteral(first))
-        return MULTI_LINE;
-    
-    if (elements.length > 3 && !isObjectExpression(first))
-        return MULTI_LINE;
-    
-    if (isSimpleAndNotEmptyObject(elements))
-        return MULTI_LINE;
-    
-    if (isOneSimple(path))
-        return ONE_LINE;
-    
-    if (isOneSpread(elements))
-        return ONE_LINE;
-    
-    if (elements.length === 2 && isIdentifierAndIdentifier(elements))
-        return ONE_LINE;
-    
-    if (isCallInsideArrow(path))
-        return ONE_LINE;
-    
-    if (isIncreaseIndent(path))
-        return ONE_LINE;
-    
-    if (isInsideLoop(path))
-        return ONE_LINE;
-    
-    if (isBooleanAndSimple(elements))
-        return ONE_LINE;
-    
-    if (isNullAndSimple(elements))
-        return ONE_LINE;
-    
-    if (isSimpleAndCall(elements))
-        return ONE_LINE;
-    
-    if (isShortTwoSimplesInsideCall(path, maxElementsInOneLine))
-        return ONE_LINE;
-    
-    if (isTwoStringsDifferentLength(elements))
-        return ONE_LINE;
-    
-    if (isTwoSimplesInsideObjectProperty(path))
-        return ONE_LINE;
-    
-    if (isStringAndArray(elements) && elements.length < 3)
-        return ONE_LINE;
-    
-    if (isStringAndMember(elements))
-        return ONE_LINE;
-    
-    if (isStringAndIdentifier(elements))
-        return ONE_LINE;
-    
-    if (isIdentifierAndString(elements))
-        return ONE_LINE;
-    
-    if (isSimpleAndObject(elements))
-        return ONE_LINE;
-    
-    if (isStringAndString(elements) && path.parentPath.isArrayExpression() && isArrayExpression(path.parentPath.node.elements[0]))
-        return ONE_LINE;
-    
-    if (isSiblingIsArray(path))
-        return ONE_LINE;
-    
-    if (tooLong(path) || isCoupleLines(path) || !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path))
-        return MULTI_LINE;
-    
-    return ONE_LINE;
+const isElementsMoreThenMax = (path, {maxElementsInOneLine}) => {
+    const {elements} = path.node;
+    return elements.length > maxElementsInOneLine;
 };
 
-const isForOf = ({parentPath}) => parentPath.isForOfStatement();
+const isElementsMoreThenThree = (path) => {
+    const {elements} = path.node;
+    return elements.length > 3;
+};
 
-const isStringAndString = ([a, b]) => isStringLiteral(a) && isStringLiteral(b);
+const isElementsMoreThenThreeWithNotFirstObject = createTypeChecker([
+    '-: node.elements.0 -> ObjectExpression',
+    isElementsMoreThenThree,
+]);
 
-const isShortTwoSimplesInsideCall = (path, maxElementsInOneLine) => {
-    const {node, parentPath} = path;
-    
-    const {elements} = node;
-    const {length} = elements;
-    const [a, b] = elements;
-    
-    if (!parentPath.isCallExpression())
-        return false;
-    
-    if (!isStringLiteral(a) || !isStringLiteral(b))
-        return false;
-    
-    return length < maxElementsInOneLine;
-};
+const isElementsMoreThenMaxWithFirstString = createTypeChecker([
+    '-: node.elements.0 -> !StringLiteral',
+    isElementsMoreThenMax,
+]);
 
-const isTwoSimplesInsideObjectProperty = (path) => {
-    const {node, parentPath} = path;
-    
-    const {elements} = node;
-    const {length} = elements;
-    const [a, b] = elements;
-    
-    if (length > 2)
-        return false;
-    
-    if (!parentPath.isObjectProperty())
-        return false;
-    
-    if (!isStringLiteral(a) || !isStringLiteral(b))
-        return false;
-    
-    return !isCoupleLines(path);
-};
+export const isMultiLine = createTypeChecker([
+    ['-', isMaxElementLengthInOneLine],
+    isMoreThenMaxElementLengthInOneLine,
+    isElementsMoreThenMaxWithFirstString,
+    isElementsMoreThenThreeWithNotFirstObject,
+    isSimpleAndNotEmptyObject,
+    ['-', isOneSimple],
+    ['-', isOneSpread],
+    ['-', isIdentifierAndIdentifier],
+    ['-', isCallInsideArrow],
+    ['-', isIncreaseIndent],
+    ['-', isInsideLoop],
+    ['-', isBooleanAndSimple],
+    ['-', isNullAndSimple],
+    ['-', isSimpleAndCall],
+    ['-', isShortTwoSimplesInsideCall],
+    ['-', isTwoStringsDifferentLength],
+    ['-', isTwoSimplesInsideObjectProperty],
+    ['-', isStringAndArray],
+    ['-', isStringAndMember],
+    ['-', isStringAndIdentifier],
+    ['-', isIdentifierAndString],
+    ['-', isSimpleAndObject],
+    ['-', isSiblingIsArray],
+    ['-', isStringsInsideArray],
+    tooLong,
+    isCoupleLines,
+    isNumbersArray,
+]);
 
 function isOneSimple(path) {
     const elements = path.get('elements');
@@ -228,17 +248,18 @@ function isOneSimple(path) {
     return first.isMemberExpression();
 }
 
-function isTwoStringsDifferentLength(strings) {
-    const [a, b] = strings;
+function isTwoStringsDifferentLength(path) {
+    const {elements} = path.node;
+    const [a, b] = elements;
     
-    if (strings.length > 2)
+    if (elements.length > 2)
         return false;
     
-    if (!a?.isStringLiteral() || !b?.isStringLiteral())
+    if (!isStringLiteral(a) || !isStringLiteral(b))
         return false;
     
-    const aLength = a.node.value.length;
-    const bLength = b.node.value.length;
+    const aLength = a.value.length;
+    const bLength = b.value.length;
     
     return round(bLength / aLength) > 2;
 }
@@ -275,17 +296,13 @@ function isCallInsideArrow(path) {
 
 function isNumbers(elements) {
     for (const element of elements) {
-        if (element.isNumericLiteral())
+        if (isNumericLiteral(element))
             return true;
     }
     
     return false;
 }
 
-const isLastArg = ({parentPath}) => !parentPath.isCallExpression();
-
-const isParentProperty = (path) => path.find(isObjectProperty);
-
 export function isIncreaseIndent(path) {
     const elements = path.get('elements');
     

package/lib/tokenize/expressions/function/function-declaration.js

@@ -1,7 +1,11 @@
 import {types} from '@putout/babel';
 import {printParams} from '#print-params';
 import {markAfter} from '#mark';
-import {isNext, isNextParent} from '#is';
+import {
+    getNext,
+    isNext,
+    isNextParent,
+} from '#is';
 import {createTypeChecker} from '#type-checker';
 
 const {
@@ -12,8 +16,6 @@ const {
 
 const hasFnBody = ({node}) => node.body.body.length;
 
-const getNext = (fn) => (path) => fn(path.getNextSibling());
-
 const isIndentAfter = createTypeChecker([
     ['+', getNext(isFunctionDeclaration)],
     ['+', isNext],

package/lib/tokenize/expressions/object-expression/object-expression.js

@@ -149,4 +149,3 @@ const hasNextLeadingComment = (path) => {
     
     return hasLeadingComment(next);
 };
-

package/lib/tokenize/is.js

@@ -28,6 +28,8 @@ export const isInsideExpression = ({parentPath}) => isExpressionStatement(parent
 export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPath);
 
 export const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
+export const isInsideReturn = ({parentPath}) => parentPath.isReturnStatement();
+export const getNext = (fn) => (path) => fn(path.getNextSibling());
 
 export const isNext = (path) => {
     const next = path.getNextSibling();
@@ -89,7 +91,10 @@ export function isCoupleLines(path) {
 
 export const exists = (a) => a.node;
 
-export function isStringAndIdentifier([a, b]) {
+export function isStringAndIdentifier(path) {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
     return isStringLiteral(a) && isIdentifier(b);
 }
 
@@ -105,7 +110,8 @@ const checkObject = (elements) => {
     return a.node.properties.length;
 };
 
-export const isSimpleAndNotEmptyObject = (elements) => {
+export const isSimpleAndNotEmptyObject = (path) => {
+    const elements = path.get('elements');
     const [a] = elements;
     
     const simpleTypes = [
@@ -122,20 +128,44 @@ export const isSimpleAndNotEmptyObject = (elements) => {
     return checkObject(elements);
 };
 
-export const isIdentifierAndIdentifier = ([a, b]) => {
+export const isIdentifierAndIdentifier = (path) => {
+    const {elements} = path.node;
+    
+    if (elements.length !== 2)
+        return;
+    
+    const [a, b] = elements;
+    
     return isIdentifier(a) && isIdentifier(b);
 };
 
-export const isStringAndMember = ([a, b]) => isStringLiteral(a) && isMemberExpression(b);
-export const isIdentifierAndString = ([a, b]) => isIdentifier(a) && isStringLiteral(b);
-export const isStringAndArray = ([a, b]) => {
+export const isStringAndMember = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isStringLiteral(a) && isMemberExpression(b);
+};
+export const isIdentifierAndString = (path) => {
+    const {elements} = path.node;
+    const [a, b] = elements;
+    
+    return isIdentifier(a) && isStringLiteral(b);
+};
+export const isStringAndArray = (path) => {
+    const elements = path.get('elements');
+    
+    if (elements.length !== 2)
+        return false;
+    
+    const [a, b] = elements;
+    
     if (!isStringLiteral(a))
         return false;
     
     if (!isArrayExpression(b))
         return false;
     
-    return !isStringAndIdentifier(b.node.elements);
+    return !isStringAndIdentifier(b);
 };
 
 const isIfOrStatement = (a) => isIfStatement(a) || isStatement(a);

package/lib/tokenize/statements/expression-statement/after-if.js

@@ -0,0 +1,52 @@
+import {createTypeChecker} from '#type-checker';
+import {
+    hasTrailingComment,
+    isCoupleLines,
+    isInsideBlock,
+    isLast,
+    isNext,
+    isParentLast,
+    satisfy,
+} from '#is';
+
+function isNotLastOrParentLast(path) {
+    return !isLast(path) && !isParentLast(path);
+}
+
+const isNextUp = (path) => path.findParent(isNext);
+
+const isTopParentLast = createTypeChecker([
+    '-: parentPath -> !IfStatement',
+    '-: parentPath.parentPath -> !IfStatement',
+    '-: parentPath.parentPath.parentPath -> !IfStatement',
+    ['+: parentPath.parentPath.parentPath', isLast],
+]);
+
+const satisfyAfter = satisfy([
+    isNotLastOrParentLast,
+    isInsideBlock,
+    isNext,
+    isNextUp,
+]);
+
+const isPathIsConsequent = ({node, parentPath}) => node !== parentPath.node.consequent;
+
+const isBeforeElse = createTypeChecker([
+    '-: parentPath -> !IfStatement',
+    ['-:', isPathIsConsequent],
+    ['+: parentPath.node.alternate', Boolean],
+]);
+
+const hasTrailingCommentNotCoupleLines = createTypeChecker([
+    ['-: -> !', hasTrailingComment],
+    ['+: -> !', isCoupleLines],
+]);
+
+export const afterIf = createTypeChecker([
+    ['-', isTopParentLast],
+    ['-', hasTrailingCommentNotCoupleLines],
+    ['+', satisfyAfter],
+    ['+', isBeforeElse],
+    ['-: -> !', hasTrailingComment],
+    ['+', isLast],
+]);

package/lib/tokenize/statements/expression-statement/before-if.js

@@ -0,0 +1,7 @@
+import {createTypeChecker} from '#type-checker';
+import {isInsideLabel, isInsideReturn} from '#is';
+
+export const beforeIf = createTypeChecker([
+    ['-', isInsideReturn],
+    ['+: -> !', isInsideLabel],
+]);

package/lib/tokenize/statements/expression-statement/expression-statement.js

@@ -1,73 +1,67 @@
-import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 import {
     isNext,
     isLast,
-    isInsideBlock,
-    isParentLast,
     isNewlineBetweenSiblings,
-    satisfy,
     noTrailingComment,
     hasTrailingComment,
     isCoupleLines,
-    isInsideLabel,
+    isInsideReturn,
+    getNext,
+    hasLeadingComment,
 } from '#is';
-import {isInsideAssignNextAssignFunction} from './is-inside-assign-next-assign-function.js';
 import {
     printLeadingCommentLine,
     printLeadingCommentBlock,
-} from './expression-statement-comments.js';
+} from './comments.js';
+import {afterIf} from './after-if.js';
+import {beforeIf} from './before-if.js';
 
-const isCommentBlock = (a) => a?.type === 'CommentBlock';
-
-const {
-    isCallExpression,
-    isExpressionStatement,
-    isAssignmentExpression,
-} = types;
-
-const not = (fn) => (...a) => !fn(...a);
+const isCallInsideExpression = createTypeChecker([
+    '-: -> !ExpressionStatement',
+    '+: node.expression -> CallExpression',
+]);
 
-const isBeforeElse = (path) => {
-    if (!path.parentPath.isIfStatement())
-        return false;
-    
-    if (path !== path.parentPath.get('consequent'))
-        return false;
-    
-    return Boolean(path.parentPath.node.alternate);
-};
+const isNextToAssignmentCall = createTypeChecker([
+    '-: node.expression -> AssignmentExpression',
+    ['+', getNext(isCallInsideExpression)],
+]);
 
-const isInsideReturn = ({parentPath}) => parentPath.isReturnStatement();
-const notInsideReturn = not(isInsideReturn);
+const isNextStatementWithBlockComment = createTypeChecker([
+    '-: node.expression -> !CallExpression',
+    '-: node.expression.arguments.0 -> !CallExpression',
+    '+: node.trailingComments.0 -> CommentBlock',
+]);
 
-const satisfyAfter = satisfy([
-    isNotLastOrParentLast,
-    isInsideBlock,
-    isNext,
-    isNextUp,
+const isBreaklineAfter = createTypeChecker([
+    ['-: -> !', hasTrailingComment],
+    ['-: -> !', isLast],
+    ['+', isCoupleLines],
 ]);
 
 const isNextIf = (path) => path
     .getNextSibling()
     .isIfStatement();
 
-const shouldBreakline = satisfy([
-    isNewlineBetweenSiblings,
-    isNotLastBody,
-    isNextIf,
+const isBreakline = createTypeChecker([isNewlineBetweenSiblings, isNextIf]);
+
+const isIndent = createTypeChecker([
+    noTrailingComment,
+    isNextToAssignmentCall,
+    isNextStatementWithBlockComment,
+]);
+
+export const isIndentAfter = createTypeChecker([
+    '-: node.expression -> !AssignmentExpression',
+    ['+', getNext(hasLeadingComment)],
 ]);
 
 export const ExpressionStatement = {
-    beforeIf(path) {
-        if (isInsideReturn(path))
-            return false;
-        
-        return !isInsideLabel(path);
-    },
+    beforeIf,
     before(path, {indent}) {
         indent();
     },
-    print(path, {print, maybe, store, indent}) {
+    print(path, {print, maybe, store}) {
         const insideReturn = isInsideReturn(path);
         
         print('__expression');
@@ -76,109 +70,23 @@ export const ExpressionStatement = {
         if (!isNext(path))
             return;
         
-        if (!insideReturn && shouldBreakline(path)) {
+        if (isBreakline(path)) {
             print.newline();
-            
-            const condition = isNext(path)
-                && noTrailingComment(path)
-                || isNextToAssignmentCall(path)
-                || isNextStatementWithBlockComment(path);
-            
-            if (condition)
-                indent();
-            
+            maybe.indent(isIndent(path));
             store(true);
         }
     },
-    afterIf: (path) => {
-        if (satisfyAfter(path))
-            return true;
+    afterIf,
+    after(path, {print, maybe, store}) {
+        maybe.print.breakline(isBreaklineAfter(path));
         
-        if (hasTrailingComment(path) && isLast(path))
-            return true;
-        
-        return isBeforeElse(path);
-    },
-    after(path, {print, maybe, store, indent}) {
-        if (hasTrailingComment(path) && isLast(path) && isCoupleLines(path))
-            print.breakline();
-        
-        if (hasTrailingComment(path) && !isCoupleLines(path))
-            return;
-        
-        if (isTopParentLast(path))
+        if (isInsideReturn(path))
             return;
         
-        if (notInsideReturn(path)) {
-            if (isInsideAssignNextAssignFunction(path))
-                indent();
-            
-            print.newline();
-            maybe.markAfter(store(), path);
-        }
+        maybe.indent(isIndentAfter(path));
+        print.newline();
+        maybe.markAfter(store(), path);
     },
 };
 ExpressionStatement.printLeadingCommentLine = printLeadingCommentLine;
 ExpressionStatement.printLeadingCommentBlock = printLeadingCommentBlock;
-
-function isTopParentLast({parentPath}) {
-    if (!parentPath.isIfStatement())
-        return false;
-    
-    const nextParent = parentPath.parentPath;
-    
-    if (!nextParent.isIfStatement())
-        return false;
-    
-    const nextNext = nextParent.parentPath;
-    
-    if (!nextNext.isIfStatement())
-        return false;
-    
-    return isLast(nextNext);
-}
-
-function isNotLastBody(path) {
-    return path.parentPath.get('body') === path;
-}
-
-function isNotLastOrParentLast(path) {
-    return !isLast(path) && !isParentLast(path);
-}
-
-function isNextUp(path) {
-    return path.findParent(isNext);
-}
-
-function isNextToAssignmentCall(path) {
-    if (isAssignmentExpression(path.node.expression))
-        return false;
-    
-    const nextPath = path.getNextSibling();
-    
-    if (!isExpressionStatement(nextPath))
-        return false;
-    
-    const {expression} = nextPath.node;
-    
-    return isCallExpression(expression);
-}
-
-function isNextStatementWithBlockComment(path) {
-    const {expression} = path.node;
-    
-    if (!isCallExpression(expression))
-        return false;
-    
-    if (!isCallExpression(expression.arguments[0]))
-        return false;
-    
-    return hasTrailingBlock(path);
-}
-
-function hasTrailingBlock(path) {
-    const {trailingComments} = path.node;
-    const [first] = trailingComments;
-    
-    return isCommentBlock(first);
-}

package/lib/tokenize/statements/for-statement.js

@@ -1,4 +1,8 @@
-import {isInsideLabel, exists} from '#is';
+import {
+    isInsideLabel,
+    exists,
+    getNext,
+} from '#is';
 import {markAfter} from '#mark';
 
 export const ForStatement = {
@@ -36,9 +40,7 @@ export const ForStatement = {
         print('__body');
         maybe.indent.dec(is);
     },
-    afterIf(path) {
-        return exists(path.getNextSibling());
-    },
+    afterIf: getNext(exists),
     after(path, {print}) {
         print.linebreak();
         markAfter(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "18.0.15",
+  "version": "18.1.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",

package/lib/tokenize/statements/expression-statement/is-inside-assign-next-assign-function.js

@@ -1,32 +0,0 @@
-import {types} from '@putout/babel';
-
-const {
-    isExpressionStatement,
-    isFunction,
-    isAssignmentExpression,
-} = types;
-
-export const isInsideAssignNextAssignFunction = (path) => {
-    const {expression} = path.node;
-    
-    if (!isAssignmentExpression(expression))
-        return false;
-    
-    const next = path.getNextSibling();
-    
-    if (isFunction(next) && next.node.leadingComments)
-        return true;
-    
-    if (!isExpressionStatement(next))
-        return false;
-    
-    const {leadingComments} = next.node;
-    
-    if (!leadingComments)
-        return false;
-    
-    if (!isAssignmentExpression(next.node.expression))
-        return false;
-    
-    return isFunction(next.node.expression.right);
-};