@putout/bundle 4.4.0 → 4.4.2

package/bundle/putout.js

@@ -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,
@@ -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;
     
@@ -23513,7 +23513,7 @@ var TokContext$1 = class TokContext {
     }
 };
 
-var types$3u = {
+var types$3v = {
     brace: new TokContext$1('{'),
     j_oTag: new TokContext$1('<tag'),
     j_cTag: new TokContext$1('</tag'),
@@ -26032,7 +26032,7 @@ var flow$1 = (superClass) => class FlowParserMixin extends superClass {
     }
     
     flowInTopLevelContext(cb) {
-        if (this.curContext() !== types$3u.brace) {
+        if (this.curContext() !== types$3v.brace) {
             const oldContext = this.state.context;
             
             this.state.context = [oldContext[0]];
@@ -26076,7 +26076,7 @@ var flow$1 = (superClass) => class FlowParserMixin extends superClass {
         });
         this.state.inType = oldInType;
         
-        if (!this.state.inType && this.curContext() === types$3u.brace) {
+        if (!this.state.inType && this.curContext() === types$3v.brace) {
             this.reScan_lt_gt();
         }
         
@@ -27696,7 +27696,7 @@ var flow$1 = (superClass) => class FlowParserMixin extends superClass {
             
             const currentContext = context[context.length - 1];
             
-            if (currentContext === types$3u.j_oTag || currentContext === types$3u.j_expr) {
+            if (currentContext === types$3v.j_oTag || currentContext === types$3v.j_expr) {
                 context.pop();
             }
         }
@@ -28989,9 +28989,9 @@ var jsx$b = (superClass) => class JSXParserMixin extends superClass {
         switch(this.state.type) {
         case 5:
             node = this.startNode();
-            this.setContext(types$3u.brace);
+            this.setContext(types$3v.brace);
             this.next();
-            node = this.jsxParseExpressionContainer(node, types$3u.j_oTag);
+            node = this.jsxParseExpressionContainer(node, types$3v.j_oTag);
             
             if (node.expression.type === 'JSXEmptyExpression') {
                 this.raise(JsxErrors$1.AttributeIsEmpty, node);
@@ -29016,7 +29016,7 @@ var jsx$b = (superClass) => class JSXParserMixin extends superClass {
     jsxParseSpreadChild(node) {
         this.next();
         node.expression = this.parseExpression();
-        this.setContext(types$3u.j_expr);
+        this.setContext(types$3v.j_expr);
         this.state.canStartJSXElement = true;
         this.expect(8);
         return this.finishNode(node, 'JSXSpreadChild');
@@ -29046,11 +29046,11 @@ var jsx$b = (superClass) => class JSXParserMixin extends superClass {
         const node = this.startNode();
         
         if (this.match(5)) {
-            this.setContext(types$3u.brace);
+            this.setContext(types$3v.brace);
             this.next();
             this.expect(21);
             node.argument = this.parseMaybeAssignAllowIn();
-            this.setContext(types$3u.j_oTag);
+            this.setContext(types$3v.j_oTag);
             this.state.canStartJSXElement = true;
             this.expect(8);
             return this.finishNode(node, 'JSXSpreadAttribute');
@@ -29124,13 +29124,13 @@ var jsx$b = (superClass) => class JSXParserMixin extends superClass {
                 
                 case 5: {
                     const node2 = this.startNode();
-                    this.setContext(types$3u.brace);
+                    this.setContext(types$3v.brace);
                     this.next();
                     
                     if (this.match(21)) {
                         children.push(this.jsxParseSpreadChild(node2));
                     } else {
-                        children.push(this.jsxParseExpressionContainer(node2, types$3u.j_expr));
+                        children.push(this.jsxParseExpressionContainer(node2, types$3v.j_expr));
                     }
                     
                     break;
@@ -29206,12 +29206,12 @@ var jsx$b = (superClass) => class JSXParserMixin extends superClass {
     getTokenFromCode(code2) {
         const context = this.curContext();
         
-        if (context === types$3u.j_expr) {
+        if (context === types$3v.j_expr) {
             this.jsxReadToken();
             return;
         }
         
-        if (context === types$3u.j_oTag || context === types$3u.j_cTag) {
+        if (context === types$3v.j_oTag || context === types$3v.j_cTag) {
             if (isIdentifierStart2$1(code2)) {
                 this.jsxReadWord();
                 return;
@@ -29223,7 +29223,7 @@ var jsx$b = (superClass) => class JSXParserMixin extends superClass {
                 return;
             }
             
-            if ((code2 === 34 || code2 === 39) && context === types$3u.j_oTag) {
+            if ((code2 === 34 || code2 === 39) && context === types$3v.j_oTag) {
                 this.jsxReadString(code2);
                 return;
             }
@@ -29242,18 +29242,18 @@ var jsx$b = (superClass) => class JSXParserMixin extends superClass {
         const {context, type} = this.state;
         
         if (type === 56 && prevType === 143) {
-            context.splice(-2, 2, types$3u.j_cTag);
+            context.splice(-2, 2, types$3v.j_cTag);
             this.state.canStartJSXElement = false;
         } else if (type === 143) {
-            context.push(types$3u.j_oTag);
+            context.push(types$3v.j_oTag);
         } else if (type === 144) {
             const out = context[context.length - 1];
             
-            if (out === types$3u.j_oTag && prevType === 56 || out === types$3u.j_cTag) {
+            if (out === types$3v.j_oTag && prevType === 56 || out === types$3v.j_cTag) {
                 context.pop();
-                this.state.canStartJSXElement = context[context.length - 1] === types$3u.j_expr;
+                this.state.canStartJSXElement = context[context.length - 1] === types$3v.j_expr;
             } else {
-                this.setContext(types$3u.j_expr);
+                this.setContext(types$3v.j_expr);
                 this.state.canStartJSXElement = true;
             }
         } else {
@@ -29732,7 +29732,7 @@ var State$3 = class _State {
         __publicField$1(this, 'end', 0);
         __publicField$1(this, 'lastTokEndLoc', null);
         __publicField$1(this, 'lastTokStartLoc', null);
-        __publicField$1(this, 'context', [types$3u.brace]);
+        __publicField$1(this, 'context', [types$3v.brace]);
         __publicField$1(this, 'firstInvalidTemplateEscapePos', null);
         __publicField$1(this, 'strictErrors',         /* @__PURE__ */new Map());
         __publicField$1(this, 'tokensLength', 0);
@@ -34254,7 +34254,7 @@ var typescript$c = (superClass) => class TypeScriptParserMixin extends superClas
     }
     
     tsInTopLevelContext(cb) {
-        if (this.curContext() !== types$3u.brace) {
+        if (this.curContext() !== types$3v.brace) {
             const oldContext = this.state.context;
             
             this.state.context = [oldContext[0]];
@@ -34686,7 +34686,7 @@ var typescript$c = (superClass) => class TypeScriptParserMixin extends superClas
         
         if (node.params.length === 0) {
             this.raise(TSErrors$1.EmptyTypeArguments, node);
-        } else if (!this.state.inType && this.curContext() === types$3u.brace) {
+        } else if (!this.state.inType && this.curContext() === types$3v.brace) {
             this.reScan_lt_gt();
         }
         
@@ -35539,7 +35539,7 @@ var typescript$c = (superClass) => class TypeScriptParserMixin extends superClas
             
             const currentContext = context[context.length - 1];
             
-            if (currentContext === types$3u.j_oTag || currentContext === types$3u.j_expr) {
+            if (currentContext === types$3v.j_oTag || currentContext === types$3v.j_expr) {
                 context.pop();
             }
         }
@@ -56268,9 +56268,9 @@ var fullstore$7 = (value) => {
     };
 };
 
-var types$3t = {};
+var types$3u = {};
 
-types$3t.TYPES = {
+types$3u.TYPES = {
     TOKEN: 'Token',
     NEWLINE: 'Newline',
     LINEBREAK: 'Linebreak',
@@ -56290,7 +56290,7 @@ var arrowFunctionExpression$5 = {};
 
 var is$8 = {};
 
-const {types: types$3s} = bundle$1;
+const {types: types$3t} = bundle$1;
 const {
     isStringLiteral: isStringLiteral$y,
     isIdentifier: isIdentifier$M,
@@ -56302,7 +56302,7 @@ const {
     isArrayExpression: isArrayExpression$B,
     isObjectExpression: isObjectExpression$s,
     isLabeledStatement: isLabeledStatement$6,
-} = types$3s;
+} = types$3t;
 
 const isParentProgram$9 = (path) => path.parentPath?.isProgram();
 const isParentBlock$j = (path) => path.parentPath.isBlockStatement();
@@ -56606,7 +56606,7 @@ commentsPrinter$4.printTrailingComments = (path, printer, semantics, {currentTra
     }
 };
 
-const {types: types$3r} = bundle$1;
+const {types: types$3s} = bundle$1;
 const {
     hasTrailingComment: hasTrailingComment$t,
     satisfy: satisfy$j,
@@ -56632,7 +56632,7 @@ const {
     isBinaryExpression: isBinaryExpression$a,
     isClassMethod: isClassMethod$6,
     isDecorator: isDecorator$a,
-} = types$3r;
+} = types$3s;
 
 const isProperty$5 = satisfy$j([
     isObjectProperty$f,
@@ -56884,7 +56884,7 @@ function build$4(path) {
     return prop;
 }
 
-const {types: types$3q} = bundle$1;
+const {types: types$3r} = bundle$1;
 const {chain: chain$j} = chain$k;
 const {satisfy: satisfy$i} = is$8;
 
@@ -56893,7 +56893,7 @@ const {
     isIfStatement: isIfStatement$e,
     isCallExpression: isCallExpression$B,
     isIdentifier: isIdentifier$L,
-} = types$3q;
+} = types$3r;
 
 const isArgOfCall$4 = (path) => path.parentPath?.isCallExpression() && path.parentPath.get('arguments.0') === path;
 const isCall$5 = (a) => a.type === 'CallExpression';
@@ -56966,7 +56966,7 @@ const isIfUp$4 = (path) => {
     return is;
 };
 
-const {types: types$3p} = bundle$1;
+const {types: types$3q} = bundle$1;
 
 const {
     isLast: isLast$Y,
@@ -56986,7 +56986,7 @@ const {
     isMemberExpression: isMemberExpression$r,
     isExpressionStatement: isExpressionStatement$v,
     isCallExpression: isCallExpression$A,
-} = types$3p;
+} = types$3q;
 
 const hasBody$9 = (path) => {
     if (path.isTSModuleDeclaration())
@@ -57280,7 +57280,7 @@ maybeParens$1a.maybeParens = (print) => {
     if (isFn$e(print))
         return maybeParensPrint$4(print);
     
-    return maybeParensCondition$4(print);
+    return maybeParensCondition$5(print);
 };
 
 const maybeParensPrint$4 = (print) => ({
@@ -57294,9 +57294,16 @@ const maybeParensPrint$4 = (print) => ({
     },
 });
 
-const maybeParensCondition$4 = ({print, condition}) => ({
+const maybeParensCondition$5 = ({print, condition, checkParens = true}) => ({
     ...maybeParensPrint$4(print),
-    condition: (path) => condition?.(path) || isParens$j(path),
+    condition: (path, print, semantics) => {
+        const is = condition?.(path, print, semantics);
+        
+        if (!checkParens)
+            return is;
+        
+        return is || isParens$j(path);
+    },
 });
 
 const {exists: exists$1a} = is$8;
@@ -57338,7 +57345,7 @@ arrowFunctionExpression$5.ArrowFunctionExpression = maybeParens$19((path, printe
 
 var functionDeclaration$5 = {};
 
-const {types: types$3o} = bundle$1;
+const {types: types$3p} = bundle$1;
 const {markAfter: markAfter$W} = mark$4;
 const {isNext: isNext$1_, isNextParent: isNextParent$s} = is$8;
 const {printParams: printParams$$} = params$4;
@@ -57354,7 +57361,7 @@ const {
     isExpressionStatement: isExpressionStatement$u,
     isFunctionDeclaration: isFunctionDeclaration$f,
     isExportDefaultDeclaration: isExportDefaultDeclaration$5,
-} = types$3o;
+} = types$3p;
 
 const isInsideNamedExport$9 = ({parentPath}) => isExportNamedDeclaration$b(parentPath);
 
@@ -57502,7 +57509,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 +57525,7 @@ const isAllParamsHasLeadingComments$4 = (path) => {
         const [firstDecorator] = decorators;
         ++decoratorsCount;
         
-        if (hasLeadingComment$9(firstDecorator))
+        if (hasLeadingComment$b(firstDecorator))
             ++commentsCount;
     }
     
@@ -57859,7 +57866,7 @@ maybeDeclare$y.maybeDeclare = (visit) => (path, printer, semantics) => {
     visit(path, printer, semantics);
 };
 
-const {types: types$3n} = bundle$1;
+const {types: types$3o} = bundle$1;
 
 const {isNext: isNext$1X} = is$8;
 const {markAfter: markAfter$V} = mark$4;
@@ -57875,7 +57882,7 @@ const isInsideTSModuleBlock = (path) => {
 const {
     isFunction: isFunction$r,
     isTSModuleBlock: isTSModuleBlock$b,
-} = types$3n;
+} = types$3o;
 
 const isInsideExport$4 = ({parentPath}) => parentPath.isExportDeclaration();
 const isFunctionLike$4 = (path) => isFunction$r(path.parentPath.parentPath);
@@ -58040,14 +58047,14 @@ function tooLong$9(args) {
 
 var newExpression$5 = {};
 
-const {types: types$3m} = bundle$1;
+const {types: types$3n} = bundle$1;
 const {exists: exists$17} = is$8;
 const {isMarkedAfter: isMarkedAfter$i} = mark$4;
 
 const {
     isExpressionStatement: isExpressionStatement$t,
     isMemberExpression: isMemberExpression$q,
-} = types$3m;
+} = types$3n;
 
 const isInsideExpressionStatement$4 = ({parentPath}) => isExpressionStatement$t(parentPath);
 const notFirst$4 = ({parentPath}) => exists$17(parentPath.getPrevSibling());
@@ -58126,8 +58133,8 @@ var objectExpression$7 = {};
 
 var isInsideTuple$9 = {};
 
-const {types: types$3l} = bundle$1;
-const {isArrayExpression: isArrayExpression$A} = types$3l;
+const {types: types$3m} = bundle$1;
+const {isArrayExpression: isArrayExpression$A} = types$3m;
 
 const TYPES$g = [
     'NullLiteral',
@@ -58151,12 +58158,12 @@ isInsideTuple$9.isInsideTuple = (path) => {
 
 var isThirdObjectInsideArray$9 = {};
 
-const {types: types$3k} = bundle$1;
+const {types: types$3l} = bundle$1;
 const {
     isArrayExpression: isArrayExpression$z,
     isCallExpression: isCallExpression$z,
     isIdentifier: isIdentifier$K,
-} = types$3k;
+} = types$3l;
 
 isThirdObjectInsideArray$9.isThirdObjectInsideArray = ({parentPath}) => {
     if (!isArrayExpression$z(parentPath))
@@ -58167,7 +58174,7 @@ isThirdObjectInsideArray$9.isThirdObjectInsideArray = ({parentPath}) => {
     return isCallExpression$z(second) && !!isIdentifier$K(second);
 };
 
-const {types: types$3j} = bundle$1;
+const {types: types$3k} = bundle$1;
 const {
     isCoupleLines: isCoupleLines$L,
     isForOf: isForOf$j,
@@ -58175,7 +58182,7 @@ const {
     noTrailingComment: noTrailingComment$e,
     isNewlineBetweenSiblings: isNewlineBetweenSiblings$i,
     noLeadingComment: noLeadingComment$4,
-    hasLeadingComment: hasLeadingComment$8,
+    hasLeadingComment: hasLeadingComment$a,
     exists: exists$16,
 } = is$8;
 
@@ -58187,7 +58194,7 @@ const {isThirdObjectInsideArray: isThirdObjectInsideArray$8} = isThirdObjectInsi
 const {
     isStringLiteral: isStringLiteral$x,
     isArrayExpression: isArrayExpression$y,
-} = types$3j;
+} = types$3k;
 
 const isBodyOfArrow$4 = (path) => path.parentPath.node.body === path.node;
 const isLogical$4 = (path) => path.get('argument').isLogicalExpression();
@@ -58302,7 +58309,7 @@ const hasNextLeadingComment$4 = (path) => {
     if (!exists$16(next))
         return false;
     
-    return hasLeadingComment$8(next);
+    return hasLeadingComment$a(next);
 };
 
 const notLastArgInsideCall$4 = (path) => {
@@ -58353,12 +58360,12 @@ var objectProperty$8 = {};
 
 var concatenate$9 = {};
 
-const {types: types$3i} = bundle$1;
+const {types: types$3j} = bundle$1;
 const {
     isStringLiteral: isStringLiteral$w,
     isTemplateLiteral: isTemplateLiteral$8,
     isBinaryExpression: isBinaryExpression$9,
-} = types$3i;
+} = types$3j;
 
 const isStringLike$4 = (a) => {
     if (isStringLiteral$w(a))
@@ -58405,11 +58412,11 @@ concatenate$9.concatenate = (path, {print, indent}) => {
         indent.dec();
 };
 
-const {types: types$3h} = bundle$1;
+const {types: types$3i} = bundle$1;
 const {isConcatenation: isConcatenation$e} = concatenate$9;
 const {isOneLine: isOneLine$8} = objectExpression$7;
 const {printKey: printKey$A} = printKey$D;
-const {isTSImportType: isTSImportType$5} = types$3h;
+const {isTSImportType: isTSImportType$5} = types$3i;
 const isInsideTSImportType$4 = ({parentPath}) => isTSImportType$5(parentPath.parentPath);
 
 objectProperty$8.ObjectProperty = (path, printer, semantics) => {
@@ -58463,11 +58470,11 @@ moreThenMaxPropertiesInOneLine$9.moreThenMaxPropertiesInOneLine = (path, {maxPro
 
 var maybeTypeAnnotation$o = {};
 
-const {types: types$3g} = bundle$1;
+const {types: types$3h} = bundle$1;
 const {
     isMemberExpression: isMemberExpression$p,
     isSequenceExpression: isSequenceExpression$6,
-} = types$3g;
+} = types$3h;
 
 maybeTypeAnnotation$o.maybePrintTypeAnnotation = maybePrintTypeAnnotation$j;
 
@@ -58498,11 +58505,11 @@ function maybePrintTypeAnnotation$j(path, printer) {
 
 var moreThenMaxPropertiesLengthInOneLine$9 = {};
 
-const {types: types$3f} = bundle$1;
+const {types: types$3g} = bundle$1;
 const {
     isAssignmentPattern: isAssignmentPattern$a,
     isIdentifier: isIdentifier$J,
-} = types$3f;
+} = types$3g;
 
 function getLength$4(left, right) {
     if (isIdentifier$J(left) && isIdentifier$J(right))
@@ -58539,7 +58546,7 @@ moreThenMaxPropertiesLengthInOneLine$9.moreThenMaxPropertiesLengthInOneLine = (p
     return false;
 };
 
-const {types: types$3e} = bundle$1;
+const {types: types$3f} = bundle$1;
 const {wrongShorthand: wrongShorthand$4} = wrongShortand$4;
 
 const {
@@ -58563,7 +58570,7 @@ const {
     isObjectPattern: isObjectPattern$7,
     isForOfStatement: isForOfStatement$9,
     isVariableDeclaration: isVariableDeclaration$g,
-} = types$3e;
+} = types$3f;
 
 const isInsideFn$4 = (path) => {
     if (isFunction$q(path.parentPath))
@@ -58898,94 +58905,98 @@ classProperty$5.ClassAccessorProperty = (path, printer, semantics) => {
     });
 };
 
-var assignmentExpression$5 = {};
+var assignmentExpression$5 = {exports: {}};
 
-var maybeWriteBrace$j = {};
-
-const {isParens: isParens$h} = maybeParens$1a;
+var maybeParensCondition$4 = {};
 
-maybeWriteBrace$j.maybePrintLeftBrace = (path, printer, semantics) => {
-    maybeWriteBrace$i(path, printer, semantics, {
-        brace: '(',
-    });
-};
+const {hasLeadingComment: hasLeadingComment$9} = is$8;
 
-maybeWriteBrace$j.maybePrintRightBrace = (path, printer, semantics) => {
-    maybeWriteBrace$i(path, printer, semantics, {
-        brace: ')',
-    });
-};
+const {isParens: isParens$h} = maybeParens$1a;
 
-function maybeWriteBrace$i(path, printer, semantics, {brace}) {
+maybeParensCondition$4.condition = (path, printer, semantics) => {
     const {parentPath} = path;
     const {type} = parentPath;
     const {roundBraces} = semantics;
-    const {write} = printer;
     
-    if (path.node.left.type === 'ObjectPattern') {
-        write(brace);
-        return;
-    }
+    if (path.node.left.type === 'ObjectPattern')
+        return true;
     
-    if (type === 'LogicalExpression') {
-        write(brace);
-        return;
-    }
+    if (type === 'LogicalExpression')
+        return true;
     
-    if (type === 'BinaryExpression') {
-        write(brace);
-        return;
-    }
+    if (type === 'BinaryExpression')
+        return true;
     
-    if (type === 'UnaryExpression') {
-        write(brace);
-        return;
-    }
+    if (type === 'UnaryExpression')
+        return true;
     
-    if (!roundBraces.assign)
+    if (!roundBraces.assign && !hasLeadingComment$9(path))
+        return false;
+    
+    return isParens$h(path);
+};
+
+var assignmentExpressionComments = {};
+
+const {types: types$3e} = bundle$1;
+const {hasLeadingComment: hasLeadingComment$8} = is$8;
+const {isReturnStatement: isReturnStatement$b} = types$3e;
+
+assignmentExpressionComments.printLeadingCommentLine = (path, printer, semantics, {printComment}) => {
+    const {parentPath} = path;
+    const {print} = printer;
+    
+    if (isReturnStatement$b(parentPath))
         return;
     
-    if (!isParens$h(path))
+    printComment();
+    print.newline();
+};
+
+assignmentExpressionComments.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
+    const {parentPath} = path;
+    const is = isReturnStatement$b(parentPath);
+    
+    if (is && 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();
+        }
+    }
+};
+
+assignmentExpressionComments.maybeInsideReturnWithCommentEnd = (path, {print, indent}) => {
+    const {parentPath} = path;
+    const is = isReturnStatement$b(parentPath);
+    
+    if (!is || !hasLeadingComment$8(path))
         return;
     
-    write(brace);
-}
+    indent.dec();
+    print.breakline();
+};
 
-const {types: types$3d} = bundle$1;
-const {
-    maybePrintLeftBrace: maybePrintLeftBrace$4,
-    maybePrintRightBrace: maybePrintRightBrace$4,
-} = maybeWriteBrace$j;
+var printSeparator = {};
 
+const {types: types$3d} = bundle$1;
 const {
-    isExpressionStatement: isExpressionStatement$s,
     isAssignmentExpression: isAssignmentExpression$e,
+    isExpressionStatement: isExpressionStatement$s,
 } = types$3d;
 
-const isInsideBlock$o = ({parentPath}) => /BlockStatement|Program/.test(parentPath.type);
-
-assignmentExpression$5.AssignmentExpression = (path, printer, semantics) => {
-    const {print} = printer;
-    const {operator} = path.node;
-    
-    maybePrintLeftBrace$4(path, printer, semantics);
-    print('__left');
-    print.space();
-    print(operator);
-    
+printSeparator.printSeparator = (path, {print}) => {
     if (isMultiline$4(path))
         print.breakline();
     else
         print.space();
-    
-    print('__right');
-    
-    if (isInsideBlock$o(path)) {
-        print(';');
-        print.breakline();
-    }
-    
-    maybePrintRightBrace$4(path, printer, semantics);
 };
 
 function isMultiline$4(path) {
@@ -58997,6 +59008,51 @@ function isMultiline$4(path) {
     return isAssignmentExpression$e(right);
 }
 
+(function (module) {
+
+	const {condition} = maybeParensCondition$4;
+
+	const {
+	    printLeadingCommentLine,
+	    maybeInsideReturnWithCommentEnd,
+	    maybeInsideReturnWithCommentStart,
+	} = assignmentExpressionComments;
+
+	const {maybeParens} = maybeParens$1a;
+	const {printSeparator: printSeparator$1} = printSeparator;
+
+	const isInsideBlock = ({parentPath}) => /BlockStatement|Program/.test(parentPath.type);
+
+	module.exports.AssignmentExpression = maybeParens({
+	    checkParens: false,
+	    condition,
+	    print(path, printer) {
+	        const {print} = printer;
+	        const {operator} = path.node;
+	        
+	        maybeInsideReturnWithCommentStart(path, printer);
+	        
+	        print('__left');
+	        print.space();
+	        print(operator);
+	        printSeparator$1(path, printer);
+	        print('__right');
+	        
+	        if (isInsideBlock(path)) {
+	            print(';');
+	            print.breakline();
+	        }
+	        
+	        maybeInsideReturnWithCommentEnd(path, printer);
+	    },
+	});
+
+	module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine; 
+} (assignmentExpression$5));
+
+var assignmentExpressionExports = assignmentExpression$5.exports;
+assignmentExpressionExports.default;
+
 var arrayExpression$8 = {};
 
 var newline$4 = {};
@@ -60918,7 +60974,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;
@@ -64715,7 +64771,7 @@ function snakeCase(str) {
 const process$5 = require$$0$3;
 const toSnakeCase$4 = justSnakeCase;
 const {codeFrameColumns: codeFrameColumns$6} = bundle$1;
-const {TYPES: TYPES$f} = types$3t;
+const {TYPES: TYPES$f} = types$3u;
 
 const {stringify: stringify$b} = JSON;
 const {
@@ -64902,7 +64958,7 @@ const initSemantics$4 = (format, semantics = {}) => ({
 const fullstore$6 = fullstore$7;
 
 const babelTraverse$6 = bundle$1.traverse;
-const {TYPES: TYPES$e} = types$3t;
+const {TYPES: TYPES$e} = types$3u;
 const baseVisitors$4 = visitors$a;
 
 const {