@putout/printer 17.13.0 → 18.0.1

package/ChangeLog

@@ -1,3 +1,26 @@
+2026.03.04, v18.0.1
+
+feature:
+- 5e6e906 @putout/printer: VariableDeclaration: after: simplify
+- 852f982 @putout/printer: @putout/plugin-printer v8.0.0
+- 7b3977d @putout/printer: VariableDeclaration: skipAfter
+- 4f43a9f VariableDeclaration: isNeedNewline
+- 9dece24 @putout/printer: VariableDeclaration: isSemicolon
+- b9a27e0 @putout/printer: VariableDeclaration: isInsideIf
+- 06d6255 @putout/printer: is: isParentProgram -> isInsideProgram
+- 2a0ef4e is: isParentBlock -> isInsideBlock
+
+2026.03.04, v18.0.0
+
+feature:
+- 1aaf942 @putout/printer: ArrayExpression: newline: is more then max element length in one line
+- a0d465b @putout/printer: maxElementLengthInOneLine: 10 -> 15
+- eea22ae @putout/printer: BlockStatement: newline: simplify
+- c9c9f34 @putout/printer: BlockStatement: isMethodOrArrow: simplify
+- 010780c @putout/printer: private-imports: #type-checker
+- 9a4b938 BlockStatements: apply type-checker
+- 9357d36 type-checker: simplify
+
 2026.03.04, v17.13.0
 
 feature:

package/README.md

