@putout/bundle 3.19.0 → 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;
@@ -9437,7 +9437,7 @@ __export(lib_exports, {
         return tsUndefinedKeyword;
     },
     TSUnionType: function() {
-        return tsUnionType;
+        return tsUnionType$1;
     },
     TSUnknownKeyword: function() {
         return tsUnknownKeyword;
@@ -11171,7 +11171,7 @@ __export(lib_exports, {
         return isJSX;
     },
     isJSXAttribute: function() {
-        return isJSXAttribute$2;
+        return isJSXAttribute$3;
     },
     isJSXClosingElement: function() {
         return isJSXClosingElement;
@@ -11192,7 +11192,7 @@ __export(lib_exports, {
         return isJSXFragment;
     },
     isJSXIdentifier: function() {
-        return isJSXIdentifier$1;
+        return isJSXIdentifier$3;
     },
     isJSXMemberExpression: function() {
         return isJSXMemberExpression;
@@ -12224,7 +12224,7 @@ __export(lib_exports, {
         return tsTypePredicate;
     },
     tsTypeQuery: function() {
-        return tsTypeQuery;
+        return tsTypeQuery$1;
     },
     tsTypeReference: function() {
         return tsTypeReference$1;
@@ -12233,7 +12233,7 @@ __export(lib_exports, {
         return tsUndefinedKeyword;
     },
     tsUnionType: function() {
-        return tsUnionType;
+        return tsUnionType$1;
     },
     tsUnknownKeyword: function() {
         return tsUnknownKeyword;
@@ -14418,7 +14418,7 @@ function isOptionalIndexedAccessType(node, opts) {
     if (node.type !== "OptionalIndexedAccessType") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isJSXAttribute$2(node, opts) {
+function isJSXAttribute$3(node, opts) {
     if (!node) return false;
     if (node.type !== "JSXAttribute") return false;
     return opts == null || shallowEqual(node, opts);
@@ -14448,7 +14448,7 @@ function isJSXSpreadChild(node, opts) {
     if (node.type !== "JSXSpreadChild") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isJSXIdentifier$1(node, opts) {
+function isJSXIdentifier$3(node, opts) {
     if (!node) return false;
     if (node.type !== "JSXIdentifier") return false;
     return opts == null || shallowEqual(node, opts);
@@ -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",
@@ -23458,7 +23458,7 @@ function tsNamedTupleMember$1(label, elementType) {
     validate$4(defs.optional, node, "optional", optional);
     return node;
 }
-function tsUnionType(types2) {
+function tsUnionType$1(types2) {
     var node = {
         type: "TSUnionType",
         types: types2
@@ -25026,7 +25026,7 @@ function createTSUnionType(typeAnnotations) {
     if (flattened.length === 1) {
         return flattened[0];
     } else {
-        return tsUnionType(flattened);
+        return tsUnionType$1(flattened);
     }
 }
 function buildUndefinedNode() {
@@ -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);
@@ -49874,7 +49874,7 @@ function TSNamedTupleMember$1(node) {
     this.space();
     this.print(node.elementType);
 }
-function TSUnionType(node) {
+function TSUnionType$2(node) {
     tsPrintUnionOrIntersectionType(this, node, "|");
 }
 function TSIntersectionType$1(node) {
@@ -50457,10 +50457,10 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     TSTypeParameterDeclaration: TSTypeParameterInstantiation,
     TSTypeParameterInstantiation: TSTypeParameterInstantiation,
     TSTypePredicate: TSTypePredicate,
-    TSTypeQuery: TSTypeQuery,
+    TSTypeQuery: TSTypeQuery$1,
     TSTypeReference: TSTypeReference$1,
     TSUndefinedKeyword: TSUndefinedKeyword,
-    TSUnionType: TSUnionType,
+    TSUnionType: TSUnionType$2,
     TSUnknownKeyword: TSUnknownKeyword,
     TSVoidKeyword: TSVoidKeyword,
     TaggedTemplateExpression: TaggedTemplateExpression$1,
@@ -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;
     
@@ -80040,7 +80041,7 @@ function isParens$5(path) {
 
 var objectProperty = {};
 
-var concatanate$1 = {};
+var concatenate$1 = {};
 
 const {
     isStringLiteral: isStringLiteral$7,
@@ -80055,7 +80056,7 @@ const isStringLike = (a) => {
     return isTemplateLiteral$3(a);
 };
 
-concatanate$1.isConcatenation = (path) => {
+concatenate$1.isConcatenation = (path) => {
     const {parentPath} = path;
     const {operator} = path.node;
     
@@ -80077,7 +80078,7 @@ concatanate$1.isConcatenation = (path) => {
     return isBinaryExpression(left) && isStringLike(right);
 };
 
-concatanate$1.concatanate = (path, {print, indent}) => {
+concatenate$1.concatenate = (path, {print, indent}) => {
     if (!path.parentPath.isBinaryExpression()) {
         indent.inc();
         print.breakline();
@@ -80093,7 +80094,7 @@ concatanate$1.concatanate = (path, {print, indent}) => {
         indent.dec();
 };
 
-const {isConcatenation: isConcatenation$2} = concatanate$1;
+const {isConcatenation: isConcatenation$2} = concatenate$1;
 const {isOneLine} = objectExpression;
 const {printKey: printKey$4} = printKey$7;
 
@@ -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);
@@ -80643,7 +80629,8 @@ const {
     isClassMethod,
     isTemplateLiteral: isTemplateLiteral$2,
     isJSXText: isJSXText$3,
-    isJSXAttribute: isJSXAttribute$1,
+    isJSXAttribute: isJSXAttribute$2,
+    isJSXIdentifier: isJSXIdentifier$2,
     isTSTypeReference: isTSTypeReference$2,
     isTSTypeParameter,
 } = types$q;
@@ -80656,6 +80643,9 @@ function extract$5(node) {
     if (isIdentifier$7(node))
         return node.name;
     
+    if (isJSXIdentifier$2(node))
+        return node.name;
+    
     if (isRegExpLiteral$1(node))
         return node.pattern;
     
@@ -80677,7 +80667,7 @@ function extract$5(node) {
     if (isJSXText$3(node))
         return node.value;
     
-    if (isJSXAttribute$1(node))
+    if (isJSXAttribute$2(node))
         return node.name.name;
     
     if (isClassMethod(node))
@@ -80697,6 +80687,7 @@ function extract$5(node) {
         'RegExpLiteral',
         'ArrayExpression',
         'MemberExpression',
+        'JSXIdentifier',
         'JSXAttribute',
         'JSXText',
         'TSTypeParameter',
@@ -82149,16 +82140,16 @@ maybeSpace$1.maybeSpace = (path, {print}) => {
 };
 
 const {
-    concatanate,
+    concatenate,
     isConcatenation: isConcatenation$1,
-} = concatanate$1;
+} = 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();
@@ -82186,7 +82177,7 @@ const BinaryExpression$1 = {
         }
         
         if (isConcatenation$1(path))
-            return concatanate(path, {
+            return concatenate(path, {
                 print,
                 indent,
                 maybe,
@@ -82210,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 = {};
 
@@ -82660,7 +82642,7 @@ const {hasPrevNewline: hasPrevNewline$2} = mark;
 const {isExportDeclaration: isExportDeclaration$3} = bundle.types;
 const {maybeSpaceAfterKeyword: maybeSpaceAfterKeyword$2} = maybeSpaceAfterKeyword$3;
 
-const {isConcatenation} = concatanate$1;
+const {isConcatenation} = concatenate$1;
 const {parseLeadingComments: parseLeadingComments$2} = comment;
 const {maybeDeclare: maybeDeclare$4} = maybeDeclare$6;
 
@@ -84138,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,
@@ -84618,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, '(');
@@ -84752,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);
@@ -84947,6 +84929,48 @@ tsMethodSignature.TSMethodSignature = (path, printer, semantics) => {
     write.newline();
 };
 
+var tsUnionType = {};
+
+const {maybeParens: maybeParens$2} = maybeParens$c;
+const insideTypeDeclaration = ({parentPath}) => parentPath.isTSTypeAliasDeclaration();
+
+tsUnionType.TSUnionType = maybeParens$2((path, printer, {maxTypesInOneLine}) => {
+    const types = path.get('types');
+    const {length} = types;
+    
+    if (!insideTypeDeclaration(path) || length <= maxTypesInOneLine)
+        printInOneLine(types, printer);
+    else
+        printInCoupleLines(types, printer);
+});
+
+function printInOneLine(types, {traverse, write}) {
+    const n = types.length - 1;
+    
+    for (const [i, type] of types.entries()) {
+        traverse(type);
+        
+        if (i < n) {
+            write.space();
+            write('|');
+            write.space();
+        }
+    }
+}
+
+function printInCoupleLines(types, {traverse, write, indent}) {
+    indent.inc();
+    
+    for (const type of types) {
+        write.breakline();
+        write('|');
+        write.space();
+        traverse(type);
+    }
+    
+    indent.dec();
+}
+
 var tsImportType = {};
 
 const {createImportExpression} = importExpression;
@@ -84982,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');
 });
@@ -85026,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;
@@ -85055,11 +85088,7 @@ const {TSConstructorType} = tsConstructorType;
 const {TSCallSignatureDeclaration} = tsCallSignatureDeclaration;
 const {TSConstructSignatureDeclaration} = tsConstructSignatureDeclaration;
 const {TSMethodSignature} = tsMethodSignature;
-
-const {
-    maybeParenOpen,
-    maybeParenClose,
-} = parens;
+const {TSUnionType} = tsUnionType;
 
 const {maybePrintTypeAnnotation} = maybeTypeAnnotation$4;
 const {TSImportType} = tsImportType;
@@ -85067,6 +85096,7 @@ const {TSExportAssignment} = tsExportAssignment;
 const {TSTypeReference} = tsTypeReference;
 const {TSInferType} = tsInferType;
 const {TSParameterProperty} = tsParameterProperty;
+const {TSTypeQuery} = tsTypeQuery;
 
 var typescript$1 = {
     TSAsExpression,
@@ -85081,6 +85111,8 @@ var typescript$1 = {
     TSModuleBlock,
     TSIntersectionType,
     TSImportType,
+    TSUnionType,
+    TSTypeQuery,
     TSBigIntKeyword(path, {write}) {
         write('bigint');
     },
@@ -85090,10 +85122,6 @@ var typescript$1 = {
     TSSymbolKeyword(path, {write}) {
         write('symbol');
     },
-    TSTypeQuery(path, {print}) {
-        print('typeof ');
-        print('__exprName');
-    },
     TSNeverKeyword(path, {write}) {
         write('never');
     },
@@ -85153,26 +85181,6 @@ var typescript$1 = {
         print(' satisfies ');
         print('__typeAnnotation');
     },
-    TSUnionType(path, printer) {
-        const {traverse, write} = printer;
-        
-        const types = path.get('types');
-        const n = types.length - 1;
-        
-        maybeParenOpen(path, printer);
-        
-        for (const [i, type] of types.entries()) {
-            traverse(type);
-            
-            if (i < n) {
-                write.space();
-                write('|');
-                write.space();
-            }
-        }
-        
-        maybeParenClose(path, printer);
-    },
     TSNumberKeyword(path, {write}) {
         write('number');
     },
@@ -85722,6 +85730,7 @@ function initSemantics(semantics = {}) {
         maxSpecifiersInOneLine: 2,
         maxElementsInOneLine: 5,
         maxVariablesInOneLine: 4,
+        maxTypesInOneLine: 3,
         trailingComma: true,
         encodeSingleQuote: true,
         encodeDoubleQuote: false,
@@ -114820,8 +114829,8 @@ const {
     isExportSpecifier,
     isRegExpLiteral,
     isJSXText: isJSXText$2,
-    isJSXIdentifier,
-    isJSXAttribute,
+    isJSXIdentifier: isJSXIdentifier$1,
+    isJSXAttribute: isJSXAttribute$1,
     isTSTypeReference: isTSTypeReference$1,
     isTSTypeParameterDeclaration,
 } = types$f;
@@ -115002,10 +115011,10 @@ is$2.isJSXChildren = (a) => {
 is$2.isJSXAttributes = (a) => {
     const b = !isArray$6(a) ? a : a[0];
     
-    if (!isJSXAttribute(b))
+    if (!isJSXAttribute$1(b))
         return false;
     
-    return isJSXIdentifier(b.name, {
+    return isJSXIdentifier$1(b.name, {
         name: JSX_ATTRIBUTES,
     });
 };
@@ -115139,7 +115148,7 @@ is$2.isLinkedNode = (a) => {
     if (isJSXText$2(a) && LINKED_NODE.test(a.value))
         return true;
     
-    if (isJSXIdentifier(a) && LINKED_NODE.test(a.name))
+    if (isJSXIdentifier$1(a) && LINKED_NODE.test(a.name))
         return true;
     
     if (isTemplateElement$2(a) && LINKED_NODE.test(a.value.raw))
@@ -115188,6 +115197,7 @@ const {
     isIdentifier: isIdentifier$3,
     isStatement: isStatement$1,
     isJSXElement,
+    isJSXAttribute,
     isStringLiteral: isStringLiteral$3,
     isTemplateLiteral: isTemplateLiteral$1,
     TemplateElement,
@@ -115231,12 +115241,15 @@ function findVarsWays$2(node) {
     
     traverse$7(node, {
         noScope: true,
-        'Identifier|BooleanLiteral|StringLiteral|TemplateElement|RegExpLiteral|JSXText|JSXAttribute|TSTypeReference|TSTypeParameter'(path) {
+        'Identifier|JSXIdentifier|BooleanLiteral|StringLiteral|TemplateElement|RegExpLiteral|JSXText|JSXAttribute|TSTypeReference|TSTypeParameter'(path) {
             if (isInsideTypeReference(path))
                 return;
             
             const {node} = path;
             
+            if (isJSXAttribute(path.parentPath) && path.parentPath.node.name === node)
+                return;
+            
             const way = [];
             const name = extract(node);
             
@@ -115394,13 +115407,14 @@ const {
     isTemplateElement: isTemplateElement$1,
     isTSTypeReference,
     isJSXText: isJSXText$1,
+    isJSXIdentifier,
 } = types$d;
 
 const parseName = (node) => {
     node = node[0] || node;
     const {name, value} = node;
     
-    if (isIdentifier$2(node))
+    if (isIdentifier$2(node) || isJSXIdentifier(node))
         return name;
     
     if (isLiteral(node))
@@ -115414,6 +115428,8 @@ const parseName = (node) => {
     
     if (isJSXText$1(node))
         return node.value;
+    
+    throw Error(`☝️ Looks like type of node '${node.type}' not supported by 'compare -> link -> parseName()'`);
 };
 
 link$1.exports = ({add, value, nodeValue, templateStore}) => {
@@ -115603,7 +115619,9 @@ function compareTemplateElements(node, template) {
 }
 
 function linkNodes(node, template, {add, templateStore}) {
-    if (node && isLinkedNode$1(template) || isLinkedArgs(template) || isLinkedId$1(node, template) || isLinkedBool(node, template))
+    const is = node && (isLinkedNode$1(template) || isLinkedArgs(template) || isLinkedId$1(node, template) || isLinkedBool(node, template));
+    
+    if (is)
         return link({
             add,
             value: template,