@putout/bundle 4.4.1 → 4.4.3

package/bundle/putout.js

@@ -178,15 +178,15 @@ var versions = {};
 var release = {};
 var config = {};
 
-function noop$8() {}
+function noop$9() {}
 
-var on = noop$8;
-var addListener = noop$8;
-var once$y = noop$8;
-var off = noop$8;
-var removeListener = noop$8;
-var removeAllListeners = noop$8;
-var emit = noop$8;
+var on = noop$9;
+var addListener = noop$9;
+var once$y = noop$9;
+var off = noop$9;
+var removeListener = noop$9;
+var removeAllListeners = noop$9;
+var emit = noop$9;
 
 function binding(name) {
     throw new Error('process.binding is not supported');
@@ -5797,7 +5797,7 @@ __export$1(lib_exports$1, {
     isArrayPattern: () => isArrayPattern$1,
     isArrayTypeAnnotation: () => isArrayTypeAnnotation$1,
     isArrowFunctionExpression: () => isArrowFunctionExpression$b,
-    isAssignmentExpression: () => isAssignmentExpression$f,
+    isAssignmentExpression: () => isAssignmentExpression$g,
     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$v,
+    isExpressionStatement: () => isExpressionStatement$w,
     isExpressionWrapper: () => isExpressionWrapper$1,
     isFile: () => isFile$7,
     isFlow: () => isFlow$1,
@@ -7758,7 +7758,7 @@ function isArrayExpression$C(node, opts) {
     return opts == null || shallowEqual$1(node, opts);
 }
 
-function isAssignmentExpression$f(node, opts) {
+function isAssignmentExpression$g(node, opts) {
     if (!node)
         return false;
     
@@ -7898,7 +7898,7 @@ function isEmptyStatement$1(node, opts) {
     return opts == null || shallowEqual$1(node, opts);
 }
 
-function isExpressionStatement$v(node, opts) {
+function isExpressionStatement$w(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$v(node)) {
+    if (isExpressionStatement$w(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$f(node)) {
+    } else if (isAssignmentExpression$g(node)) {
         return expressionStatement$e(node);
     }
     
@@ -22051,7 +22051,7 @@ function getBindingIdentifiers$4(node, duplicates, outerOnly, newBindingsOnly) {
         if (!id)
             continue;
         
-        if (newBindingsOnly && (isAssignmentExpression$f(id) || isUnaryExpression$6(id) || isUpdateExpression$1(id))) {
+        if (newBindingsOnly && (isAssignmentExpression$g(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$f(parent, {operator: '=', right: node})) {
+    } else if (isAssignmentExpression$g(parent, {operator: '=', right: node})) {
         id = parent.left;
     }
 
@@ -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,
@@ -56984,9 +56984,9 @@ const {
 const {
     isDecorator: isDecorator$9,
     isMemberExpression: isMemberExpression$r,
-    isExpressionStatement: isExpressionStatement$u,
+    isExpressionStatement: isExpressionStatement$v,
     isCallExpression: isCallExpression$A,
-} = types$3p;
+} = types$3q;
 
 const hasBody$9 = (path) => {
     if (path.isTSModuleDeclaration())
@@ -57129,7 +57129,7 @@ parseTrailingComments$e.parseTrailingComments = (path, printer, semantics, {curr
 function isPrevCall$4(path) {
     const prev = path.getPrevSibling();
     
-    if (isExpressionStatement$u(prev))
+    if (isExpressionStatement$v(prev))
         return false;
     
     const {expression} = path.node;
@@ -57189,7 +57189,7 @@ comment$4.parseComments = parseComments$H;
 
 const {parseComments: parseComments$G} = comment$4;
 
-const noop$7 = () => {};
+const noop$8 = () => {};
 const parseParams$4 = (path) => path.get('params');
 
 params$4.printParams = (path, printer, semantics, customization = {}) => {
@@ -57205,8 +57205,8 @@ params$4.printParams = (path, printer, semantics, customization = {}) => {
         braceOpen = '(',
         braceClose = ')',
         printSpace = print.space,
-        printAfterOpen = noop$7,
-        printBeforeClose = noop$7,
+        printAfterOpen = noop$8,
+        printBeforeClose = noop$8,
     } = customization;
     
     if (typeParameters)
@@ -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;
@@ -57347,14 +57354,14 @@ const not$4 = (fn) => (...a) => !fn(...a);
 const notInsideExportDefaultWithBody$4 = not$4(isInsideExportDefaultWithBody$4);
 
 const {
-    isAssignmentExpression: isAssignmentExpression$e,
+    isAssignmentExpression: isAssignmentExpression$f,
     isTSModuleBlock: isTSModuleBlock$c,
     isBlockStatement: isBlockStatement$n,
     isExportNamedDeclaration: isExportNamedDeclaration$b,
-    isExpressionStatement: isExpressionStatement$t,
+    isExpressionStatement: isExpressionStatement$u,
     isFunctionDeclaration: isFunctionDeclaration$f,
     isExportDefaultDeclaration: isExportDefaultDeclaration$5,
-} = types$3o;
+} = types$3p;
 
 const isInsideNamedExport$9 = ({parentPath}) => isExportNamedDeclaration$b(parentPath);
 
@@ -57409,10 +57416,10 @@ const isNextFunction$4 = (path) => {
 const isNextAssign$9 = (path) => {
     const next = path.getNextSibling();
     
-    if (!isExpressionStatement$t(next))
+    if (!isExpressionStatement$u(next))
         return false;
     
-    return isAssignmentExpression$e(next.node.expression);
+    return isAssignmentExpression$f(next.node.expression);
 };
 
 function isInsideBlockStatement$4(path) {
@@ -57502,7 +57509,7 @@ kind$4.printKind = (path, {write}) => {
 var printFunctionParams$9 = {};
 
 const {printParams: printParams$_} = params$4;
-const {hasLeadingComment: hasLeadingComment$b} = is$8;
+const {hasLeadingComment: hasLeadingComment$c} = 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$b(firstDecorator))
+        if (hasLeadingComment$c(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,16 +58047,16 @@ 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$s,
+    isExpressionStatement: isExpressionStatement$t,
     isMemberExpression: isMemberExpression$q,
-} = types$3m;
+} = types$3n;
 
-const isInsideExpressionStatement$4 = ({parentPath}) => isExpressionStatement$s(parentPath);
+const isInsideExpressionStatement$4 = ({parentPath}) => isExpressionStatement$t(parentPath);
 const notFirst$4 = ({parentPath}) => exists$17(parentPath.getPrevSibling());
 const isInsideMember$4 = ({parentPath}) => isMemberExpression$q(parentPath);
 
@@ -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$a,
+    hasLeadingComment: hasLeadingComment$b,
     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$a(next);
+    return hasLeadingComment$b(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))
@@ -58900,70 +58907,69 @@ classProperty$5.ClassAccessorProperty = (path, printer, semantics) => {
 
 var assignmentExpression$5 = {exports: {}};
 
-var maybeWriteBrace$j = {};
-
-const {hasLeadingComment: hasLeadingComment$9} = is$8;
-const {isParens: isParens$h} = maybeParens$1a;
+var maybeParensCondition$4 = {};
 
-maybeWriteBrace$j.maybePrintLeftBrace = (path, printer, semantics) => {
-    maybeWriteBrace$i(path, printer, semantics, {
-        brace: '(',
-    });
-};
+const {hasLeadingComment: hasLeadingComment$a} = 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 (type === 'LogicalExpression') {
-        write(brace);
-        return;
-    }
+    if (path.node.left.type === 'ObjectPattern')
+        return true;
     
-    if (type === 'BinaryExpression') {
-        write(brace);
-        return;
-    }
+    if (type === 'LogicalExpression')
+        return true;
     
-    if (type === 'UnaryExpression') {
-        write(brace);
-        return;
-    }
+    if (type === 'BinaryExpression')
+        return true;
     
-    if (!roundBraces.assign && !hasLeadingComment$9(path))
-        return;
+    if (type === 'UnaryExpression')
+        return true;
     
-    if (!isParens$h(path))
-        return;
+    if (!roundBraces.assign && !hasLeadingComment$a(path))
+        return false;
     
-    write(brace);
-}
+    return isParens$h(path);
+};
 
 var assignmentExpressionComments = {};
 
-const {types: types$3d} = bundle$1;
-const {hasLeadingComment: hasLeadingComment$8} = is$8;
-const {isReturnStatement: isReturnStatement$b} = types$3d;
+const {types: types$3e} = bundle$1;
+const {hasLeadingComment: hasLeadingComment$9} = is$8;
+const {isReturnStatement: isReturnStatement$b} = types$3e;
+
+assignmentExpressionComments.printLeadingCommentLine = (path, printer, semantics, {printComment, isLast}) => {
+    const {parentPath} = path;
+    const {print, maybe} = printer;
+    
+    if (isReturnStatement$b(parentPath))
+        return;
+    
+    maybe.print.breakline(!isLast);
+    printComment();
+    print.breakline();
+};
 
-assignmentExpressionComments.printLeadingCommentLine = ({parentPath}) => !isReturnStatement$b(parentPath);
+assignmentExpressionComments.printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
+    const {parentPath} = path;
+    const {print} = printer;
+    
+    if (isReturnStatement$b(parentPath))
+        return;
+    
+    printComment();
+    print.indent();
+};
 
 assignmentExpressionComments.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
     const {parentPath} = path;
+    const is = isReturnStatement$b(parentPath);
     
-    if (isReturnStatement$b(parentPath) && hasLeadingComment$8(path)) {
+    if (is && hasLeadingComment$9(path)) {
         indent.inc();
         const {leadingComments} = path.node;
         
@@ -58981,74 +58987,81 @@ assignmentExpressionComments.maybeInsideReturnWithCommentStart = (path, {print,
 
 assignmentExpressionComments.maybeInsideReturnWithCommentEnd = (path, {print, indent}) => {
     const {parentPath} = path;
+    const is = isReturnStatement$b(parentPath);
     
-    if (!isReturnStatement$b(parentPath) || !hasLeadingComment$8(path))
+    if (!is || !hasLeadingComment$9(path))
         return;
     
     indent.dec();
     print.breakline();
 };
 
-(function (module) {
+var printSeparator = {};
 
-	const {types} = bundle$1;
+const {types: types$3d} = bundle$1;
+const {
+    isAssignmentExpression: isAssignmentExpression$e,
+    isExpressionStatement: isExpressionStatement$s,
+} = types$3d;
 
-	const {
-	    maybePrintLeftBrace,
-	    maybePrintRightBrace,
-	} = maybeWriteBrace$j;
+printSeparator.printSeparator = (path, {print}) => {
+    if (isMultiline$4(path))
+        print.breakline();
+    else
+        print.space();
+};
+
+function isMultiline$4(path) {
+    const {right} = path.node;
+    
+    if (!path.parentPath.find(isExpressionStatement$s))
+        return false;
+    
+    return isAssignmentExpression$e(right);
+}
+
+(function (module) {
+
+	const {condition} = maybeParensCondition$4;
 
 	const {
 	    printLeadingCommentLine,
 	    maybeInsideReturnWithCommentEnd,
 	    maybeInsideReturnWithCommentStart,
+	    printLeadingCommentBlock,
 	} = assignmentExpressionComments;
 
-	const {
-	    isExpressionStatement,
-	    isAssignmentExpression,
-	} = types;
+	const {maybeParens} = maybeParens$1a;
+	const {printSeparator: printSeparator$1} = printSeparator;
 
 	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
+	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('__right');
-	    
-	    if (isInsideBlock(path)) {
-	        print(';');
-	        print.breakline();
-	    }
-	    
-	    maybeInsideReturnWithCommentEnd(path, printer);
-	    
-	    maybePrintRightBrace(path, printer, semantics);
-	};
+	        print(operator);
+	        printSeparator$1(path, printer);
+	        print('__right');
+	        
+	        if (isInsideBlock(path)) {
+	            print(';');
+	            print.breakline();
+	        }
+	        
+	        maybeInsideReturnWithCommentEnd(path, printer);
+	    },
+	});
 
 	module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine;
-
-	function isMultiline(path) {
-	    const {right} = path.node;
-	    
-	    if (!path.parentPath.find(isExpressionStatement))
-	        return false;
-	    
-	    return isAssignmentExpression(right);
-	} 
+	module.exports.AssignmentExpression.printLeadingCommentBlock = printLeadingCommentBlock; 
 } (assignmentExpression$5));
 
 var assignmentExpressionExports = assignmentExpression$5.exports;
@@ -60650,71 +60663,108 @@ spreadElement$5.SpreadElement = (path, printer) => {
         print(',');
 };
 
-var sequenceExpression$5 = {};
+var sequenceExpression$5 = {exports: {}};
 
-var maybeWriteBrace$h = {};
-
-maybeWriteBrace$h.maybeWriteLeftBrace = (path, printer, semantics) => {
-    maybeWriteBrace$g(path, printer, semantics, {
-        brace: '(',
-    });
-};
-
-maybeWriteBrace$h.maybeWriteRightBrace = (path, printer, semantics) => {
-    maybeWriteBrace$g(path, printer, semantics, {
-        brace: ')',
-    });
-};
+var maybeWriteBrace$g = {};
 
-function maybeWriteBrace$g(path, printer, semantics, {brace}) {
+maybeWriteBrace$g.condition = (path, printer, semantics) => {
     const {parentPath} = path;
     const {type} = parentPath;
     const {roundBraces} = semantics;
-    const {write} = printer;
-    
-    if (type === 'ArrowFunctionExpression') {
-        write(brace);
-        return;
-    }
     
-    if (type === 'ConditionalExpression' && path !== parentPath.get('test')) {
-        write(brace);
-        return;
-    }
+    if (type === 'ArrowFunctionExpression')
+        return true;
     
-    if (type === 'LogicalExpression') {
-        write(brace);
-        return;
-    }
+    if (type === 'ConditionalExpression' && path !== parentPath.get('test'))
+        return true;
     
-    if (!roundBraces.sequence)
-        return;
+    if (type === 'LogicalExpression')
+        return true;
     
-    write(brace);
-}
+    return roundBraces.sequence;
+};
 
-const {
-    maybeWriteLeftBrace: maybeWriteLeftBrace$4,
-    maybeWriteRightBrace: maybeWriteRightBrace$4,
-} = maybeWriteBrace$h;
+var sequenceExpressionComments = {};
 
-sequenceExpression$5.SequenceExpression = (path, printer, semantics) => {
-    const {maybe, traverse} = printer;
-    
-    const expressions = path.get('expressions');
-    const n = expressions.length - 1;
-    
-    maybeWriteLeftBrace$4(path, printer, semantics);
-    
-    for (const [index, expression] of expressions.entries()) {
-        traverse(expression);
-        maybe.write(index < n, ',');
-        maybe.write.space(index < n);
+const {hasLeadingComment: hasLeadingComment$8} = is$8;
+const noop$7 = () => {};
+
+sequenceExpressionComments.printLeadingCommentLine = noop$7;
+sequenceExpressionComments.printLeadingCommentBlock = noop$7;
+
+sequenceExpressionComments.maybePrintComments = (path, {print}) => {
+    if (hasLeadingComment$8(path)) {
+        const {leadingComments} = path.node;
+        
+        for (const {type, value} of leadingComments) {
+            if (type === 'CommentLine')
+                print(`//${value}`);
+            else
+                print(`/*${value}*/`);
+            
+            print.breakline();
+        }
     }
-    
-    maybeWriteRightBrace$4(path, printer, semantics);
 };
 
+(function (module) {
+
+	const {hasLeadingComment} = is$8;
+	const {maybeParens} = maybeParens$1a;
+	const {condition} = maybeWriteBrace$g;
+
+	const {
+	    maybePrintComments,
+	    printLeadingCommentLine,
+	    printLeadingCommentBlock,
+	} = sequenceExpressionComments;
+
+	module.exports.SequenceExpression = maybeParens({
+	    checkParens: false,
+	    condition,
+	    print(path, printer) {
+	        const {
+	            write,
+	            traverse,
+	            indent,
+	            maybe,
+	        } = printer;
+	        
+	        const expressions = path.get('expressions');
+	        const n = expressions.length - 1;
+	        
+	        const withComment = hasLeadingComment(path);
+	        
+	        if (withComment) {
+	            indent.inc();
+	            write.breakline();
+	            maybePrintComments(path, printer);
+	        }
+	        
+	        for (const [index, expression] of expressions.entries()) {
+	            traverse(expression);
+	            
+	            if (index < n) {
+	                write(',');
+	                maybe.write.space(!withComment);
+	                maybe.print.breakline(withComment);
+	            }
+	        }
+	        
+	        if (withComment) {
+	            indent.dec();
+	            write.breakline();
+	        }
+	    },
+	});
+
+	module.exports.SequenceExpression.printLeadingCommentLine = printLeadingCommentLine;
+	module.exports.SequenceExpression.printLeadingCommentBlock = printLeadingCommentBlock; 
+} (sequenceExpression$5));
+
+var sequenceExpressionExports = sequenceExpression$5.exports;
+sequenceExpressionExports.default;
+
 var taggedTemplateExpression$5 = {};
 
 taggedTemplateExpression$5.TaggedTemplateExpression = (path, {print}) => {
@@ -60981,7 +61031,7 @@ const {ArrayPattern: ArrayPattern$4} = arrayPattern$5;
 const {AssignmentPattern: AssignmentPattern$5} = assignmentPattern$5;
 const {RestElement: RestElement$5} = restElement$5;
 const {SpreadElement: SpreadElement$4} = spreadElement$5;
-const {SequenceExpression: SequenceExpression$5} = sequenceExpression$5;
+const {SequenceExpression: SequenceExpression$5} = sequenceExpressionExports;
 const {TaggedTemplateExpression: TaggedTemplateExpression$5} = taggedTemplateExpression$5;
 const {BinaryExpression: BinaryExpression$5} = binaryExpression$5;
 const {LogicalExpression: LogicalExpression$5} = logicalExpression$5;
@@ -64507,7 +64557,7 @@ jsxText$5.JSXText = (path, {write, indent}) => {
     const isSpacesOnly = /^\s+$/.test(value);
     const hasNext = isNext$1E(path);
     
-    if (extra.raw.includes('&'))
+    if (extra?.raw.includes('&'))
         return write(extra.raw);
     
     if (isSpacesOnly && hasNext) {
@@ -64772,7 +64822,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 {
@@ -64959,7 +65009,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 {