@putout/bundle 4.4.0 → 4.4.1

package/bundle/putout.js

@@ -5797,7 +5797,7 @@ __export$1(lib_exports$1, {
     isArrayPattern: () => isArrayPattern$1,
     isArrayTypeAnnotation: () => isArrayTypeAnnotation$1,
     isArrowFunctionExpression: () => isArrowFunctionExpression$b,
-    isAssignmentExpression: () => isAssignmentExpression$g,
+    isAssignmentExpression: () => isAssignmentExpression$f,
     isAssignmentPattern: () => isAssignmentPattern$b,
     isAwaitExpression: () => isAwaitExpression$6,
     isBigIntLiteral: () => isBigIntLiteral$1,
@@ -5869,7 +5869,7 @@ __export$1(lib_exports$1, {
     isExportNamespaceSpecifier: () => isExportNamespaceSpecifier$6,
     isExportSpecifier: () => isExportSpecifier$2,
     isExpression: () => isExpression$5,
-    isExpressionStatement: () => isExpressionStatement$w,
+    isExpressionStatement: () => isExpressionStatement$v,
     isExpressionWrapper: () => isExpressionWrapper$1,
     isFile: () => isFile$7,
     isFlow: () => isFlow$1,
@@ -5983,7 +5983,7 @@ __export$1(lib_exports$1, {
     isRegexLiteral: () => isRegexLiteral$1,
     isRestElement: () => isRestElement$1,
     isRestProperty: () => isRestProperty$1,
-    isReturnStatement: () => isReturnStatement$b,
+    isReturnStatement: () => isReturnStatement$c,
     isScopable: () => isScopable$1,
     isScope: () => isScope$1,
     isSequenceExpression: () => isSequenceExpression$7,
@@ -7758,7 +7758,7 @@ function isArrayExpression$C(node, opts) {
     return opts == null || shallowEqual$1(node, opts);
 }
 
-function isAssignmentExpression$g(node, opts) {
+function isAssignmentExpression$f(node, opts) {
     if (!node)
         return false;
     
@@ -7898,7 +7898,7 @@ function isEmptyStatement$1(node, opts) {
     return opts == null || shallowEqual$1(node, opts);
 }
 
-function isExpressionStatement$w(node, opts) {
+function isExpressionStatement$v(node, opts) {
     if (!node)
         return false;
     
@@ -8118,7 +8118,7 @@ function isRestElement$1(node, opts) {
     return opts == null || shallowEqual$1(node, opts);
 }
 
-function isReturnStatement$b(node, opts) {
+function isReturnStatement$c(node, opts) {
     if (!node)
         return false;
     
@@ -21672,7 +21672,7 @@ function toComputedKey$1(node, key = node.key || node.property) {
 }
 
 function toExpression$5(node) {
-    if (isExpressionStatement$w(node)) {
+    if (isExpressionStatement$v(node)) {
         node = node.expression;
     }
     
@@ -21826,7 +21826,7 @@ function toStatement$2(node, ignore) {
     } else if (isFunction$s(node)) {
         mustHaveId = true;
         newType = 'FunctionDeclaration';
-    } else if (isAssignmentExpression$g(node)) {
+    } else if (isAssignmentExpression$f(node)) {
         return expressionStatement$e(node);
     }
     
@@ -22051,7 +22051,7 @@ function getBindingIdentifiers$4(node, duplicates, outerOnly, newBindingsOnly) {
         if (!id)
             continue;
         
-        if (newBindingsOnly && (isAssignmentExpression$g(id) || isUnaryExpression$6(id) || isUpdateExpression$1(id))) {
+        if (newBindingsOnly && (isAssignmentExpression$f(id) || isUnaryExpression$6(id) || isUpdateExpression$1(id))) {
             continue;
         }
         
@@ -22205,7 +22205,7 @@ function getFunctionName$1(node, parent) {
             prefix2 = 'set ';
     } else if (isVariableDeclarator$l(parent, {init: node})) {
         id = parent.id;
-    } else if (isAssignmentExpression$g(parent, {operator: '=', right: node})) {
+    } else if (isAssignmentExpression$f(parent, {operator: '=', right: node})) {
         id = parent.left;
     }
 
@@ -56984,7 +56984,7 @@ const {
 const {
     isDecorator: isDecorator$9,
     isMemberExpression: isMemberExpression$r,
-    isExpressionStatement: isExpressionStatement$v,
+    isExpressionStatement: isExpressionStatement$u,
     isCallExpression: isCallExpression$A,
 } = types$3p;
 
@@ -57129,7 +57129,7 @@ parseTrailingComments$e.parseTrailingComments = (path, printer, semantics, {curr
 function isPrevCall$4(path) {
     const prev = path.getPrevSibling();
     
-    if (isExpressionStatement$v(prev))
+    if (isExpressionStatement$u(prev))
         return false;
     
     const {expression} = path.node;
@@ -57347,11 +57347,11 @@ const not$4 = (fn) => (...a) => !fn(...a);
 const notInsideExportDefaultWithBody$4 = not$4(isInsideExportDefaultWithBody$4);
 
 const {
-    isAssignmentExpression: isAssignmentExpression$f,
+    isAssignmentExpression: isAssignmentExpression$e,
     isTSModuleBlock: isTSModuleBlock$c,
     isBlockStatement: isBlockStatement$n,
     isExportNamedDeclaration: isExportNamedDeclaration$b,
-    isExpressionStatement: isExpressionStatement$u,
+    isExpressionStatement: isExpressionStatement$t,
     isFunctionDeclaration: isFunctionDeclaration$f,
     isExportDefaultDeclaration: isExportDefaultDeclaration$5,
 } = types$3o;
@@ -57409,10 +57409,10 @@ const isNextFunction$4 = (path) => {
 const isNextAssign$9 = (path) => {
     const next = path.getNextSibling();
     
-    if (!isExpressionStatement$u(next))
+    if (!isExpressionStatement$t(next))
         return false;
     
-    return isAssignmentExpression$f(next.node.expression);
+    return isAssignmentExpression$e(next.node.expression);
 };
 
 function isInsideBlockStatement$4(path) {
@@ -57502,7 +57502,7 @@ kind$4.printKind = (path, {write}) => {
 var printFunctionParams$9 = {};
 
 const {printParams: printParams$_} = params$4;
-const {hasLeadingComment: hasLeadingComment$9} = is$8;
+const {hasLeadingComment: hasLeadingComment$b} = is$8;
 
 const isAllParamsHasLeadingComments$4 = (path) => {
     const params = path.get('params');
@@ -57518,7 +57518,7 @@ const isAllParamsHasLeadingComments$4 = (path) => {
         const [firstDecorator] = decorators;
         ++decoratorsCount;
         
-        if (hasLeadingComment$9(firstDecorator))
+        if (hasLeadingComment$b(firstDecorator))
             ++commentsCount;
     }
     
@@ -58045,11 +58045,11 @@ const {exists: exists$17} = is$8;
 const {isMarkedAfter: isMarkedAfter$i} = mark$4;
 
 const {
-    isExpressionStatement: isExpressionStatement$t,
+    isExpressionStatement: isExpressionStatement$s,
     isMemberExpression: isMemberExpression$q,
 } = types$3m;
 
-const isInsideExpressionStatement$4 = ({parentPath}) => isExpressionStatement$t(parentPath);
+const isInsideExpressionStatement$4 = ({parentPath}) => isExpressionStatement$s(parentPath);
 const notFirst$4 = ({parentPath}) => exists$17(parentPath.getPrevSibling());
 const isInsideMember$4 = ({parentPath}) => isMemberExpression$q(parentPath);
 
@@ -58175,7 +58175,7 @@ const {
     noTrailingComment: noTrailingComment$e,
     isNewlineBetweenSiblings: isNewlineBetweenSiblings$i,
     noLeadingComment: noLeadingComment$4,
-    hasLeadingComment: hasLeadingComment$8,
+    hasLeadingComment: hasLeadingComment$a,
     exists: exists$16,
 } = is$8;
 
@@ -58302,7 +58302,7 @@ const hasNextLeadingComment$4 = (path) => {
     if (!exists$16(next))
         return false;
     
-    return hasLeadingComment$8(next);
+    return hasLeadingComment$a(next);
 };
 
 const notLastArgInsideCall$4 = (path) => {
@@ -58898,10 +58898,11 @@ classProperty$5.ClassAccessorProperty = (path, printer, semantics) => {
     });
 };
 
-var assignmentExpression$5 = {};
+var assignmentExpression$5 = {exports: {}};
 
 var maybeWriteBrace$j = {};
 
+const {hasLeadingComment: hasLeadingComment$9} = is$8;
 const {isParens: isParens$h} = maybeParens$1a;
 
 maybeWriteBrace$j.maybePrintLeftBrace = (path, printer, semantics) => {
@@ -58942,7 +58943,7 @@ function maybeWriteBrace$i(path, printer, semantics, {brace}) {
         return;
     }
     
-    if (!roundBraces.assign)
+    if (!roundBraces.assign && !hasLeadingComment$9(path))
         return;
     
     if (!isParens$h(path))
@@ -58951,51 +58952,107 @@ function maybeWriteBrace$i(path, printer, semantics, {brace}) {
     write(brace);
 }
 
-const {types: types$3d} = bundle$1;
-const {
-    maybePrintLeftBrace: maybePrintLeftBrace$4,
-    maybePrintRightBrace: maybePrintRightBrace$4,
-} = maybeWriteBrace$j;
+var assignmentExpressionComments = {};
 
-const {
-    isExpressionStatement: isExpressionStatement$s,
-    isAssignmentExpression: isAssignmentExpression$e,
-} = types$3d;
+const {types: types$3d} = bundle$1;
+const {hasLeadingComment: hasLeadingComment$8} = is$8;
+const {isReturnStatement: isReturnStatement$b} = types$3d;
 
-const isInsideBlock$o = ({parentPath}) => /BlockStatement|Program/.test(parentPath.type);
+assignmentExpressionComments.printLeadingCommentLine = ({parentPath}) => !isReturnStatement$b(parentPath);
 
-assignmentExpression$5.AssignmentExpression = (path, printer, semantics) => {
-    const {print} = printer;
-    const {operator} = path.node;
-    
-    maybePrintLeftBrace$4(path, printer, semantics);
-    print('__left');
-    print.space();
-    print(operator);
-    
-    if (isMultiline$4(path))
-        print.breakline();
-    else
-        print.space();
-    
-    print('__right');
+assignmentExpressionComments.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
+    const {parentPath} = path;
     
-    if (isInsideBlock$o(path)) {
-        print(';');
+    if (isReturnStatement$b(parentPath) && hasLeadingComment$8(path)) {
+        indent.inc();
+        const {leadingComments} = path.node;
+        
         print.breakline();
+        for (const {type, value} of leadingComments) {
+            if (type === 'CommentLine')
+                print(`//${value}`);
+            else
+                print(`/*${value}*/`);
+            
+            print.breakline();
+        }
     }
-    
-    maybePrintRightBrace$4(path, printer, semantics);
 };
 
-function isMultiline$4(path) {
-    const {right} = path.node;
+assignmentExpressionComments.maybeInsideReturnWithCommentEnd = (path, {print, indent}) => {
+    const {parentPath} = path;
     
-    if (!path.parentPath.find(isExpressionStatement$s))
-        return false;
+    if (!isReturnStatement$b(parentPath) || !hasLeadingComment$8(path))
+        return;
     
-    return isAssignmentExpression$e(right);
-}
+    indent.dec();
+    print.breakline();
+};
+
+(function (module) {
+
+	const {types} = bundle$1;
+
+	const {
+	    maybePrintLeftBrace,
+	    maybePrintRightBrace,
+	} = maybeWriteBrace$j;
+
+	const {
+	    printLeadingCommentLine,
+	    maybeInsideReturnWithCommentEnd,
+	    maybeInsideReturnWithCommentStart,
+	} = assignmentExpressionComments;
+
+	const {
+	    isExpressionStatement,
+	    isAssignmentExpression,
+	} = types;
+
+	const isInsideBlock = ({parentPath}) => /BlockStatement|Program/.test(parentPath.type);
+
+	module.exports.AssignmentExpression = (path, printer, semantics) => {
+	    const {print} = printer;
+	    const {operator} = path.node;
+	    
+	    maybePrintLeftBrace(path, printer, semantics);
+	    maybeInsideReturnWithCommentStart(path, printer);
+	    
+	    print('__left');
+	    print.space();
+	    print(operator);
+	    
+	    if (isMultiline(path))
+	        print.breakline();
+	    else
+	        print.space();
+	    
+	    print('__right');
+	    
+	    if (isInsideBlock(path)) {
+	        print(';');
+	        print.breakline();
+	    }
+	    
+	    maybeInsideReturnWithCommentEnd(path, printer);
+	    
+	    maybePrintRightBrace(path, printer, semantics);
+	};
+
+	module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine;
+
+	function isMultiline(path) {
+	    const {right} = path.node;
+	    
+	    if (!path.parentPath.find(isExpressionStatement))
+	        return false;
+	    
+	    return isAssignmentExpression(right);
+	} 
+} (assignmentExpression$5));
+
+var assignmentExpressionExports = assignmentExpression$5.exports;
+assignmentExpressionExports.default;
 
 var arrayExpression$8 = {};
 
@@ -60918,7 +60975,7 @@ const {
     PrivateName: PrivateName$6,
 } = classProperty$5;
 
-const {AssignmentExpression: AssignmentExpression$5} = assignmentExpression$5;
+const {AssignmentExpression: AssignmentExpression$5} = assignmentExpressionExports;
 const {ArrayExpression: ArrayExpression$5} = arrayExpression$8;
 const {ArrayPattern: ArrayPattern$4} = arrayPattern$5;
 const {AssignmentPattern: AssignmentPattern$5} = assignmentPattern$5;