@putout/printer 16.5.0 → 17.0.0

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

@@ -1,25 +1,22 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-
-const {isParentBlock} = require('#is');
-const {
+import {types} from '@putout/babel';
+import {isParentBlock} from '#is';
+import {
     markAfter,
     isMarkedAfter,
     hasPrevNewline,
-} = require('../../mark');
-
-const {
+} from '../../mark.js';
+import {
     isNewlineBetweenSiblings,
     exists,
     isNext,
     isLast,
-} = require('../../is');
+} from '../../is.js';
 
 const {
     isExportNamespaceSpecifier,
     isVariableDeclaration,
     isExportNamedDeclaration,
+    isExportDefaultSpecifier,
 } = types;
 
 const isDeclarationNewline = (path) => isMarkedAfter(path.get('declaration'));
@@ -31,7 +28,7 @@ const options = {
     },
 };
 
-module.exports.ExportSpecifier = (path, {print}) => {
+export const ExportSpecifier = (path, {print}) => {
     const {local, exported} = path.node;
     
     print('__local');
@@ -42,12 +39,16 @@ module.exports.ExportSpecifier = (path, {print}) => {
     }
 };
 
-module.exports.ExportNamespaceSpecifier = (path, {print}) => {
+export const ExportNamespaceSpecifier = (path, {print}) => {
     print('* as ');
     print('__exported');
 };
 
-module.exports.ExportNamedDeclaration = {
+export const ExportDefaultSpecifier = (path, {print}) => {
+    print('__exported');
+};
+
+export const ExportNamedDeclaration = {
     beforeIf(path) {
         const prev = path.getPrevSibling();
         
@@ -88,15 +89,30 @@ module.exports.ExportNamedDeclaration = {
         
         if (specifiers && !path.node.declaration) {
             print.space();
-            print('{');
             
-            if (specifiers.length) {
+            const [first, ...rest] = specifiers;
+            
+            if (!specifiers.length) {
+                print('{}');
+            } else if (isExportDefaultSpecifier(first) && !rest.length) {
+                traverse(first);
+            } else {
+                if (isExportDefaultSpecifier(first)) {
+                    traverse(first);
+                    print(',');
+                    print.space();
+                } else {
+                    rest.unshift(first);
+                }
+                
+                print('{');
+                
                 indent.inc();
                 maybe.print.newline(isNewline);
                 
                 const lastIndex = n - 1;
                 
-                for (const [i, spec] of specifiers.entries()) {
+                for (const [i, spec] of rest.entries()) {
                     const isType = spec.node.exportKind === 'type';
                     const isLast = i < lastIndex;
                     
@@ -114,9 +130,9 @@ module.exports.ExportNamedDeclaration = {
                 
                 indent.dec();
                 indent();
+                print('}');
             }
             
-            print('}');
             const source = path.get('source');
             
             if (exists(source)) {

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

@@ -1,7 +1,5 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {isNext} = require('../../is');
+import {types} from '@putout/babel';
+import {isNext} from '../../is.js';
 
 const {
     isVariableDeclaration,
@@ -15,7 +13,7 @@ function shouldAddSemicolon(path) {
     return !path.isFunctionDeclaration();
 }
 
-module.exports.ExportDefaultDeclaration = {
+export const ExportDefaultDeclaration = {
     print(path, {print, traverse, maybe}) {
         const declaration = path.get('declaration');
         print('export default ');

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

@@ -1,7 +1,5 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {hasTrailingComment} = require('#is');
+import {types} from '@putout/babel';
+import {hasTrailingComment} from '#is';
 
 const {
     isBlockStatement,
@@ -9,7 +7,7 @@ const {
     isIfStatement,
 } = types;
 
-module.exports.printLeadingCommentLine = (path, printer, semantics, {index, isLast, printComment}) => {
+export const printLeadingCommentLine = (path, printer, semantics, {index, isLast, printComment}) => {
     const {print, indent} = printer;
     const prev = path.getPrevSibling();
     const {parentPath} = path;
@@ -27,7 +25,7 @@ module.exports.printLeadingCommentLine = (path, printer, semantics, {index, isLa
         print.indent();
 };
 
-module.exports.printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
+export const printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
     const {indent} = printer;
     const prev = path.getPrevSibling();
     

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

@@ -1,7 +1,5 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {
+import {types} from '@putout/babel';
+import {
     isNext,
     isLast,
     isParentBlock,
@@ -12,14 +10,12 @@ const {
     hasTrailingComment,
     isCoupleLines,
     isInsideLabel,
-} = require('../../is');
-
-const {isInsideAssignNextAssignFunction} = require('./is-inside-assign-next-assign-function');
-
-const {
+} from '../../is.js';
+import {isInsideAssignNextAssignFunction} from './is-inside-assign-next-assign-function.js';
+import {
     printLeadingCommentLine,
     printLeadingCommentBlock,
-} = require('./expression-statement-comments');
+} from './expression-statement-comments.js';
 
 const isCommentBlock = (a) => a?.type === 'CommentBlock';
 
@@ -58,11 +54,10 @@ const isNextIf = (path) => path
 const shouldBreakline = satisfy([
     isNewlineBetweenSiblings,
     isNotLastBody,
-    isStrictMode,
     isNextIf,
 ]);
 
-module.exports.ExpressionStatement = {
+export const ExpressionStatement = {
     beforeIf(path) {
         if (isInsideReturn(path))
             return false;
@@ -123,8 +118,8 @@ module.exports.ExpressionStatement = {
         }
     },
 };
-module.exports.ExpressionStatement.printLeadingCommentLine = printLeadingCommentLine;
-module.exports.ExpressionStatement.printLeadingCommentBlock = printLeadingCommentBlock;
+ExpressionStatement.printLeadingCommentLine = printLeadingCommentLine;
+ExpressionStatement.printLeadingCommentBlock = printLeadingCommentBlock;
 
 function isTopParentLast({parentPath}) {
     if (!parentPath.isIfStatement())
@@ -155,17 +150,6 @@ function isNextUp(path) {
     return path.findParent(isNext);
 }
 
-function isStrictMode(path) {
-    const expressionPath = path.get('expression');
-    
-    if (!expressionPath.isStringLiteral())
-        return false;
-    
-    const {value} = path.node.expression;
-    
-    return value === 'use strict';
-}
-
 function isNextToAssignmentCall(path) {
     if (isAssignmentExpression(path.node.expression))
         return false;

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

@@ -1,13 +1,12 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {
     isExpressionStatement,
     isFunction,
     isAssignmentExpression,
 } = types;
 
-module.exports.isInsideAssignNextAssignFunction = (path) => {
+export const isInsideAssignNextAssignFunction = (path) => {
     const {expression} = path.node;
     
     if (!isAssignmentExpression(expression))

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

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.ForInStatement = (path, {print, indent}) => {
+export const ForInStatement = (path, {print, indent}) => {
     indent();
     print('for');
     print.space();

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

@@ -1,19 +1,16 @@
-'use strict';
-
-const {
+import {
     hasPrevNewline,
     markAfter,
     markBefore,
     isMarkedAfter,
-} = require('../../mark');
-
-const {
+} from '../../mark.js';
+import {
     isFirst,
     isNext,
     isLast,
-} = require('../../is');
+} from '../../is.js';
 
-module.exports.ForOfStatement = {
+export const ForOfStatement = {
     beforeIf(path) {
         const {parentPath} = path;
         

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

@@ -1,11 +1,8 @@
-'use strict';
+import {isInsideLabel} from '#is';
+import {exists} from '../is.js';
+import {markAfter} from '../mark.js';
 
-const {isInsideLabel} = require('#is');
-const {exists} = require('../is');
-
-const {markAfter} = require('../mark');
-
-module.exports.ForStatement = {
+export const ForStatement = {
     print(path, {print, maybe}) {
         const {
             test,

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

@@ -1,13 +1,10 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-
-const {markAfter} = require('../../mark');
-const {
+import {types} from '@putout/babel';
+import {markAfter} from '../../mark.js';
+import {
     exists,
     isNext,
     isInsideIf,
-} = require('../../is');
+} from '../../is.js';
 
 const {
     isBlockStatement,
@@ -58,7 +55,7 @@ const isLastEmptyInsideBody = (path) => {
     return isFunctionDeclaration(path.parentPath.parentPath);
 };
 
-module.exports.IfStatement = {
+export const IfStatement = {
     print: (path, {indent, print, maybe, write, traverse}) => {
         const {parentPath} = path;
         const partOfAlternate = parentPath.get('alternate');

package/lib/tokenize/statements/import-declaration/import-attribute.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.ImportAttribute = (path, {print}) => {
+export const ImportAttribute = (path, {print}) => {
     print('__key');
     print(':');
     print.space();
@@ -8,7 +6,7 @@ module.exports.ImportAttribute = (path, {print}) => {
     print(',');
 };
 
-module.exports.printAttributes = (path, keyword, {write, traverse, indent}) => {
+export const printAttributes = (path, keyword, {write, traverse, indent}) => {
     const attributes = path.get('attributes');
     
     if (!attributes.length)

package/lib/tokenize/statements/import-declaration/import-declaration-comments.js

@@ -1,15 +1,14 @@
-'use strict';
+import {types} from '@putout/babel';
 
-const {types} = require('@putout/babel');
 const {isExportDeclaration} = types;
 
-module.exports.printTrailingCommentLine = (path, printer, semantics, {printComment}) => {
+export const printTrailingCommentLine = (path, printer, semantics, {printComment}) => {
     const {print} = printer;
     printComment();
     print.breakline();
 };
 
-module.exports.printTrailingCommentBlock = (path, printer, semantics, {printComment}) => {
+export const printTrailingCommentBlock = (path, printer, semantics, {printComment}) => {
     const {maybe} = printer;
     const next = path.getNextSibling();
     

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

@@ -1,22 +1,15 @@
-'use strict';
+import {parseImportSpecifiers} from 'parse-import-specifiers';
+import {markAfter} from '../../mark.js';
+import {isLast, isNext} from '../../is.js';
+import {printAttributes} from './import-attribute.js';
 
-const {parseImportSpecifiers} = require('parse-import-specifiers');
-
-const {markAfter} = require('../../mark');
-const {isLast, isNext} = require('../../is');
-
-const {
-    ImportAttribute,
-    printAttributes,
-} = require('./import-attribute');
-
-const {
+export {ImportAttribute} from './import-attribute.js';
+import {
     printTrailingCommentBlock,
     printTrailingCommentLine,
-} = require('./import-declaration-comments');
+} from './import-declaration-comments.js';
 
-module.exports.ImportAttribute = ImportAttribute;
-module.exports.ImportDeclaration = {
+export const ImportDeclaration = {
     print(path, printer, semantics) {
         const {
             print,
@@ -138,5 +131,5 @@ function parseMaxSpecifiers(imports, semantics) {
     return maxSpecifiersInOneLine;
 }
 
-module.exports.ImportDeclaration.printTrailingCommentBlock = printTrailingCommentBlock;
-module.exports.ImportDeclaration.printTrailingCommentLine = printTrailingCommentLine;
+ImportDeclaration.printTrailingCommentBlock = printTrailingCommentBlock;
+ImportDeclaration.printTrailingCommentLine = printTrailingCommentLine;

package/lib/tokenize/statements/index.js

@@ -1,64 +1,31 @@
-'use strict';
+export {WithStatement} from './with-statement/with-statement.js';
+export {EmptyStatement} from './empty-statement/empty-statement.js';
+export {LabeledStatement} from './labeled-statement/labeled-statement.js';
+export {ContinueStatement} from './continue-statement/continue-statement.js';
+export {Program} from './program/program.js';
+export {DoWhileStatement} from './do-while-statement/do-while-statement.js';
+export {BreakStatement} from './break-statement/break-statement.js';
+export {ExportDefaultDeclaration} from './export-declaration/export-default-declaration.js';
+export {ForInStatement} from './for-in-statement.js';
+export {SwitchStatement} from './switch-statement/switch-statement.js';
+export {WhileStatement} from './while-statement/while-statement.js';
+export {ExportAllDeclaration} from './export-declaration/export-all-declaration.js';
+export * from './export-declaration/export-declaration.js';
+export * from './import-declaration/import-declaration.js';
+export {ForStatement} from './for-statement.js';
+export {DebuggerStatement} from './debugger-statement.js';
+export * from './try-statement/try-statements.js';
+export {ReturnStatement} from './return-statement/return-statement.js';
+export {BlockStatement} from './block-statement/block-statement.js';
+export {ForOfStatement} from './for-of-statement/for-of-statement.js';
+export {IfStatement} from './if-statement/if-statement.js';
+export {VariableDeclaration} from './variable-declaration/variable-declaration.js';
+export {ExpressionStatement} from './expression-statement/expression-statement.js';
 
-const {ExpressionStatement} = require('./expression-statement/expression-statement');
-const {VariableDeclaration} = require('./variable-declaration/variable-declaration');
-const {IfStatement} = require('./if-statement/if-statement');
-const {ForOfStatement} = require('./for-of-statement/for-of-statement');
-const {BlockStatement} = require('./block-statement/block-statement');
-const {ReturnStatement} = require('./return-statement/return-statement');
-const TryStatements = require('./try-statement/try-statements');
-const {DebuggerStatement} = require('./debugger-statement');
-const {ForStatement} = require('./for-statement');
-const importDeclarations = require('./import-declaration/import-declaration');
-const exportDeclarations = require('./export-declaration/export-declaration');
-const {ExportAllDeclaration} = require('./export-declaration/export-all-declaration');
+const SHEBANG_HASHBANG = '#!';
 
-const {WhileStatement} = require('./while-statement/while-statement');
-const {SwitchStatement} = require('./switch-statement/switch-statement');
-const {ForInStatement} = require('./for-in-statement');
-const {ExportDefaultDeclaration} = require('./export-declaration/export-default-declaration');
-const {BreakStatement} = require('./break-statement/break-statement');
-const {DoWhileStatement} = require('./do-while-statement/do-while-statement');
-const {Program} = require('./program/program');
-const {ContinueStatement} = require('./continue-statement/continue-statement');
-const {LabeledStatement} = require('./labeled-statement/labeled-statement');
-const {EmptyStatement} = require('./empty-statement/empty-statement');
-const {WithStatement} = require('./with-statement/with-statement');
-
-const {
-    ExportNamespaceSpecifier,
-    ExportSpecifier,
-} = exportDeclarations;
-
-module.exports = {
-    ...importDeclarations,
-    ...exportDeclarations,
-    BlockStatement,
-    DoWhileStatement,
-    ExpressionStatement,
-    ExportSpecifier,
-    ExportNamespaceSpecifier,
-    ExportDefaultDeclaration,
-    ExportAllDeclaration,
-    VariableDeclaration,
-    IfStatement,
-    ForStatement,
-    ForInStatement,
-    ForOfStatement,
-    ReturnStatement,
-    DebuggerStatement,
-    LabeledStatement,
-    Program,
-    EmptyStatement,
-    InterpreterDirective(path, {print}) {
-        // shebang, hashbang
-        print(`#!${path.node.value}\n`);
-        print.newline();
-    },
-    SwitchStatement,
-    ...TryStatements,
-    BreakStatement,
-    ContinueStatement,
-    WhileStatement,
-    WithStatement,
+export const InterpreterDirective = (path, {print}) => {
+    print(`${SHEBANG_HASHBANG}${path.node.value}\n`);
+    print.newline();
 };
+

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

@@ -1,8 +1,6 @@
-'use strict';
+import {isInsideLabel} from '../../is.js';
 
-const {isInsideLabel} = require('../../is');
-
-module.exports.LabeledStatement = (path, {print, maybe}) => {
+export const LabeledStatement = (path, {print, maybe}) => {
     maybe.indent(!isInsideLabel(path));
     print('__label');
     print(':');

package/lib/tokenize/statements/program/program.js

@@ -1,10 +1,8 @@
-'use strict';
+import {parseComments} from '../../comment/comment.js';
+import {getDirectives} from '../block-statement/get-directives.js';
+import {hasCoupleTrailingComments} from '../../is.js';
 
-const {parseComments} = require('../../comment/comment');
-const {getDirectives} = require('../block-statement/get-directives');
-const {hasCoupleTrailingComments} = require('../../is');
-
-module.exports.Program = (path, printer, semantics) => {
+export const Program = (path, printer, semantics) => {
     const {body} = path.node;
     const {
         traverse,

package/lib/tokenize/statements/return-statement/maybe-space-after-keyword.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.maybeSpaceAfterKeyword = (path, {print}, semantics) => {
+export const maybeSpaceAfterKeyword = (path, {print}, semantics) => {
     const {roundBraces} = semantics;
     const {node} = path;
     

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

@@ -1,23 +1,19 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-
-const {isInsideLabel} = require('#is');
-const {
+import {types} from '@putout/babel';
+import {isInsideLabel} from '#is';
+import {
     isPrevBody,
     noTrailingComment,
     isLast,
-} = require('../../is');
-
-const {hasPrevNewline} = require('../../mark');
-const {maybeSpaceAfterKeyword} = require('./maybe-space-after-keyword');
+} from '../../is.js';
+import {hasPrevNewline} from '../../mark.js';
+import {maybeSpaceAfterKeyword} from './maybe-space-after-keyword.js';
 
 const {isJSXElement} = types;
 const isBodyLength = ({parentPath}) => parentPath.node?.body?.length > 2;
 
 const isInsideIfWithElse = ({parentPath}) => parentPath.isIfStatement() && parentPath.node.alternate;
 
-module.exports.ReturnStatement = {
+export const ReturnStatement = {
     beforeIf(path) {
         return !hasPrevNewline(path) && isBodyLength(path) || isPrevBody(path);
     },
@@ -62,6 +58,7 @@ module.exports.ReturnStatement = {
         print.newline();
     },
 };
+
 function isJSXWithComment(path) {
     const arg = path.node.argument;
     

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

@@ -1,16 +1,12 @@
-'use strict';
-
-const {
+import {
     isNext,
     exists,
     isLast,
-} = require('#is');
-
-const {parseLeadingComments} = require('../../comment/comment');
-
-const {maybeSpaceAfterKeyword} = require('../return-statement/maybe-space-after-keyword.js');
+} from '#is';
+import {parseLeadingComments} from '../../comment/comment.js';
+import {maybeSpaceAfterKeyword} from '../return-statement/maybe-space-after-keyword.js';
 
-module.exports.SwitchStatement = {
+export const SwitchStatement = {
     print(path, printer, semantics) {
         const {
             print,

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

@@ -1,8 +1,6 @@
-'use strict';
+import {isNext} from '../../is.js';
 
-const {isNext} = require('../../is');
-
-module.exports.TryStatement = {
+export const TryStatement = {
     print(path, {print}) {
         const finalizer = path.get('finalizer');
         print.indent();
@@ -26,7 +24,7 @@ module.exports.TryStatement = {
     },
 };
 
-module.exports.CatchClause = (path, {print, maybe}) => {
+export const CatchClause = (path, {print, maybe}) => {
     const param = path.get('param');
     const body = path.get('body');
     

package/lib/tokenize/statements/variable-declaration/maybe-space-after-keyword.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.maybeSpaceAfterKeyword = (path, {write}) => {
+export const maybeSpaceAfterKeyword = (path, {write}) => {
     const {declarations} = path.node;
     
     if (!declarations.length)

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

@@ -1,20 +1,16 @@
-'use strict';
-
-const {types} = require('@putout/babel');
-const {
+import {types} from '@putout/babel';
+import {hasPrevNewline} from '../../mark.js';
+import {
     isNext,
     isCoupleLines,
     isNewlineBetweenSiblings,
     exists,
     noTrailingComment,
-} = require('../../is');
-
-const {hasPrevNewline} = require('../../mark');
-const {maybeSpaceAfterKeyword} = require('./maybe-space-after-keyword');
-
-const {isConcatenation} = require('../../expressions/binary-expression/concatenate');
-const {parseLeadingComments} = require('../../comment/comment');
-const {maybeDeclare} = require('../../maybe/maybe-declare');
+} from '../../is.js';
+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';
 
 const {isExportDeclaration} = types;
 
@@ -25,7 +21,7 @@ const isParentSwitchCase = (path) => path.parentPath.isSwitchCase();
 const isFirstInSwitch = (path) => path.parentPath.get('consequent.0') === path;
 const isParentIf = (path) => path.parentPath.isIfStatement();
 
-module.exports.VariableDeclaration = {
+export const VariableDeclaration = {
     beforeIf: shouldAddNewlineBefore,
     before(path, {print}) {
         print.breakline();