@putout/printer 16.6.0 → 17.0.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2026.01.04, v17.0.0
+
+feature:
+- b33d062 @putout/printer: migrate to ESM
+- dcd78dd @putout/printer: redlint v5.0.2
+- 45b4570 @putout/printer: goldstein v7.0.0
+- 97a49eb @putout/printer: madrun v12.0.0
+- 063fda0 @putout/printer: samadhi v4.0.2
+- 3ff6ea5 @putout/printer: try-catch v4.0.6
+- 09f5c5a @putout/printer: @putout/eslint v5.0.2
+
 2026.01.03, v16.6.0
 
 feature:

package/README.md

@@ -54,8 +54,8 @@ To benefit from it.
 ## Example
 
 ```js
-const {print} = require('@putout/printer');
-const {parse} = require('putout');
+import {print} from '@putout/printer';
+import {parse} from 'putout';
 const ast = parse('const a = (b, c) => {const d = 5; return a;}');
 
 print(ast);
@@ -309,10 +309,10 @@ This is the same as `print('__left')` but more low-level, and supports only obje
 About speed, for file `speed.js`:
 
 ```js
-const {readFileSync} = require('node:fs');
+import {readFileSync} from 'node:fs';
 
-const putout = require('putout');
-const parser = require('@babel/parser');
+import {putout} from 'putout';
+import parser from '@babel/parser';
 
 const code = readFileSync('./lib/tokenize/tokenize.js', 'utf8');
 const ast = parser.parse(code);

package/lib/json.js

@@ -1,14 +1,12 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {isJSON} = require('@putout/operator-json');
+import {types} from '@putout/babel';
+import {isJSON} from '@putout/operator-json';
 
 const {
     isCallExpression,
     isIdentifier,
 } = types;
 
