@putout/bundle 3.19.1 → 3.19.2

package/bundle/putout.js

@@ -9428,7 +9428,7 @@ __export(lib_exports, {
         return tsTypePredicate;
     },
     TSTypeQuery: function() {
-        return tsTypeQuery;
+        return tsTypeQuery$1;
     },
     TSTypeReference: function() {
         return tsTypeReference$1;
@@ -12224,7 +12224,7 @@ __export(lib_exports, {
         return tsTypePredicate;
     },
     tsTypeQuery: function() {
-        return tsTypeQuery;
+        return tsTypeQuery$1;
     },
     tsTypeReference: function() {
         return tsTypeReference$1;
@@ -23387,7 +23387,7 @@ function tsTypePredicate(parameterName) {
     validate$4(defs.asserts, node, "asserts", asserts);
     return node;
 }
-function tsTypeQuery(exprName) {
+function tsTypeQuery$1(exprName) {
     var typeParameters = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
     var node = {
         type: "TSTypeQuery",
@@ -46990,7 +46990,7 @@ function Identifier$1$1(node, parent, tokenContext, _inForInit, getRawIdentifier
         await: false
     });
 }
-var parens$1 = /* @__PURE__ */ Object.freeze({
+var parens = /* @__PURE__ */ Object.freeze({
     __proto__: null,
     ArrowFunctionExpression: ConditionalExpression$1,
     AssignmentExpression: AssignmentExpression$1,
@@ -47088,7 +47088,7 @@ function expandAliases(obj) {
     }
     return map;
 }
-var expandedParens = expandAliases(parens$1);
+var expandedParens = expandAliases(parens);
 var expandedWhitespaceNodes = expandAliases(nodes);
 function isOrHasCallExpression(node) {
     if (isCallExpression$1$1(node)) {
@@ -49835,7 +49835,7 @@ function TSTypePredicate(node) {
         this.print(node.typeAnnotation.typeAnnotation);
     }
 }
-function TSTypeQuery(node) {
+function TSTypeQuery$1(node) {
     this.word("typeof");
     this.space();
     this.print(node.exprName);
@@ -50457,7 +50457,7 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     TSTypeParameterDeclaration: TSTypeParameterInstantiation,
     TSTypeParameterInstantiation: TSTypeParameterInstantiation,
     TSTypePredicate: TSTypePredicate,
-    TSTypeQuery: TSTypeQuery,
+    TSTypeQuery: TSTypeQuery$1,
     TSTypeReference: TSTypeReference$1,
     TSUndefinedKeyword: TSUndefinedKeyword,
     TSUnionType: TSUnionType$2,
@@ -79031,12 +79031,13 @@ function isOneArgArrow(path) {
     return param.type === 'Identifier';
 }
 
-var maybeParens$9 = {};
+var maybeParens$c = {};
 
-maybeParens$9.maybeParens = (print) => ({
-    condition(path) {
-        return path.node.extra?.parenthesized;
-    },
+const isParens$4 = (path) => path.node.extra?.parenthesized;
+
+maybeParens$c.isParens = isParens$4;
+maybeParens$c.maybeParens = (print) => ({
+    condition: isParens$4,
     before(path, {write}) {
         write('(');
     },
@@ -79048,9 +79049,9 @@ maybeParens$9.maybeParens = (print) => ({
 
 const {exists: exists$e} = is$3;
 const {printParams: printParams$c} = params;
-const {maybeParens: maybeParens$8} = maybeParens$9;
+const {maybeParens: maybeParens$b} = maybeParens$c;
 
-arrowFunctionExpression.ArrowFunctionExpression = maybeParens$8((path, printer, semantics) => {
+arrowFunctionExpression.ArrowFunctionExpression = maybeParens$b((path, printer, semantics) => {
     const {
         print,
         maybe,
@@ -79306,9 +79307,9 @@ var functionExpression = {};
 
 const {exists: exists$d} = is$3;
 const {printParams: printParams$8} = params;
-const {maybeParens: maybeParens$7} = maybeParens$9;
+const {maybeParens: maybeParens$a} = maybeParens$c;
 
-functionExpression.FunctionExpression = maybeParens$7((path, printer, semantics) => {
+functionExpression.FunctionExpression = maybeParens$a((path, printer, semantics) => {
     const {
         print,
         maybe,
@@ -79358,11 +79359,11 @@ var unaryExpressions$1 = {};
 
 const {isLast: isLast$b, isNext: isNext$m} = is$3;
 
-const {maybeParens: maybeParens$6} = maybeParens$9;
+const {maybeParens: maybeParens$9} = maybeParens$c;
 
 const isWord = (a) => /^(delete|typeof|void|throw)$/.test(a);
 
-const unaryExpression = maybeParens$6((path, printer) => {
+const unaryExpression = maybeParens$9((path, printer) => {
     const {maybe, traverse} = printer;
     const {prefix, operator} = path.node;
     const argPath = path.get('argument');
@@ -79382,7 +79383,7 @@ unaryExpressions$1.AwaitExpression = (path, {print}) => {
     });
 };
 
-unaryExpressions$1.YieldExpression = maybeParens$6((path, {print, maybe}) => {
+unaryExpressions$1.YieldExpression = maybeParens$9((path, {print, maybe}) => {
     const {delegate} = path.node;
     
     print(`yield`);
@@ -79495,7 +79496,7 @@ const {chain} = chain$1;
 const {satisfy: satisfy$3} = is$3;
 
 const {maybePrintComputed} = maybePrintComputed$2;
-const {maybeParens: maybeParens$5} = maybeParens$9;
+const {maybeParens: maybeParens$8} = maybeParens$c;
 
 const isArgOfCall = (path) => path.parentPath.isCallExpression() && path.parentPath.get('arguments.0') === path;
 
@@ -79530,7 +79531,7 @@ memberExpressions$1.MemberExpression = (path, printer) => {
     maybe.indent.dec(isChain);
 };
 
-memberExpressions$1.OptionalMemberExpression = maybeParens$5((path, {print, maybe}) => {
+memberExpressions$1.OptionalMemberExpression = maybeParens$8((path, {print, maybe}) => {
     const {computed, optional} = path.node;
     
     print('__object');
@@ -79711,7 +79712,7 @@ _class.ClassDeclaration = {
 var callExpression = {};
 
 const {exists: exists$c} = is$3;
-const {maybeParens: maybeParens$4} = maybeParens$9;
+const {maybeParens: maybeParens$7} = maybeParens$c;
 const {isArray: isArray$e} = Array;
 
 const parseArgs = (path) => {
@@ -79723,7 +79724,7 @@ const parseArgs = (path) => {
     return argsPath;
 };
 
-const CallExpression$1 = maybeParens$4((path, {indent, print, maybe, traverse}) => {
+const CallExpression$1 = maybeParens$7((path, {indent, print, maybe, traverse}) => {
     const args = parseArgs(path);
     const isParentCall = tooLong$1(args) && path.parentPath.isCallExpression();
     
@@ -79926,7 +79927,7 @@ objectExpression.ObjectExpression = (path, printer, semantics) => {
     
     const properties = path.get('properties');
     const {length} = properties;
-    const parens = isParens$5(path);
+    const parens = isParens$3(path);
     const manyLines = !isOneLine$1(path);
     
     maybe.print(parens, '(');
@@ -80031,7 +80032,7 @@ function isOneLine$1(path) {
     return !isValue(path);
 }
 
-function isParens$5(path) {
+function isParens$3(path) {
     if (isBodyOfArrow(path))
         return true;
     
@@ -80475,22 +80476,7 @@ var assignmentExpression = {};
 
 var maybeWriteBrace$3 = {};
 
-var parens = {};
-
-const isParens$4 = (path) => path.node.extra?.parenthesized;
-
-parens.isParens = isParens$4;
-
-parens.maybeParenOpen = (path, {maybe}) => {
-    maybe.write(isParens$4(path), '(');
-};
-
-parens.maybeParenClose = (path, {maybe}) => {
-    maybe.write(isParens$4(path), ')');
-};
-
-const {isParens: isParens$3} = parens;
-
+const {isParens: isParens$2} = maybeParens$c;
 maybeWriteBrace$3.maybePrintLeftBrace = (path, printer, semantics) => {
     maybeWriteBrace$2(path, printer, semantics, {
         brace: '(',
@@ -80527,7 +80513,7 @@ function maybeWriteBrace$2(path, printer, semantics, {brace}) {
     if (!roundBraces.assign)
         return;
     
-    if (!isParens$3(path))
+    if (!isParens$2(path))
         return;
     
     write(brace);
@@ -82159,11 +82145,11 @@ const {
 } = concatenate$1;
 
 const {maybeSpace} = maybeSpace$1;
-const {isParens: isParens$2} = parens;
+const {isParens: isParens$1} = maybeParens$c;
 
 const BinaryExpression$1 = {
     condition(path) {
-        if (isParens$2(path))
+        if (isParens$1(path))
             return true;
         
         return path.parentPath.isAwaitExpression();
@@ -82215,28 +82201,19 @@ binaryExpression.LogicalExpression = BinaryExpression$1;
 
 var conditionalExpression = {};
 
-const {isParens: isParens$1} = parens;
+const {maybeParens: maybeParens$6} = maybeParens$c;
 
-conditionalExpression.ConditionalExpression = {
-    condition: isParens$1,
-    before(path, {print}) {
-        print('(');
-    },
-    print(path, {print}) {
-        print('__test');
-        print.space();
-        print('?');
-        print.space();
-        print('__consequent');
-        print.space();
-        print(':');
-        print.space();
-        print('__alternate');
-    },
-    after(path, {print}) {
-        print(')');
-    },
-};
+conditionalExpression.ConditionalExpression = maybeParens$6((path, {print}) => {
+    print('__test');
+    print.space();
+    print('?');
+    print.space();
+    print('__consequent');
+    print.space();
+    print(':');
+    print.space();
+    print('__alternate');
+});
 
 var staticBlock = {};
 
@@ -84143,10 +84120,10 @@ maybeGet.maybeDecorators = (path) => {
 };
 
 const {maybeDecorators} = maybeGet;
-const {maybeParens: maybeParens$3} = maybeParens$9;
+const {maybeParens: maybeParens$5} = maybeParens$c;
 const {maybeTypeAnnotation} = maybeTypeAnnotation$4;
 
-identifier.Identifier = maybeParens$3(maybeTypeAnnotation((path, printer) => {
+identifier.Identifier = maybeParens$5(maybeTypeAnnotation((path, printer) => {
     const {
         write,
         maybe,
@@ -84623,13 +84600,13 @@ tsInterfaceDeclaration.TSInterfaceDeclaration = {
 
 var tsAsExpression = {};
 
-const {maybeParens: maybeParens$2} = maybeParens$9;
+const {maybeParens: maybeParens$4} = maybeParens$c;
 const {
     isVariableDeclarator,
     isObjectExpression: isObjectExpression$1,
 } = bundle.types;
 
-tsAsExpression.TSAsExpression = maybeParens$2((path, {print, maybe}) => {
+tsAsExpression.TSAsExpression = maybeParens$4((path, {print, maybe}) => {
     const is = isParens(path);
     
     maybe.print(is, '(');
@@ -84757,9 +84734,9 @@ printReturnType$5.printReturnType = (path, {traverse}) => {
 const {printParams: printParams$5} = params;
 const {printReturnType: printReturnType$4} = printReturnType$5;
 
-const {maybeParens: maybeParens$1} = maybeParens$9;
+const {maybeParens: maybeParens$3} = maybeParens$c;
 
-tsFunctionType.TSFunctionType = maybeParens$1((path, printer, semantics) => {
+tsFunctionType.TSFunctionType = maybeParens$3((path, printer, semantics) => {
     const {print} = printer;
     
     printParams$5(path, printer, semantics);
@@ -84954,23 +84931,18 @@ tsMethodSignature.TSMethodSignature = (path, printer, semantics) => {
 
 var tsUnionType = {};
 
-const {
-    maybeParenOpen,
-    maybeParenClose,
-} = parens;
+const {maybeParens: maybeParens$2} = maybeParens$c;
+const insideTypeDeclaration = ({parentPath}) => parentPath.isTSTypeAliasDeclaration();
 
-tsUnionType.TSUnionType = (path, printer, semantics) => {
+tsUnionType.TSUnionType = maybeParens$2((path, printer, {maxTypesInOneLine}) => {
     const types = path.get('types');
+    const {length} = types;
     
-    maybeParenOpen(path, printer);
-    
-    if (types.length <= semantics.maxTypesInOneLine)
+    if (!insideTypeDeclaration(path) || length <= maxTypesInOneLine)
         printInOneLine(types, printer);
     else
         printInCoupleLines(types, printer);
-    
-    maybeParenClose(path, printer);
-};
+});
 
 function printInOneLine(types, {traverse, write}) {
     const n = types.length - 1;
@@ -85034,9 +85006,9 @@ tsTypeReference.TSTypeReference = (path, {print}) => {
 
 var tsInferType = {};
 
-const {maybeParens} = maybeParens$9;
+const {maybeParens: maybeParens$1} = maybeParens$c;
 
-tsInferType.TSInferType = maybeParens((path, {print}) => {
+tsInferType.TSInferType = maybeParens$1((path, {print}) => {
     print('infer ');
     print('__typeParameter');
 });
@@ -85078,6 +85050,15 @@ tsParameterProperty.TSParameterProperty = (path, {print, maybe}) => {
     maybe.print.breakline(decoratorsLength);
 };
 
+var tsTypeQuery = {};
+
+const {maybeParens} = maybeParens$c;
+
+tsTypeQuery.TSTypeQuery = maybeParens((path, {print}) => {
+    print('typeof ');
+    print('__exprName');
+});
+
 const {isNext: isNext$1} = is$3;
 const {TSTypeLiteral} = tsTypeLiteral;
 const {TSTypeAliasDeclaration} = tsTypeAliasDeclaration;
@@ -85115,6 +85096,7 @@ const {TSExportAssignment} = tsExportAssignment;
 const {TSTypeReference} = tsTypeReference;
 const {TSInferType} = tsInferType;
 const {TSParameterProperty} = tsParameterProperty;
+const {TSTypeQuery} = tsTypeQuery;
 
 var typescript$1 = {
     TSAsExpression,
@@ -85130,6 +85112,7 @@ var typescript$1 = {
     TSIntersectionType,
     TSImportType,
     TSUnionType,
+    TSTypeQuery,
     TSBigIntKeyword(path, {write}) {
         write('bigint');
     },
@@ -85139,10 +85122,6 @@ var typescript$1 = {
     TSSymbolKeyword(path, {write}) {
         write('symbol');
     },
-    TSTypeQuery(path, {print}) {
-        print('typeof ');
-        print('__exprName');
-    },
     TSNeverKeyword(path, {write}) {
         write('never');
     },