prettier-plugin-java 2.5.0 → 2.6.0

package/dist/printers/printer-utils.js

@@ -1,42 +1,16 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printArrayList = exports.isUniqueMethodInvocation = exports.sortImports = exports.isStatementEmptyStatement = exports.binary = exports.putIntoBraces = exports.getInterfaceBodyDeclarationsSeparator = exports.getClassBodyDeclarationsSeparator = exports.getBlankLinesSeparator = exports.isExplicitLambdaParameter = exports.displaySemicolon = exports.findDeepElementInPartsArray = exports.sortModifiers = exports.sortClassTypeChildren = exports.matchCategory = exports.sortNodes = exports.sortTokens = exports.sortAnnotationIdentifier = exports.rejectAndConcat = exports.rejectAndJoin = exports.rejectSeparators = exports.reject = exports.rejectAndJoinSeps = exports.buildFqn = void 0;
-var findIndex_1 = __importDefault(require("lodash/findIndex"));
-var findLastIndex_1 = __importDefault(require("lodash/findLastIndex"));
-var forEach_1 = __importDefault(require("lodash/forEach"));
-var forEachRight_1 = __importDefault(require("lodash/forEachRight"));
-var includes_1 = __importDefault(require("lodash/includes"));
-var doc_1 = require("prettier/doc");
-var utils_1 = require("../types/utils");
-var utils_2 = require("../utils");
-var comments_utils_1 = require("./comments/comments-utils");
-var format_comments_1 = require("./comments/format-comments");
-var prettier_builder_1 = require("./prettier-builder");
-var indent = doc_1.builders.indent, hardline = doc_1.builders.hardline, line = doc_1.builders.line;
-var orderedModifiers = [
+import findIndex from "lodash/findIndex.js";
+import findLastIndex from "lodash/findLastIndex.js";
+import forEach from "lodash/forEach.js";
+import forEachRight from "lodash/forEachRight.js";
+import includes from "lodash/includes.js";
+import { builders } from "prettier/doc";
+import { isCstNode } from "../types/utils.js";
+import { isEmptyDoc } from "../utils/index.js";
+import { hasComments, hasLeadingComments, hasTrailingComments } from "./comments/comments-utils.js";
+import { getTokenLeadingComments, printTokenWithComments } from "./comments/format-comments.js";
+import { concat, group, ifBreak, indentIfBreak, join } from "./prettier-builder.js";
+const { indent, hardline, line } = builders;
+const orderedModifiers = [
     "Public",
     "Protected",
     "Private",
@@ -52,28 +26,26 @@ var orderedModifiers = [
     "NonSealed",
     "Strictfp"
 ];
-function buildFqn(tokens, dots) {
+export function buildFqn(tokens, dots) {
     return rejectAndJoinSeps(dots ? dots : [], tokens);
 }
-exports.buildFqn = buildFqn;
-function rejectAndJoinSeps(sepTokens, elems, sep) {
+export function rejectAndJoinSeps(sepTokens, elems, sep) {
     if (!Array.isArray(sepTokens)) {
         return rejectAndJoin(sepTokens, elems);
     }
-    var actualElements = reject(elems);
-    var res = [];
-    for (var i = 0; i < sepTokens.length; i++) {
+    const actualElements = reject(elems);
+    const res = [];
+    for (let i = 0; i < sepTokens.length; i++) {
         res.push(actualElements[i], sepTokens[i]);
         if (sep) {
             res.push(sep);
         }
     }
-    res.push.apply(res, actualElements.slice(sepTokens.length));
-    return (0, prettier_builder_1.concat)(res);
+    res.push(...actualElements.slice(sepTokens.length));
+    return concat(res);
 }
-exports.rejectAndJoinSeps = rejectAndJoinSeps;
-function reject(elems) {
-    return elems.filter(function (item) {
+export function reject(elems) {
+    return elems.filter(item => {
         if (typeof item === "string") {
             return item !== "";
         }
@@ -82,95 +54,87 @@ function reject(elems) {
         return item != false && item !== undefined;
     });
 }
-exports.reject = reject;
-function rejectSeparators(separators, elems) {
-    var realElements = reject(elems);
-    var realSeparators = [];
-    for (var i = 0; i < realElements.length - 1; i++) {
+export function rejectSeparators(separators, elems) {
+    const realElements = reject(elems);
+    const realSeparators = [];
+    for (let i = 0; i < realElements.length - 1; i++) {
         if (realElements[i] !== "") {
             realSeparators.push(separators[i]);
         }
     }
     return realSeparators;
 }
-exports.rejectSeparators = rejectSeparators;
-function rejectAndJoin(sep, elems) {
-    var actualElements = reject(elems);
-    return (0, prettier_builder_1.join)(sep, actualElements);
+export function rejectAndJoin(sep, elems) {
+    const actualElements = reject(elems);
+    return join(sep, actualElements);
 }
-exports.rejectAndJoin = rejectAndJoin;
-function rejectAndConcat(elems) {
-    var actualElements = reject(elems);
-    return (0, prettier_builder_1.concat)(actualElements);
+export function rejectAndConcat(elems) {
+    const actualElements = reject(elems);
+    return concat(actualElements);
 }
-exports.rejectAndConcat = rejectAndConcat;
-function sortAnnotationIdentifier(annotations, identifiers) {
-    var tokens = __spreadArray([], identifiers, true);
+export function sortAnnotationIdentifier(annotations, identifiers) {
+    let tokens = [...identifiers];
     if (annotations && annotations.length > 0) {
-        tokens = __spreadArray(__spreadArray([], tokens, true), annotations, true);
+        tokens = [...tokens, ...annotations];
     }
-    return tokens.sort(function (a, b) {
-        var startOffset1 = (0, utils_1.isCstNode)(a)
+    return tokens.sort((a, b) => {
+        const startOffset1 = isCstNode(a)
             ? a.children.At[0].startOffset
             : a.startOffset;
-        var startOffset2 = (0, utils_1.isCstNode)(b)
+        const startOffset2 = isCstNode(b)
             ? b.children.At[0].startOffset
             : b.startOffset;
         return startOffset1 - startOffset2;
     });
 }
-exports.sortAnnotationIdentifier = sortAnnotationIdentifier;
-function sortTokens(values) {
-    var tokens = [];
-    (0, forEach_1.default)(values, function (argument) {
+export function sortTokens(values) {
+    let tokens = [];
+    forEach(values, argument => {
         if (argument) {
             tokens = tokens.concat(argument);
         }
     });
-    return tokens.sort(function (a, b) {
+    return tokens.sort((a, b) => {
         return a.startOffset - b.startOffset;
     });
 }
-exports.sortTokens = sortTokens;
-function sortNodes(values) {
-    var nodes = [];
-    (0, forEach_1.default)(values, function (argument) {
+export function sortNodes(values) {
+    let nodes = [];
+    forEach(values, argument => {
         if (argument) {
             nodes = nodes.concat(argument);
         }
     });
-    return nodes.sort(function (a, b) {
-        var aOffset = a.location.startOffset;
-        var bOffset = b.location.startOffset;
+    return nodes.sort((a, b) => {
+        const aOffset = a.location.startOffset;
+        const bOffset = b.location.startOffset;
         return aOffset - bOffset;
     });
 }
-exports.sortNodes = sortNodes;
-function matchCategory(token, categoryName) {
-    var labels = (token.tokenType.CATEGORIES || []).map(function (category) {
+export function matchCategory(token, categoryName) {
+    const labels = (token.tokenType.CATEGORIES || []).map(category => {
         return category.LABEL;
     });
     return labels.indexOf(categoryName) !== -1;
 }
-exports.matchCategory = matchCategory;
-function sortClassTypeChildren(annotations, typeArguments, identifiers, dots) {
-    var tokens = __spreadArray([], identifiers, true);
+export function sortClassTypeChildren(annotations, typeArguments, identifiers, dots) {
+    let tokens = [...identifiers];
     if (annotations && annotations.length > 0) {
-        tokens = __spreadArray(__spreadArray([], tokens, true), annotations, true);
+        tokens = [...tokens, ...annotations];
     }
     if (typeArguments && typeArguments.length > 0) {
-        tokens = __spreadArray(__spreadArray([], tokens, true), typeArguments, true);
+        tokens = [...tokens, ...typeArguments];
     }
     if (dots && dots.length > 0) {
-        tokens = __spreadArray(__spreadArray([], tokens, true), dots, true);
+        tokens = [...tokens, ...dots];
     }
-    return tokens.sort(function (a, b) {
-        var startOffsetA = (0, utils_1.isCstNode)(a)
+    return tokens.sort((a, b) => {
+        const startOffsetA = isCstNode(a)
             ? a.children.At
                 ? a.children.At[0].startOffset
                 : a.children.Less[0].startOffset
             : a.startOffset;
-        var startOffsetB = (0, utils_1.isCstNode)(b)
+        const startOffsetB = isCstNode(b)
             ? b.children.At
                 ? b.children.At[0].startOffset
                 : b.children.Less[0].startOffset
@@ -178,20 +142,19 @@ function sortClassTypeChildren(annotations, typeArguments, identifiers, dots) {
         return startOffsetA - startOffsetB;
     });
 }
-exports.sortClassTypeChildren = sortClassTypeChildren;
-function sortModifiers(modifiers) {
-    var firstAnnotations = [];
-    var otherModifiers = [];
-    var lastAnnotations = [];
-    var hasOtherModifier = false;
+export function sortModifiers(modifiers) {
+    let firstAnnotations = [];
+    const otherModifiers = [];
+    let lastAnnotations = [];
+    let hasOtherModifier = false;
     /**
      * iterate in reverse order because we special-case
      * type annotations which come after all other
      * modifiers
      */
-    (0, forEachRight_1.default)(modifiers, function (modifier) {
-        var isAnnotation = modifier.children.annotation !== undefined;
-        var isTypeAnnotation = isAnnotation &&
+    forEachRight(modifiers, modifier => {
+        const isAnnotation = modifier.children.annotation !== undefined;
+        const isTypeAnnotation = isAnnotation &&
             (modifier.name === "methodModifier" ||
                 modifier.name === "interfaceMethodModifier" ||
                 modifier.name === "fieldModifier");
@@ -216,27 +179,26 @@ function sortModifiers(modifiers) {
         firstAnnotations = firstAnnotations.concat(lastAnnotations);
         lastAnnotations = [];
     }
-    otherModifiers.sort(function (a, b) {
-        var modifierIndexA = orderedModifiers.indexOf(Object.keys(a.children)[0]);
-        var modifierIndexB = orderedModifiers.indexOf(Object.keys(b.children)[0]);
+    otherModifiers.sort((a, b) => {
+        const modifierIndexA = orderedModifiers.indexOf(Object.keys(a.children)[0]);
+        const modifierIndexB = orderedModifiers.indexOf(Object.keys(b.children)[0]);
         return modifierIndexA - modifierIndexB;
     });
     return [firstAnnotations, otherModifiers.concat(lastAnnotations)];
 }
-exports.sortModifiers = sortModifiers;
-function findDeepElementInPartsArray(item, elt) {
+export function findDeepElementInPartsArray(item, elt) {
     if (Array.isArray(item)) {
-        if ((0, includes_1.default)(item, elt)) {
+        if (includes(item, elt)) {
             return true;
         }
-        for (var i = 0; i < item.length; i++) {
+        for (let i = 0; i < item.length; i++) {
             if (findDeepElementInPartsArray(item[i], elt)) {
                 return true;
             }
         }
     }
     else {
-        for (var key in item) {
+        for (const key in item) {
             if (typeof item[key] === "object" &&
                 findDeepElementInPartsArray(item[key], elt)) {
                 return true;
@@ -245,39 +207,35 @@ function findDeepElementInPartsArray(item, elt) {
     }
     return false;
 }
-exports.findDeepElementInPartsArray = findDeepElementInPartsArray;
-function displaySemicolon(token, params) {
+export function displaySemicolon(token, params) {
     if (params !== undefined && params.allowEmptyStatement) {
-        return (0, format_comments_1.printTokenWithComments)(token);
+        return printTokenWithComments(token);
     }
-    if (!(0, comments_utils_1.hasComments)(token)) {
+    if (!hasComments(token)) {
         return "";
     }
     token.image = "";
-    return (0, format_comments_1.printTokenWithComments)(token);
+    return printTokenWithComments(token);
 }
-exports.displaySemicolon = displaySemicolon;
-function isExplicitLambdaParameter(ctx) {
+export function isExplicitLambdaParameter(ctx) {
     return (ctx &&
         ctx.lambdaParameterList &&
         ctx.lambdaParameterList[0] &&
         ctx.lambdaParameterList[0].children &&
         ctx.lambdaParameterList[0].children.explicitLambdaParameterList);
 }
-exports.isExplicitLambdaParameter = isExplicitLambdaParameter;
-function getBlankLinesSeparator(ctx, separator) {
-    if (separator === void 0) { separator = hardline; }
+export function getBlankLinesSeparator(ctx, separator = hardline) {
     if (ctx === undefined) {
         return [];
     }
-    var separators = [];
-    for (var i = 0; i < ctx.length - 1; i++) {
-        var node = ctx[i];
-        var previousRuleEndLineWithComment = (0, comments_utils_1.hasTrailingComments)(node)
+    const separators = [];
+    for (let i = 0; i < ctx.length - 1; i++) {
+        const node = ctx[i];
+        const previousRuleEndLineWithComment = hasTrailingComments(node)
             ? node.trailingComments[node.trailingComments.length - 1].endLine
             : node.location.endLine;
-        var nextNode = ctx[i + 1];
-        var nextRuleStartLineWithComment = (0, comments_utils_1.hasLeadingComments)(nextNode)
+        const nextNode = ctx[i + 1];
+        const nextRuleStartLineWithComment = hasLeadingComments(nextNode)
             ? nextNode.leadingComments[0].startLine
             : nextNode.location.startLine;
         if (nextRuleStartLineWithComment - previousRuleEndLineWithComment > 1) {
@@ -289,8 +247,7 @@ function getBlankLinesSeparator(ctx, separator) {
     }
     return separators;
 }
-exports.getBlankLinesSeparator = getBlankLinesSeparator;
-var isTwoHardLine = function (userBlankLinesSeparator) {
+const isTwoHardLine = (userBlankLinesSeparator) => {
     if (!Array.isArray(userBlankLinesSeparator)) {
         return false;
     }
@@ -299,28 +256,28 @@ var isTwoHardLine = function (userBlankLinesSeparator) {
         userBlankLinesSeparator[1] === hardline);
 };
 function getDeclarationsSeparator(declarations, needLineDeclaration, isSemicolon) {
-    var declarationsWithoutEmptyStatements = declarations.filter(function (declaration) { return !isSemicolon(declaration); });
-    var userBlankLinesSeparators = getBlankLinesSeparator(declarationsWithoutEmptyStatements);
-    var additionalBlankLines = declarationsWithoutEmptyStatements.map(needLineDeclaration);
-    var separators = [];
-    var indexNextNotEmptyDeclaration = 0;
-    for (var i = 0; i < declarations.length - 1; i++) {
+    const declarationsWithoutEmptyStatements = declarations.filter(declaration => !isSemicolon(declaration));
+    const userBlankLinesSeparators = getBlankLinesSeparator(declarationsWithoutEmptyStatements);
+    const additionalBlankLines = declarationsWithoutEmptyStatements.map(needLineDeclaration);
+    const separators = [];
+    let indexNextNotEmptyDeclaration = 0;
+    for (let i = 0; i < declarations.length - 1; i++) {
         // if the empty statement has comments
         // we want to print them on their own line
         if (isSemicolon(declarations[i])) {
-            if ((0, comments_utils_1.hasComments)(declarations[i])) {
+            if (hasComments(declarations[i])) {
                 separators.push(hardline);
             }
         }
         else if (indexNextNotEmptyDeclaration <
             declarationsWithoutEmptyStatements.length - 1) {
-            var isNextSeparatorTwoHardLine = isTwoHardLine(userBlankLinesSeparators[indexNextNotEmptyDeclaration]);
-            var additionalSep = !isNextSeparatorTwoHardLine &&
+            const isNextSeparatorTwoHardLine = isTwoHardLine(userBlankLinesSeparators[indexNextNotEmptyDeclaration]);
+            const additionalSep = !isNextSeparatorTwoHardLine &&
                 (additionalBlankLines[indexNextNotEmptyDeclaration + 1] ||
                     additionalBlankLines[indexNextNotEmptyDeclaration])
                 ? hardline
                 : "";
-            separators.push((0, prettier_builder_1.concat)([
+            separators.push(concat([
                 userBlankLinesSeparators[indexNextNotEmptyDeclaration],
                 additionalSep
             ]));
@@ -333,9 +290,9 @@ function needLineClassBodyDeclaration(declaration) {
     if (declaration.children.classMemberDeclaration === undefined) {
         return true;
     }
-    var classMemberDeclaration = declaration.children.classMemberDeclaration[0];
+    const classMemberDeclaration = declaration.children.classMemberDeclaration[0];
     if (classMemberDeclaration.children.fieldDeclaration !== undefined) {
-        var fieldDeclaration = classMemberDeclaration.children.fieldDeclaration[0];
+        const fieldDeclaration = classMemberDeclaration.children.fieldDeclaration[0];
         if (fieldDeclaration.children.fieldModifier !== undefined &&
             hasAnnotation(fieldDeclaration.children.fieldModifier) &&
             hasNonTrailingAnnotation(fieldDeclaration.children.fieldModifier)) {
@@ -350,7 +307,7 @@ function needLineClassBodyDeclaration(declaration) {
 }
 function needLineInterfaceMemberDeclaration(declaration) {
     if (declaration.children.constantDeclaration !== undefined) {
-        var constantDeclaration = declaration.children.constantDeclaration[0];
+        const constantDeclaration = declaration.children.constantDeclaration[0];
         if (constantDeclaration.children.constantModifier !== undefined &&
             hasAnnotation(constantDeclaration.children.constantModifier) &&
             hasNonTrailingAnnotation(constantDeclaration.children.constantModifier)) {
@@ -359,7 +316,7 @@ function needLineInterfaceMemberDeclaration(declaration) {
         return false;
     }
     else if (declaration.children.interfaceMethodDeclaration !== undefined) {
-        var interfaceMethodDeclaration = declaration.children.interfaceMethodDeclaration[0];
+        const interfaceMethodDeclaration = declaration.children.interfaceMethodDeclaration[0];
         if (interfaceMethodDeclaration.children.interfaceMethodModifier !==
             undefined &&
             hasNonTrailingAnnotation(interfaceMethodDeclaration.children.interfaceMethodModifier)) {
@@ -382,7 +339,7 @@ function isInterfaceMemberASemicolon(interfaceMemberDeclaration) {
     return interfaceMemberDeclaration.children.Semicolon !== undefined;
 }
 function hasAnnotation(modifiers) {
-    return modifiers.some(function (modifier) { return modifier.children.annotation !== undefined; });
+    return modifiers.some(modifier => modifier.children.annotation !== undefined);
 }
 /**
  * Return true if there is a modifier that does not come after all other modifiers
@@ -392,83 +349,80 @@ function hasAnnotation(modifiers) {
  * @returns {boolean}
  */
 function hasNonTrailingAnnotation(modifiers) {
-    var firstAnnotationIndex = (0, findIndex_1.default)(modifiers, function (modifier) { return modifier.children.annotation !== undefined; });
-    var lastNonAnnotationIndex = (0, findLastIndex_1.default)(modifiers, function (modifier) { return modifier.children.annotation === undefined; });
+    const firstAnnotationIndex = findIndex(modifiers, modifier => modifier.children.annotation !== undefined);
+    const lastNonAnnotationIndex = findLastIndex(modifiers, modifier => modifier.children.annotation === undefined);
     return (firstAnnotationIndex < lastNonAnnotationIndex ||
         lastNonAnnotationIndex === -1);
 }
-function getClassBodyDeclarationsSeparator(classBodyDeclarationContext) {
+export function getClassBodyDeclarationsSeparator(classBodyDeclarationContext) {
     return getDeclarationsSeparator(classBodyDeclarationContext, needLineClassBodyDeclaration, isClassBodyDeclarationASemicolon);
 }
-exports.getClassBodyDeclarationsSeparator = getClassBodyDeclarationsSeparator;
-function getInterfaceBodyDeclarationsSeparator(interfaceMemberDeclarationContext) {
+export function getInterfaceBodyDeclarationsSeparator(interfaceMemberDeclarationContext) {
     return getDeclarationsSeparator(interfaceMemberDeclarationContext, needLineInterfaceMemberDeclaration, isInterfaceMemberASemicolon);
 }
-exports.getInterfaceBodyDeclarationsSeparator = getInterfaceBodyDeclarationsSeparator;
 function getAndRemoveLeadingComment(doc) {
-    var isTokenWithLeadingComment = typeof doc !== "string" && "leadingComments" in doc;
+    const isTokenWithLeadingComment = typeof doc !== "string" && "leadingComments" in doc;
     if (!isTokenWithLeadingComment) {
         return [];
     }
-    var leadingComments = (0, format_comments_1.getTokenLeadingComments)(doc);
+    const leadingComments = getTokenLeadingComments(doc);
     delete doc.leadingComments;
     return leadingComments;
 }
-function putIntoBraces(argument, separator, LBrace, RBrace) {
-    var rightBraceLeadingComments = getAndRemoveLeadingComment(RBrace);
-    var lastBreakLine = 
+export function putIntoBraces(argument, separator, LBrace, RBrace) {
+    const rightBraceLeadingComments = getAndRemoveLeadingComment(RBrace);
+    const lastBreakLine = 
     // check if last element of the array is a line
     rightBraceLeadingComments.length !== 0 &&
         rightBraceLeadingComments[rightBraceLeadingComments.length - 1] === hardline
         ? rightBraceLeadingComments.pop()
         : separator;
-    var contentInsideBraces;
-    if ((0, utils_2.isEmptyDoc)(argument)) {
+    let contentInsideBraces;
+    if (isEmptyDoc(argument)) {
         if (rightBraceLeadingComments.length === 0) {
-            return (0, prettier_builder_1.concat)([LBrace, RBrace]);
+            return concat([LBrace, RBrace]);
         }
-        contentInsideBraces = __spreadArray([separator], rightBraceLeadingComments, true);
+        contentInsideBraces = [separator, ...rightBraceLeadingComments];
     }
     else if (rightBraceLeadingComments.length !== 0) {
-        contentInsideBraces = __spreadArray([
+        contentInsideBraces = [
             separator,
             argument,
-            separator
-        ], rightBraceLeadingComments, true);
+            separator,
+            ...rightBraceLeadingComments
+        ];
     }
     else {
         contentInsideBraces = [separator, argument];
     }
-    return (0, prettier_builder_1.group)(rejectAndConcat([
+    return group(rejectAndConcat([
         LBrace,
-        indent((0, prettier_builder_1.concat)(contentInsideBraces)),
+        indent(concat(contentInsideBraces)),
         lastBreakLine,
         RBrace
     ]));
 }
-exports.putIntoBraces = putIntoBraces;
-function binary(nodes, tokens, isRoot) {
-    if (isRoot === void 0) { isRoot = false; }
-    var levelOperator;
-    var levelPrecedence;
-    var level = [];
+export function binary(nodes, tokens, isRoot = false) {
+    let levelOperator;
+    let levelPrecedence;
+    let level = [];
     while (tokens.length) {
-        var nextOperator = getOperator(tokens);
-        var nextPrecedence = getOperatorPrecedence(nextOperator);
+        const nextOperator = getOperator(tokens);
+        const nextPrecedence = getOperatorPrecedence(nextOperator);
         if (levelPrecedence === undefined || nextPrecedence === levelPrecedence) {
-            var tokenLength = ["<<", ">>", ">>>"].includes(nextOperator)
+            const tokenLength = ["<<", ">>", ">>>"].includes(nextOperator)
                 ? nextOperator.length
                 : 1;
-            var operator = (0, prettier_builder_1.concat)(tokens.splice(0, tokenLength));
+            const operator = concat(tokens.splice(0, tokenLength));
             if (levelOperator !== undefined &&
                 needsParentheses(levelOperator, nextOperator)) {
                 level.push(nodes.shift());
                 level = [
-                    (0, prettier_builder_1.concat)(["(", (0, prettier_builder_1.group)(indent((0, prettier_builder_1.join)(line, level))), ") ", operator])
+                    concat(["(", group(indent(join(line, level))), ") ", operator])
                 ];
             }
             else {
-                level.push((0, prettier_builder_1.join)(" ", [nodes.shift(), operator]));
+                level.push(join(" ", [nodes.shift(), operator]));
             }
             levelOperator = nextOperator;
             levelPrecedence = nextPrecedence;
@@ -476,43 +430,48 @@ function binary(nodes, tokens, isRoot) {
         else if (nextPrecedence < levelPrecedence) {
             level.push(nodes.shift());
             if (isRoot) {
-                var content_1 = (0, prettier_builder_1.group)(indent((0, prettier_builder_1.join)(line, level)));
+                const content = group(indent(join(line, level)));
                 nodes.unshift(levelOperator !== undefined &&
                     needsParentheses(levelOperator, nextOperator)
-                    ? (0, prettier_builder_1.concat)(["(", content_1, ")"])
-                    : content_1);
+                    ? concat(["(", content, ")"])
+                    : content);
                 level = [];
                 levelOperator = undefined;
                 levelPrecedence = undefined;
             }
             else {
-                return (0, prettier_builder_1.group)((0, prettier_builder_1.join)(line, level));
+                return group(join(line, level));
             }
         }
         else {
-            var content_2 = indent(binary(nodes, tokens));
+            const content = indent(binary(nodes, tokens));
             nodes.unshift(levelOperator !== undefined &&
                 needsParentheses(nextOperator, levelOperator)
-                ? (0, prettier_builder_1.concat)(["(", content_2, ")"])
-                : content_2);
+                ? concat(["(", content, ")"])
+                : content);
         }
     }
     level.push(nodes.shift());
-    var content = (0, prettier_builder_1.group)((0, prettier_builder_1.join)(line, level));
-    return levelOperator === "=" ? indent(content) : content;
+    const lineGroupId = Symbol("line");
+    return group(levelOperator === "="
+        ? [
+            level[0],
+            indent(group(line, { id: lineGroupId })),
+            indentIfBreak(level[1], { groupId: lineGroupId })
+        ]
+        : join(line, level));
 }
-exports.binary = binary;
 function getOperator(tokens) {
     if (!tokens.length) {
         return "";
     }
-    var _a = tokens[0], image = _a.image, startOffset = _a.startOffset;
+    const [{ image, startOffset }] = tokens;
     if (!["<", ">"].includes(image)) {
         return image;
     }
-    var repeatedTokenCount = 1;
-    for (var i = 1; i < Math.min(3, tokens.length); i++) {
-        var token = tokens[i];
+    let repeatedTokenCount = 1;
+    for (let i = 1; i < Math.min(3, tokens.length); i++) {
+        const token = tokens[i];
         if (token.image !== image || token.startOffset !== startOffset + i) {
             break;
         }
@@ -531,7 +490,7 @@ function getOperator(tokens) {
         return ">>>";
     }
 }
-var PRECEDENCES_BY_OPERATOR = new Map([
+const PRECEDENCES_BY_OPERATOR = new Map([
     ["||"],
     ["&&"],
     ["|"],
@@ -542,7 +501,7 @@ var PRECEDENCES_BY_OPERATOR = new Map([
     ["<<", ">>", ">>>"],
     ["+", "-"],
     ["*", "/", "%"]
-].flatMap(function (operators, index) { return operators.map(function (operator) { return [operator, index]; }); }));
+].flatMap((operators, index) => operators.map(operator => [operator, index])));
 function getOperatorPrecedence(operator) {
     var _a;
     return (_a = PRECEDENCES_BY_OPERATOR.get(operator)) !== null && _a !== void 0 ? _a : -1;
@@ -552,22 +511,21 @@ function needsParentheses(operator, parentOperator) {
         (["|", "^", "&", "<<", ">>", ">>>"].includes(parentOperator) &&
             getOperatorPrecedence(operator) >
                 getOperatorPrecedence(parentOperator)) ||
-        [operator, parentOperator].every(function (o) { return ["==", "!="].includes(o); }) ||
-        [operator, parentOperator].every(function (o) { return ["<<", ">>", ">>>"].includes(o); }) ||
+        [operator, parentOperator].every(o => ["==", "!="].includes(o)) ||
+        [operator, parentOperator].every(o => ["<<", ">>", ">>>"].includes(o)) ||
         (operator === "*" && parentOperator === "/") ||
         (operator === "/" && parentOperator === "*") ||
         (operator === "%" && ["+", "-", "*", "/"].includes(parentOperator)) ||
         (["*", "/"].includes(operator) && parentOperator === "%"));
 }
-function isStatementEmptyStatement(statement) {
+export function isStatementEmptyStatement(statement) {
     return (statement === ";" || (Array.isArray(statement) && statement[0] === ";"));
 }
-exports.isStatementEmptyStatement = isStatementEmptyStatement;
-function sortImports(imports) {
-    var staticImports = [];
-    var nonStaticImports = [];
+export function sortImports(imports) {
+    const staticImports = [];
+    const nonStaticImports = [];
     if (imports !== undefined) {
-        for (var i = 0; i < imports.length; i++) {
+        for (let i = 0; i < imports.length; i++) {
             if (imports[i].children.Static !== undefined) {
                 staticImports.push(imports[i]);
             }
@@ -576,23 +534,20 @@ function sortImports(imports) {
             }
         }
         // TODO: Could be optimized as we could expect that the array is already almost sorted
-        var comparator = function (first, second) {
-            return compareFqn(first.children.packageOrTypeName[0], second.children.packageOrTypeName[0]);
-        };
+        const comparator = (first, second) => compareFqn(first.children.packageOrTypeName[0], second.children.packageOrTypeName[0]);
         staticImports.sort(comparator);
         nonStaticImports.sort(comparator);
     }
     return {
-        staticImports: staticImports,
-        nonStaticImports: nonStaticImports
+        staticImports,
+        nonStaticImports
     };
 }
-exports.sortImports = sortImports;
 function compareFqn(packageOrTypeNameFirst, packageOrTypeNameSecond) {
-    var identifiersFirst = packageOrTypeNameFirst.children.Identifier;
-    var identifiersSecond = packageOrTypeNameSecond.children.Identifier;
-    var minParts = Math.min(identifiersFirst.length, identifiersSecond.length);
-    for (var i = 0; i < minParts; i++) {
+    const identifiersFirst = packageOrTypeNameFirst.children.Identifier;
+    const identifiersSecond = packageOrTypeNameSecond.children.Identifier;
+    const minParts = Math.min(identifiersFirst.length, identifiersSecond.length);
+    for (let i = 0; i < minParts; i++) {
         if (identifiersFirst[i].image < identifiersSecond[i].image) {
             return -1;
         }
@@ -608,12 +563,12 @@ function compareFqn(packageOrTypeNameFirst, packageOrTypeNameSecond) {
     }
     return 0;
 }
-function isUniqueMethodInvocation(primarySuffixes) {
+export function isUniqueMethodInvocation(primarySuffixes) {
     if (primarySuffixes === undefined) {
         return 0;
     }
-    var count = 0;
-    primarySuffixes.forEach(function (primarySuffix) {
+    let count = 0;
+    primarySuffixes.forEach(primarySuffix => {
         if (primarySuffix.children.methodInvocationSuffix !== undefined) {
             count++;
             if (count > 1) {
@@ -623,18 +578,15 @@ function isUniqueMethodInvocation(primarySuffixes) {
     });
     return count;
 }
-exports.isUniqueMethodInvocation = isUniqueMethodInvocation;
-function printArrayList(_a) {
-    var list = _a.list, extraComma = _a.extraComma, LCurly = _a.LCurly, RCurly = _a.RCurly, trailingComma = _a.trailingComma;
-    var optionalComma;
+export function printArrayList({ list, extraComma, LCurly, RCurly, trailingComma }) {
+    let optionalComma;
     if (trailingComma !== "none" && list !== "") {
         optionalComma = extraComma
-            ? (0, prettier_builder_1.ifBreak)(extraComma[0], __assign(__assign({}, extraComma[0]), { image: "" }))
-            : (0, prettier_builder_1.ifBreak)(",", "");
+            ? ifBreak(extraComma[0], Object.assign(Object.assign({}, extraComma[0]), { image: "" }))
+            : ifBreak(",", "");
     }
     else {
-        optionalComma = extraComma ? __assign(__assign({}, extraComma[0]), { image: "" }) : "";
+        optionalComma = extraComma ? Object.assign(Object.assign({}, extraComma[0]), { image: "" }) : "";
     }
     return putIntoBraces(rejectAndConcat([list, optionalComma]), line, LCurly, RCurly);
 }
-exports.printArrayList = printArrayList;