@@ -97,7 +97,7 @@ print(ast, {
         comments: true,
         maxSpecifiersInOneLine: 2,
         maxElementsInOneLine: 3,
-        maxElementLengthInOneLine: 10,
+        maxElementLengthInOneLine: 15,
         maxLogicalsInOneLine: 3,
         maxVariablesInOneLine: 4,
         maxTypesInOneLine: 3,

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

@@ -1,5 +1,6 @@
 import {isSimple} from '@putout/operate';
 import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
 import {
     isStringAndMember,
     isStringAndIdentifier,
@@ -8,6 +9,7 @@ import {
     isStringAndArray,
     isIdentifierAndIdentifier,
     isSimpleAndNotEmptyObject,
+    isInsideCall,
 } from '#is';
 
 const {
@@ -57,6 +59,28 @@ const isSiblingIsArray = (path) => {
         .isArrayExpression();
 };
 
+const isEmptyArray = (path) => !path.node.elements.length;
+
+const isAllLiterals = (path) => {
+    const {elements} = path.node;
+    const literals = elements.filter(isStringLiteral);
+    
+    return literals.length !== elements.length;
+};
+
+const isMoreThenMaxLiteralLength = (path, {maxElementLengthInOneLine}) => {
+    const [first] = path.node.elements;
+    
+    return first.value.length > maxElementLengthInOneLine;
+};
+
+const isMoreThenMaxElementLengthInOneLine = createTypeChecker([
+    ['-', isEmptyArray],
+    ['-: -> !', isInsideCall],
+    ['-', isAllLiterals],
+    ['+', isMoreThenMaxLiteralLength],
+]);
+
 function isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine) {
     if (elements.length > 1)
         return false;
@@ -75,6 +99,9 @@ export const isMultiLine = (path, {elements, maxElementsInOneLine, maxElementLen
     if (isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine))
         return ONE_LINE;
     
+    if (isMoreThenMaxElementLengthInOneLine(path, {elements, maxElementLengthInOneLine}))
+        return MULTI_LINE;
+    
     if (elements.length > maxElementsInOneLine && isStringLiteral(first))
         return MULTI_LINE;
     
@@ -194,9 +221,6 @@ function isOneSimple(path) {
     
     const [first] = elements;
     
-    if (first.isIdentifier() && first.node.name.length < 15)
-        return true;
-    
     if (first.isStringLiteral() && first.node.value.length > 10)
         return false;
     
@@ -288,12 +312,10 @@ export function isIncreaseIndent(path) {
     return isStringAndObject(elements);
 }
 
-function isInsideCallLoop(path) {
-    if (!path.parentPath.isCallExpression())
-        return false;
-    
-    return path.parentPath.parentPath.isForOfStatement();
-}
+const isInsideCallLoop = createTypeChecker([
+    ['-: -> !', isInsideCall],
+    '+: parentPath.parentPath -> ForOfStatement',
+]);
 
 const isStringAndObject = (elements) => {
     const first = elements.at(0);

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

@@ -1,7 +1,7 @@
 import {maybeParens} from '#maybe-parens';
 import {
-    isParentBlock,
-    isParentProgram,
+    isInsideBlock,
+    isInsideProgram,
 } from '#is';
 import {condition} from './maybe-parens-condition.js';
 import {printSeparator} from './print-separator.js';
@@ -27,7 +27,7 @@ export const AssignmentExpression = maybeParens({
         printSeparator(path, printer);
         print('__right');
         
-        if (isParentBlock(path) || isParentProgram(path)) {
+        if (isInsideBlock(path) || isInsideProgram(path)) {
             print(';');
             print.breakline();
         }

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

@@ -1,4 +1,4 @@
-import {exists} from '#is';
+import {exists, isInsideCall} from '#is';
 import {maybeParens} from '#maybe-parens';
 
 const {isArray} = Array;
@@ -14,7 +14,7 @@ const parseArgs = (path) => {
 
 export const CallExpression = maybeParens((path, {indent, print, maybe, traverse}) => {
     const args = parseArgs(path);
-    const isParentCall = tooLong(args) && path.parentPath.isCallExpression();
+    const isParentCall = tooLong(args) && isInsideCall(path);
     
     const callee = path.get('callee');
     const typeParameters = path.get('typeArguments');

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

@@ -6,7 +6,7 @@ import {
     isNext,
     isNextParent,
 } from '#is';
-import {createTypeChecker} from '../../type-checker/type-checker.js';
+import {createTypeChecker} from '#type-checker';
 
 const {
     isAssignmentExpression,

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

@@ -8,6 +8,7 @@ import {
     noLeadingComment,
     hasLeadingComment,
     exists,
+    isInsideCall,
 } from '#is';
 import {parseComments} from '../../comment/comment.js';
 import {isInsideTuple} from './is-inside-tuple.js';
@@ -37,8 +38,6 @@ const isMemberExpressionCallee = ({parentPath}) => {
     return isLooksLikeChain(callee);
 };
 
-const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
-
 function isInsideNestedArrayCall({parentPath}) {
     if (!isArrayExpression(parentPath))
         return false;

package/lib/tokenize/is.js

@@ -1,5 +1,5 @@
 import {types} from '@putout/babel';
-import {createTypeChecker} from './type-checker/type-checker.js';
+import {createTypeChecker} from '#type-checker';
 
 const {
     isStringLiteral,
@@ -18,8 +18,8 @@ const {
     isTSModuleBlock,
 } = types;
 
-export const isParentProgram = (path) => isProgram(path.parentPath);
-export const isParentBlock = (path) => isBlockStatement(path.parentPath);
+export const isInsideProgram = (path) => isProgram(path.parentPath);
+export const isInsideBlock = (path) => isBlockStatement(path.parentPath);
 
 export const isParentBlockLike = createTypeChecker('path.parentPath', [
     'Program',
@@ -32,6 +32,8 @@ export const isInsideTSModuleBlock = ({parentPath}) => {
     return isTSModuleBlock(parentPath?.parentPath);
 };
 
+export const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
+
 export const isNext = (path) => {
     const next = path.getNextSibling();
     
@@ -57,7 +59,7 @@ export const isPrev = (path) => {
 };
 
 export const isNextParent = (path) => isNext(path.parentPath);
-export const isLast = (path) => isParentProgram(path) && !isNext(path);
+export const isLast = (path) => isInsideProgram(path) && !isNext(path);
 
 export const isNextObject = (a) => a
     .getNextSibling()

package/lib/tokenize/overrides/overrides.js

@@ -33,7 +33,7 @@ const initSemantics = (format, semantics = {}) => ({
     maxPropertiesLengthInOneLine: 15,
     maxSpecifiersInOneLine: 2,
     maxElementsInOneLine: 5,
-    maxElementLengthInOneLine: 10,
+    maxElementLengthInOneLine: 15,
     maxLogicalsInOneLine: 3,
     maxVariablesInOneLine: 4,
     maxTypesInOneLine: 3,

package/lib/tokenize/statements/block-statement/block-statement-newline.js

@@ -0,0 +1,98 @@
+import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
+import {
+    isNext,
+    isInsideProgram,
+    isLast,
+    exists,
+    satisfy,
+    isInsideBlock,
+} from '#is';
+import {insideIfWithNoBody} from './inside-if-with-no-body.js';
+
+const parentIfWithoutElse = ({parentPath}) => {
+    if (!parentPath.isIfStatement())
+        return false;
+    
+    return !parentPath.node.alternate;
+};
+
+const {
+    isFunctionDeclaration,
+    isExportDeclaration,
+    isDoWhileStatement,
+} = types;
+
+const isTopLevelWithNoNext = (path) => {
+    if (isNext(path))
+        return false;
+    
+    return !isNext(path.parentPath) && isInsideProgram(path.parentPath);
+};
+
+const isInsideDoWhile = ({parentPath}) => isDoWhileStatement(parentPath);
+const isMethodOrArrow = createTypeChecker(['ArrowFunctionExpression', 'ObjectMethod']);
+const isInsideFn = (path) => path.find(isMethodOrArrow);
+
+const isInsideIfWithoutElseInsideFn = createTypeChecker([
+    ['-: -> !', parentIfWithoutElse],
+    ['+', isInsideFn],
+]);
+
+const isEmptyBodyNoNext = (path) => {
+    const {parentPath} = path;
+    return parentPath.isStatement() && !path.node.body.length && !isNext(parentPath);
+};
+
+const isLooksLikeInsideFn = ({parentPath}) => {
+    return /FunctionExpression/.test(parentPath.type);
+};
+
+const isNoNewline = satisfy([
+    isInsideDoWhile,
+    isTopLevelWithNoNext,
+    insideIfWithNoBody,
+]);
+
+export const shouldAddNewlineAfter = createTypeChecker([
+    ['+', isInsideBlock],
+    ['-', isNoNewline],
+    ['+', isInsideIfWithoutElseInsideFn],
+    ['-', isEmptyBodyNoNext],
+    ['-', isTry],
+    ['-', isLooksLikeInsideFn],
+    ['-', isLast],
+    ['-', isExportFunction],
+    ['+: -> !', isNextIfAlternate],
+]);
+
+function isExportFunction(path) {
+    if (!isFunctionDeclaration(path.parentPath))
+        return false;
+    
+    if (!isExportDeclaration(path.parentPath?.parentPath))
+        return false;
+    
+    return !isNext(path.parentPath?.parentPath);
+}
+
+function isNextIfAlternate(path) {
+    const {parentPath} = path;
+    
+    if (!parentPath.isIfStatement())
+        return false;
+    
+    const alternate = parentPath.get('alternate');
+    
+    if (path === alternate)
+        return false;
+    
+    return exists(alternate);
+}
+
+function isTry({parentPath}) {
+    if (parentPath.isTryStatement())
+        return true;
+    
+    return parentPath.parentPath?.isTryStatement();
+}

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

@@ -1,30 +1,18 @@
 import {types} from '@putout/babel';
 import {markAfter} from '#mark';
-import {
-    isNext,
-    isParentProgram,
-    isLast,
-    exists,
-    satisfy,
-    isParentBlock,
-} from '#is';
+import {isNext} from '#is';
 import {parseComments} from '../../comment/comment.js';
-import {insideIfWithNoBody} from './inside-if-with-no-body.js';
 import {getDirectives} from './get-directives.js';
 import {isCallInsideChain} from './is-call-inside-chain.js';
+import {shouldAddNewlineAfter} from './block-statement-newline.js';
 
 const {
-    isArrowFunctionExpression,
     isObjectMethod,
-    isFunctionDeclaration,
-    isExportDeclaration,
-    isDoWhileStatement,
     isArrayExpression,
 } = types;
 
 const isFirstStatement = (path) => path.node.body[0];
 const isFirstDirective = (path) => path.node.directives?.[0];
-const isMethodOrArrow = (path) => isArrowFunctionExpression(path) || isObjectMethod(path);
 
 const isInsideArrayTupleOfThree = (path) => {
     const {parentPath} = path.parentPath;
@@ -37,13 +25,6 @@ const isInsideArrayTupleOfThree = (path) => {
     return length === 3;
 };
 
-const parentIfWithoutElse = ({parentPath}) => {
-    if (!parentPath.isIfStatement())
-        return false;
-    
-    return !parentPath.node.alternate;
-};
-
 export const BlockStatement = {
     print(path, printer, semantics) {
         const {trailingComma} = semantics;
@@ -102,93 +83,3 @@ export const BlockStatement = {
         markAfter(path.parentPath);
     },
 };
-
-const isTopLevelWithNoNext = (path) => {
-    if (isNext(path))
-        return false;
-    
-    return !isNext(path.parentPath) && isParentProgram(path.parentPath);
-};
-
-const isInsideIfWithoutElseInsideFn = (path) => {
-    return parentIfWithoutElse(path) && path.find(isMethodOrArrow);
-};
-
-const isEmptyBodyNoNext = (path) => {
-    const {parentPath} = path;
-    return parentPath.isStatement() && !path.node.body.length && !isNext(parentPath);
-};
-
-const isLooksLikeInsideFn = ({parentPath}) => {
-    return /FunctionExpression/.test(parentPath.type);
-};
-
-const NEWLINE = true;
-const NO_NEWLINE = false;
-
-const isInsideDoWhile = ({parentPath}) => isDoWhileStatement(parentPath);
-
-const isNoNewline = satisfy([
-    isInsideDoWhile,
-    isTopLevelWithNoNext,
-    insideIfWithNoBody,
-]);
-
-function shouldAddNewlineAfter(path) {
-    if (isParentBlock(path))
-        return NEWLINE;
-    
-    if (isNoNewline(path))
-        return NO_NEWLINE;
-    
-    if (isInsideIfWithoutElseInsideFn(path))
-        return NEWLINE;
-    
-    if (isEmptyBodyNoNext(path))
-        return NO_NEWLINE;
-    
-    if (isTry(path))
-        return NO_NEWLINE;
-    
-    if (isLooksLikeInsideFn(path))
-        return NO_NEWLINE;
-    
-    if (isLast(path))
-        return NO_NEWLINE;
-    
-    if (isExportFunction(path))
-        return NO_NEWLINE;
-    
-    return !isNextIfAlternate(path);
-}
-
-function isExportFunction(path) {
-    if (!isFunctionDeclaration(path.parentPath))
-        return false;
-    
-    if (!isExportDeclaration(path.parentPath?.parentPath))
-        return false;
-    
-    return !isNext(path.parentPath?.parentPath);
-}
-
-function isNextIfAlternate(path) {
-    const {parentPath} = path;
-    
-    if (!parentPath.isIfStatement())
-        return false;
-    
-    const alternate = parentPath.get('alternate');
-    
-    if (path === alternate)
-        return false;
-    
-    return exists(alternate);
-}
-
-function isTry({parentPath}) {
-    if (parentPath.isTryStatement())
-        return true;
-    
-    return parentPath.parentPath?.isTryStatement();
-}

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

@@ -1,5 +1,5 @@
 import {
-    isParentBlock,
+    isInsideBlock,
     isNextParent,
     isInsideIf,
     isInsideLabel,
@@ -21,7 +21,7 @@ export const BreakStatement = {
         print(';');
     },
     afterSatisfy: () => [
-        isParentBlock,
+        isInsideBlock,
         isNextParent,
         isInsideCase,
         isInsideIf,

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

@@ -1,7 +1,7 @@
 import {
     isNext,
     isInsideIf,
-    isParentBlock,
+    isInsideBlock,
 } from '#is';
 
 export const DebuggerStatement = {
@@ -11,7 +11,7 @@ export const DebuggerStatement = {
     },
     afterSatisfy: () => [
         isNext,
-        isParentBlock,
+        isInsideBlock,
         isInsideIf,
     ],
     after(path, {print}) {

package/lib/tokenize/statements/export-declaration/export-declaration.js

@@ -1,7 +1,7 @@
 import {types} from '@putout/babel';
 import {printAttributes} from '#import-attributes';
 import {
-    isParentBlock,
+    isInsideBlock,
     isNewlineBetweenSiblings,
     exists,
     isNext,
@@ -169,7 +169,7 @@ export const ExportNamedDeclaration = {
         if (isNewlineBetweenSiblings(path))
             return true;
         
-        return isParentBlock(path);
+        return isInsideBlock(path);
     },
     after(path, {print, indent}) {
         const next = path.getNextSibling();

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

@@ -2,7 +2,7 @@ import {types} from '@putout/babel';
 import {
     isNext,
     isLast,
-    isParentBlock,
+    isInsideBlock,
     isParentLast,
     isNewlineBetweenSiblings,
     satisfy,
@@ -42,7 +42,7 @@ const notInsideReturn = not(isInsideReturn);
 
 const satisfyAfter = satisfy([
     isNotLastOrParentLast,
-    isParentBlock,
+    isInsideBlock,
     isNext,
     isNextUp,
 ]);

package/lib/tokenize/statements/if-statement/if-statement-comments.js

@@ -1,5 +1,5 @@
 import {types} from '@putout/babel';
-import {isNext, isParentBlock} from '#is';
+import {isNext, isInsideBlock} from '#is';
 
 const {isBlockStatement} = types;
 
@@ -24,6 +24,6 @@ export const printTrailingCommentLine = (path, printer, semantics, {printComment
     
     printComment();
     
-    if (hasNext || isParentBlock(path))
+    if (hasNext || isInsideBlock(path))
         print.newline();
 };

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

@@ -2,7 +2,7 @@ import {types} from '@putout/babel';
 import {
     isNext,
     isNextTry,
-    isParentBlock,
+    isInsideBlock,
 } from '#is';
 
 const {isExpressionStatement} = types;
@@ -55,5 +55,5 @@ export const CatchClause = (path, {print, maybe}) => {
     }
     
     print(body);
-    maybe.print.newline(isParentBlock(parentPath));
+    maybe.print.newline(isInsideBlock(parentPath));
 };

package/lib/tokenize/statements/variable-declaration/variable-declaration.js

@@ -1,5 +1,6 @@
 import {types} from '@putout/babel';
 import {hasPrevNewline} from '#mark';
+import {createTypeChecker} from '#type-checker';
 import {
     isNext,
     isCoupleLines,
@@ -7,27 +8,43 @@ import {
     exists,
     noTrailingComment,
     isParentBlockLike,
+    isInsideIf,
+    isInsideBlock,
 } from '#is';
 import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
 import {isConcatenation} from '../../expressions/binary-expression/concatenate.js';
 import {parseLeadingComments} from '../../comment/comment.js';
 import {maybeDeclare} from '../../maybe/maybe-declare.js';
-import {createTypeChecker} from '../../type-checker/type-checker.js';
+
+const isLast = (path) => path.parentPath?.isProgram() && !isNext(path);
 
 const {isExportDeclaration} = types;
 
 const isParentTSModuleBlock = (path) => path.parentPath.isTSModuleBlock();
 const isParentSwitchCase = (path) => path.parentPath.isSwitchCase();
 const isFirstInSwitch = (path) => path.parentPath.get('consequent.0') === path;
-const isParentIf = (path) => path.parentPath.isIfStatement();
 
-const isParentBlock = createTypeChecker('path.parentPath', [
+const isIsideParentLike = createTypeChecker('path.parentPath', [
     'Program',
     'BlockStatement',
     'ExportNamedDeclaration',
     'LabeledStatement',
 ]);
 
+const isNeedSemicolon = createTypeChecker([
+    isIsideParentLike,
+    isParentSwitchCase,
+    isParentTSModuleBlock,
+    isInsideIf,
+]);
+
+const isNeedNewline = createTypeChecker([
+    ['-: -> !', isIsideParentLike],
+    ['-: -> !', isNext],
+    ['+', noTrailingComment],
+    ['+', isNewlineBetweenSiblings],
+]);
+
 export const VariableDeclaration = {
     beforeIf: shouldAddNewlineBefore,
     before(path, {print}) {
@@ -78,9 +95,7 @@ export const VariableDeclaration = {
         }
         
         maybe.indent.dec(n);
-        
-        if (isParentBlock(path) || isParentSwitchCase(path) || isParentTSModuleBlock(path) || isParentIf(path))
-            write(';');
+        maybe.write(isNeedSemicolon(path), ';');
         
         let wasNewline = false;
         
@@ -91,7 +106,7 @@ export const VariableDeclaration = {
                 wasNewline = true;
         }
         
-        if (isParentBlock(path) && isNext(path) && (noTrailingComment(path) || isNewlineBetweenSiblings(path))) {
+        if (isNeedNewline(path)) {
             write.newline();
             wasNewline = true;
         }
@@ -110,18 +125,23 @@ export const VariableDeclaration = {
         notLastParentExport,
         isParentTSModuleBlock,
     ],
-    after(path, {maybe, store}) {
+    after(path, {maybe, store, print}) {
         const wasNewline = store();
         
-        if (isLast(path.parentPath) && !path.parentPath.isBlockStatement() || !isParentBlock(path) && !isParentTSModuleBlock(path))
-            return false;
+        if (skipAfter(path))
+            return;
         
-        maybe.print.linebreak(wasNewline);
-        maybe.print.newline(!wasNewline);
+        maybe.indent(wasNewline);
+        print.newline();
         maybe.markAfter(wasNewline, path);
     },
 };
 
+const skipAfter = createTypeChecker([
+    ['-: parentPath -> !', isLast],
+    ['+: -> !', isInsideBlock],
+]);
+
 function noNextParentBlock(path) {
     if (isNext(path))
         return false;
@@ -169,8 +189,6 @@ function isNextCoupleLines(path) {
     return isCoupleLines(next);
 }
 
-const isLast = (path) => path.parentPath?.isProgram() && !isNext(path);
-
 function shouldAddNewlineBefore(path) {
     if (isFirst(path))
         return false;

package/lib/tokenize/type-checker/comparators.js

@@ -0,0 +1,24 @@
+const isFn = (a) => typeof a === 'function';
+const isString = (a) => typeof a === 'string';
+
+export const equal = (not, a, b) => {
+    if (!isString(b))
+        return false;
+    
+    if (not)
+        return a !== b;
+    
+    return a === b;
+};
+
+export const maybeCall = (fn, not, a, options) => {
+    if (!isFn(fn))
+        return false;
+    
+    const result = fn(a, options);
+    
+    if (not)
+        return !result;
+    
+    return result;
+};

package/lib/tokenize/type-checker/create-tuple.js

@@ -0,0 +1,17 @@
+export function createTuple(typeName) {
+    const afterSplit = typeName.split(' ');
+    const typeWithNot = afterSplit.pop();
+    const array = typeWithNot.split('!');
+    const operation = afterSplit.join(' ');
+    
+    if (array.length === 1)
+        return [
+            `${operation} `,
+            typeWithNot,
+        ];
+    
+    return [
+        `${operation} !`,
+        array[1],
+    ];
+}

package/lib/tokenize/type-checker/parsers.js

@@ -0,0 +1,51 @@
+import {isArray} from '@putout/compare/lib/is.js';
+import {createTuple} from './create-tuple.js';
+
+const isString = (a) => typeof a === 'string';
+
+export const parseOperation = (operation) => {
+    const [result, command] = operation.split(':');
+    const parsedResult = parseResult(result);
+    
+    if (!command)
+        return [parsedResult, '', ''];
+    
+    const [selector, not] = command.split(' -> ');
+    
+    return [parsedResult, selector.trim(), not];
+};
+
+const parseResult = (a) => a === '+';
+
+export function parseTypeNames(typeNames) {
+    const tuples = [];
+    
+    if (isArray(typeNames)) {
+        for (const typeName of typeNames) {
+            if (isArray(typeName)) {
+                tuples.push(typeName);
+                continue;
+            }
+            
+            if (isString(typeName) && typeName.includes(' -> ')) {
+                const tuple = createTuple(typeName);
+                tuples.push(tuple);
+                continue;
+            }
+            
+            tuples.push(['+', typeName]);
+        }
+        
+        return tuples;
+    }
+    
+    for (const typeName of typeNames.include) {
+        tuples.push(['+', typeName]);
+    }
+    
+    for (const typeName of typeNames.exclude) {
+        tuples.push(['-', typeName]);
+    }
+    
+    return tuples;
+}

package/lib/tokenize/type-checker/type-checker.js

@@ -1,31 +1,6 @@
 import {jessy} from 'jessy';
-
-const {isArray} = Array;
-
-const isString = (a) => typeof a === 'string';
-const isFn = (a) => typeof a === 'function';
-
-const equal = (not, a, b) => {
-    if (!isString(b))
-        return false;
-    
-    if (not)
-        return a !== b;
-    
-    return a === b;
-};
-
-const exec = (fn, not, a) => {
-    if (!isFn(fn))
-        return false;
-    
-    const result = fn(a);
-    
-    if (not)
-        return !result;
-    
-    return result;
-};
+import {parseOperation, parseTypeNames} from './parsers.js';
+import {equal, maybeCall} from './comparators.js';
 
 export const createTypeChecker = (deepness, typeNames) => {
     if (!typeNames) {
@@ -35,7 +10,7 @@ export const createTypeChecker = (deepness, typeNames) => {
     
     const tuples = parseTypeNames(typeNames);
     
-    return (path) => {
+    return (path, options) => {
         let i = deepness.split('.').length;
         
         while (--i)
@@ -56,75 +31,10 @@ export const createTypeChecker = (deepness, typeNames) => {
             if (equal(not, type, typeName))
                 return result;
             
-            if (exec(typeName, not, currentPath))
+            if (maybeCall(typeName, not, currentPath, options))
                 return result;
         }
         
         return false;
     };
 };
-
-const parseOperation = (operation) => {
-    const [result, command] = operation.split(':');
-    const parsedResult = parseResult(result);
-    
-    if (!command)
-        return [parsedResult, '', ''];
-    
-    const [selector, not] = command.split(' -> ');
-    
-    return [parsedResult, selector.trim(), not];
-};
-
-const parseResult = (a) => a === '+';
-
-function parseTypeNames(typeNames) {
-    const tuples = [];
-    
-    if (isArray(typeNames)) {
-        for (const typeName of typeNames) {
-            if (isArray(typeName)) {
-                tuples.push(typeName);
-                continue;
-            }
-            
-            if (isString(typeName) && typeName.includes(' -> ')) {
-                const tuple = createTuple(typeName);
-                tuples.push(tuple);
-                continue;
-            }
-            
-            tuples.push(['+', typeName]);
-        }
-        
-        return tuples;
-    }
-    
-    for (const typeName of typeNames.include) {
-        tuples.push(['+', typeName]);
-    }
-    
-    for (const typeName of typeNames.exclude) {
-        tuples.push(['-', typeName]);
-    }
-    
-    return tuples;
-}
-
-function createTuple(typeName) {
-    const afterSplit = typeName.split(' ');
-    const typeWithNot = afterSplit.pop();
-    const array = typeWithNot.split('!');
-    const operation = afterSplit.join(' ');
-    
-    if (array.length === 1)
-        return [
-            `${operation} `,
-            typeWithNot,
-        ];
-    
-    return [
-        `${operation} !`,
-        array[1],
-    ];
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "17.13.0",
+  "version": "18.0.1",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -62,14 +62,15 @@
     "#maybe-parens": "./lib/tokenize/maybe/maybe-parens.js",
     "#print-params": "./lib/tokenize/expressions/function/params.js",
     "#import-attributes": "./lib/tokenize/statements/import-declaration/import-attribute.js",
-    "#types": "./lib/types.js"
+    "#types": "./lib/types.js",
+    "#type-checker": "./lib/tokenize/type-checker/type-checker.js"
   },
   "devDependencies": {
     "@babel/parser": "^7.28.5",
     "@putout/eslint": "^6.0.0",
     "@putout/eslint-flat": "^4.0.0",
     "@putout/plugin-minify": "^11.2.1",
-    "@putout/plugin-printer": "^7.0.0",
+    "@putout/plugin-printer": "^8.0.0",
     "@putout/plugin-promises": "^19.0.0",
     "@putout/plugin-react-hook-form": "^6.0.0",
     "@putout/plugin-react-hooks": "^9.0.0",