-module.exports.maybeJSON = (ast, overrides) => {
+export const maybeJSON = (ast, overrides) => {
     if (isASTJSON(ast))
         return {
             ...overrides,

package/lib/print-tokens/cook.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.cook = (tokens) => {
+export const cook = (tokens) => {
     const cookedTokens = [];
     
     for (const {value} of tokens) {

package/lib/print-tokens/index.js

@@ -1,8 +1,6 @@
-'use strict';
+import {cook} from './cook.js';
 
-const {cook} = require('./cook');
-
-module.exports.printTokens = (tokens) => {
+export const printTokens = (tokens) => {
     const cookedTokens = cook(tokens);
     return cookedTokens.join('');
 };

package/lib/printer.js

@@ -1,13 +1,11 @@
-'use strict';
+import {tokenize} from './tokenize/tokenize.js';
+import {printTokens} from './print-tokens/index.js';
+import {maybeJSON} from './json.js';
 
-const {tokenize} = require('./tokenize/tokenize');
-const {printTokens} = require('./print-tokens');
-const {maybeJSON} = require('./json');
+export {maybeVisitor} from './tokenize/maybe/index.js';
+export * as visitors from './tokenize/visitors.js';
 
-const {maybeVisitor} = require('./tokenize/maybe/index');
-const visitors = require('./tokenize/visitors');
-
-module.exports.print = (ast, overrides = {}) => {
+export const print = (ast, overrides = {}) => {
     check(ast);
     
     const options = maybeJSON(ast, overrides);
@@ -16,9 +14,6 @@ module.exports.print = (ast, overrides = {}) => {
     return printTokens(tokens);
 };
 
-module.exports.visitors = visitors;
-module.exports.maybeVisitor = maybeVisitor;
-
 function check(ast) {
     if (typeof ast !== 'object')
         throw Error('☝️Looks like ast not an object');

package/lib/tokenize/comment/comment.js

@@ -1,9 +1,3 @@
-'use strict';
-
-const {parseLeadingComments} = require('./parse-leading-comments');
-const {parseTrailingComments} = require('./parse-trailing-comments');
-const {parseComments} = require('./parse-comments');
-
-module.exports.parseLeadingComments = parseLeadingComments;
-module.exports.parseTrailingComments = parseTrailingComments;
-module.exports.parseComments = parseComments;
+export {parseLeadingComments} from './parse-leading-comments.js';
+export {parseTrailingComments} from './parse-trailing-comments.js';
+export {parseComments} from './parse-comments.js';

package/lib/tokenize/comment/comments-printer/comments-printer.js

@@ -1,9 +1,7 @@
-'use strict';
-
 const createPrintCommentLine = (fn, value) => () => fn(`//${value}`);
 const createPrintCommentBlock = (fn, value) => () => fn(`/*${value}*/\n`);
 
-module.exports.hasTrailingCommentsPrinter = (currentTraverse) => {
+export const hasTrailingCommentsPrinter = (currentTraverse) => {
     const {
         printTrailingCommentBlock,
         printTrailingCommentLine,
@@ -15,7 +13,7 @@ module.exports.hasTrailingCommentsPrinter = (currentTraverse) => {
     return Boolean(printTrailingCommentLine);
 };
 
-module.exports.hasLeadingCommentsPrinter = (currentTraverse) => {
+export const hasLeadingCommentsPrinter = (currentTraverse) => {
     const {
         printLeadingCommentLine,
         printLeadingCommentBlock,
@@ -27,7 +25,7 @@ module.exports.hasLeadingCommentsPrinter = (currentTraverse) => {
     return Boolean(printLeadingCommentBlock);
 };
 
-module.exports.printLeadingComments = (path, printer, semantics, {currentTraverse}) => {
+export const printLeadingComments = (path, printer, semantics, {currentTraverse}) => {
     const {print} = printer;
     const {
         leadingComments = [],
@@ -58,7 +56,7 @@ module.exports.printLeadingComments = (path, printer, semantics, {currentTravers
     }
 };
 
-module.exports.printTrailingComments = (path, printer, semantics, {currentTraverse}) => {
+export const printTrailingComments = (path, printer, semantics, {currentTraverse}) => {
     const {print} = printer;
     const {
         trailingComments = []} = path.node;

package/lib/tokenize/comment/maybe-inside-fn.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.maybeInsideFn = (insideFn, {print, indent}) => {
+export const maybeInsideFn = (insideFn, {print, indent}) => {
     if (!insideFn)
         return;
     

package/lib/tokenize/comment/parse-comments.js

@@ -1,8 +1,6 @@
-'use strict';
+import {isNext} from '../is.js';
 
-const {isNext} = require('../is');
-
-module.exports.parseComments = (path, {write, maybe}, semantics) => {
+export const parseComments = (path, {write, maybe}, semantics) => {
     if (!semantics.comments)
         return;
     

package/lib/tokenize/comment/parse-leading-comments.js

@@ -1,18 +1,14 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {
+import {types} from '@putout/babel';
+import {
     hasTrailingComment,
     satisfy,
-} = require('../is');
-
-const {markBefore} = require('../mark');
-const {maybeInsideFn} = require('./maybe-inside-fn');
-
-const {
+} from '../is.js';
+import {markBefore} from '../mark.js';
+import {maybeInsideFn} from './maybe-inside-fn.js';
+import {
     printLeadingComments,
     hasLeadingCommentsPrinter,
-} = require('./comments-printer/comments-printer');
+} from './comments-printer/comments-printer.js';
 
 const {
     isArrowFunctionExpression,
@@ -86,7 +82,7 @@ const isFirst = (path) => {
     return false;
 };
 
-module.exports.parseLeadingComments = (path, printer, semantics, {currentTraverse = {}} = {}) => {
+export const parseLeadingComments = (path, printer, semantics, {currentTraverse = {}} = {}) => {
     const {
         print,
         maybe,

package/lib/tokenize/comment/parse-trailing-comments.js

@@ -1,19 +1,14 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-
-const {
+import {types} from '@putout/babel';
+import {
     isLast,
     isCoupleLines,
     isNext,
-} = require('../is');
-
-const {isLooksLikeChain} = require('../expressions/member-expression/is-looks-like-chain');
-
-const {
+} from '../is.js';
+import {isLooksLikeChain} from '../expressions/member-expression/is-looks-like-chain.js';
+import {
     printTrailingComments,
     hasTrailingCommentsPrinter,
-} = require('./comments-printer/comments-printer');
+} from './comments-printer/comments-printer.js';
 
 const {
     isDecorator,
@@ -42,7 +37,7 @@ function isSameLine(path, loc) {
     return path.node.loc?.start.line === loc.start.line || path.node.loc?.end.line === loc.end.line;
 }
 
-const isTrailingIsLeading = (path) => path.node.trailingComments === path.getNextSibling().node?.leadingComments;
+export const isTrailingIsLeading = (path) => path.node.trailingComments === path.getNextSibling().node?.leadingComments;
 
 const isNewlineAfter = (path) => {
     const {parentPath} = path;
@@ -58,8 +53,6 @@ const isNewlineAfter = (path) => {
     return !isLast(path);
 };
 
-module.exports.isTrailingIsLeading = isTrailingIsLeading;
-
 function isCommentOnNextLine(path) {
     const {node} = path;
     const {
@@ -95,7 +88,7 @@ function isCommentOnNextLine(path) {
     return isNextLine || isNextLineAfterNewline;
 }
 
-module.exports.parseTrailingComments = (path, printer, semantics, {currentTraverse} = {}) => {
+export const parseTrailingComments = (path, printer, semantics, {currentTraverse} = {}) => {
     const {parentPath} = path;
     const {
         write,

package/lib/tokenize/debug.js

@@ -1,9 +1,7 @@
-'use strict';
-
-const process = require('node:process');
-const toSnakeCase = require('just-snake-case');
-const {codeFrameColumns} = require('@putout/babel');
-const {TYPES} = require('../types');
+import process from 'node:process';
+import toSnakeCase from 'just-snake-case';
+import {codeFrameColumns} from '@putout/babel';
+import {TYPES} from '../types.js';
 
 const {stringify} = JSON;
 const {
@@ -14,7 +12,7 @@ const {
     LOG_DEBUG,
 } = process.env;
 
-module.exports.createDebug = (tokens) => (a) => {
+export const createDebug = (tokens) => (a) => {
     if (!LOG_DEBUG)
         return;
     
@@ -24,7 +22,7 @@ module.exports.createDebug = (tokens) => (a) => {
     });
 };
 
-module.exports.createLog = ({newline = '\n', store = createStore()} = {}) => ({type, value}) => {
+export const createLog = ({newline = '\n', store = createStore()} = {}) => ({type, value}) => {
     if (LOG_TOKENS) {
         console.log(codeFrameColumns(stringify({
             type,

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

@@ -1,31 +1,26 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {
+import {types} from '@putout/babel';
+import {
     isCoupleLines,
     isStringAndIdentifier,
     isIdentifierAndIdentifier,
     isStringAndArray,
     isSimpleAndNotEmptyObject,
     isNextObject,
-} = require('#is');
-
-const {
+} from '#is';
+import {
     isIncreaseIndent,
     isCurrentNewLine,
     isMultiLine,
-} = require('./newline');
-
-const {
+} from './newline.js';
+import {
     isInsideArray,
     isArrayInsideArray,
     isArrayIndented,
-} = require('./indent');
-
-const {
+} from './indent.js';
+import {
     isObjectAfterSimple,
     isNextSimple,
-} = require('./is-object-after-simple');
+} from './is-object-after-simple.js';
 
 const {
     isObjectExpression,
@@ -79,7 +74,7 @@ const isNextSimpleBetweenObjects = (a) => {
 
 const isInsideOneElementArray = ({parentPath}) => parentPath.node.elements.length === 1;
 
-module.exports.ArrayExpression = {
+export const ArrayExpression = {
     beforeIf(path) {
         const {parentPath} = path;
         const {elements} = path.node;

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

@@ -1,18 +1,14 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {isIndented} = require('../../is');
+import {types} from '@putout/babel';
+import {isIndented} from '../../is.js';
 
 const {
     isStringLiteral,
     isArrayExpression,
 } = types;
 
-const isInsideArray = (path) => path.parentPath.isArrayExpression();
-
-module.exports.isInsideArray = isInsideArray;
+export const isInsideArray = (path) => path.parentPath.isArrayExpression();
 
-module.exports.isArrayIndented = (path) => {
+export const isArrayIndented = (path) => {
     const elements = path.get('elements');
     
     if (isArrayInsideArray(path))
@@ -23,9 +19,7 @@ module.exports.isArrayIndented = (path) => {
     return !isTwoLongStrings(elements) || !isInsideArray(path) && isIndented(first);
 };
 
-module.exports.isArrayInsideArray = isArrayInsideArray;
-
-function isArrayInsideArray(path) {
+export function isArrayInsideArray(path) {
     if (!path.isArrayExpression() || !path.parentPath.isArrayExpression())
         return false;
     

package/lib/tokenize/expressions/array-expression/is-object-after-simple.js

@@ -1,6 +1,4 @@
-'use strict';
-
-const {isNextObject, isPrevObject} = require('../../is');
+import {isNextObject, isPrevObject} from '../../is.js';
 
 const SIMPLE_TYPES = [
     'ArrayExpression',
@@ -11,7 +9,7 @@ const SIMPLE_TYPES = [
     'NewExpression',
 ];
 
-module.exports.isObjectAfterSimple = (a) => {
+export const isObjectAfterSimple = (a) => {
     const {type} = a;
     
     if (!isNextObject(a) || isPrevObject(a))
@@ -20,7 +18,7 @@ module.exports.isObjectAfterSimple = (a) => {
     return SIMPLE_TYPES.includes(type);
 };
 
-module.exports.isNextSimple = (a) => {
+export const isNextSimple = (a) => {
     const {type} = a.getNextSibling();
     
     return SIMPLE_TYPES.includes(type);

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

@@ -1,9 +1,6 @@
-'use strict';
-
-const {isSimple} = require('@putout/operate');
-const {types} = require('@putout/babel');
-
-const {
+import {isSimple} from '@putout/operate';
+import {types} from '@putout/babel';
+import {
     isStringAndMember,
     isStringAndIdentifier,
     isIdentifierAndString,
@@ -11,7 +8,7 @@ const {
     isStringAndArray,
     isIdentifierAndIdentifier,
     isSimpleAndNotEmptyObject,
-} = require('../../is');
+} from '../../is.js';
 
 const {
     isObjectExpression,
@@ -72,7 +69,7 @@ function isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine) {
     return first.node.name.length < maxElementLengthInOneLine;
 }
 
-module.exports.isMultiLine = (path, {elements, maxElementsInOneLine, maxElementLengthInOneLine}) => {
+export const isMultiLine = (path, {elements, maxElementsInOneLine, maxElementLengthInOneLine}) => {
     const [first] = elements;
     
     if (isMaxElementLengthInOneLine(elements, maxElementLengthInOneLine))
@@ -270,8 +267,7 @@ const isLastArg = ({parentPath}) => !parentPath.isCallExpression();
 
 const isParentProperty = (path) => path.find(isObjectProperty);
 
-module.exports.isIncreaseIndent = isIncreaseIndent;
-function isIncreaseIndent(path) {
+export function isIncreaseIndent(path) {
     const elements = path.get('elements');
     
     if (!elements.length)
@@ -306,7 +302,7 @@ const isStringAndObject = (elements) => {
     return isStringLiteral(first) && isObjectExpression(last);
 };
 
-module.exports.isCurrentNewLine = (path) => {
+export const isCurrentNewLine = (path) => {
     if (path.isSpreadElement())
         return true;
     

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

@@ -1,9 +1,8 @@
-'use strict';
+import {maybeTypeAnnotation} from '../../maybe/maybe-type-annotation.js';
 
-const {maybeTypeAnnotation} = require('../../maybe/maybe-type-annotation');
 const isForOf = ({parentPath}) => parentPath.parentPath.parentPath?.isForOfStatement();
 
-module.exports.ArrayPattern = maybeTypeAnnotation((path, {indent, maybe, print}, semantics) => {
+export const ArrayPattern = maybeTypeAnnotation((path, {indent, maybe, print}, semantics) => {
     const {maxElementsInOneLine} = semantics;
     
     print('[');

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

@@ -1,10 +1,9 @@
-'use strict';
+import {types} from '@putout/babel';
+import {hasLeadingComment} from '#is';
 
-const {types} = require('@putout/babel');
-const {hasLeadingComment} = require('#is');
 const {isReturnStatement} = types;
 
-module.exports.printLeadingCommentLine = (path, printer, semantics, {printComment, isLast}) => {
+export const printLeadingCommentLine = (path, printer, semantics, {printComment, isLast}) => {
     const {parentPath} = path;
     const {print, maybe} = printer;
     
@@ -16,7 +15,7 @@ module.exports.printLeadingCommentLine = (path, printer, semantics, {printCommen
     print.breakline();
 };
 
-module.exports.printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
+export const printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
     const {parentPath} = path;
     const {print} = printer;
     
@@ -27,7 +26,7 @@ module.exports.printLeadingCommentBlock = (path, printer, semantics, {printComme
     print.indent();
 };
 
-module.exports.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
+export const maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
     const {parentPath} = path;
     const is = isReturnStatement(parentPath);
     
@@ -47,7 +46,7 @@ module.exports.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
     }
 };
 
-module.exports.maybeInsideReturnWithCommentEnd = (path, {print, indent}) => {
+export const maybeInsideReturnWithCommentEnd = (path, {print, indent}) => {
     const {parentPath} = path;
     const is = isReturnStatement(parentPath);
     

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

@@ -1,20 +1,16 @@
-'use strict';
-
-const {condition} = require('./maybe-parens-condition');
-
-const {
+import {condition} from './maybe-parens-condition.js';
+import {
     printLeadingCommentLine,
     maybeInsideReturnWithCommentEnd,
     maybeInsideReturnWithCommentStart,
     printLeadingCommentBlock,
-} = require('./assignment-expression-comments');
-
-const {maybeParens} = require('../../maybe/maybe-parens');
-const {printSeparator} = require('./print-separator');
+} from './assignment-expression-comments.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
+import {printSeparator} from './print-separator.js';
 
 const isInsideBlock = ({parentPath}) => /BlockStatement|Program/.test(parentPath.type);
 
-module.exports.AssignmentExpression = maybeParens({
+export const AssignmentExpression = maybeParens({
     checkParens: false,
     condition,
     print(path, printer) {
@@ -38,5 +34,5 @@ module.exports.AssignmentExpression = maybeParens({
     },
 });
 
-module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine;
-module.exports.AssignmentExpression.printLeadingCommentBlock = printLeadingCommentBlock;
+AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine;
+AssignmentExpression.printLeadingCommentBlock = printLeadingCommentBlock;

package/lib/tokenize/expressions/assignment-expression/maybe-parens-condition.js

@@ -1,10 +1,7 @@
-'use strict';
+import {hasLeadingComment} from '#is';
+import {isParens} from '../../maybe/maybe-parens.js';
 
-const {hasLeadingComment} = require('#is');
-
-const {isParens} = require('../../maybe/maybe-parens');
-
-module.exports.condition = (path, printer, semantics) => {
+export const condition = (path, printer, semantics) => {
     const {parentPath} = path;
     const {type} = parentPath;
     const {roundBraces} = semantics;

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

@@ -1,12 +1,11 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isAssignmentExpression,
     isExpressionStatement,
 } = types;
 
-module.exports.printSeparator = (path, {print}) => {
+export const printSeparator = (path, {print}) => {
     if (isMultiline(path))
         print.breakline();
     else

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

@@ -1,8 +1,6 @@
-'use strict';
-
 const isArg = (path) => path.parentPath.isFunction();
 
-module.exports.AssignmentPattern = {
+export const AssignmentPattern = {
     print(path, {print, maybe}) {
         maybe.print(shouldPrint(path), '__left');
         print.space();

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

@@ -1,14 +1,11 @@
-'use strict';
-
-const {
+import {
     concatenate,
     isConcatenation,
-} = require('./concatenate');
-
-const {maybeSpace} = require('./maybe-space');
-const {maybeParens} = require('../../maybe/maybe-parens');
+} from './concatenate.js';
+import {maybeSpace} from './maybe-space.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
 
-module.exports.BinaryExpression = maybeParens((path, {print, indent, maybe}) => {
+export const BinaryExpression = maybeParens((path, {print, indent, maybe}) => {
     const {operator} = path.node;
     
     if (operator === 'in' || operator === 'instanceof') {

package/lib/tokenize/expressions/binary-expression/concatenate.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isStringLiteral,
     isTemplateLiteral,
@@ -14,7 +13,7 @@ const isStringLike = (a) => {
     return isTemplateLiteral(a);
 };
 
-module.exports.isConcatenation = (path) => {
+export const isConcatenation = (path) => {
     const {parentPath} = path;
     const {operator} = path.node;
     
@@ -36,7 +35,7 @@ module.exports.isConcatenation = (path) => {
     return isBinaryExpression(left) && isStringLike(right);
 };
 
-module.exports.concatenate = (path, {print, indent}) => {
+export const concatenate = (path, {print, indent}) => {
     if (!path.parentPath.isBinaryExpression()) {
         indent.inc();
         print.breakline();

package/lib/tokenize/expressions/binary-expression/maybe-space.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.maybeSpace = (path, {print}) => {
+export const maybeSpace = (path, {print}) => {
     const {right} = path.node;
     
     if (right.type === 'UnaryExpression' && right.operator === '+')