@putout/bundle 4.4.2 → 4.5.0

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');
@@ -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)
@@ -57509,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');
@@ -57525,7 +57525,7 @@ const isAllParamsHasLeadingComments$4 = (path) => {
         const [firstDecorator] = decorators;
         ++decoratorsCount;
         
-        if (hasLeadingComment$b(firstDecorator))
+        if (hasLeadingComment$c(firstDecorator))
             ++commentsCount;
     }
     
@@ -58182,7 +58182,7 @@ const {
     noTrailingComment: noTrailingComment$e,
     isNewlineBetweenSiblings: isNewlineBetweenSiblings$i,
     noLeadingComment: noLeadingComment$4,
-    hasLeadingComment: hasLeadingComment$a,
+    hasLeadingComment: hasLeadingComment$b,
     exists: exists$16,
 } = is$8;
 
@@ -58309,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) => {
@@ -58909,7 +58909,7 @@ var assignmentExpression$5 = {exports: {}};
 
 var maybeParensCondition$4 = {};
 
-const {hasLeadingComment: hasLeadingComment$9} = is$8;
+const {hasLeadingComment: hasLeadingComment$a} = is$8;
 
 const {isParens: isParens$h} = maybeParens$1a;
 
@@ -58930,7 +58930,7 @@ maybeParensCondition$4.condition = (path, printer, semantics) => {
     if (type === 'UnaryExpression')
         return true;
     
-    if (!roundBraces.assign && !hasLeadingComment$9(path))
+    if (!roundBraces.assign && !hasLeadingComment$a(path))
         return false;
     
     return isParens$h(path);
@@ -58939,10 +58939,22 @@ maybeParensCondition$4.condition = (path, printer, semantics) => {
 var assignmentExpressionComments = {};
 
 const {types: types$3e} = bundle$1;
-const {hasLeadingComment: hasLeadingComment$8} = is$8;
+const {hasLeadingComment: hasLeadingComment$9} = is$8;
 const {isReturnStatement: isReturnStatement$b} = types$3e;
 
-assignmentExpressionComments.printLeadingCommentLine = (path, printer, semantics, {printComment}) => {
+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.printLeadingCommentBlock = (path, printer, semantics, {printComment}) => {
     const {parentPath} = path;
     const {print} = printer;
     
@@ -58950,14 +58962,14 @@ assignmentExpressionComments.printLeadingCommentLine = (path, printer, semantics
         return;
     
     printComment();
-    print.newline();
+    print.indent();
 };
 
 assignmentExpressionComments.maybeInsideReturnWithCommentStart = (path, {print, indent}) => {
     const {parentPath} = path;
     const is = isReturnStatement$b(parentPath);
     
-    if (is && hasLeadingComment$8(path)) {
+    if (is && hasLeadingComment$9(path)) {
         indent.inc();
         const {leadingComments} = path.node;
         
@@ -58977,7 +58989,7 @@ assignmentExpressionComments.maybeInsideReturnWithCommentEnd = (path, {print, in
     const {parentPath} = path;
     const is = isReturnStatement$b(parentPath);
     
-    if (!is || !hasLeadingComment$8(path))
+    if (!is || !hasLeadingComment$9(path))
         return;
     
     indent.dec();
@@ -59016,6 +59028,7 @@ function isMultiline$4(path) {
 	    printLeadingCommentLine,
 	    maybeInsideReturnWithCommentEnd,
 	    maybeInsideReturnWithCommentStart,
+	    printLeadingCommentBlock,
 	} = assignmentExpressionComments;
 
 	const {maybeParens} = maybeParens$1a;
@@ -59047,7 +59060,8 @@ function isMultiline$4(path) {
 	    },
 	});
 
-	module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine; 
+	module.exports.AssignmentExpression.printLeadingCommentLine = printLeadingCommentLine;
+	module.exports.AssignmentExpression.printLeadingCommentBlock = printLeadingCommentBlock; 
 } (assignmentExpression$5));
 
 var assignmentExpressionExports = assignmentExpression$5.exports;
@@ -60649,71 +60663,108 @@ spreadElement$5.SpreadElement = (path, printer) => {
         print(',');
 };
 
-var sequenceExpression$5 = {};
-
-var maybeWriteBrace$h = {};
-
-maybeWriteBrace$h.maybeWriteLeftBrace = (path, printer, semantics) => {
-    maybeWriteBrace$g(path, printer, semantics, {
-        brace: '(',
-    });
-};
+var sequenceExpression$5 = {exports: {}};
 
-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}) => {
@@ -60980,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;
@@ -64506,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) {
@@ -107726,12 +107777,12 @@ var setLiteral$1 = (node) => {
     }
     
     if (node.regex) {
-        transformRegExp(node);
+        transformRegExp$1(node);
         return;
     }
 };
 
-function transformRegExp(node) {
+function transformRegExp$1(node) {
     node.type = 'RegExpLiteral';
     
     for (const key of Object.keys(node.regex)) {
@@ -167335,16 +167386,16 @@ function parseError(message) {
   throw new SyntaxError(message);
 }
 
-var regexpTree$3 = yyparse;
+var regexpTree$4 = yyparse;
 
-regexpTree$3.default;
+regexpTree$4.default;
 
 /**
  * The MIT License (MIT)
  * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
  */
 
-var regexpTreeParser = regexpTree$3;
+var regexpTreeParser = regexpTree$4;
 
 /**
  * Original parse function.
@@ -172120,7 +172171,7 @@ var _require = runtime,
  */
 
 
-var regexpTree$2 = {
+var regexpTree$3 = {
   /**
    * Parser module exposed.
    */
@@ -172277,27 +172328,27 @@ var regexpTree$2 = {
   }
 };
 
-var regexpTree_1 = regexpTree$2;
+var regexpTree_1 = regexpTree$3;
 
 /**
  * The MIT License (MIT)
  * Copyright (c) 2017-present Dmitry Soshnikov <dmitry.soshnikov@gmail.com>
  */
 
-var regexpTree$1 = regexpTree_1;
+var regexpTree$2 = regexpTree_1;
 
-const regexpTree = regexpTree$1;
+const regexpTree$1 = regexpTree$2;
 
 const notSimpleChar = ({type, kind}) => type !== 'Char' || kind !== 'simple';
 
 var isSimpleRegexp = (regexp) => {
     let containsMoreThenSimpleChars = false;
-    const ast = regexpTree.parse(regexp);
+    const ast = regexpTree$1.parse(regexp);
     
     if (ast.body.type !== 'Alternative')
         return false;
     
-    regexpTree.traverse(ast, {
+    regexpTree$1.traverse(ast, {
         RegExp({node}) {
             const {expressions} = node.body;
             containsMoreThenSimpleChars = Boolean(expressions.find(notSimpleChar));
@@ -172309,10 +172360,43 @@ var isSimpleRegexp = (regexp) => {
 
 isSimpleRegexp.default;
 
+var transformRegexp = {};
+
+const regexpTree = regexpTree$2;
+
+transformRegexp.transformRegExp = (str, {report, traverse, fix}) => {
+    const ast = regexpTree.parse(str, {
+        captureLocations: true,
+    });
+    
+    const places = [];
+    const push = (path) => {
+        const {start} = (path.path || path).node.loc;
+        
+        places.push({
+            position: start,
+            message: report(path),
+        });
+        
+        fix(path);
+    };
+    
+    regexpTree.traverse(ast, traverse({
+        push,
+    }));
+    
+    return [
+        regexpTree.generate(ast),
+        places,
+    ];
+};
+
 const isSimpleRegExp = isSimpleRegexp;
+const {transformRegExp} = transformRegexp;
 
 var regexp = {
     isSimpleRegExp,
+    transformRegExp,
 };
 
 var addArgs = {};