@putout/bundle 3.14.1 → 3.15.0

package/bundle/putout.js

@@ -8392,7 +8392,7 @@ __export(lib_exports, {
         return tsTypeQuery;
     },
     TSTypeReference: function() {
-        return tsTypeReference;
+        return tsTypeReference$1;
     },
     TSUndefinedKeyword: function() {
         return tsUndefinedKeyword;
@@ -11185,7 +11185,7 @@ __export(lib_exports, {
         return tsTypeQuery;
     },
     tSTypeReference: function() {
-        return tsTypeReference;
+        return tsTypeReference$1;
     },
     tSUndefinedKeyword: function() {
         return tsUndefinedKeyword;
@@ -11431,7 +11431,7 @@ __export(lib_exports, {
         return tsTypeQuery;
     },
     tsTypeReference: function() {
-        return tsTypeReference;
+        return tsTypeReference$1;
     },
     tsUndefinedKeyword: function() {
         return tsUndefinedKeyword;
@@ -21863,7 +21863,7 @@ function tsConstructorType$1() {
         typeAnnotation: typeAnnotation2
     });
 }
-function tsTypeReference(typeName) {
+function tsTypeReference$1(typeName) {
     var typeParameters = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null;
     return validateNode({
         type: "TSTypeReference",
@@ -47566,7 +47566,7 @@ function tsPrintFunctionOrConstructorType(node) {
     var returnType = node.returnType;
     this.print(returnType.typeAnnotation, node);
 }
-function TSTypeReference(node) {
+function TSTypeReference$1(node) {
     this.print(node.typeName, node, true);
     this.print(node.typeParameters, node, true);
 }
@@ -48172,7 +48172,7 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     TSTypeParameterInstantiation: TSTypeParameterInstantiation,
     TSTypePredicate: TSTypePredicate,
     TSTypeQuery: TSTypeQuery,
-    TSTypeReference: TSTypeReference,
+    TSTypeReference: TSTypeReference$1,
     TSUndefinedKeyword: TSUndefinedKeyword,
     TSUnionType: TSUnionType,
     TSUnknownKeyword: TSUnknownKeyword,
@@ -77151,15 +77151,30 @@ maybeDecorators$4.maybeDecorators = (visitor) => (path, printer, semantics, opti
     visitor(path, printer, semantics, options);
 };
 
-var kind = {};
+var printKey$7 = {};
+
+var maybePrintComputed$2 = {};
 
-kind.printKey = (path, {write, traverse, maybe}) => {
+maybePrintComputed$2.maybePrintComputed = (path, key, {maybe, traverse}) => {
+    const {computed} = path.node;
+    
+    maybe.write(computed, '[');
+    traverse(key);
+    maybe.write(computed, ']');
+};
+
+const {maybePrintComputed: maybePrintComputed$1} = maybePrintComputed$2;
+
+printKey$7.printKey = (path, printer) => {
     const key = path.get('key');
-    const {
-        kind,
-        computed,
-        generator,
-    } = path.node;
+    
+    maybePrintComputed$1(path, key, printer);
+};
+
+var kind = {};
+
+kind.printKind = (path, {write}) => {
+    const {kind, generator} = path.node;
     
     const isGetter = kind === 'get' || kind === 'set';
     
@@ -77167,16 +77182,13 @@ kind.printKey = (path, {write, traverse, maybe}) => {
         write(`${kind} `);
     else if (generator)
         write('*');
-    
-    maybe.write(computed, '[');
-    traverse(key);
-    maybe.write(computed, ']');
 };
 
 const {isNext: isNext$n} = is$3;
 const {printParams: printParams$a} = params;
 const {maybeDecorators: maybeDecorators$3} = maybeDecorators$4;
-const {printKey: printKey$2} = kind;
+const {printKey: printKey$6} = printKey$7;
+const {printKind: printKind$3} = kind;
 
 const ClassMethod$1 = {
     print: maybeDecorators$3((path, printer, semantics) => {
@@ -77199,7 +77211,8 @@ const ClassMethod$1 = {
             print(' ');
         }
         
-        printKey$2(path, printer);
+        printKind$3(path, printer);
+        printKey$6(path, printer);
         printParams$a(path, printer, semantics);
         
         if (returnType) {
@@ -77224,7 +77237,8 @@ var objectMethod = {};
 
 const {isNewlineBetweenSiblings: isNewlineBetweenSiblings$4} = is$3;
 const {printParams: printParams$9} = params;
-const {printKey: printKey$1} = kind;
+const {printKey: printKey$5} = printKey$7;
+const {printKind: printKind$2} = kind;
 
 objectMethod.ObjectMethod = {
     beforeIf(path) {
@@ -77236,7 +77250,8 @@ objectMethod.ObjectMethod = {
     print(path, printer, semantics) {
         const {print} = printer;
         
-        printKey$1(path, printer);
+        printKind$2(path, printer);
+        printKey$5(path, printer);
         printParams$9(path, printer, semantics);
         
         print.space();
@@ -77330,14 +77345,14 @@ unaryExpressions$1.AwaitExpression = (path, {print}) => {
     });
 };
 
-unaryExpressions$1.YieldExpression = (path, {print, maybe}) => {
+unaryExpressions$1.YieldExpression = maybeParens$3((path, {print, maybe}) => {
     const {delegate} = path.node;
     
     print(`yield`);
     maybe.print(delegate, '*');
     print(' ');
     print('__argument');
-};
+});
 
 unaryExpressions$1.ThrowStatement = (path, {print, indent, maybe}) => {
     indent();
@@ -77442,10 +77457,19 @@ const {
 const {chain} = chain$1;
 const {satisfy: satisfy$3} = is$3;
 
+const {maybePrintComputed} = maybePrintComputed$2;
+
 const isArgOfCall = (path) => path.parentPath.isCallExpression() && path.parentPath.get('arguments.0') === path;
 
-memberExpressions$1.MemberExpression = (path, {print, maybe, traverse}) => {
+memberExpressions$1.MemberExpression = (path, printer) => {
+    const {
+        print,
+        maybe,
+        traverse,
+    } = printer;
+    
     const object = path.get('object');
+    const property = path.get('property');
     const isParens = object.isAwaitExpression() || object.isAssignmentExpression();
     const {computed} = path.node;
     
@@ -77453,13 +77477,8 @@ memberExpressions$1.MemberExpression = (path, {print, maybe, traverse}) => {
     traverse(object);
     maybe.print(isParens, ')');
     
-    if (computed) {
-        print('[');
-        print('__property');
-        print(']');
-        
-        return;
-    }
+    if (computed)
+        return maybePrintComputed(path, property, printer);
     
     const isChain = likeChain$1(path);
     
@@ -78017,21 +78036,24 @@ concatanate$1.concatanate = (path, {print, indent}) => {
 
 const {isConcatenation: isConcatenation$2} = concatanate$1;
 const {isOneLine} = objectExpression;
+const {printKey: printKey$4} = printKey$7;
 
-objectProperty.ObjectProperty = (path, {maybe, traverse, write}, semantics) => {
+objectProperty.ObjectProperty = (path, printer, semantics) => {
     const {trailingComma} = semantics;
-    const {shorthand, computed} = path.node;
+    const {shorthand} = path.node;
+    const {
+        maybe,
+        traverse,
+        write,
+    } = printer;
     
-    const key = path.get('key');
     const value = path.get('value');
     
     const properties = path.parentPath.get('properties');
     const isLast = path === properties.at(-1);
     const manyLines = !isOneLine(path.parentPath);
     
-    maybe.write(computed, '[');
-    traverse(key);
-    maybe.write(computed, ']');
+    printKey$4(path, printer);
     
     if (!shorthand) {
         write(':');
@@ -78140,6 +78162,7 @@ const {moreThenMaxPropertiesInOneLine} = moreThenMaxPropertiesInOneLine$1;
 
 const {maybeTypeAnnotation: maybeTypeAnnotation$3} = maybeTypeAnnotation$4;
 const {moreThenMaxPropertiesLengthInOneLine} = moreThenMaxPropertiesLengthInOneLine$1;
+const {printKey: printKey$3} = printKey$7;
 
 const isTwoLevelsDeep = ({parentPath}) => parentPath.parentPath.parentPath.isObjectProperty();
 const isOneParentProperty = ({parentPath}) => parentPath.parentPath.node.properties?.length === 1;
@@ -78159,13 +78182,19 @@ const isCoupleProperties = ({path, valuePath, property}) => {
 };
 
 objectPattern.ObjectPattern = {
-    print: maybeTypeAnnotation$3((path, {print, maybe, indent}, semantics) => {
+    print: maybeTypeAnnotation$3((path, printer, semantics) => {
         const shouldIndent = isIndent(path);
         const {
             maxPropertiesInOneLine,
             maxPropertiesLengthInOneLine,
         } = semantics;
         
+        const {
+            print,
+            maybe,
+            indent,
+        } = printer;
+        
         maybe.indent.inc(shouldIndent);
         print('{');
         
@@ -78205,9 +78234,7 @@ objectPattern.ObjectPattern = {
             maybe.indent(is);
             maybe.print.breakline(couple);
             
-            maybe.print(computed, '[');
-            print(keyPath);
-            maybe.print(computed, ']');
+            printKey$3(property, printer);
             
             if (!shorthand || wrongShorthand({computed, isAssign, keyPath, valuePath})) {
                 print(':');
@@ -78336,6 +78363,8 @@ var classProperty = {};
 const {exists: exists$8} = is$3;
 const {maybePrintTypeAnnotation: maybePrintTypeAnnotation$2} = maybeTypeAnnotation$4;
 const {maybeDecorators: maybeDecorators$1} = maybeDecorators$4;
+const {printKey: printKey$2} = printKey$7;
+const {printKind: printKind$1} = kind;
 
 const processClassProperty = maybeDecorators$1((path, printer, semantics, {accessor} = {}) => {
     const {node} = path;
@@ -78356,7 +78385,9 @@ const processClassProperty = maybeDecorators$1((path, printer, semantics, {acces
     maybe.print(node.readonly, 'readonly ');
     maybe.print(declare, 'declare ');
     
-    print('__key');
+    printKind$1(path, printer);
+    printKey$2(path, printer);
+    
     maybe.print(optional, '?');
     
     maybePrintTypeAnnotation$2(path, printer);
@@ -81182,9 +81213,10 @@ tryStatements.CatchClause = (path, {print, maybe}) => {
     
     print.space();
     print('catch');
-    print.space();
     
-    if (param.node) {
+    if (!param.node) {
+        print.space();
+    } else {
         print('(');
         print(param);
         print(')');
@@ -82493,23 +82525,15 @@ const {
     isNext: isNext$4,
 } = is$3;
 
+const {printKey: printKey$1} = printKey$7;
+
 tsPropertySignature.TSPropertySignature = (path, printer) => {
-    const {
-        print,
-        maybe,
-        write,
-    } = printer;
+    const {maybe, write} = printer;
     
-    const {
-        computed,
-        optional,
-        readonly,
-    } = path.node;
+    const {optional, readonly} = path.node;
     
     maybe.print(readonly, 'readonly ');
-    maybe.print(computed, '[');
-    print('__key');
-    maybe.print(computed, ']');
+    printKey$1(path, printer);
     maybe.print(optional, '?');
     
     maybePrintTypeAnnotation$1(path, printer);
@@ -82696,15 +82720,18 @@ tsConstructSignatureDeclaration.TSConstructSignatureDeclaration = (path, printer
 var tsMethodSignature = {};
 
 const {printParams: printParams$1} = params;
-const {printKey} = kind;
+const {printKind} = kind;
 const {
     hasReturnType,
     printReturnType,
 } = printReturnType$5;
 
+const {printKey} = printKey$7;
+
 tsMethodSignature.TSMethodSignature = (path, printer, semantics) => {
     const {write} = printer;
     
+    printKind(path, printer);
     printKey(path, printer);
     printParams$1(path, printer, semantics);
     
@@ -82744,6 +82771,13 @@ tsExportAssignment.TSExportAssignment = {
     },
 };
 
+var tsTypeReference = {};
+
+tsTypeReference.TSTypeReference = (path, {print}) => {
+    print('__typeName');
+    print('__typeParameters');
+};
+
 const {isNext: isNext$1} = is$3;
 const {TSTypeLiteral} = tsTypeLiteral;
 const {TSTypeAliasDeclaration} = tsTypeAliasDeclaration;
@@ -82782,6 +82816,7 @@ const {
 const {maybePrintTypeAnnotation} = maybeTypeAnnotation$4;
 const {TSImportType} = tsImportType;
 const {TSExportAssignment} = tsExportAssignment;
+const {TSTypeReference} = tsTypeReference;
 
 var typescript$1 = {
     TSAsExpression,
@@ -82842,14 +82877,11 @@ var typescript$1 = {
             braceClose: '>',
         });
     },
-    TSTypeReference(path, {print}) {
-        print('__typeName');
-        print('__typeParameters');
-    },
     TSArrayType(path, {print}) {
         print('__elementType');
         print('[]');
     },
+    TSTypeReference,
     TSTypeOperator(path, {write, print}) {
         const {operator} = path.node;
         write(`${operator} `);
@@ -83167,7 +83199,7 @@ jsxText.JSXText = (path, {write, indent}) => {
     const isSpacesOnly = /^\s+$/.test(value);
     const hasNext = isNext(path);
     
-    if (extra?.raw.startsWith('&'))
+    if (extra.raw.includes('&'))
         return write(extra.raw);
     
     if (isSpacesOnly && hasNext) {
@@ -112831,6 +112863,9 @@ function setValues$2({waysTo, values, path}) {
                 continue;
             }
             
+            if (isImportsStr(name) || isExportsStr(name))
+                way = way.replace(/\.0.local$/, '');
+            
             if (isArgsStr(name) || isJSXChildrenStr(name) || isJSXAttributesStr(name))
                 way = way.replace(/\.0$/, '');
             
@@ -112852,12 +112887,16 @@ function setValues$2({waysTo, values, path}) {
                 way = way.replace(BODY_AND_CLASS_REG, '');
             
             const {extra} = jessy(way, node);
-            const valueExtra = values[name].extra;
             
-            values[name].extra = {
-                ...extra,
-                ...valueExtra,
-            };
+            if (extra) {
+                const valueExtra = values[name].extra;
+                
+                values[name].extra = {
+                    ...extra,
+                    ...valueExtra,
+                };
+            }
+            
             nessy(way, values[name], node);
         }
     }