prettier 2.0.3 → 2.0.4

package/bin-prettier.js

@@ -50,7 +50,7 @@ var pleaseUpgradeNode = function pleaseUpgradeNode(pkg, opts) {
 };
 
 var name = "prettier";
-var version = "2.0.3";
+var version = "2.0.4";
 var description = "Prettier is an opinionated code formatter";
 var bin = "./bin/prettier.js";
 var repository = "prettier/prettier";
@@ -147,7 +147,7 @@ var devDependencies = {
 	"jest-snapshot-serializer-ansi": "1.0.0",
 	"jest-snapshot-serializer-raw": "1.1.0",
 	"jest-watch-typeahead": "0.5.0",
-	prettier: "2.0.2",
+	prettier: "2.0.3",
 	rimraf: "3.0.2",
 	rollup: "2.3.2",
 	"rollup-plugin-babel": "4.4.0",
@@ -36573,7 +36573,7 @@ function isTypeAnnotationAFunction(node, options) {
   return (node.type === "TypeAnnotation" || node.type === "TSTypeAnnotation") && node.typeAnnotation.type === "FunctionTypeAnnotation" && !node.static && !sameLocStart(node, node.typeAnnotation, options);
 }
 
-const binaryishNodeTypes = new Set(["BinaryExpression", "LogicalExpression", "NGPipeExpression", "TSAsExpression"]);
+const binaryishNodeTypes = new Set(["BinaryExpression", "LogicalExpression", "NGPipeExpression"]);
 
 function isBinaryish(node) {
   return binaryishNodeTypes.has(node.type);
@@ -38389,12 +38389,7 @@ function printPathNoParens(path, options, print, args) {
     case "BinaryExpression":
     case "LogicalExpression":
     case "NGPipeExpression":
-    case "TSAsExpression":
       {
-        const {
-          rightNodeName,
-          operator
-        } = getBinaryishNodeNames(n);
         const parent = path.getParentNode();
         const parentParent = path.getParentNode(1);
         const isInsideParenthesis = n !== parent.body && (parent.type === "IfStatement" || parent.type === "WhileStatement" || parent.type === "SwitchStatement" || parent.type === "DoWhileStatement");
@@ -38429,19 +38424,11 @@ function printPathNoParens(path, options, print, args) {
         // indented accordingly. We should indent sub-expressions where the first case isn't indented.
 
 
-        let shouldNotIndent = parent.type === "ReturnStatement" || parent.type === "ThrowStatement" || parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" || operator !== "|" && parent.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (parent.type === "NGRoot" && options.parser === "__ng_binding" || parent.type === "NGMicrosyntaxExpression" && parentParent.type === "NGMicrosyntax" && parentParent.body.length === 1) || n === parent.body && parent.type === "ArrowFunctionExpression" || n !== parent.body && parent.type === "ForStatement" || parent.type === "ConditionalExpression" && parentParent.type !== "ReturnStatement" && parentParent.type !== "ThrowStatement" && parentParent.type !== "CallExpression" && parentParent.type !== "OptionalCallExpression" || parent.type === "TemplateLiteral";
+        const shouldNotIndent = parent.type === "ReturnStatement" || parent.type === "ThrowStatement" || parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" || n.operator !== "|" && parent.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (parent.type === "NGRoot" && options.parser === "__ng_binding" || parent.type === "NGMicrosyntaxExpression" && parentParent.type === "NGMicrosyntax" && parentParent.body.length === 1) || n === parent.body && parent.type === "ArrowFunctionExpression" || n !== parent.body && parent.type === "ForStatement" || parent.type === "ConditionalExpression" && parentParent.type !== "ReturnStatement" && parentParent.type !== "ThrowStatement" && parentParent.type !== "CallExpression" && parentParent.type !== "OptionalCallExpression" || parent.type === "TemplateLiteral";
+        const shouldIndentIfInlining = parent.type === "AssignmentExpression" || parent.type === "VariableDeclarator" || parent.type === "ClassProperty" || parent.type === "TSAbstractClassProperty" || parent.type === "ClassPrivateProperty" || parent.type === "ObjectProperty" || parent.type === "Property";
+        const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$1(n.operator, n.left.operator);
 
-        if (!shouldNotIndent) {
-          if (shouldInlineLogicalExpression(n)) {
-            const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$1(operator, n.left.operator);
-            shouldNotIndent = !samePrecedenceSubExpression;
-          } else {
-            const shouldIndentIfInlining = parent.type === "AssignmentExpression" || parent.type === "VariableDeclarator" || parent.type === "ClassProperty" || parent.type === "TSAbstractClassProperty" || parent.type === "ClassPrivateProperty" || parent.type === "ObjectProperty" || parent.type === "Property";
-            shouldNotIndent = shouldIndentIfInlining;
-          }
-        }
-
-        if (shouldNotIndent) {
+        if (shouldNotIndent || shouldInlineLogicalExpression(n) && !samePrecedenceSubExpression || !shouldInlineLogicalExpression(n) && shouldIndentIfInlining) {
           return group$2(concat$6(parts));
         }
 
@@ -38457,7 +38444,7 @@ function printPathNoParens(path, options, print, args) {
         //   )
 
 
-        const hasJSX = isJSXNode$1(n[rightNodeName]);
+        const hasJSX = isJSXNode$1(n.right);
         const rest = concat$6(hasJSX ? parts.slice(1, -1) : parts.slice(1));
         const groupId = Symbol("logicalChain-" + ++uid);
         const chain = group$2(concat$6([// Don't include the initial expression in the indentation
@@ -39594,7 +39581,7 @@ function printPathNoParens(path, options, print, args) {
             if (!isSimple) {
               // Breaks at the template element boundaries (${ and }) are preferred to breaking
               // in the middle of a MemberExpression
-              if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || isBinaryish$1(n.expressions[i])) {
+              if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || n.expressions[i].type === "TSAsExpression" || isBinaryish$1(n.expressions[i])) {
                 printed = concat$6([indent$3(concat$6([softline$2, printed])), softline$2]);
               }
             }
@@ -40160,6 +40147,9 @@ function printPathNoParens(path, options, print, args) {
     case "TSVoidKeyword":
       return "void";
 
+    case "TSAsExpression":
+      return concat$6([path.call(print, "expression"), " as ", path.call(print, "typeAnnotation")]);
+
     case "TSArrayType":
       return concat$6([path.call(print, "elementType"), "[]"]);
 
@@ -41809,17 +41799,6 @@ function shouldInlineLogicalExpression(node) {
   }
 
   return false;
-}
-
-function getBinaryishNodeNames(node) {
-  const leftNodeName = node.type === "TSAsExpression" ? "expression" : "left";
-  const rightNodeName = node.type === "TSAsExpression" ? "typeAnnotation" : "right";
-  const operator = node.type === "NGPipeExpression" ? "|" : node.type === "TSAsExpression" ? "as" : node.operator;
-  return {
-    leftNodeName,
-    rightNodeName,
-    operator
-  };
 } // For binary expressions to be consistent, we need to group
 // subsequent operators with the same precedence level under a single
 // group. Otherwise they will be nested such that some of them break
@@ -41832,14 +41811,10 @@ function getBinaryishNodeNames(node) {
 
 function printBinaryishExpressions(path, print, options, isNested, isInsideParenthesis) {
   let parts = [];
-  const node = path.getValue(); // We treat BinaryExpression, LogicalExpression, NGPipeExpression and TSAsExpression the same.
+  const node = path.getValue(); // We treat BinaryExpression and LogicalExpression nodes the same.
 
   if (isBinaryish$1(node)) {
-    const {
-      leftNodeName,
-      rightNodeName,
-      operator
-    } = getBinaryishNodeNames(node); // Put all operators with the same precedence level in the same
+    // Put all operators with the same precedence level in the same
     // group. The reason we only need to do this with the `left`
     // expression is because given an expression like `1 + 2 - 3`, it
     // is always parsed like `((1 + 2) - 3)`, meaning the `left` side
@@ -41848,24 +41823,24 @@ function printBinaryishExpressions(path, print, options, isNested, isInsideParen
     // precedence level and should be treated as a separate group, so
     // print them normally. (This doesn't hold for the `**` operator,
     // which is unique in that it is right-associative.)
-
-    if (node.type === "NGPipeExpression" || node.type !== "TSAsExpression" && shouldFlatten$1(operator, node[leftNodeName].operator)) {
+    if (shouldFlatten$1(node.operator, node.left.operator)) {
       // Flatten them out by recursively calling this function.
       parts = parts.concat(path.call(left => printBinaryishExpressions(left, print, options,
       /* isNested */
-      true, isInsideParenthesis), leftNodeName));
+      true, isInsideParenthesis), "left"));
     } else {
-      parts.push(path.call(print, leftNodeName));
+      parts.push(path.call(print, "left"));
     }
 
     const shouldInline = shouldInlineLogicalExpression(node);
-    const lineBeforeOperator = (operator === "|>" || node.type === "NGPipeExpression" || operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node[rightNodeName], options);
+    const lineBeforeOperator = (node.operator === "|>" || node.type === "NGPipeExpression" || node.operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node.right, options);
+    const operator = node.type === "NGPipeExpression" ? "|" : node.operator;
     const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length !== 0 ? group$2(indent$3(concat$6([softline$2, ": ", join$4(concat$6([softline$2, ":", ifBreak$1(" ")]), path.map(print, "arguments").map(arg => align$1(2, group$2(arg))))]))) : "";
-    const right = shouldInline ? concat$6([operator, " ", path.call(print, rightNodeName), rightSuffix]) : concat$6([lineBeforeOperator ? softline$2 : "", operator, lineBeforeOperator ? " " : line$4, path.call(print, rightNodeName), rightSuffix]); // If there's only a single binary expression, we want to create a group
+    const right = shouldInline ? concat$6([operator, " ", path.call(print, "right"), rightSuffix]) : concat$6([lineBeforeOperator ? softline$2 : "", operator, lineBeforeOperator ? " " : line$4, path.call(print, "right"), rightSuffix]); // If there's only a single binary expression, we want to create a group
     // in order to avoid having a small right part like -1 be on its own line.
 
     const parent = path.getParentNode();
-    const shouldGroup = !(isInsideParenthesis && node.type === "LogicalExpression") && parent.type !== node.type && node[leftNodeName].type !== node.type && node[rightNodeName].type !== node.type;
+    const shouldGroup = !(isInsideParenthesis && node.type === "LogicalExpression") && parent.type !== node.type && node.left.type !== node.type && node.right.type !== node.type;
     parts.push(" ", shouldGroup ? group$2(right) : right); // The root comments are already printed, but we need to manually print
     // the other ones since we don't call the normal print on BinaryExpression,
     // only for the left and right parts

package/index.js

@@ -12,7 +12,7 @@ var stream$5 = _interopDefault(require('stream'));
 var events = _interopDefault(require('events'));
 
 var name = "prettier";
-var version = "2.0.3";
+var version = "2.0.4";
 var description = "Prettier is an opinionated code formatter";
 var bin = "./bin/prettier.js";
 var repository = "prettier/prettier";
@@ -109,7 +109,7 @@ var devDependencies = {
 	"jest-snapshot-serializer-ansi": "1.0.0",
 	"jest-snapshot-serializer-raw": "1.1.0",
 	"jest-watch-typeahead": "0.5.0",
-	prettier: "2.0.2",
+	prettier: "2.0.3",
 	rimraf: "3.0.2",
 	rollup: "2.3.2",
 	"rollup-plugin-babel": "4.4.0",
@@ -36531,7 +36531,7 @@ function isTypeAnnotationAFunction(node, options) {
   return (node.type === "TypeAnnotation" || node.type === "TSTypeAnnotation") && node.typeAnnotation.type === "FunctionTypeAnnotation" && !node.static && !sameLocStart(node, node.typeAnnotation, options);
 }
 
-const binaryishNodeTypes = new Set(["BinaryExpression", "LogicalExpression", "NGPipeExpression", "TSAsExpression"]);
+const binaryishNodeTypes = new Set(["BinaryExpression", "LogicalExpression", "NGPipeExpression"]);
 
 function isBinaryish(node) {
   return binaryishNodeTypes.has(node.type);
@@ -38347,12 +38347,7 @@ function printPathNoParens(path, options, print, args) {
     case "BinaryExpression":
     case "LogicalExpression":
     case "NGPipeExpression":
-    case "TSAsExpression":
       {
-        const {
-          rightNodeName,
-          operator
-        } = getBinaryishNodeNames(n);
         const parent = path.getParentNode();
         const parentParent = path.getParentNode(1);
         const isInsideParenthesis = n !== parent.body && (parent.type === "IfStatement" || parent.type === "WhileStatement" || parent.type === "SwitchStatement" || parent.type === "DoWhileStatement");
@@ -38387,19 +38382,11 @@ function printPathNoParens(path, options, print, args) {
         // indented accordingly. We should indent sub-expressions where the first case isn't indented.
 
 
-        let shouldNotIndent = parent.type === "ReturnStatement" || parent.type === "ThrowStatement" || parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" || operator !== "|" && parent.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (parent.type === "NGRoot" && options.parser === "__ng_binding" || parent.type === "NGMicrosyntaxExpression" && parentParent.type === "NGMicrosyntax" && parentParent.body.length === 1) || n === parent.body && parent.type === "ArrowFunctionExpression" || n !== parent.body && parent.type === "ForStatement" || parent.type === "ConditionalExpression" && parentParent.type !== "ReturnStatement" && parentParent.type !== "ThrowStatement" && parentParent.type !== "CallExpression" && parentParent.type !== "OptionalCallExpression" || parent.type === "TemplateLiteral";
+        const shouldNotIndent = parent.type === "ReturnStatement" || parent.type === "ThrowStatement" || parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" || n.operator !== "|" && parent.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (parent.type === "NGRoot" && options.parser === "__ng_binding" || parent.type === "NGMicrosyntaxExpression" && parentParent.type === "NGMicrosyntax" && parentParent.body.length === 1) || n === parent.body && parent.type === "ArrowFunctionExpression" || n !== parent.body && parent.type === "ForStatement" || parent.type === "ConditionalExpression" && parentParent.type !== "ReturnStatement" && parentParent.type !== "ThrowStatement" && parentParent.type !== "CallExpression" && parentParent.type !== "OptionalCallExpression" || parent.type === "TemplateLiteral";
+        const shouldIndentIfInlining = parent.type === "AssignmentExpression" || parent.type === "VariableDeclarator" || parent.type === "ClassProperty" || parent.type === "TSAbstractClassProperty" || parent.type === "ClassPrivateProperty" || parent.type === "ObjectProperty" || parent.type === "Property";
+        const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$1(n.operator, n.left.operator);
 
-        if (!shouldNotIndent) {
-          if (shouldInlineLogicalExpression(n)) {
-            const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$1(operator, n.left.operator);
-            shouldNotIndent = !samePrecedenceSubExpression;
-          } else {
-            const shouldIndentIfInlining = parent.type === "AssignmentExpression" || parent.type === "VariableDeclarator" || parent.type === "ClassProperty" || parent.type === "TSAbstractClassProperty" || parent.type === "ClassPrivateProperty" || parent.type === "ObjectProperty" || parent.type === "Property";
-            shouldNotIndent = shouldIndentIfInlining;
-          }
-        }
-
-        if (shouldNotIndent) {
+        if (shouldNotIndent || shouldInlineLogicalExpression(n) && !samePrecedenceSubExpression || !shouldInlineLogicalExpression(n) && shouldIndentIfInlining) {
           return group$2(concat$6(parts));
         }
 
@@ -38415,7 +38402,7 @@ function printPathNoParens(path, options, print, args) {
         //   )
 
 
-        const hasJSX = isJSXNode$1(n[rightNodeName]);
+        const hasJSX = isJSXNode$1(n.right);
         const rest = concat$6(hasJSX ? parts.slice(1, -1) : parts.slice(1));
         const groupId = Symbol("logicalChain-" + ++uid);
         const chain = group$2(concat$6([// Don't include the initial expression in the indentation
@@ -39552,7 +39539,7 @@ function printPathNoParens(path, options, print, args) {
             if (!isSimple) {
               // Breaks at the template element boundaries (${ and }) are preferred to breaking
               // in the middle of a MemberExpression
-              if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || isBinaryish$1(n.expressions[i])) {
+              if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || n.expressions[i].type === "TSAsExpression" || isBinaryish$1(n.expressions[i])) {
                 printed = concat$6([indent$3(concat$6([softline$2, printed])), softline$2]);
               }
             }
@@ -40118,6 +40105,9 @@ function printPathNoParens(path, options, print, args) {
     case "TSVoidKeyword":
       return "void";
 
+    case "TSAsExpression":
+      return concat$6([path.call(print, "expression"), " as ", path.call(print, "typeAnnotation")]);
+
     case "TSArrayType":
       return concat$6([path.call(print, "elementType"), "[]"]);
 
@@ -41767,17 +41757,6 @@ function shouldInlineLogicalExpression(node) {
   }
 
   return false;
-}
-
-function getBinaryishNodeNames(node) {
-  const leftNodeName = node.type === "TSAsExpression" ? "expression" : "left";
-  const rightNodeName = node.type === "TSAsExpression" ? "typeAnnotation" : "right";
-  const operator = node.type === "NGPipeExpression" ? "|" : node.type === "TSAsExpression" ? "as" : node.operator;
-  return {
-    leftNodeName,
-    rightNodeName,
-    operator
-  };
 } // For binary expressions to be consistent, we need to group
 // subsequent operators with the same precedence level under a single
 // group. Otherwise they will be nested such that some of them break
@@ -41790,14 +41769,10 @@ function getBinaryishNodeNames(node) {
 
 function printBinaryishExpressions(path, print, options, isNested, isInsideParenthesis) {
   let parts = [];
-  const node = path.getValue(); // We treat BinaryExpression, LogicalExpression, NGPipeExpression and TSAsExpression the same.
+  const node = path.getValue(); // We treat BinaryExpression and LogicalExpression nodes the same.
 
   if (isBinaryish$1(node)) {
-    const {
-      leftNodeName,
-      rightNodeName,
-      operator
-    } = getBinaryishNodeNames(node); // Put all operators with the same precedence level in the same
+    // Put all operators with the same precedence level in the same
     // group. The reason we only need to do this with the `left`
     // expression is because given an expression like `1 + 2 - 3`, it
     // is always parsed like `((1 + 2) - 3)`, meaning the `left` side
@@ -41806,24 +41781,24 @@ function printBinaryishExpressions(path, print, options, isNested, isInsideParen
     // precedence level and should be treated as a separate group, so
     // print them normally. (This doesn't hold for the `**` operator,
     // which is unique in that it is right-associative.)
-
-    if (node.type === "NGPipeExpression" || node.type !== "TSAsExpression" && shouldFlatten$1(operator, node[leftNodeName].operator)) {
+    if (shouldFlatten$1(node.operator, node.left.operator)) {
       // Flatten them out by recursively calling this function.
       parts = parts.concat(path.call(left => printBinaryishExpressions(left, print, options,
       /* isNested */
-      true, isInsideParenthesis), leftNodeName));
+      true, isInsideParenthesis), "left"));
     } else {
-      parts.push(path.call(print, leftNodeName));
+      parts.push(path.call(print, "left"));
     }
 
     const shouldInline = shouldInlineLogicalExpression(node);
-    const lineBeforeOperator = (operator === "|>" || node.type === "NGPipeExpression" || operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node[rightNodeName], options);
+    const lineBeforeOperator = (node.operator === "|>" || node.type === "NGPipeExpression" || node.operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node.right, options);
+    const operator = node.type === "NGPipeExpression" ? "|" : node.operator;
     const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length !== 0 ? group$2(indent$3(concat$6([softline$2, ": ", join$4(concat$6([softline$2, ":", ifBreak$1(" ")]), path.map(print, "arguments").map(arg => align$1(2, group$2(arg))))]))) : "";
-    const right = shouldInline ? concat$6([operator, " ", path.call(print, rightNodeName), rightSuffix]) : concat$6([lineBeforeOperator ? softline$2 : "", operator, lineBeforeOperator ? " " : line$4, path.call(print, rightNodeName), rightSuffix]); // If there's only a single binary expression, we want to create a group
+    const right = shouldInline ? concat$6([operator, " ", path.call(print, "right"), rightSuffix]) : concat$6([lineBeforeOperator ? softline$2 : "", operator, lineBeforeOperator ? " " : line$4, path.call(print, "right"), rightSuffix]); // If there's only a single binary expression, we want to create a group
     // in order to avoid having a small right part like -1 be on its own line.
 
     const parent = path.getParentNode();
-    const shouldGroup = !(isInsideParenthesis && node.type === "LogicalExpression") && parent.type !== node.type && node[leftNodeName].type !== node.type && node[rightNodeName].type !== node.type;
+    const shouldGroup = !(isInsideParenthesis && node.type === "LogicalExpression") && parent.type !== node.type && node.left.type !== node.type && node.right.type !== node.type;
     parts.push(" ", shouldGroup ? group$2(right) : right); // The root comments are already printed, but we need to manually print
     // the other ones since we don't call the normal print on BinaryExpression,
     // only for the left and right parts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prettier",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Prettier is an opinionated code formatter",
   "bin": "./bin-prettier.js",
   "repository": "prettier/prettier",

package/standalone.js

@@ -5,7 +5,7 @@
 }(this, (function () { 'use strict';
 
   var name = "prettier";
-  var version = "2.0.3";
+  var version = "2.0.4";
   var description = "Prettier is an opinionated code formatter";
   var bin = "./bin/prettier.js";
   var repository = "prettier/prettier";
@@ -102,7 +102,7 @@
   	"jest-snapshot-serializer-ansi": "1.0.0",
   	"jest-snapshot-serializer-raw": "1.1.0",
   	"jest-watch-typeahead": "0.5.0",
-  	prettier: "2.0.2",
+  	prettier: "2.0.3",
   	rimraf: "3.0.2",
   	rollup: "2.3.2",
   	"rollup-plugin-babel": "4.4.0",
@@ -24640,7 +24640,7 @@
     return (node.type === "TypeAnnotation" || node.type === "TSTypeAnnotation") && node.typeAnnotation.type === "FunctionTypeAnnotation" && !node.static && !sameLocStart(node, node.typeAnnotation, options);
   }
 
-  const binaryishNodeTypes = new Set(["BinaryExpression", "LogicalExpression", "NGPipeExpression", "TSAsExpression"]);
+  const binaryishNodeTypes = new Set(["BinaryExpression", "LogicalExpression", "NGPipeExpression"]);
 
   function isBinaryish(node) {
     return binaryishNodeTypes.has(node.type);
@@ -26456,12 +26456,7 @@
       case "BinaryExpression":
       case "LogicalExpression":
       case "NGPipeExpression":
-      case "TSAsExpression":
         {
-          const {
-            rightNodeName,
-            operator
-          } = getBinaryishNodeNames(n);
           const parent = path.getParentNode();
           const parentParent = path.getParentNode(1);
           const isInsideParenthesis = n !== parent.body && (parent.type === "IfStatement" || parent.type === "WhileStatement" || parent.type === "SwitchStatement" || parent.type === "DoWhileStatement");
@@ -26496,19 +26491,11 @@
           // indented accordingly. We should indent sub-expressions where the first case isn't indented.
 
 
-          let shouldNotIndent = parent.type === "ReturnStatement" || parent.type === "ThrowStatement" || parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" || operator !== "|" && parent.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (parent.type === "NGRoot" && options.parser === "__ng_binding" || parent.type === "NGMicrosyntaxExpression" && parentParent.type === "NGMicrosyntax" && parentParent.body.length === 1) || n === parent.body && parent.type === "ArrowFunctionExpression" || n !== parent.body && parent.type === "ForStatement" || parent.type === "ConditionalExpression" && parentParent.type !== "ReturnStatement" && parentParent.type !== "ThrowStatement" && parentParent.type !== "CallExpression" && parentParent.type !== "OptionalCallExpression" || parent.type === "TemplateLiteral";
+          const shouldNotIndent = parent.type === "ReturnStatement" || parent.type === "ThrowStatement" || parent.type === "JSXExpressionContainer" && parentParent.type === "JSXAttribute" || n.operator !== "|" && parent.type === "JsExpressionRoot" || n.type !== "NGPipeExpression" && (parent.type === "NGRoot" && options.parser === "__ng_binding" || parent.type === "NGMicrosyntaxExpression" && parentParent.type === "NGMicrosyntax" && parentParent.body.length === 1) || n === parent.body && parent.type === "ArrowFunctionExpression" || n !== parent.body && parent.type === "ForStatement" || parent.type === "ConditionalExpression" && parentParent.type !== "ReturnStatement" && parentParent.type !== "ThrowStatement" && parentParent.type !== "CallExpression" && parentParent.type !== "OptionalCallExpression" || parent.type === "TemplateLiteral";
+          const shouldIndentIfInlining = parent.type === "AssignmentExpression" || parent.type === "VariableDeclarator" || parent.type === "ClassProperty" || parent.type === "TSAbstractClassProperty" || parent.type === "ClassPrivateProperty" || parent.type === "ObjectProperty" || parent.type === "Property";
+          const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$1(n.operator, n.left.operator);
 
-          if (!shouldNotIndent) {
-            if (shouldInlineLogicalExpression(n)) {
-              const samePrecedenceSubExpression = isBinaryish$1(n.left) && shouldFlatten$1(operator, n.left.operator);
-              shouldNotIndent = !samePrecedenceSubExpression;
-            } else {
-              const shouldIndentIfInlining = parent.type === "AssignmentExpression" || parent.type === "VariableDeclarator" || parent.type === "ClassProperty" || parent.type === "TSAbstractClassProperty" || parent.type === "ClassPrivateProperty" || parent.type === "ObjectProperty" || parent.type === "Property";
-              shouldNotIndent = shouldIndentIfInlining;
-            }
-          }
-
-          if (shouldNotIndent) {
+          if (shouldNotIndent || shouldInlineLogicalExpression(n) && !samePrecedenceSubExpression || !shouldInlineLogicalExpression(n) && shouldIndentIfInlining) {
             return group$b(concat$d(parts));
           }
 
@@ -26524,7 +26511,7 @@
           //   )
 
 
-          const hasJSX = isJSXNode$1(n[rightNodeName]);
+          const hasJSX = isJSXNode$1(n.right);
           const rest = concat$d(hasJSX ? parts.slice(1, -1) : parts.slice(1));
           const groupId = Symbol("logicalChain-" + ++uid);
           const chain = group$b(concat$d([// Don't include the initial expression in the indentation
@@ -27661,7 +27648,7 @@
               if (!isSimple) {
                 // Breaks at the template element boundaries (${ and }) are preferred to breaking
                 // in the middle of a MemberExpression
-                if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || isBinaryish$1(n.expressions[i])) {
+                if (n.expressions[i].comments && n.expressions[i].comments.length || n.expressions[i].type === "MemberExpression" || n.expressions[i].type === "OptionalMemberExpression" || n.expressions[i].type === "ConditionalExpression" || n.expressions[i].type === "SequenceExpression" || n.expressions[i].type === "TSAsExpression" || isBinaryish$1(n.expressions[i])) {
                   printed = concat$d([indent$7(concat$d([softline$6, printed])), softline$6]);
                 }
               }
@@ -28227,6 +28214,9 @@
       case "TSVoidKeyword":
         return "void";
 
+      case "TSAsExpression":
+        return concat$d([path.call(print, "expression"), " as ", path.call(print, "typeAnnotation")]);
+
       case "TSArrayType":
         return concat$d([path.call(print, "elementType"), "[]"]);
 
@@ -29876,17 +29866,6 @@
     }
 
     return false;
-  }
-
-  function getBinaryishNodeNames(node) {
-    const leftNodeName = node.type === "TSAsExpression" ? "expression" : "left";
-    const rightNodeName = node.type === "TSAsExpression" ? "typeAnnotation" : "right";
-    const operator = node.type === "NGPipeExpression" ? "|" : node.type === "TSAsExpression" ? "as" : node.operator;
-    return {
-      leftNodeName,
-      rightNodeName,
-      operator
-    };
   } // For binary expressions to be consistent, we need to group
   // subsequent operators with the same precedence level under a single
   // group. Otherwise they will be nested such that some of them break
@@ -29899,14 +29878,10 @@
 
   function printBinaryishExpressions(path, print, options, isNested, isInsideParenthesis) {
     let parts = [];
-    const node = path.getValue(); // We treat BinaryExpression, LogicalExpression, NGPipeExpression and TSAsExpression the same.
+    const node = path.getValue(); // We treat BinaryExpression and LogicalExpression nodes the same.
 
     if (isBinaryish$1(node)) {
-      const {
-        leftNodeName,
-        rightNodeName,
-        operator
-      } = getBinaryishNodeNames(node); // Put all operators with the same precedence level in the same
+      // Put all operators with the same precedence level in the same
       // group. The reason we only need to do this with the `left`
       // expression is because given an expression like `1 + 2 - 3`, it
       // is always parsed like `((1 + 2) - 3)`, meaning the `left` side
@@ -29915,24 +29890,24 @@
       // precedence level and should be treated as a separate group, so
       // print them normally. (This doesn't hold for the `**` operator,
       // which is unique in that it is right-associative.)
-
-      if (node.type === "NGPipeExpression" || node.type !== "TSAsExpression" && shouldFlatten$1(operator, node[leftNodeName].operator)) {
+      if (shouldFlatten$1(node.operator, node.left.operator)) {
         // Flatten them out by recursively calling this function.
         parts = parts.concat(path.call(left => printBinaryishExpressions(left, print, options,
         /* isNested */
-        true, isInsideParenthesis), leftNodeName));
+        true, isInsideParenthesis), "left"));
       } else {
-        parts.push(path.call(print, leftNodeName));
+        parts.push(path.call(print, "left"));
       }
 
       const shouldInline = shouldInlineLogicalExpression(node);
-      const lineBeforeOperator = (operator === "|>" || node.type === "NGPipeExpression" || operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node[rightNodeName], options);
+      const lineBeforeOperator = (node.operator === "|>" || node.type === "NGPipeExpression" || node.operator === "|" && options.parser === "__vue_expression") && !hasLeadingOwnLineComment$1(options.originalText, node.right, options);
+      const operator = node.type === "NGPipeExpression" ? "|" : node.operator;
       const rightSuffix = node.type === "NGPipeExpression" && node.arguments.length !== 0 ? group$b(indent$7(concat$d([softline$6, ": ", join$9(concat$d([softline$6, ":", ifBreak$6(" ")]), path.map(print, "arguments").map(arg => align$1(2, group$b(arg))))]))) : "";
-      const right = shouldInline ? concat$d([operator, " ", path.call(print, rightNodeName), rightSuffix]) : concat$d([lineBeforeOperator ? softline$6 : "", operator, lineBeforeOperator ? " " : line$9, path.call(print, rightNodeName), rightSuffix]); // If there's only a single binary expression, we want to create a group
+      const right = shouldInline ? concat$d([operator, " ", path.call(print, "right"), rightSuffix]) : concat$d([lineBeforeOperator ? softline$6 : "", operator, lineBeforeOperator ? " " : line$9, path.call(print, "right"), rightSuffix]); // If there's only a single binary expression, we want to create a group
       // in order to avoid having a small right part like -1 be on its own line.
 
       const parent = path.getParentNode();
-      const shouldGroup = !(isInsideParenthesis && node.type === "LogicalExpression") && parent.type !== node.type && node[leftNodeName].type !== node.type && node[rightNodeName].type !== node.type;
+      const shouldGroup = !(isInsideParenthesis && node.type === "LogicalExpression") && parent.type !== node.type && node.left.type !== node.type && node.right.type !== node.type;
       parts.push(" ", shouldGroup ? group$b(right) : right); // The root comments are already printed, but we need to manually print
       // the other ones since we don't call the normal print on BinaryExpression,
       // only for the left and right parts