@putout/printer 16.6.0 → 17.0.0

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

@@ -1,7 +1,6 @@
-'use strict';
+import {exists} from '../../is.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
 
-const {exists} = require('../../is');
-const {maybeParens} = require('../../maybe/maybe-parens');
 const {isArray} = Array;
 
 const parseArgs = (path) => {
@@ -13,7 +12,7 @@ const parseArgs = (path) => {
     return argsPath;
 };
 
-const CallExpression = maybeParens((path, {indent, print, maybe, traverse}) => {
+export const CallExpression = maybeParens((path, {indent, print, maybe, traverse}) => {
     const args = parseArgs(path);
     const isParentCall = tooLong(args) && path.parentPath.isCallExpression();
     
@@ -61,8 +60,7 @@ const CallExpression = maybeParens((path, {indent, print, maybe, traverse}) => {
     print(')');
 });
 
-module.exports.OptionalCallExpression = CallExpression;
-module.exports.CallExpression = CallExpression;
+export const OptionalCallExpression = CallExpression;
 
 function tooLong(args) {
     for (const arg of args) {

package/lib/tokenize/expressions/class/class-property.js

@@ -1,10 +1,8 @@
-'use strict';
-
-const {exists} = require('../../is');
-const {maybePrintTypeAnnotation} = require('../../maybe/maybe-type-annotation');
-const {maybeDecorators} = require('../../maybe/maybe-decorators');
-const {printKey} = require('../object-expression/print-key');
-const {printKind} = require('../function/kind');
+import {exists} from '../../is.js';
+import {maybePrintTypeAnnotation} from '../../maybe/maybe-type-annotation.js';
+import {maybeDecorators} from '../../maybe/maybe-decorators.js';
+import {printKey} from '../object-expression/print-key.js';
+import {printKind} from '../function/kind.js';
 
 const processClassProperty = maybeDecorators((path, printer, semantics, {accessor} = {}) => {
     const {node} = path;
@@ -43,15 +41,15 @@ const processClassProperty = maybeDecorators((path, printer, semantics, {accesso
     print.newline();
 });
 
-module.exports.ClassProperty = processClassProperty;
-module.exports.ClassPrivateProperty = processClassProperty;
+export const ClassProperty = processClassProperty;
+export const ClassPrivateProperty = processClassProperty;
 
-module.exports.PrivateName = (path, {print}) => {
+export const PrivateName = (path, {print}) => {
     print('#');
     print('__id');
 };
 
-module.exports.ClassAccessorProperty = (path, printer, semantics) => {
+export const ClassAccessorProperty = (path, printer, semantics) => {
     processClassProperty(path, printer, semantics, {
         accessor: true,
     });

package/lib/tokenize/expressions/class/class.js

@@ -1,13 +1,9 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-
-const {isNext} = require('../../is');
-const {markAfter} = require('../../mark');
-
-const {maybeDeclare} = require('../../maybe/maybe-declare');
-const {parseComments} = require('../../comment/comment');
-const {maybeDecorators} = require('../../maybe/maybe-decorators');
+import {types} from '@putout/babel';
+import {isNext} from '../../is.js';
+import {markAfter} from '../../mark.js';
+import {maybeDeclare} from '../../maybe/maybe-declare.js';
+import {parseComments} from '../../comment/comment.js';
+import {maybeDecorators} from '../../maybe/maybe-decorators.js';
 
 const isInsideTSModuleBlock = (path) => {
     return isTSModuleBlock(path.parentPath.parentPath);
@@ -89,9 +85,9 @@ const classVisitor = maybeDecorators((path, printer, semantics) => {
     print('}');
 });
 
-module.exports.ClassExpression = classVisitor;
+export const ClassExpression = classVisitor;
 
-module.exports.ClassDeclaration = {
+export const ClassDeclaration = {
     print: maybeDeclare((path, printer, semantics) => {
         const {maybe} = printer;
         maybe.indent(!isInsideExport(path));

package/lib/tokenize/expressions/class/static-block.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.StaticBlock = (path, {print, traverse}) => {
+export const StaticBlock = (path, {print, traverse}) => {
     print('static ');
     print('{');
     print.breakline();

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

@@ -1,8 +1,6 @@
-'use strict';
+import {maybeParens} from '../maybe/maybe-parens.js';
 
-const {maybeParens} = require('../maybe/maybe-parens');
-
-module.exports.ConditionalExpression = maybeParens((path, {print}) => {
+export const ConditionalExpression = maybeParens((path, {print}) => {
     print('__test');
     print.space();
     print('?');

package/lib/tokenize/expressions/function/arrow-function-expression.js

@@ -1,10 +1,8 @@
-'use strict';
+import {exists} from '../../is.js';
+import {printParams} from './params.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
 
-const {exists} = require('../../is');
-const {printParams} = require('./params');
-const {maybeParens} = require('../../maybe/maybe-parens');
-
-module.exports.ArrowFunctionExpression = maybeParens((path, printer, semantics) => {
+export const ArrowFunctionExpression = maybeParens((path, printer, semantics) => {
     const {
         print,
         maybe,

package/lib/tokenize/expressions/function/class-method.js

@@ -1,14 +1,11 @@
-'use strict';
-
-const {
+import {
     isNext,
     hasTrailingComment,
-} = require('../../is');
-
-const {maybeDecorators} = require('../../maybe/maybe-decorators');
-const {printKey} = require('../object-expression/print-key');
-const {printKind} = require('./kind');
-const {printFunctionParams} = require('./print-function-params');
+} from '../../is.js';
+import {maybeDecorators} from '../../maybe/maybe-decorators.js';
+import {printKey} from '../object-expression/print-key.js';
+import {printKind} from './kind.js';
+import {printFunctionParams} from './print-function-params.js';
 
 const noTrailingCommentAndNext = (path) => {
     if (hasTrailingComment(path))
@@ -17,7 +14,7 @@ const noTrailingCommentAndNext = (path) => {
     return isNext(path);
 };
 
-const ClassMethod = {
+export const ClassMethod = {
     print: maybeDecorators((path, printer, semantics) => {
         const {print} = printer;
         const {node} = path;
@@ -62,5 +59,4 @@ const ClassMethod = {
     },
 };
 
-module.exports.ClassPrivateMethod = ClassMethod;
-module.exports.ClassMethod = ClassMethod;
+export const ClassPrivateMethod = ClassMethod;

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

@@ -1,9 +1,7 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {markAfter} = require('../../mark');
-const {isNext, isNextParent} = require('../../is');
-const {printParams} = require('./params');
+import {types} from '@putout/babel';
+import {markAfter} from '../../mark.js';
+import {isNext, isNextParent} from '../../is.js';
+import {printParams} from './params.js';
 
 const not = (fn) => (...a) => !fn(...a);
 const notInsideExportDefaultWithBody = not(isInsideExportDefaultWithBody);
@@ -20,7 +18,7 @@ const {
 
 const isInsideNamedExport = ({parentPath}) => isExportNamedDeclaration(parentPath);
 
-module.exports.FunctionDeclaration = {
+export const FunctionDeclaration = {
     print(path, printer, semantics) {
         const {print, maybe} = printer;
         

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

@@ -1,10 +1,8 @@
-'use strict';
+import {exists} from '../../is.js';
+import {printParams} from './params.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
 
-const {exists} = require('../../is');
-const {printParams} = require('./params');
-const {maybeParens} = require('../../maybe/maybe-parens');
-
-module.exports.FunctionExpression = maybeParens((path, printer, semantics) => {
+export const FunctionExpression = maybeParens((path, printer, semantics) => {
     const {
         print,
         maybe,

package/lib/tokenize/expressions/function/functions.js

@@ -1,19 +1,5 @@
-'use strict';
-
-const {ArrowFunctionExpression} = require('./arrow-function-expression');
-const {FunctionDeclaration} = require('./function-declaration');
-
-const {
-    ClassMethod,
-    ClassPrivateMethod,
-} = require('./class-method');
-
-const {ObjectMethod} = require('./object-method');
-const {FunctionExpression} = require('./function-expression');
-
-module.exports.FunctionDeclaration = FunctionDeclaration;
-module.exports.FunctionExpression = FunctionExpression;
-module.exports.ArrowFunctionExpression = ArrowFunctionExpression;
-module.exports.ClassMethod = ClassMethod;
-module.exports.ClassPrivateMethod = ClassPrivateMethod;
-module.exports.ObjectMethod = ObjectMethod;
+export {ArrowFunctionExpression} from './arrow-function-expression.js';
+export {FunctionDeclaration} from './function-declaration.js';
+export {ClassPrivateMethod, ClassMethod} from './class-method.js';
+export {ObjectMethod} from './object-method.js';
+export {FunctionExpression} from './function-expression.js';

package/lib/tokenize/expressions/function/kind.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.printKind = (path, {write}) => {
+export const printKind = (path, {write}) => {
     const {kind, generator} = path.node;
     
     const isGetter = kind === 'get' || kind === 'set';

package/lib/tokenize/expressions/function/object-method.js

@@ -1,11 +1,9 @@
-'use strict';
+import {isNewlineBetweenSiblings} from '../../is.js';
+import {printParams} from './params.js';
+import {printKey} from '../object-expression/print-key.js';
+import {printKind} from './kind.js';
 
-const {isNewlineBetweenSiblings} = require('../../is');
-const {printParams} = require('./params');
-const {printKey} = require('../object-expression/print-key');
-const {printKind} = require('./kind');
-
-module.exports.ObjectMethod = {
+export const ObjectMethod = {
     beforeIf(path) {
         return path.node.async;
     },

package/lib/tokenize/expressions/function/params.js

@@ -1,11 +1,9 @@
-'use strict';
-
-const {parseComments} = require('../../comment/comment');
+import {parseComments} from '../../comment/comment.js';
 
 const noop = () => {};
 const parseParams = (path) => path.get('params');
 
-module.exports.printParams = (path, printer, semantics, customization = {}) => {
+export const printParams = (path, printer, semantics, customization = {}) => {
     const {extra, typeParameters} = path.node;
     const {
         print,

package/lib/tokenize/expressions/function/print-function-params.js

@@ -1,7 +1,5 @@
-'use strict';
-
-const {printParams} = require('./params');
-const {hasLeadingComment} = require('../../is');
+import {printParams} from './params.js';
+import {hasLeadingComment} from '../../is.js';
 
 const isAllParamsHasLeadingComments = (path) => {
     const params = path.get('params');
@@ -26,7 +24,7 @@ const isAllParamsHasLeadingComments = (path) => {
 
 const hasDecorators = ({decorators}) => decorators?.length;
 
-module.exports.printFunctionParams = (path, printer, semantics) => {
+export const printFunctionParams = (path, printer, semantics) => {
     const {params} = path.node;
     const isNewline = params.filter(hasDecorators).length;
     const isAllHasComments = isAllParamsHasLeadingComments(path);
@@ -81,7 +79,7 @@ const createPrintBeforeClose = ({isNewline, printer, isAllHasComments, type}) =>
     print.breakline();
 };
 
-const createPrintSpace = ({isNewline, printer}) => () => {
+export const createPrintSpace = ({isNewline, printer}) => () => {
     const {print} = printer;
     
     if (!isNewline)
@@ -89,5 +87,3 @@ const createPrintSpace = ({isNewline, printer}) => () => {
     
     print.breakline();
 };
-
-module.exports.createPrintSpace = createPrintSpace;

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

@@ -1,9 +1,6 @@
-'use strict';
+export const ImportExpression = createImportExpression;
 
-module.exports.ImportExpression = createImportExpression;
-module.exports.createImportExpression = createImportExpression;
-
-function createImportExpression(path, printer) {
+export function createImportExpression(path, printer) {
     const {print, maybe} = printer;
     const {options} = path.node;
     

package/lib/tokenize/expressions/index.js

@@ -1,78 +1,39 @@
-'use strict';
-
-const functions = require('./function/functions');
-const unaryExpressions = require('./unary-expression/unary-expressions');
-const memberExpressions = require('./member-expression/member-expressions');
-
-const {
+export * from './function/functions.js';
+export * from './unary-expression/unary-expressions.js';
+export * from './member-expression/member-expressions.js';
+export {
     ClassExpression,
     ClassDeclaration,
-} = require('./class/class');
-
-const {
+} from './class/class.js';
+export {
     CallExpression,
     OptionalCallExpression,
-} = require('./call-expression/call-expression');
-
-const {NewExpression} = require('./new-expression/new-expression');
-
-const {ObjectExpression} = require('./object-expression/object-expression');
-const {ObjectProperty} = require('./object-expression/object-property');
-const {ObjectPattern} = require('./object-pattern/object-pattern');
-
-const {
+} from './call-expression/call-expression.js';
+export {NewExpression} from './new-expression/new-expression.js';
+export {ObjectExpression} from './object-expression/object-expression.js';
+export {ObjectProperty} from './object-expression/object-property.js';
+export {ObjectPattern} from './object-pattern/object-pattern.js';
+export {AssignmentExpression} from './assignment-expression/assignment-expression.js';
+export {ArrayExpression} from './array-expression/array-expression.js';
+export {ArrayPattern} from './array-pattern/array-pattern.js';
+export {AssignmentPattern} from './assignment-pattern.js';
+export {RestElement} from './rest-element.js';
+export {SpreadElement} from './spread-element.js';
+export {SequenceExpression} from './sequence-expression/sequence-expression.js';
+export {TaggedTemplateExpression} from './tagged-template-expression.js';
+export {BinaryExpression} from './binary-expression/binary-expression.js';
+export {LogicalExpression} from './logical-expression/logical-expression.js';
+export {ConditionalExpression} from './conditional-expression.js';
+export {StaticBlock} from './class/static-block.js';
+export {ImportExpression} from './import-expression.js';
+export {ParenthesizedExpression} from './parenthesized-expression/parenthesized-expression.js';
+export {
     ClassProperty,
     ClassAccessorProperty,
     ClassPrivateProperty,
     PrivateName,
-} = require('./class/class-property');
+} from './class/class-property.js';
 
-const {AssignmentExpression} = require('./assignment-expression/assignment-expression');
-const {ArrayExpression} = require('./array-expression/array-expression');
-const {ArrayPattern} = require('./array-pattern/array-pattern');
-const {AssignmentPattern} = require('./assignment-pattern');
-const {RestElement} = require('./rest-element');
-const {SpreadElement} = require('./spread-element');
-const {SequenceExpression} = require('./sequence-expression/sequence-expression');
-const {TaggedTemplateExpression} = require('./tagged-template-expression');
-const {BinaryExpression} = require('./binary-expression/binary-expression');
-const {LogicalExpression} = require('./logical-expression/logical-expression');
-const {ConditionalExpression} = require('./conditional-expression');
-const {StaticBlock} = require('./class/static-block');
-const {ImportExpression} = require('./import-expression');
-const {ParenthesizedExpression} = require('./parenthesized-expression/parenthesized-expression');
-
-module.exports = {
-    ...functions,
-    ...unaryExpressions,
-    ...memberExpressions,
-    ArrayPattern,
-    ArrayExpression,
-    AssignmentExpression,
-    AssignmentPattern,
-    BinaryExpression,
-    CallExpression,
-    ClassExpression,
-    ClassProperty,
-    ClassAccessorProperty,
-    ClassPrivateProperty,
-    ClassDeclaration,
-    ConditionalExpression,
-    NewExpression,
-    LogicalExpression,
-    OptionalCallExpression,
-    ObjectExpression,
-    ObjectProperty,
-    ObjectPattern,
-    ParenthesizedExpression,
-    PrivateName,
-    RestElement,
-    ImportExpression,
-    SpreadElement,
-    SequenceExpression,
-    StaticBlock,
-    TaggedTemplateExpression,
-    ThisExpression(path, {write}) {
-        write('this');
-    },
+export const ThisExpression = (path, {write}) => {
+    write('this');
 };

package/lib/tokenize/expressions/logical-expression/chain.js

@@ -1,17 +1,16 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isLogicalExpression,
     isReturnStatement,
     isVariableDeclarator,
 } = types;
 
-module.exports.isRootOk = (path) => {
+export const isRootOk = (path) => {
     return isReturnStatement(path) || isVariableDeclarator(path);
 };
 
-module.exports.chain = (path) => {
+export const chain = (path) => {
     const [downCount] = down(path);
     const [upCount, root] = up(path);
     

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

@@ -1,9 +1,7 @@
-'use strict';
+import {maybeParens} from '../../maybe/maybe-parens.js';
+import {chain, isRootOk} from './chain.js';
 
-const {maybeParens} = require('../../maybe/maybe-parens');
-const {chain, isRootOk} = require('./chain');
-
-module.exports.LogicalExpression = maybeParens({
+export const LogicalExpression = maybeParens({
     condition(path) {
         if (path.parentPath.isUnaryExpression())
             return true;

package/lib/tokenize/expressions/member-expression/chain.js

@@ -1,9 +1,8 @@
-'use strict';
+import {hasTrailingComment} from '../../is.js';
 
-const {hasTrailingComment} = require('../../is');
 const {assign} = Object;
 
-module.exports.chain = (path) => {
+export const chain = (path) => {
     const all = [
         ...down(path),
         ...up(path),

package/lib/tokenize/expressions/member-expression/is-looks-like-chain.js

@@ -1,8 +1,6 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {chain} = require('./chain');
-const {satisfy} = require('../../is');
+import {types} from '@putout/babel';
+import {chain} from './chain.js';
+import {satisfy} from '../../is.js';
 
 const {
     isUnaryExpression,
@@ -39,7 +37,7 @@ function isLastArgInCall(path) {
     return path === parentPath.get('arguments').at(-1);
 }
 
-module.exports.isLooksLikeChain = (path) => {
+export const isLooksLikeChain = (path) => {
     const [root, properties] = chain(path);
     
     if (isInsideMemberCall(path))

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

@@ -1,16 +1,14 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {maybePrintComputed} = require('../object-expression/maybe-print-computed');
-const {maybeParens} = require('../../maybe/maybe-parens');
-const {isLooksLikeChain} = require('./is-looks-like-chain');
+import {types} from '@putout/babel';
+import {maybePrintComputed} from '../object-expression/maybe-print-computed.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
+import {isLooksLikeChain} from './is-looks-like-chain.js';
 
 const {
     isObjectExpression,
     isArrowFunctionExpression,
 } = types;
 
-module.exports.MemberExpression = maybeParens({
+export const MemberExpression = maybeParens({
     checkParens: false,
     condition: (path) => isObjectInsideArrow(path),
     print: (path, printer) => {
@@ -41,7 +39,7 @@ module.exports.MemberExpression = maybeParens({
     },
 });
 
-module.exports.OptionalMemberExpression = maybeParens((path, {print, maybe}) => {
+export const OptionalMemberExpression = maybeParens((path, {print, maybe}) => {
     const {computed, optional} = path.node;
     
     print('__object');

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

@@ -1,8 +1,6 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {exists} = require('../../is');
-const {isMarkedAfter} = require('../../mark');
+import {types} from '@putout/babel';
+import {exists} from '../../is.js';
+import {isMarkedAfter} from '../../mark.js';
 
 const {
     isExpressionStatement,
@@ -22,7 +20,7 @@ const getPrev = ({parentPath}) => {
     ];
 };
 
-module.exports.NewExpression = {
+export const NewExpression = {
     beforeIf(path) {
         if (!isInsideExpressionStatement(path))
             return false;

package/lib/tokenize/expressions/object-expression/is-inside-tuple.js

@@ -1,6 +1,5 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {isArrayExpression} = types;
 
 const TYPES = [
@@ -9,7 +8,7 @@ const TYPES = [
     'BigIntLiteral',
 ];
 
-module.exports.isInsideTuple = (path) => {
+export const isInsideTuple = (path) => {
     const {parentPath} = path;
     
     if (!isArrayExpression(parentPath))

package/lib/tokenize/expressions/object-expression/is-third-object-inside-array.js

@@ -1,13 +1,12 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isArrayExpression,
     isCallExpression,
     isIdentifier,
 } = types;
 
-module.exports.isThirdObjectInsideArray = ({parentPath}) => {
+export const isThirdObjectInsideArray = ({parentPath}) => {
     if (!isArrayExpression(parentPath))
         return false;
     

package/lib/tokenize/expressions/object-expression/maybe-print-computed.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.maybePrintComputed = (path, key, {maybe, traverse}) => {
+export const maybePrintComputed = (path, key, {maybe, traverse}) => {
     const {computed} = path.node;
     
     maybe.write(computed, '[');