@putout/printer 16.5.0 → 17.0.0

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

@@ -1,9 +1,7 @@
-'use strict';
+import {isNext} from '#is';
+import {markAfter} from '../../mark.js';
 
-const {isNext} = require('#is');
-const {markAfter} = require('../../mark');
-
-module.exports.WhileStatement = {
+export const WhileStatement = {
     print(path, {print, indent}) {
         indent();
         print('while');

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

@@ -1,9 +1,7 @@
-'use strict';
+import {isNext} from '#is';
+import {markAfter} from '../../mark.js';
 
-const {isNext} = require('#is');
-const {markAfter} = require('../../mark');
-
-module.exports.WithStatement = {
+export const WithStatement = {
     print(path, {print, indent}) {
         indent();
         print('with');

package/lib/tokenize/tokenize.js

@@ -1,26 +1,20 @@
-'use strict';
-
-const fullstore = require('fullstore');
-
-const babelTraverse = require('@putout/babel').traverse;
-const {TYPES} = require('../types');
-const baseVisitors = require('./visitors');
-
-const {
+import fullstore from 'fullstore';
+import {traverse as babelTraverse} from '@putout/babel';
+import {TYPES} from '../types.js';
+import * as baseVisitors from './visitors.js';
+import {
     maybeFile,
     maybeVisitor,
     maybeThrow,
-} = require('./maybe');
-
-const {createDebug, createLog} = require('./debug');
-const {maybeMarkAfter} = require('./mark');
-
-const {
+} from './maybe/index.js';
+import {createDebug, createLog} from './debug.js';
+import {maybeMarkAfter} from './mark.js';
+import {
     parseLeadingComments,
     parseTrailingComments,
-} = require('./comment/comment');
+} from './comment/comment.js';
+import {parseOverrides} from './overrides/overrides.js';
 
-const {parseOverrides} = require('./overrides/overrides');
 const isObject = (a) => a && typeof a === 'object';
 const {round} = Math;
 const isString = (a) => typeof a === 'string';
@@ -38,7 +32,7 @@ const createAddToken = (tokens) => {
     };
 };
 
-module.exports.tokenize = (ast, overrides) => {
+export const tokenize = (ast, overrides) => {
     const {
         visitors,
         format,

package/lib/tokenize/typescript/enum/ts-enum-declaration.js

@@ -1,14 +1,11 @@
-'use strict';
-
-const {
+import {
     isNext,
     isNextParent,
     isLast,
-} = require('../../is');
-
-const {markAfter} = require('../../mark');
+} from '../../is.js';
+import {markAfter} from '../../mark.js';
 
-module.exports.TSEnumDeclaration = {
+export const TSEnumDeclaration = {
     beforeIf(path) {
         return path.node.const;
     },

package/lib/tokenize/typescript/enum/ts-enum-member.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.TSEnumMember = (path, {print, indent}) => {
+export const TSEnumMember = (path, {print, indent}) => {
     const {initializer} = path.node;
     indent();
     print('__id');

package/lib/tokenize/typescript/function/print-return-type.js

@@ -1,7 +1,5 @@
-'use strict';
+export const hasReturnType = (path) => path.node.returnType;
 
-module.exports.hasReturnType = (path) => path.node.returnType;
-
-module.exports.printReturnType = (path, {traverse}) => {
+export const printReturnType = (path, {traverse}) => {
     traverse(path.get('returnType'));
 };

package/lib/tokenize/typescript/function/ts-call-signature-declaration.js

@@ -1,9 +1,7 @@
-'use strict';
+import {printReturnType} from './print-return-type.js';
+import {printParams} from '../../expressions/function/params.js';
 
-const {printReturnType} = require('./print-return-type');
-const {printParams} = require('../../expressions/function/params');
-
-module.exports.TSCallSignatureDeclaration = (path, printer, semantics) => {
+export const TSCallSignatureDeclaration = (path, printer, semantics) => {
     const {print} = printer;
     printParams(path, printer, semantics);
     print(':');

package/lib/tokenize/typescript/function/ts-construct-signature-declaration.js

@@ -1,13 +1,10 @@
-'use strict';
-
-const {printParams} = require('../../expressions/function/params');
-
-const {
+import {printParams} from '../../expressions/function/params.js';
+import {
     hasReturnType,
     printReturnType,
-} = require('./print-return-type');
+} from './print-return-type.js';
 
-module.exports.TSConstructSignatureDeclaration = (path, printer, semantics) => {
+export const TSConstructSignatureDeclaration = (path, printer, semantics) => {
     const {write} = printer;
     
     write('new');

package/lib/tokenize/typescript/function/ts-constructor-type.js

@@ -1,9 +1,7 @@
-'use strict';
+import {printParams} from '../../expressions/function/params.js';
+import {printReturnType} from './print-return-type.js';
 
-const {printParams} = require('../../expressions/function/params');
-const {printReturnType} = require('./print-return-type');
-
-module.exports.TSConstructorType = (path, printer, semantics) => {
+export const TSConstructorType = (path, printer, semantics) => {
     const {print} = printer;
     
     print('new');

package/lib/tokenize/typescript/function/ts-declare-function.js

@@ -1,8 +1,6 @@
-'use strict';
-
-const {printParams} = require('../../expressions/function/params');
-const {isNext} = require('../../is');
-const {maybeDeclare} = require('../../maybe/maybe-declare');
+import {printParams} from '../../expressions/function/params.js';
+import {isNext} from '../../is.js';
+import {maybeDeclare} from '../../maybe/maybe-declare.js';
 
 const isInsideDefaultExport = (path) => {
     return path.parentPath.isExportDefaultDeclaration();
@@ -12,7 +10,7 @@ const isInsideNamedExport = (path) => {
     return path.parentPath.isExportNamedDeclaration();
 };
 
-module.exports.TSDeclareFunction = {
+export const TSDeclareFunction = {
     beforeIf: (path) => !isInsideNamedExport(path),
     before: (path, {indent}) => {
         indent();

package/lib/tokenize/typescript/function/ts-declare-method.js

@@ -1,8 +1,6 @@
-'use strict';
+import {printParams} from '../../expressions/function/params.js';
 
-const {printParams} = require('../../expressions/function/params');
-
-module.exports.TSDeclareMethod = (path, printer, semantics) => {
+export const TSDeclareMethod = (path, printer, semantics) => {
     const {print} = printer;
     const {
         accessibility,

package/lib/tokenize/typescript/function/ts-function-type.js

@@ -1,11 +1,8 @@
-'use strict';
+import {printParams} from '../../expressions/function/params.js';
+import {printReturnType} from './print-return-type.js';
+import {maybeParens} from '../../maybe/maybe-parens.js';
 
-const {printParams} = require('../../expressions/function/params');
-const {printReturnType} = require('./print-return-type');
-
-const {maybeParens} = require('../../maybe/maybe-parens');
-
-module.exports.TSFunctionType = maybeParens((path, printer, semantics) => {
+export const TSFunctionType = maybeParens((path, printer, semantics) => {
     const {print} = printer;
     
     printParams(path, printer, semantics);

package/lib/tokenize/typescript/function/ts-method-signature.js

@@ -1,15 +1,12 @@
-'use strict';
-
-const {printParams} = require('../../expressions/function/params');
-const {printKind} = require('../../expressions/function/kind');
-const {
+import {printParams} from '../../expressions/function/params.js';
+import {printKind} from '../../expressions/function/kind.js';
+import {
     hasReturnType,
     printReturnType,
-} = require('./print-return-type');
-
-const {printKey} = require('../../expressions/object-expression/print-key');
+} from './print-return-type.js';
+import {printKey} from '../../expressions/object-expression/print-key.js';
 
-module.exports.TSMethodSignature = (path, printer, semantics) => {
+export const TSMethodSignature = (path, printer, semantics) => {
     const {write} = printer;
     
     printKind(path, printer);

package/lib/tokenize/typescript/index.js

@@ -1,213 +1,178 @@
-'use strict';
+import {isNext} from '#is';
+import {printParams} from '../expressions/function/params.js';
+import {maybePrintTypeAnnotation} from '../maybe/maybe-type-annotation.js';
 
-const {isNext} = require('../is');
-const {TSTypeLiteral} = require('./type/ts-type-literal');
-const {TSTypeAliasDeclaration} = require('./type/ts-type-alias-declaration');
-const {TSMappedType} = require('./mapped-type/ts-mapped-type');
-const {TSConditionalType} = require('./ts-conditional-type');
-const {TSTypeParameter} = require('./type/ts-type-parameter');
-const {TSDeclareFunction} = require('./function/ts-declare-function');
-const {TSDeclareMethod} = require('./function/ts-declare-method');
+export {TSTypeLiteral} from './type/ts-type-literal.js';
+export {TSTypeAliasDeclaration} from './type/ts-type-alias-declaration.js';
+export {TSMappedType} from './mapped-type/ts-mapped-type.js';
+export {TSConditionalType} from './ts-conditional-type.js';
+export {TSTypeParameter} from './type/ts-type-parameter.js';
+export {TSDeclareFunction} from './function/ts-declare-function.js';
+export {TSDeclareMethod} from './function/ts-declare-method.js';
+export {TSModuleDeclaration, TSModuleBlock} from './namespace/ts-module-declaration.js';
+export {TSInterfaceDeclaration} from './interface/ts-interface-declaration.js';
+export {TSAsExpression} from './ts-as-expression/ts-as-expression.js';
+export {TSInterfaceBody} from './interface/ts-interface-body.js';
+export {TSIntersectionType} from './ts-intersection-type.js';
+export {TSPropertySignature} from './ts-property-signature/ts-property-signature.js';
+export {TSFunctionType} from './function/ts-function-type.js';
+export {TSEnumDeclaration} from './enum/ts-enum-declaration.js';
+export {TSEnumMember} from './enum/ts-enum-member.js';
+export {TSTupleType} from './tuple/ts-tuple-type.js';
+export {TSNamedTupleMember} from './tuple/ts-named-tuple-member.js';
+export {TSConstructorType} from './function/ts-constructor-type.js';
+export {TSCallSignatureDeclaration} from './function/ts-call-signature-declaration.js';
+export {TSConstructSignatureDeclaration} from './function/ts-construct-signature-declaration.js';
+export {TSMethodSignature} from './function/ts-method-signature.js';
+export {TSUnionType} from './ts-union-type/ts-union-type.js';
+export {TSImportType} from './ts-import-type/ts-import-type.js';
+export {TSExportAssignment} from './ts-export-assignment/ts-export-assignment.js';
+export {TSTypeReference} from './ts-type-reference/ts-type-reference.js';
+export {TSInferType} from './ts-infer-type/ts-infer-type.js';
+export {TSParameterProperty} from './ts-parameter-property/ts-parameter-property.js';
+export {TSTypeParameterDeclaration} from './ts-type-parameter-declaration/ts-type-parameter-declaration.js';
+export {TSTypeQuery} from './ts-type-query/ts-type-query.js';
+export {TSParenthesizedType} from './ts-parenthesized-type/ts-parenthesized-type.js';
+export {TSTemplateLiteralType} from './ts-template-literal-type/ts-template-literal-type.js';
+export {TSOptionalType} from './ts-optional-type/ts-optional-type.js';
 
-const {
-    TSModuleDeclaration,
-    TSModuleBlock,
-} = require('./namespace/ts-module-declaration');
+export const TSBigIntKeyword = (path, {write}) => {
+    write('bigint');
+};
+export const TSNullKeyword = (path, {write}) => {
+    write('null');
+};
+export const TSSymbolKeyword = (path, {write}) => {
+    write('symbol');
+};
+export const TSNeverKeyword = (path, {write}) => {
+    write('never');
+};
+export const TSUnknownKeyword = (path, {write}) => {
+    write('unknown');
+};
+export const TSObjectKeyword = (path, {write}) => {
+    write('object');
+};
+export const TSLiteralType = (path, {print}) => {
+    print('__literal');
+};
+export const TSRestType = (path, {print}) => {
+    print('...');
+    print('__typeAnnotation');
+};
+export const TSTypeParameterInstantiation = (path, printer, semantics) => {
+    printParams(path, printer, semantics, {
+        braceOpen: '<',
+        braceClose: '>',
+    });
+};
+export const TSArrayType = (path, {print}) => {
+    print('__elementType');
+    print('[]');
+};
+export const TSTypeOperator = (path, {write, print}) => {
+    const {operator} = path.node;
+    write(`${operator} `);
+    print('__typeAnnotation');
+};
+export const TSTypeAssertion = (path, {print}) => {
+    print('<');
+    print('__typeAnnotation');
+    print('>');
+    print('__expression');
+};
+export const TSUndefinedKeyword = (path, {write}) => {
+    write('undefined');
+};
+export const TSBooleanKeyword = (path, {write}) => {
+    write('boolean');
+};
+export const TSSatisfiesExpression = (path, {print}) => {
+    print('__expression');
+    print(' satisfies ');
+    print('__typeAnnotation');
+};
+export const TSNumberKeyword = (path, {write}) => {
+    write('number');
+};
+export const TSIndexedAccessType = (path, {print}) => {
+    print('__objectType');
+    print('[');
+    print('__indexType');
+    print(']');
+};
+export const TSStringKeyword = (path, {write}) => {
+    write('string');
+};
+export const TSInstantiationExpression = (path, {print}) => {
+    print('__expression');
+    print('__typeArguments');
+};
+export const TSAnyKeyword = (path, {write}) => {
+    write('any');
+};
+export const TSVoidKeyword = (path, {write}) => {
+    write('void');
+};
+export const TSQualifiedName = (path, {print}) => {
+    print('__left');
+    print('.');
+    print('__right');
+};
+export const TSTypeAnnotation = (path, {print}) => {
+    print('__typeAnnotation');
+};
 
-const {TSInterfaceDeclaration} = require('./interface/ts-interface-declaration');
-const {TSAsExpression} = require('./ts-as-expression/ts-as-expression');
-const {TSInterfaceBody} = require('./interface/ts-interface-body');
-const {TSIntersectionType} = require('./ts-intersection-type');
-const {TSPropertySignature} = require('./ts-property-signature/ts-property-signature');
-const {TSFunctionType} = require('./function/ts-function-type');
-const {printParams} = require('../expressions/function/params');
-const {TSEnumDeclaration} = require('./enum/ts-enum-declaration');
-const {TSEnumMember} = require('./enum/ts-enum-member');
-const {TSTupleType} = require('./tuple/ts-tuple-type');
-const {TSNamedTupleMember} = require('./tuple/ts-named-tuple-member');
-const {TSConstructorType} = require('./function/ts-constructor-type');
-const {TSCallSignatureDeclaration} = require('./function/ts-call-signature-declaration');
-const {TSConstructSignatureDeclaration} = require('./function/ts-construct-signature-declaration');
-const {TSMethodSignature} = require('./function/ts-method-signature');
-const {TSUnionType} = require('./ts-union-type/ts-union-type');
+export const TSIndexSignature = (path, printer) => {
+    const {print} = printer;
+    print('[');
+    print('__parameters.0');
+    print(']');
+    maybePrintTypeAnnotation(path, printer);
+    print(';');
+    print.newline();
+};
+
+export const TSClassImplements = (path, {print}) => {
+    print('__expression');
+    print('__typeArguments');
+};
 
-const {maybePrintTypeAnnotation} = require('../maybe/maybe-type-annotation');
-const {TSImportType} = require('./ts-import-type/ts-import-type');
-const {TSExportAssignment} = require('./ts-export-assignment/ts-export-assignment');
-const {TSTypeReference} = require('./ts-type-reference/ts-type-reference');
-const {TSInferType} = require('./ts-infer-type/ts-infer-type');
-const {TSParameterProperty} = require('./ts-parameter-property/ts-parameter-property');
-const {TSTypeParameterDeclaration} = require('./ts-type-parameter-declaration/ts-type-parameter-declaration');
-const {TSTypeQuery} = require('./ts-type-query/ts-type-query');
-const {TSParenthesizedType} = require('./ts-parenthesized-type/ts-parenthesized-type');
-const {TSTemplateLiteralType} = require('./ts-template-literal-type/ts-template-literal-type');
-const {TSOptionalType} = require('./ts-optional-type/ts-optional-type');
+export const TSInterfaceHeritage = (path, {print}) => {
+    print('__expression');
+    print('__typeArguments');
+};
 
-module.exports = {
-    TSAsExpression,
-    TSExportAssignment,
-    TSTypeLiteral,
-    TSTypeAliasDeclaration,
-    TSTypeParameter,
-    TSMappedType,
-    TSConditionalType,
-    TSDeclareFunction,
-    TSModuleDeclaration,
-    TSModuleBlock,
-    TSIntersectionType,
-    TSImportType,
-    TSUnionType,
-    TSTypeQuery,
-    TSTemplateLiteralType,
-    TSOptionalType,
-    TSTypeParameterDeclaration,
-    TSBigIntKeyword(path, {write}) {
-        write('bigint');
-    },
-    TSNullKeyword(path, {write}) {
-        write('null');
-    },
-    TSSymbolKeyword(path, {write}) {
-        write('symbol');
-    },
-    TSNeverKeyword(path, {write}) {
-        write('never');
-    },
-    TSUnknownKeyword(path, {write}) {
-        write('unknown');
-    },
-    TSObjectKeyword(path, {write}) {
-        write('object');
-    },
-    TSLiteralType(path, {print}) {
-        print('__literal');
-    },
-    TSTupleType,
-    TSInferType,
-    TSRestType(path, {print}) {
-        print('...');
-        print('__typeAnnotation');
-    },
-    TSTypeParameterInstantiation(path, printer, semantics) {
-        printParams(path, printer, semantics, {
-            braceOpen: '<',
-            braceClose: '>',
-        });
-    },
-    TSArrayType(path, {print}) {
-        print('__elementType');
-        print('[]');
-    },
-    TSTypeReference,
-    TSTypeOperator(path, {write, print}) {
-        const {operator} = path.node;
-        write(`${operator} `);
-        print('__typeAnnotation');
-    },
-    TSInterfaceDeclaration,
-    TSInterfaceBody,
-    TSTypeAssertion(path, {print}) {
-        print('<');
-        print('__typeAnnotation');
-        print('>');
-        print('__expression');
-    },
-    TSUndefinedKeyword(path, {write}) {
-        write('undefined');
-    },
-    TSBooleanKeyword(path, {write}) {
-        write('boolean');
-    },
-    TSSatisfiesExpression(path, {print}) {
-        print('__expression');
-        print(' satisfies ');
-        print('__typeAnnotation');
-    },
-    TSNumberKeyword(path, {write}) {
-        write('number');
-    },
-    TSIndexedAccessType(path, {print}) {
-        print('__objectType');
-        print('[');
-        print('__indexType');
-        print(']');
-    },
-    TSStringKeyword(path, {write}) {
-        write('string');
-    },
-    TSInstantiationExpression(path, {print}) {
-        print('__expression');
-        print('__typeArguments');
-    },
-    TSAnyKeyword(path, {write}) {
-        write('any');
-    },
-    TSVoidKeyword(path, {write}) {
-        write('void');
-    },
-    TSQualifiedName(path, {print}) {
-        print('__left');
-        print('.');
-        print('__right');
-    },
-    TSTypeAnnotation(path, {print}) {
-        print('__typeAnnotation');
-    },
-    TSParameterProperty,
-    TSConstructSignatureDeclaration,
-    TSIndexSignature(path, printer) {
-        const {print} = printer;
-        print('[');
-        print('__parameters.0');
-        print(']');
-        maybePrintTypeAnnotation(path, printer);
-        print(';');
-        print.newline();
-    },
-    TSClassImplements(path, {print}) {
-        print('__expression');
-        print('__typeArguments');
-    },
-    TSInterfaceHeritage(path, {print}) {
-        print('__expression');
-        print('__typeArguments');
-    },
-    TSParenthesizedType,
-    TSPropertySignature,
-    TSFunctionType,
-    TSTypePredicate(path, {print}) {
-        print('__parameterName');
-        print(' is ');
-        print('__typeAnnotation');
-    },
-    TSNonNullExpression(path, {print}) {
-        print('__expression');
-        print('!');
-    },
-    TSEnumDeclaration,
-    TSEnumMember,
-    TSImportEqualsDeclaration(path, {print, maybe}) {
-        maybe.print(path.node.isExport, 'export ');
-        print('import ');
-        print('__id');
-        print.space();
-        print('=');
-        print.space();
-        print('__moduleReference');
-        print(';');
-        maybe.print.newline(isNext(path));
-    },
-    TSExternalModuleReference(path, {print}) {
-        print('require(');
-        print('__expression');
-        print(')');
-    },
-    TSDeclareMethod,
-    TSNamedTupleMember,
-    TSConstructorType,
-    TSMethodSignature,
-    TSCallSignatureDeclaration,
-    TSThisType(path, {print}) {
-        print('this');
-    },
+export const TSTypePredicate = (path, {print}) => {
+    print('__parameterName');
+    print(' is ');
+    print('__typeAnnotation');
 };
+
+export const TSNonNullExpression = (path, {print}) => {
+    print('__expression');
+    print('!');
+};
+
+export const TSImportEqualsDeclaration = (path, {print, maybe}) => {
+    maybe.print(path.node.isExport, 'export ');
+    print('import ');
+    print('__id');
+    print.space();
+    print('=');
+    print.space();
+    print('__moduleReference');
+    print(';');
+    maybe.print.newline(isNext(path));
+};
+export const TSExternalModuleReference = (path, {print}) => {
+    print('require(');
+    print('__expression');
+    print(')');
+};
+
+export const TSThisType = (path, {print}) => {
+    print('this');
+};
+

package/lib/tokenize/typescript/interface/ts-interface-body.js

@@ -1,8 +1,6 @@
-'use strict';
+import {parseComments} from '../../comment/comment.js';
 
-const {parseComments} = require('../../comment/comment');
-
-module.exports.TSInterfaceBody = (path, printer, semantics) => {
+export const TSInterfaceBody = (path, printer, semantics) => {
     const body = path.get('body');
     const {
         traverse,

package/lib/tokenize/typescript/interface/ts-interface-declaration.js

@@ -1,10 +1,7 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-
-const {isNext, isNextParent} = require('../../is');
-const {maybeDeclare} = require('../../maybe/maybe-declare');
-const {markAfter} = require('../../mark');
+import {types} from '@putout/babel';
+import {isNext, isNextParent} from '../../is.js';
+import {maybeDeclare} from '../../maybe/maybe-declare.js';
+import {markAfter} from '../../mark.js';
 
 const {
     isTSTypeAliasDeclaration,
@@ -14,7 +11,7 @@ const {
 
 const isInsideNamespace = (path) => isTSModuleBlock(path.parentPath.parentPath);
 
-module.exports.TSInterfaceDeclaration = {
+export const TSInterfaceDeclaration = {
     print: maybeDeclare((path, {print, maybe}) => {
         const {node} = path;
         const {typeParameters} = node;