prettier-java-next-line 2.11.1 → 2.11.4

package/dist/index.cjs

@@ -1,7 +1,7 @@
 let web_tree_sitter = require("web-tree-sitter");
 let prettier = require("prettier");
 let prettier_doc = require("prettier/doc");
-//#region src/options.ts
+// src/options.ts
 var options_default = {
 	arrowParens: {
 		type: "choice",
@@ -47,7 +47,7 @@ var options_default = {
 			value: "end",
 			description: ""
 		}],
-		description: "Where to print operators when binary expressions wrap lines."
+		description: "Where to print operators when binary and ternary expressions wrap lines."
 	},
 	braceStyle: {
 		type: "choice",
@@ -95,8 +95,7 @@ var options_default = {
 		description: "Import groups in Spotless's format, such as `java,javax,,#java|#javax,#`. Module imports always come first. Empty puts static imports next, then all others."
 	}
 };
-//#endregion
-//#region src/node-types.ts
+// src/node-types.ts
 const multiFieldsByType = {
 	array_creation_expression: { dimensions: true },
 	cast_expression: { type: true },
@@ -113,9 +112,9 @@ const multiFieldsByType = {
 	requires_module_directive: { modifiers: true },
 	spread_parameter: { annotations: true }
 };
-//#endregion
-//#region src/printers/helpers.ts
-const { group: group$7, hardline: hardline$7, ifBreak: ifBreak$2, indent: indent$7, indentIfBreak: indentIfBreak$2, join: join$7, line: line$7, lineSuffixBoundary: lineSuffixBoundary$1, softline: softline$4 } = prettier_doc.builders;
+// src/printers/helpers.ts
+const { hasNewline: hasNewline$2, isNextLineEmpty: isNextLineEmpty$1, skipInlineComment, skipTrailingComment } = prettier.util;
+const { breakParent: breakParent$2, fill, group: group$7, hardline: hardline$7, ifBreak: ifBreak$2, indent: indent$7, indentIfBreak: indentIfBreak$2, join: join$7, line: line$7, lineSuffixBoundary: lineSuffixBoundary$1, softline: softline$3 } = prettier_doc.builders;
 const { mapDoc } = prettier_doc.utils;
 function hasType(path, type) {
 	return path.node.type === type;
@@ -149,6 +148,10 @@ function printDanglingComments(path, danglingCommentsPrintOptions = {}) {
 	const doc = join$7(hardline$7, parts);
 	return shouldIndent ? indent$7([hardline$7, doc]) : doc;
 }
+function printDanglingCommentsInList(path) {
+	const { node } = path;
+	return node.comments?.some(({ leading, trailing }) => !leading && !trailing) ? [indent$7([softline$3, printDanglingComments(path)]), node.comments?.some(({ type, leading, trailing }) => !leading && !trailing && type === "line_comment") ? hardline$7 : softline$3] : "";
+}
 function printComment(comment) {
 	comment.printed = true;
 	const lines = comment.value.split("\n").map((line) => line.trim());
@@ -160,62 +163,152 @@ function hasLeadingComments(node) {
 function hasDanglingComments(node) {
 	return node.comments?.some(({ leading, trailing }) => !leading && !trailing) ?? false;
 }
-function closingBracketLine(options, lineDoc = softline$4) {
+function closingBracketLine(options, lineDoc = softline$3) {
 	return options?.closingBracket === "same-line" ? "" : lineDoc;
 }
 function indentInParentheses(contents, options) {
 	return contents && !Array.isArray(contents) || contents.length ? [
 		"(",
-		indent$7([softline$4, contents]),
+		indent$7([softline$3, contents]),
 		closingBracketLine(options),
 		")"
 	] : "()";
 }
 function printArrayInitializer(path, print, options) {
-	if (!path.node.namedChildren.length) {
-		const danglingComments = printDanglingComments(path, { indent: true });
+	const { node } = path;
+	const elements = node.namedChildren;
+	const isNested = isNestedArray(path);
+	const nextLineLayout = options.braceStyle === "next-line" && node.type === "array_initializer" ? options.arrayInitializerLayout : void 0;
+	if (elements.length === 0) {
+		const danglingComments = printDanglingCommentsInList(path);
 		if (!danglingComments) return "{}";
 		const block = [
 			"{",
 			danglingComments,
-			hardline$7,
 			"}"
 		];
-		return options.braceStyle === "next-line" && !isNestedArray(path) ? [hardline$7, ...block] : block;
+		if (isNested || nextLineLayout === void 0) return group$7(block);
+		return nextLineLayout === "fit" ? group$7([softline$3, ...block]) : [hardline$7, group$7(block)];
 	}
-	const list = join$7([",", line$7], path.map(print, "namedChildren"));
-	if (list.length && options.trailingComma !== "none") list.push(ifBreak$2(","));
-	if (options.braceStyle === "next-line" && path.node.type === "array_initializer") {
-		if (options.arrayInitializerLayout === "fit") {
-			const bracketLine = options.bracketSpacing ? line$7 : softline$4;
-			const block = [
-				"{",
-				indent$7([bracketLine, ...list]),
-				bracketLine,
-				"}"
-			];
-			return group$7(isNestedArray(path) ? block : [softline$4, ...block]);
-		}
+	const groupId = Symbol("array");
+	const shouldBreak = node.comments?.some(({ type, leading, trailing }) => !leading && !trailing && type === "line_comment") || nextLineLayout !== "fit" && elements.length > 1 && elements.every((element, i, elements) => {
+		if (element.type !== "array_initializer") return false;
+		const elementType = element.type;
+		const nextElement = elements[i + 1];
+		if (nextElement && elementType !== nextElement.type) return false;
+		return element.namedChildren.length > 1;
+	});
+	const shouldUseConciseFormatting = nextLineLayout !== "always-break" && isConciselyPrintedArray(node, options);
+	const trailingComma = options.trailingComma === "none" ? "" : shouldUseConciseFormatting ? ifBreak$2(",", "", { groupId }) : ifBreak$2(",");
+	const contents = [shouldUseConciseFormatting ? printArrayElementsConcisely(path, options, print, trailingComma) : [printArrayElements(path, options, print), trailingComma], printDanglingComments(path)];
+	if (nextLineLayout === "fit") {
+		const bracketLine = options.bracketSpacing ? line$7 : softline$3;
+		const block = [
+			"{",
+			indent$7([bracketLine, contents]),
+			bracketLine,
+			"}"
+		];
+		return group$7(isNested ? block : [softline$3, ...block], {
+			shouldBreak,
+			id: groupId
+		});
+	}
+	if (nextLineLayout === "always-break") {
 		const block = [
 			"{",
-			indent$7([line$7, ...list]),
+			indent$7([line$7, contents]),
 			line$7,
 			"}"
 		];
-		return isNestedArray(path) ? block : [hardline$7, ...block];
+		return isNested ? [breakParent$2, ...block] : [hardline$7, ...block];
 	}
 	return group$7([
 		"{",
-		indent$7([line$7, ...list]),
+		indent$7([line$7, contents]),
 		line$7,
 		"}"
-	]);
+	], {
+		shouldBreak,
+		id: groupId
+	});
+}
+function isConciselyPrintedArray(node, options) {
+	return node.namedChildren.length > 0 && node.namedChildren.every((element) => element && (isNumericLiteral(element) || isSignedNumericLiteral(element) && !element.operandNode.comments) && !element.comments?.some((comment) => comment.trailing && comment.type === "line_comment" && !hasNewline$2(options.originalText, parser_default.locStart(comment), { backwards: true })));
+}
+const isNumericLiteral = createTypeCheckFunction([
+	"binary_integer_literal",
+	"decimal_floating_point_literal",
+	"decimal_integer_literal",
+	"hex_floating_point_literal",
+	"hex_integer_literal",
+	"octal_integer_literal"
+]);
+function isSignedNumericLiteral(node) {
+	return node.type === "unary_expression" && (node.operatorNode.type === "+" || node.operatorNode.type === "-") && isNumericLiteral(node.operandNode);
+}
+function isLineAfterElementEmpty({ node }, { originalText: text }) {
+	let currentIdx = parser_default.locEnd(node);
+	if (currentIdx === parser_default.locStart(node)) return false;
+	const { length } = text;
+	while (currentIdx < length) {
+		if (text[currentIdx] === ",") break;
+		currentIdx = skipInlineComment(text, skipTrailingComment(text, currentIdx + 1));
+	}
+	return isNextLineEmpty$1(text, currentIdx);
+}
+function printArrayElements(path, options, print) {
+	const parts = [];
+	path.each((element) => {
+		parts.push(group$7(print(element)));
+		if (!element.isLast) parts.push([
+			",",
+			line$7,
+			isLineAfterElementEmpty(path, options) ? softline$3 : ""
+		]);
+	}, "namedChildren");
+	return parts;
+}
+function printArrayElementsConcisely(path, options, print, trailingComma) {
+	const parts = [];
+	path.each((element) => {
+		const { next } = element;
+		parts.push([print(element), !next ? trailingComma : ","]);
+		if (next) parts.push(isLineAfterElementEmpty(path, options) ? [hardline$7, hardline$7] : next.comments?.some(({ type, leading }) => leading && type === "line_comment") ? hardline$7 : line$7);
+	}, "namedChildren");
+	return fill(parts);
 }
 function isNestedArray(path) {
 	return path.parent?.type === "array_initializer" || path.parent?.type === "element_value_array_initializer";
 }
+/**
+* Separates a header such as `void m()`, `try` or `class A` from the `{` of
+* the block that follows it. Blocks never add their own leading separator.
+*/
+function printBlockSeparator(options) {
+	return options.braceStyle === "next-line" ? hardline$7 : " ";
+}
+/**
+* Separators between a declaration header and its body. With same-line braces,
+* a non-empty body's `{` moves onto its own line when the `extends`,
+* `implements` or `permits` clauses break, so that separator sits inside the
+* clause group. With next-line braces, `{` always follows the whole header on
+* its own line.
+*/
+function printDeclarationBodySeparators(hasClauses, hasBody, options) {
+	if (options.braceStyle === "next-line") return {
+		afterClauses: "",
+		afterHeader: hardline$7
+	};
+	return hasClauses ? {
+		afterClauses: hasBody ? line$7 : " ",
+		afterHeader: ""
+	} : {
+		afterClauses: "",
+		afterHeader: " "
+	};
+}
 function printBlock(path, contents, options) {
-	if (options?.braceStyle === "next-line") return printBlockNextLine(path, contents);
 	if (contents.length) return group$7([
 		"{",
 		indent$7([hardline$7, ...join$7(hardline$7, contents)]),
@@ -229,6 +322,11 @@ function printBlock(path, contents, options) {
 		hardline$7,
 		"}"
 	];
+	if (options?.braceStyle === "next-line") return [
+		"{",
+		hardline$7,
+		"}"
+	];
 	const parent = path.parent;
 	const grandparent = path.grandparent;
 	return parent?.type === "catch_clause" && (grandparent?.type === "try_statement" || grandparent?.type === "try_with_resources_statement") && grandparent.namedChildren.filter(({ type }) => type === "catch_clause").length === 1 && !grandparent.namedChildren.some(({ type }) => type === "finally_clause") || parent && [
@@ -256,42 +354,6 @@ function printBlock(path, contents, options) {
 		"}"
 	];
 }
-function printBlockNextLine(path, contents) {
-	const parentType = path.parent?.type;
-	const isChildOfBodyDeclaration = parentType != null && [
-		"annotation_type_body",
-		"class_body",
-		"enum_body",
-		"interface_body"
-	].includes(parentType);
-	const isBlockStatement = parentType != null && [
-		"block",
-		"constructor_body",
-		"switch_block_statement_group"
-	].includes(parentType);
-	const prefix = isChildOfBodyDeclaration || isBlockStatement ? [] : [hardline$7];
-	if (contents.length) return [
-		...prefix,
-		"{",
-		indent$7([hardline$7, ...join$7(hardline$7, contents)]),
-		hardline$7,
-		"}"
-	];
-	const danglingComments = printDanglingComments(path, { indent: true });
-	if (danglingComments) return [
-		...prefix,
-		"{",
-		danglingComments,
-		hardline$7,
-		"}"
-	];
-	return [
-		...prefix,
-		"{",
-		hardline$7,
-		"}"
-	];
-}
 function printBlockStatements(path, print) {
 	const parts = [];
 	path.each((child) => {
@@ -306,7 +368,7 @@ function printBlockStatements(path, print) {
 function printBodyDeclarations(path, print, padFirst = false) {
 	const isInterfaceBody = path.node.type === "interface_body";
 	const isFormalParameters = path.node.type === "formal_parameters";
-	const separator = isFormalParameters ? softline$4 : hardline$7;
+	const separator = isFormalParameters ? softline$3 : hardline$7;
 	let previousRequiresPadding = padFirst;
 	return path.map((child) => {
 		const { node, previous } = child;
@@ -329,14 +391,14 @@ function printTypeParameters(path, print, options) {
 	];
 	const parts = [
 		"<",
-		indent$7([softline$4, join$7([",", line$7], path.map(print, "namedChildren"))]),
+		indent$7([softline$3, join$7([",", line$7], path.map(print, "namedChildren"))]),
 		closingBracketLine(options),
 		">"
 	];
 	return path.node.type === "type_arguments" ? group$7(parts) : parts;
 }
 function printVariableDeclaration(path, print) {
-	const declaration = printModifiers(path, print);
+	const declaration = printModifiers(path, print, path.parent?.type === "for_statement" ? "noBreak" : void 0);
 	declaration.push(path.call(print, "typeNode"), " ");
 	const declarators = path.map(print, "declaratorNodes");
 	if (declarators.length > 1 && path.node.declaratorNodes.some(({ valueNode }) => valueNode)) declaration.push(group$7(indent$7(join$7([",", line$7], declarators)), { shouldBreak: path.parent?.type !== "for_statement" }));
@@ -346,7 +408,7 @@ function printVariableDeclaration(path, print) {
 }
 function printAssignment(leftDoc, operator, rightDoc, rightNode) {
 	if (!rightDoc || !rightNode) return leftDoc;
-	if (rightNode.type === "binary_expression" || rightNode.type === "instanceof_expression" || rightNode.type === "ternary_expression" && (rightNode.conditionNode.type === "binary_expression" || rightNode.conditionNode.type === "instanceof_expression") || isMember(rightNode) && hasDanglingComments(rightNode) || !isMember(rightNode) && hasLeadingComments(rightNode)) return group$7([
+	if (rightNode.type === "binary_expression" || rightNode.type === "instanceof_expression" || rightNode.type === "ternary_expression" && (rightNode.conditionNode.type === "binary_expression" || rightNode.conditionNode.type === "instanceof_expression") || hasLeadingComments(rightNode)) return group$7([
 		leftDoc,
 		operator,
 		group$7(indent$7([line$7, rightDoc]))
@@ -367,22 +429,28 @@ function inferParser(options, language) {
 	return getLanguageByLanguageName(options.plugins?.filter((plugin) => typeof plugin !== "string" && !(plugin instanceof URL)).reverse().flatMap((plugin) => plugin.languages ?? []) ?? [], language)?.parsers[0];
 }
 function printTextBlock(contents) {
-	return [
-		"\"\"\"",
+	return ["\"\"\"", indent$7([
 		hardline$7,
 		contents,
 		"\"\"\""
-	];
+	])];
+}
+function isTextBlock(node) {
+	return node.type === "string_literal" && node.children[0].value === "\"\"\"";
 }
 function embedTextBlock(path, options) {
-	if (path.node.namedChildren.some(({ type }) => type === "string_interpolation") || path.node.children[0].value === "\"") return null;
+	if (path.node.namedChildren.some(({ type }) => type === "string_interpolation") || !isTextBlock(path.node)) return null;
 	const language = findEmbeddedLanguage(path);
 	if (!language) return null;
 	const parser = inferParser(options, language);
 	if (!parser) return null;
-	const text = unescapeTextBlockContents(textBlockContents(path.node));
+	const contents = textBlockContents(path.node);
+	if (/[\uE000-\uF8FF]/.test(contents)) return null;
+	const preservedEscapes = [];
+	const text = unescapeTextBlockContents(contents, preservedEscapes);
+	if (preservedEscapes.length > 6400) return null;
 	return async (textToDoc) => {
-		return printTextBlock([escapeDocForTextBlock(await textToDoc(text, { parser })), hardline$7]);
+		return printTextBlock([escapeDocForTextBlock(await textToDoc(text, { parser }), preservedEscapes), hardline$7]);
 	};
 }
 function textBlockContents(node) {
@@ -553,11 +621,19 @@ function findBaseIndent(lines) {
 function findEmbeddedLanguage(path) {
 	return [path.node, ...path.ancestors].find(({ type, comments }) => type === "block" || comments?.some(({ leading }) => leading))?.comments?.filter(({ leading }) => leading).map(({ value }) => value.match(/^(?:\/\/|\/\*)\s*language\s*=\s*(\S+)/)?.[1]).findLast((language) => language)?.toLowerCase();
 }
-function escapeDocForTextBlock(doc) {
-	return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? currentDoc.replace(/\\|"""/g, (match) => match === "\\" ? "\\\\" : "\"\"\\\"") : currentDoc);
+function escapeDocForTextBlock(doc, preservedEscapes) {
+	return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? currentDoc.replace(/\\|"""|[\uE000-\uF8FF]/g, (match) => match === "\\" ? "\\\\" : match === "\"\"\"" ? "\"\"\\\"" : preservedEscapes[match.charCodeAt(0) - 57344] ?? match) : currentDoc);
 }
-function unescapeTextBlockContents(text) {
-	return text.replace(/\\(?:([stnr"'\\])|\n|\r\n?)/g, (_, escaped) => {
+/**
+* Escapes with no safe unescaped form (\b, \f and octal) are swapped for
+* private-use placeholders and restored verbatim by escapeDocForTextBlock.
+*/
+function unescapeTextBlockContents(text, preservedEscapes) {
+	return text.replace(/\\(?:([stnr"'\\])|([bf]|[0-3][0-7]{0,2}|[4-7][0-7]?)|\n|\r\n?)/g, (match, escaped, preserved) => {
+		if (preserved) {
+			preservedEscapes.push(match);
+			return String.fromCharCode(57344 + preservedEscapes.length - 1);
+		}
 		switch (escaped) {
 			case "s": return " ";
 			case "t": return "	";
@@ -567,2085 +643,2141 @@ function unescapeTextBlockContents(text) {
 		}
 	});
 }
-//#endregion
-//#region src/printers/arrays.ts
-var arrays_default = { array_initializer: printArrayInitializer };
-//#endregion
-//#region src/printers/blocks-and-statements.ts
-const { group: group$6, hardline: hardline$6, ifBreak: ifBreak$1, indent: indent$6, indentIfBreak: indentIfBreak$1, join: join$6, line: line$6, softline: softline$3 } = prettier_doc.builders;
-var blocks_and_statements_default = {
-	block(path, print, options) {
-		return printBlock(path, printBlockStatements(path, print), options);
-	},
-	local_variable_declaration: printVariableDeclaration,
-	labeled_statement(path, print) {
-		return join$6(": ", path.map(print, "namedChildren"));
-	},
-	expression_statement(path, print) {
-		const parentType = path.parent?.type;
-		const expressionType = path.node.namedChildren[0].type;
-		const expression = path.call(print, "namedChildren", 0);
-		return expressionType === "switch_expression" && parentType !== "assignment_expression" && parentType !== "switch_rule" ? expression : [expression, ";"];
-	},
-	if_statement(path, print, options) {
-		const statement = ["if ", path.call(print, "conditionNode")];
-		if (path.node.consequenceNode.type === ";") statement.push(";");
-		else statement.push(" ", path.call(print, "consequenceNode"));
-		if (!hasChild(path, "alternativeNode")) return statement;
-		const danglingComments = printDanglingComments(path);
-		if (danglingComments) statement.push(hardline$6, danglingComments, hardline$6);
-		else if (options?.braceStyle === "next-line") statement.push(hardline$6);
-		else {
-			const ifHasBlock = path.node.consequenceNode.type === "block";
-			statement.push(ifHasBlock ? " " : hardline$6);
+// src/comments.ts
+const { hasNewline: hasNewline$1, isPreviousLineEmpty, skipNewline, skipSpaces } = prettier.util;
+const { breakParent: breakParent$1, hardline: hardline$6, line: line$6, lineSuffix } = prettier_doc.builders;
+const prettierIgnoreRangesByTree = /* @__PURE__ */ new WeakMap();
+function determinePrettierIgnoreRanges(tree) {
+	const { comments } = tree;
+	if (!comments) return;
+	const ranges = comments.filter(({ value }) => /^\/(?:\/\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*|\*\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*\*\/)$/.test(value)).reduce((ranges, { value, start }) => {
+		const previous = ranges.at(-1);
+		if (value.includes("start") || value.includes("off")) {
+			if (previous?.end !== Infinity) ranges.push({
+				start: start.index,
+				end: Infinity
+			});
+		} else if (previous?.end === Infinity) previous.end = start.index;
+		return ranges;
+	}, new Array());
+	prettierIgnoreRangesByTree.set(tree, ranges);
+}
+function isFullyBetweenPrettierIgnore(path) {
+	const { node, root } = path;
+	const start = parser_default.locStart(node);
+	const end = parser_default.locEnd(node);
+	return prettierIgnoreRangesByTree.get(root)?.some((range) => range.start < start && end < range.end) === true;
+}
+function isPrettierIgnore(comment) {
+	return /^(\/\/\s*prettier-ignore|\/\*\s*prettier-ignore\s*\*\/)$/.test(comment.value);
+}
+function canAttachComment(node, ancestors) {
+	if (!node.isNamed) return isBinaryOperator(node);
+	switch (node.type) {
+		case "enum_body_declarations":
+		case "escape_sequence":
+		case "modifier":
+		case "multiline_string_fragment":
+		case "program":
+		case "string_fragment":
+		case "visibility": return false;
+		case "parenthesized_expression": {
+			const [parent] = ancestors;
+			return !(parent.isNamed && [
+				"do_statement",
+				"if_statement",
+				"switch_expression",
+				"synchronized_statement",
+				"try_statement",
+				"try_with_resources_statement",
+				"while_statement"
+			].includes(parent.type));
 		}
-		statement.push("else");
-		if (path.node.alternativeNode.type === ";") statement.push(";");
-		else statement.push(" ", path.call(print, "alternativeNode"));
-		return statement;
-	},
-	assert_statement(path, print) {
-		return [
-			"assert ",
-			...join$6(" : ", path.map(print, "namedChildren")),
-			";"
-		];
-	},
-	switch_expression(path, print) {
-		return join$6(" ", [
-			"switch",
-			path.call(print, "conditionNode"),
-			path.call(print, "bodyNode")
-		]);
-	},
-	switch_block(path, print, options) {
-		return printBlock(path, path.map(print, "namedChildren"), options);
-	},
-	switch_block_statement_group(path, print) {
-		const parts = [];
-		path.each((child) => {
-			if (child.node.type === "switch_label") parts.push(print(child), ":");
-		}, "namedChildren");
-		const firstStatementIndex = path.node.namedChildren.findIndex(({ type }) => type !== "switch_label");
-		if (firstStatementIndex === path.node.namedChildren.length - 1 && path.node.namedChildren[firstStatementIndex].type === "block") parts.push(" ", path.call(print, "namedChildren", firstStatementIndex));
-		else if (firstStatementIndex !== -1) parts.push(indent$6([hardline$6, ...join$6(hardline$6, printBlockStatements(path, print))]));
-		return parts;
-	},
-	switch_label(path, print) {
-		if (!path.node.children.some(({ type }) => type === "case")) return "default";
-		const values = [];
-		path.each((child) => {
-			if (child.node.type !== "guard") values.push(print(child));
-		}, "namedChildren");
-		const hasMultipleValues = values.length > 1;
-		const label = hasMultipleValues ? ["case", indent$6([line$6, ...join$6([",", line$6], values)])] : ["case ", values[0]];
-		const guardIndex = path.node.namedChildren.findIndex(({ type }) => type === "guard");
-		return guardIndex !== -1 ? [group$6([...label, hasMultipleValues ? line$6 : " "]), path.call(print, "namedChildren", guardIndex)] : group$6(label);
-	},
-	switch_rule(path, print) {
-		const bodyIndex = path.node.namedChildren.findIndex(({ type }) => type === "block" || type === "expression_statement" || type === "throw_statement");
-		const body = path.call(print, "namedChildren", bodyIndex);
-		const switchLabelIndex = path.node.namedChildren.findIndex(({ type }) => type === "switch_label");
-		const parts = [path.call(print, "namedChildren", switchLabelIndex), " ->"];
-		const bodyNode = path.node.namedChildren[bodyIndex];
-		if (bodyNode.type !== "block" && hasLeadingComments(bodyNode)) parts.push(indent$6([hardline$6, body]));
-		else parts.push(" ", body);
-		return parts;
-	},
-	while_statement(path, print) {
-		const parts = ["while ", path.call(print, "conditionNode")];
-		const body = path.call(print, "bodyNode");
-		const bodyType = path.node.bodyNode.type;
-		if (bodyType === "block") {
-			parts.push(" ", body);
-			return parts;
-		} else if (bodyType === ";") {
-			parts.push(";");
-			return parts;
-		} else {
-			parts.push(line$6, body);
-			return group$6(indent$6(parts));
+		default: return true;
+	}
+}
+function handleLineComment(commentNode, _, options) {
+	return [
+		handleBinaryExpressionComments,
+		handleFormalParametersComments,
+		handleFqnOrRefTypeComments,
+		handleIfStatementComments,
+		handleJumpStatementComments,
+		handleLabeledStatementComments,
+		handleLambdaExpressionComments,
+		handleMemberChainComments,
+		handleMethodHeaderComments,
+		handleModifiersComments,
+		handleNameComments,
+		handleTernaryExpressionComments,
+		handleTryStatementComments
+	].some((fn) => fn(commentNode, options));
+}
+function handleRemainingComment(commentNode) {
+	return [
+		handleFqnOrRefTypeComments,
+		handleNameComments,
+		handleJumpStatementComments
+	].some((fn) => fn(commentNode));
+}
+function handleBinaryExpressionComments(commentNode, options) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "binary_expression") {
+		if (isBinaryOperator(followingNode)) {
+			if (options.experimentalOperatorPosition === "start") prettier.util.addLeadingComment(followingNode, commentNode);
+			else prettier.util.addTrailingComment(followingNode, commentNode);
+			return true;
+		} else if (options.experimentalOperatorPosition === "start" && isBinaryOperator(precedingNode)) {
+			prettier.util.addLeadingComment(precedingNode, commentNode);
+			return true;
 		}
-	},
-	do_statement(path, print, options) {
-		const hasEmptyStatement = path.node.bodyNode.type === ";";
-		const isNextLine = options?.braceStyle === "next-line";
-		const whilePrefix = isNextLine ? [hardline$6, "while "] : " while ";
-		return [
-			"do",
-			hasEmptyStatement ? ";" : isNextLine ? path.call(print, "bodyNode") : [" ", path.call(print, "bodyNode")],
-			whilePrefix,
-			path.call(print, "conditionNode"),
-			";"
-		];
-	},
-	for_statement(path, print, options) {
-		const danglingComments = printDanglingComments(path);
-		const hasInit = path.node.initNodes.length > 0;
-		const hasCondition = hasChild(path, "conditionNode");
-		const hasUpdate = path.node.updateNodes.length > 0;
-		const expressions = [
-			!hasInit ? ";" : path.node.initNodes[0].type === "local_variable_declaration" ? path.call(print, "initNodes", 0) : [printExpressionList(path.map(print, "initNodes")), ";"],
-			hasCondition ? [path.call(print, "conditionNode"), ";"] : ";",
-			hasUpdate ? [line$6, printExpressionList(path.map(print, "updateNodes"))] : ifBreak$1("", " ")
-		];
-		const hasEmptyStatement = path.node.bodyNode.type === ";";
-		return [
-			danglingComments && [danglingComments, hardline$6],
-			"for ",
-			hasInit || hasCondition || hasUpdate ? group$6(indentInParentheses([join$6(line$6, expressions.slice(0, 2)), expressions[2]], options)) : "(;;)",
-			hasEmptyStatement ? ";" : [" ", path.call(print, "bodyNode")]
-		];
-	},
-	update_expression(path, print) {
-		return path.map(print, "children");
-	},
-	enhanced_for_statement(path, print) {
-		const danglingComments = printDanglingComments(path);
-		const forStatement = [
-			danglingComments && [danglingComments, hardline$6],
-			"for (",
-			...printModifiers(path, print),
-			path.call(print, "typeNode"),
-			" ",
-			path.call(print, "nameNode")
-		];
-		if (hasChild(path, "dimensionsNode")) forStatement.push(path.call(print, "dimensionsNode"));
-		forStatement.push(" : ", path.call(print, "valueNode"), ")");
-		const bodyType = path.node.bodyNode.type;
-		if (bodyType === ";") forStatement.push(";");
-		else {
-			const body = path.call(print, "bodyNode");
-			forStatement.push(bodyType === "block" ? [" ", body] : indent$6([line$6, body]));
+	}
+	return false;
+}
+function handleFormalParametersComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "formal_parameters" && !precedingNode && !followingNode) {
+		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
+		return true;
+	}
+	return false;
+}
+function handleFqnOrRefTypeComments(commentNode) {
+	const { enclosingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "scoped_type_identifier" && followingNode) {
+		prettier.util.addLeadingComment(followingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleIfStatementComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode?.type === "if_statement" && precedingNode?.fieldName === "consequence") {
+		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
+		return true;
+	}
+	return false;
+}
+function handleJumpStatementComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode && !precedingNode && !followingNode && (enclosingNode.type === "break_statement" || enclosingNode.type === "continue_statement" || enclosingNode.type === "return_statement")) {
+		prettier.util.addTrailingComment(enclosingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleLabeledStatementComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode?.type === "labeled_statement" && precedingNode?.type === "identifier") {
+		prettier.util.addLeadingComment(precedingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleLambdaExpressionComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "lambda_expression" && precedingNode && followingNode && enclosingNode.children.find(({ type }) => type === "->").end.index < commentNode.start.index) {
+		if (followingNode.type === "block") {
+			if (followingNode.namedChildren.length) prettier.util.addLeadingComment(followingNode.namedChildren[0], commentNode);
+			else prettier.util.addDanglingComment(followingNode, commentNode, void 0);
+		} else prettier.util.addLeadingComment(followingNode, commentNode);
+		return true;
+	}
+}
+function handleMemberChainComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (isMember(enclosingNode)) {
+		if (commentNode.end.index <= enclosingNode.start.index) {
+			const memberChainRoot = getMemberChainRoot(enclosingNode);
+			prettier.util.addLeadingComment(memberChainRoot, commentNode);
+			return true;
 		}
-		return group$6(forStatement);
-	},
-	break_statement(path, print) {
-		const parts = ["break"];
-		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier");
-		if (identifierIndex !== -1) parts.push(" ", path.call(print, "namedChildren", identifierIndex));
-		parts.push(";");
-		return parts;
-	},
-	continue_statement(path, print) {
-		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier");
-		return identifierIndex !== -1 ? [
-			"continue ",
-			path.call(print, "namedChildren", identifierIndex),
-			";"
-		] : "continue;";
-	},
-	return_statement: printReturnOrThrowStatement,
-	throw_statement: printReturnOrThrowStatement,
-	synchronized_statement(path, print) {
-		const parenthesizedExpressionIndex = path.node.namedChildren.findIndex(({ type }) => type === "parenthesized_expression");
-		return [
-			"synchronized ",
-			path.call(print, "namedChildren", parenthesizedExpressionIndex),
-			" ",
-			path.call(print, "bodyNode")
-		];
-	},
-	try_statement(path, print, options) {
-		const parts = ["try", path.call(print, "bodyNode")];
-		path.each((child) => {
-			if (child.node.type === "catch_clause" || child.node.type === "finally_clause") parts.push(print(child));
-		}, "namedChildren");
-		if (options?.braceStyle === "next-line") return parts;
-		return join$6(" ", parts);
-	},
-	catch_clause(path, print, options) {
-		const catchFormalParameterIndex = path.node.namedChildren.findIndex(({ type }) => type === "catch_formal_parameter");
-		const params = group$6(indentInParentheses(path.call(print, "namedChildren", catchFormalParameterIndex), options));
-		const body = path.call(print, "bodyNode");
-		if (options?.braceStyle === "next-line") return [
-			hardline$6,
-			"catch ",
-			params,
-			body
-		];
-		return [
-			"catch ",
-			params,
-			" ",
-			body
-		];
-	},
-	catch_formal_parameter(path, print) {
-		const parts = printModifiers(path, print, "noBreak");
-		const catchTypeIndex = path.node.namedChildren.findIndex(({ type }) => type === "catch_type");
-		parts.push(path.call(print, "namedChildren", catchTypeIndex), " ", path.call(print, "nameNode"));
-		if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
-		return parts;
-	},
-	catch_type(path, print) {
-		return join$6([line$6, "| "], path.map(print, "namedChildren"));
-	},
-	finally_clause(path, print, options) {
-		if (options?.braceStyle === "next-line") return [
-			hardline$6,
-			"finally",
-			path.call(print, "namedChildren", 0)
-		];
-		return ["finally ", path.call(print, "namedChildren", 0)];
-	},
-	try_with_resources_statement(path, print, options) {
-		const resources = path.call(print, "resourcesNode");
-		const body = path.call(print, "bodyNode");
-		const clauses = [];
-		path.each((child) => {
-			if (child.node.type === "catch_clause" || child.node.type === "finally_clause") clauses.push(print(child));
-		}, "namedChildren");
-		if (options?.braceStyle === "next-line") return [
-			"try ",
-			resources,
-			body,
-			...clauses
-		];
-		return join$6(" ", [
-			"try",
-			resources,
-			body,
-			...clauses
-		]);
-	},
-	resource_specification(path, print, options) {
-		const resources = [];
-		let hasTrailingSemicolon = false;
-		path.each((child) => {
-			if (child.node.type === "resource") {
-				resources.push(print(child));
-				hasTrailingSemicolon = false;
-			} else if (child.node.type === ";") hasTrailingSemicolon = true;
-		}, "children");
-		const parts = join$6([";", line$6], resources);
-		if (hasTrailingSemicolon) parts.push(ifBreak$1(";"));
-		return group$6(indentInParentheses(parts, options));
-	},
-	resource(path, print) {
-		if (hasChild(path, "typeNode") && hasChild(path, "nameNode") && hasChild(path, "valueNode")) {
-			const parts = printModifiers(path, print);
-			parts.push(path.call(print, "typeNode"), " ", path.call(print, "nameNode"));
-			if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
-			parts.push(" =");
-			const value = path.call(print, "valueNode");
-			if (path.node.valueNode.type === "binary_expression" || hasLeadingComments(path.node.valueNode)) parts.push(group$6(indent$6([line$6, value])));
-			else {
-				const groupId = Symbol("assignment");
-				parts.push(group$6(indent$6(line$6), { id: groupId }), indentIfBreak$1(value, { groupId }));
-			}
-			return parts;
+		if (precedingNode && (enclosingNode.type === "field_access" || precedingNode.end.row < commentNode.start.row) && precedingNode === getMemberObject(enclosingNode)) {
+			prettier.util.addLeadingComment(enclosingNode, commentNode);
+			return true;
 		}
-		const resourceIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier" || type === "field_access");
-		return path.call(print, "namedChildren", resourceIndex);
-	},
-	yield_statement(path, print) {
-		return [
-			"yield ",
-			path.call(print, "namedChildren", 0),
-			";"
-		];
 	}
-};
-function printExpressionList(expressions) {
-	return group$6(expressions.map((expression, index) => index === 0 ? expression : [",", indent$6([line$6, expression])]));
+	return false;
 }
-function printReturnOrThrowArgument(path, print, options) {
-	const { node } = path;
-	const argumentDoc = print(path);
-	if (returnArgumentHasLeadingComment(node)) return [
-		"(",
-		indent$6([hardline$6, argumentDoc]),
-		closingBracketLine(options, hardline$6),
-		")"
-	];
-	if (node.type === "binary_expression") return group$6([
-		ifBreak$1("("),
-		indent$6([softline$3, argumentDoc]),
-		closingBracketLine(options),
-		ifBreak$1(")")
-	]);
-	return argumentDoc;
+function getMemberChainRoot(node) {
+	let current = node;
+	while (isMember(current)) {
+		const next = getMemberObject(current);
+		if (!next) return current;
+		else current = next;
+	}
+	return current;
 }
-function printReturnOrThrowStatement(path, print, options) {
-	const { node } = path;
-	return [
-		node.type === "throw_statement" ? "throw" : "return",
-		node.namedChildren.length ? [" ", path.call(() => printReturnOrThrowArgument(path, print, options), "namedChildren", 0)] : "",
-		";"
-	];
+/**
+* With same-line braces, `{` follows the method header on the same line, so a
+* comment between the header and the block moves into the block.
+*/
+function handleMethodHeaderComments(commentNode, options) {
+	const { enclosingNode, followingNode } = commentNode;
+	if (options.braceStyle !== "same-line" || enclosingNode?.type !== "method_declaration" || followingNode?.type !== "block" || followingNode !== enclosingNode.bodyNode) return false;
+	const firstStatement = followingNode.namedChildren.at(0);
+	if (firstStatement) prettier.util.addLeadingComment(firstStatement, commentNode);
+	else prettier.util.addDanglingComment(followingNode, commentNode, void 0);
+	return true;
 }
-//#endregion
-//#region src/printers/classes.ts
-const { group: group$5, hardline: hardline$5, indent: indent$5, join: join$5, line: line$5, softline: softline$2 } = prettier_doc.builders;
-var classes_default = {
-	class_declaration(path, print, options) {
-		const parts = ["class ", path.call(print, "nameNode")];
-		const definedClauses = definedKeys(path.node, [
-			"superclassNode",
-			"interfacesNode",
-			"permitsNode"
-		]);
-		const hasMultipleClauses = definedClauses.length > 1;
-		if (hasChild(path, "type_parametersNode")) {
-			const typeParameters = path.call(print, "type_parametersNode");
-			parts.push(hasMultipleClauses ? group$5(indent$5(typeParameters)) : options?.braceStyle === "next-line" ? group$5(typeParameters) : typeParameters);
-		}
-		if (definedClauses.length) {
-			const clauses = definedClauses.flatMap((clause) => {
-				if (!hasChild(path, clause)) return [];
-				return [clause === "superclassNode" || clause === "interfacesNode" ? hardline$5 : line$5, path.call(print, clause)];
-			});
-			const hasBody = path.node.bodyNode.namedChildren.length > 0;
-			const afterClauses = options?.braceStyle === "next-line" ? "" : hasBody ? line$5 : " ";
-			const clauseGroup = [indent$5(clauses), afterClauses];
-			parts.push(hasMultipleClauses ? clauseGroup : group$5(clauseGroup));
-		} else if (options?.braceStyle !== "next-line") parts.push(" ");
-		return [
-			...printModifiers(path, print, "declarationOnly"),
-			group$5(parts),
-			path.call(print, "bodyNode")
-		];
-	},
-	type_parameters: printTypeParameters,
-	superclass(path, print) {
-		return ["extends ", path.call(print, "namedChildren", 0)];
-	},
-	super_interfaces(path, print) {
-		return group$5(["implements", indent$5([line$5, path.call(print, "namedChildren", 0)])]);
-	},
-	permits(path, print) {
-		return group$5(["permits", indent$5([line$5, path.call(print, "namedChildren", 0)])]);
-	},
-	type_list(path, print) {
-		return join$5([",", line$5], path.map(print, "namedChildren"));
-	},
-	class_body(path, print, options) {
-		return printBlock(path, printBodyDeclarations(path, print, path.parent?.type === "class_declaration" && options?.braceStyle !== "next-line"), options);
-	},
-	field_declaration: printVariableDeclaration,
-	variable_declarator(path, print) {
-		const leftDoc = [path.call(print, "nameNode")];
-		if (hasChild(path, "dimensionsNode")) leftDoc.push(path.call(print, "dimensionsNode"));
-		return printAssignment(leftDoc, " =", hasChild(path, "valueNode") ? path.call(print, "valueNode") : void 0, path.node.valueNode);
-	},
-	method_declaration(path, print) {
-		const modifiers = printModifiers(path, print);
-		const declaration = [];
-		if (hasChild(path, "type_parametersNode")) declaration.push(group$5(path.call(print, "type_parametersNode")), " ");
-		path.each((child) => {
-			if (child.node.type === "annotation" || child.node.type === "marker_annotation") declaration.push(print(child), " ");
-		}, "children");
-		declaration.push(path.call(print, "typeNode"));
-		if (hasChild(path, "dimensionsNode")) declaration.push(path.call(print, "dimensionsNode"));
-		declaration.push(" ", path.call(print, "nameNode"), group$5(path.call(print, "parametersNode")));
-		const throwsIndex = path.node.namedChildren.findIndex(({ type }) => type === "throws");
-		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$5, path.call(print, "namedChildren", throwsIndex)])));
-		return hasChild(path, "bodyNode") ? [
-			modifiers,
-			group$5(declaration),
-			" ",
-			path.call(print, "bodyNode")
-		] : [
-			modifiers,
-			group$5(declaration),
-			";"
-		];
-	},
-	receiver_parameter(path, print) {
-		return path.map((child) => child.isLast ? print(child) : [print(child), child.node.type === "identifier" ? "." : " "], "namedChildren");
-	},
-	formal_parameters(path, print, options) {
-		const parameters = path.parent?.type === "record_declaration" ? printBodyDeclarations(path, print) : path.map(print, "namedChildren");
-		if (parameters.length === 0) return [
-			"(",
-			printDanglingCommentsInList(path),
-			")"
-		];
-		return indentInParentheses(join$5([",", line$5], parameters), options);
-	},
-	formal_parameter(path, print) {
-		const parameter = printModifiers(path, print, path.grandparent?.type === "record_declaration" ? "avoidBreak" : "noBreak");
-		parameter.push(path.call(print, "typeNode"));
-		if (hasChild(path, "dimensionsNode")) parameter.push(path.call(print, "dimensionsNode"));
-		parameter.push(" ", path.call(print, "nameNode"));
-		return group$5(parameter);
-	},
-	spread_parameter(path, print) {
-		const parts = printModifiers(path, print, "noBreak");
-		parts.push(path.call(print, "typeNode"));
-		if (hasChild(path, "annotationsNodes")) parts.push(...path.map((annotation) => [" ", print(annotation)], "annotationsNodes"));
-		parts.push("... ", path.call(print, "namedChildren", path.node.namedChildren.length - 1));
-		return parts;
-	},
-	throws(path, print) {
-		return ["throws ", ...join$5(", ", path.map(print, "namedChildren"))];
-	},
-	static_initializer(path, print) {
-		return ["static ", path.call(print, "namedChildren", 0)];
-	},
-	constructor_declaration(path, print) {
-		const modifiers = printModifiers(path, print, "declarationOnly");
-		const declaration = [];
-		if (hasChild(path, "type_parametersNode")) declaration.push(group$5(path.call(print, "type_parametersNode")), " ");
-		declaration.push(path.call(print, "nameNode"), group$5(path.call(print, "parametersNode")));
-		const throwsIndex = path.node.namedChildren.findIndex(({ type }) => type === "throws");
-		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$5, path.call(print, "namedChildren", throwsIndex)])));
-		return [
-			modifiers,
-			group$5(declaration),
-			" ",
-			path.call(print, "bodyNode")
-		];
-	},
-	constructor_body(path, print, options) {
-		return printBlock(path, printBlockStatements(path, print), options);
-	},
-	explicit_constructor_invocation(path, print) {
-		const invocation = [];
-		if (hasChild(path, "objectNode")) invocation.push(path.call(print, "objectNode"), ".");
-		if (hasChild(path, "type_argumentsNode")) invocation.push(path.call(print, "type_argumentsNode"));
-		invocation.push(path.call(print, "constructorNode"), path.call(print, "argumentsNode"), ";");
-		return invocation;
-	},
-	visibility: printValue,
-	modifier: printValue,
-	modifiers(path, print, _, args) {
-		const parts = [];
-		const modifiers = [];
-		const typeAnnotations = [];
-		path.each((child) => {
-			if (child.node.type === "annotation" || child.node.type === "marker_annotation") (modifiers.length ? typeAnnotations : parts).push(print(child));
-			else {
-				modifiers.push(child.node.value);
-				parts.push(...typeAnnotations);
-				typeAnnotations.length = 0;
-			}
-		}, "namedChildren");
-		const annotationMode = args && typeof args === "object" && "annotationMode" in args ? args.annotationMode : null;
-		if (annotationMode === "declarationOnly") {
-			parts.push(...typeAnnotations);
-			typeAnnotations.length = 0;
-		}
-		modifiers.sort((a, b) => (indexByModifier.get(a) ?? -1) - (indexByModifier.get(b) ?? -1));
-		if (modifiers.length || typeAnnotations.length) parts.push(join$5(" ", [...modifiers, ...typeAnnotations]));
-		return join$5(annotationMode === "avoidBreak" ? line$5 : annotationMode === "noBreak" ? " " : hardline$5, parts);
-	},
-	enum_declaration(path, print, options) {
-		const modifiers = printModifiers(path, print, "declarationOnly");
-		const parts = ["enum ", path.call(print, "nameNode")];
-		if (hasChild(path, "interfacesNode")) {
-			const hasBody = path.node.bodyNode.namedChildren.length > 0;
-			parts.push(indent$5([hardline$5, path.call(print, "interfacesNode")]), options?.braceStyle === "next-line" ? "" : hasBody ? line$5 : " ");
-		} else parts.push(" ");
-		return [
-			...modifiers,
-			group$5(parts),
-			path.call(print, "bodyNode")
-		];
-	},
-	enum_body(path, print, options) {
-		const parts = printBodyDeclarations(path, print);
-		const enumBodyDeclarationsIndex = path.node.namedChildren.findIndex(({ type }) => type === "enum_body_declarations");
-		const declarations = [];
-		if (enumBodyDeclarationsIndex !== -1) {
-			const hasDeclarations = path.node.namedChildren[enumBodyDeclarationsIndex].namedChildren.length > 0;
-			const enumBodyDeclarations = parts.pop();
-			if (hasDeclarations) {
-				if (!parts.length) declarations.push(hardline$5);
-				declarations.push(enumBodyDeclarations);
-			}
+function handleModifiersComments(commentNode) {
+	const { precedingNode } = commentNode;
+	if (precedingNode?.type === "annotation" || precedingNode?.type === "marker_annotation" || precedingNode?.type === "modifiers") {
+		prettier.util.addTrailingComment(precedingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleNameComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode && precedingNode?.type === "identifier" && (enclosingNode.type === "scoped_identifier" || enclosingNode.type === "module_declaration" || enclosingNode.type === "package_declaration" || enclosingNode.type === "scoped_type_identifier")) {
+		prettier.util.addTrailingComment(precedingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleTernaryExpressionComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "ternary_expression" && precedingNode?.isNamed && followingNode?.isNamed && precedingNode.end.row < commentNode.start.row && commentNode.end.row < followingNode.start.row) {
+		prettier.util.addLeadingComment(followingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleTryStatementComments(commentNode) {
+	const { enclosingNode, followingNode } = commentNode;
+	if (enclosingNode && (enclosingNode.type === "catch_clause" || enclosingNode.type === "try_statement" || enclosingNode.type === "try_with_resources_statement") && followingNode?.isNamed) {
+		const block = followingNode.type === "catch_clause" ? followingNode.bodyNode : followingNode.type === "finally_clause" ? followingNode.namedChildren[0] : null;
+		if (!block) return false;
+		const blockStatement = block.namedChildren.at(0);
+		if (blockStatement) prettier.util.addLeadingComment(blockStatement, commentNode);
+		else prettier.util.addDanglingComment(block, commentNode, void 0);
+		return true;
+	}
+	return false;
+}
+function getMemberObject(node) {
+	return node.type === "array_access" ? node.arrayNode : node.objectNode;
+}
+const binaryOperators = /* @__PURE__ */ new Set([
+	"<<",
+	">>",
+	">>>",
+	"instanceof",
+	"<=",
+	">=",
+	"==",
+	"-",
+	"+",
+	"&&",
+	"&",
+	"^",
+	"!=",
+	"||",
+	"|",
+	"*",
+	"/",
+	"%"
+]);
+function isBinaryOperator(node) {
+	return node !== void 0 && binaryOperators.has(node.type);
+}
+function printLeadingComment(path) {
+	const comment = path.node;
+	const parts = [printComment(comment)];
+	const originalText = path.root.value;
+	if (comment.type === "block_comment") {
+		let lineBreak = " ";
+		if (hasNewline$1(originalText, parser_default.locEnd(comment))) {
+			if (hasNewline$1(originalText, parser_default.locStart(comment), { backwards: true })) lineBreak = hardline$6;
+			else lineBreak = line$6;
 		}
-		const contents = [];
-		if (parts.length) {
-			contents.push(join$5([",", hardline$5], parts));
-			if (!declarations.length && options.trailingComma !== "none") contents.push(",");
+		parts.push(lineBreak);
+	} else parts.push(hardline$6);
+	const index = skipNewline(originalText, skipSpaces(originalText, parser_default.locEnd(comment)));
+	if (index !== false && hasNewline$1(originalText, index)) parts.push(hardline$6);
+	return parts;
+}
+function printTrailingComment(path, previousComment) {
+	const comment = path.node;
+	const printed = printComment(comment);
+	const originalText = path.root.value;
+	const isBlock = comment.type === "block_comment";
+	if (previousComment?.hasLineSuffix && !previousComment?.isBlock || hasNewline$1(originalText, parser_default.locStart(comment), { backwards: true })) {
+		const isLineBeforeEmpty = isPreviousLineEmpty(originalText, parser_default.locStart(comment));
+		return {
+			doc: lineSuffix([
+				hardline$6,
+				isLineBeforeEmpty ? hardline$6 : "",
+				printed
+			]),
+			isBlock,
+			hasLineSuffix: true
+		};
+	}
+	if (!isBlock || previousComment?.hasLineSuffix) return {
+		doc: [lineSuffix([" ", printed]), breakParent$1],
+		isBlock,
+		hasLineSuffix: true
+	};
+	return {
+		doc: [" ", printed],
+		isBlock,
+		hasLineSuffix: false
+	};
+}
+function printLeadingComments(path) {
+	if (!hasChild(path, "comments")) return [];
+	const docs = [];
+	path.each((path) => {
+		const { node: comment } = path;
+		if (!comment.leading) return;
+		docs.push(printLeadingComment(path));
+	}, "comments");
+	return docs;
+}
+function printTrailingComments(path) {
+	if (!hasChild(path, "comments")) return [];
+	const docs = [];
+	let printedTrailingComment;
+	path.each((path) => {
+		const { node: comment } = path;
+		if (!comment.trailing) return;
+		printedTrailingComment = printTrailingComment(path, printedTrailingComment);
+		docs.push(printedTrailingComment.doc);
+	}, "comments");
+	return docs;
+}
+function printCommentsSeparately(path) {
+	return {
+		leading: printLeadingComments(path),
+		trailing: printTrailingComments(path)
+	};
+}
+function printComments(path, doc) {
+	const leading = printLeadingComments(path);
+	const trailing = printTrailingComments(path);
+	return leading.length || trailing.length ? [
+		leading,
+		doc,
+		trailing
+	] : doc;
+}
+// src/parser.ts
+var parser_default = {
+	async parse(text) {
+		const tree = (await parser).parse(text);
+		try {
+			const { rootNode } = tree;
+			if (rootNode.hasError) throw new Error("Failed to parse: " + rootNode);
+			const ast = processTree(rootNode);
+			determinePrettierIgnoreRanges(ast);
+			return ast;
+		} finally {
+			tree.delete();
 		}
-		if (declarations.length) contents.push(";", hardline$5, ...declarations);
-		return printBlock(path, contents.length ? [contents] : [], options);
 	},
-	enum_constant(path, print) {
-		const initializer = printModifiers(path, print);
-		initializer.push(path.call(print, "nameNode"));
-		if (hasChild(path, "argumentsNode")) initializer.push(path.call(print, "argumentsNode"));
-		if (hasChild(path, "bodyNode")) initializer.push(" ", path.call(print, "bodyNode"));
-		return initializer;
-	},
-	enum_body_declarations(path, print) {
-		return join$5(hardline$5, printBodyDeclarations(path, print));
+	astFormat: "java",
+	hasPragma(text) {
+		return /^\/\*\*\n\s+\*\s@(format|prettier)\n\s+\*\//.test(text);
 	},
-	record_declaration(path, print) {
-		const modifiers = printModifiers(path, print, "declarationOnly");
-		const parts = ["record ", path.call(print, "nameNode")];
-		if (hasChild(path, "type_parametersNode")) parts.push(group$5(path.call(print, "type_parametersNode")));
-		parts.push(group$5(path.call(print, "parametersNode")));
-		if (hasChild(path, "interfacesNode")) {
-			const hasBody = path.node.bodyNode.namedChildren.length > 0;
-			const interfaces = [hardline$5, path.call(print, "interfacesNode")];
-			parts.push(group$5([indent$5(interfaces), hasBody ? line$5 : " "]));
-		} else parts.push(" ");
-		return [
-			...modifiers,
-			group$5(parts),
-			path.call(print, "bodyNode")
-		];
+	locStart(node) {
+		return node.start.index;
 	},
-	compact_constructor_declaration(path, print) {
-		const parts = printModifiers(path, print, "declarationOnly");
-		parts.push(path.call(print, "nameNode"), " ", path.call(print, "bodyNode"));
-		return parts;
+	locEnd(node) {
+		return node.end.index;
 	}
 };
-const indexByModifier = [
-	"public",
-	"protected",
-	"private",
-	"abstract",
-	"default",
-	"static",
-	"final",
-	"transient",
-	"volatile",
-	"synchronized",
-	"native",
-	"sealed",
-	"non-sealed",
-	"strictfp"
-].reduce((map, name, index) => map.set(name, index), /* @__PURE__ */ new Map());
-function printDanglingCommentsInList(path) {
-	const { node } = path;
-	return node.comments?.some((comment) => !(comment.leading || comment.trailing)) ? [indent$5([softline$2, printDanglingComments(path)]), node.comments.some(({ type, leading, trailing }) => !(leading || trailing) && type === "line_comment") ? hardline$5 : softline$2] : "";
-}
-//#endregion
-//#region src/printers/expressions.ts
-const { align, breakParent: breakParent$1, conditionalGroup, dedent, group: group$4, hardline: hardline$4, ifBreak, indent: indent$4, indentIfBreak, join: join$4, line: line$4, lineSuffixBoundary, softline: softline$1 } = prettier_doc.builders;
-const { getNextNonSpaceNonCommentCharacterIndex, hasNewline: hasNewline$1, isNextLineEmpty } = prettier.util;
-const { removeLines, willBreak } = prettier_doc.utils;
-var expressions_default = {
-	lambda_expression(path, print, options, args) {
-		const signatureDocs = [];
-		let bodyDoc;
-		const bodyComments = [];
-		const shouldPrintAsChain = !(args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg) && path.node.bodyNode.type === "lambda_expression";
-		let functionBody;
-		(function rec() {
-			const { node } = path;
-			const signatureDoc = printLambdaExpressionSignature(path, options, print, args);
-			if (signatureDocs.length === 0) signatureDocs.push(signatureDoc);
+const parser = (async () => {
+	await web_tree_sitter.Parser.init();
+	const parser = new web_tree_sitter.Parser();
+	const Java = await web_tree_sitter.Language.load(new URL("./tree-sitter-java_orchard.wasm", require("url").pathToFileURL(__filename).href));
+	parser.setLanguage(Java);
+	return parser;
+})();
+const isParenthesizedParent = createTypeCheckFunction([
+	"do_statement",
+	"if_statement",
+	"switch_expression",
+	"synchronized_statement",
+	"try_statement",
+	"try_with_resources_statement",
+	"while_statement"
+]);
+function processTree(node, fieldName = null, comments) {
+	const { type, isNamed, text: value, startPosition, endPosition } = node;
+	const javaNode = {
+		type,
+		isNamed,
+		value,
+		start: {
+			index: node.startIndex,
+			row: startPosition.row,
+			column: startPosition.column
+		},
+		end: {
+			index: node.endIndex,
+			row: endPosition.row,
+			column: endPosition.column
+		},
+		children: [],
+		namedChildren: [],
+		fieldName
+	};
+	if (!comments) comments = javaNode.comments = [];
+	if (!javaNode.isNamed) return javaNode;
+	const multiFields = multiFieldsByType[node.type];
+	if (multiFields) Object.keys(multiFields).forEach((name) => javaNode[`${name}Nodes`] = []);
+	node.children.forEach((child, index) => {
+		const fieldName = node.fieldNameForChild(index);
+		(child.type === "parenthesized_expression" && !isParenthesizedParent(javaNode) ? child.namedChildren : [child]).forEach((child) => {
+			const { type, text: value, startPosition, endPosition } = child;
+			if (type === "block_comment" || type === "line_comment") comments.push({
+				type,
+				value,
+				start: {
+					index: child.startIndex,
+					row: startPosition.row,
+					column: startPosition.column
+				},
+				end: {
+					index: child.endIndex,
+					row: endPosition.row,
+					column: endPosition.column
+				},
+				leading: false,
+				trailing: false,
+				printed: false
+			});
 			else {
-				const { leading, trailing } = printCommentsSeparately(path);
-				signatureDocs.push([leading, signatureDoc]);
-				bodyComments.unshift(trailing);
+				const javaChild = processTree(child, fieldName, comments);
+				javaNode.children.push(javaChild);
+				if (javaChild.isNamed) javaNode.namedChildren.push(javaChild);
+				if (fieldName) {
+					if (multiFields?.[fieldName]) javaNode[`${fieldName}Nodes`].push(javaChild);
+					else javaNode[`${fieldName}Node`] = javaChild;
+				}
 			}
-			if (!shouldPrintAsChain || node.bodyNode.type !== "lambda_expression") {
-				bodyDoc = path.call((child) => print(child, args), "bodyNode");
-				functionBody = node.bodyNode;
-			} else path.call(rec, "bodyNode");
-		})();
-		const shouldPutBodyOnSameLine = !functionBody.comments?.some((comment) => comment.leading && hasNewline$1(options.originalText, comment.end.index)) && mayBreakAfterShortPrefix(functionBody);
-		const chainGroupId = Symbol("arrow-chain");
-		const signaturesDoc = printArrowFunctionSignatures(path, { signatureDocs });
-		bodyDoc = printArrowFunctionBody(path, args, options, {
-			bodyDoc,
-			bodyComments,
-			shouldPutBodyOnSameLine
 		});
-		return group$4([
-			group$4(signaturesDoc, { id: chainGroupId }),
-			" ->",
-			shouldPrintAsChain ? indentIfBreak(bodyDoc, { groupId: chainGroupId }) : group$4(bodyDoc)
-		]);
+	});
+	return javaNode;
+}
+// src/printers/arrays.ts
+var arrays_default = { array_initializer: printArrayInitializer };
+// src/printers/blocks-and-statements.ts
+const { group: group$6, hardline: hardline$5, ifBreak: ifBreak$1, indent: indent$6, indentIfBreak: indentIfBreak$1, join: join$6, line: line$5, softline: softline$2 } = prettier_doc.builders;
+var blocks_and_statements_default = {
+	block(path, print, options) {
+		return printBlock(path, printBlockStatements(path, print), options);
 	},
-	inferred_parameters(path, print, options) {
-		const identifiers = [];
-		path.each((child) => {
-			if (child.node.type === "identifier") identifiers.push(print(child));
-		}, "namedChildren");
-		if (!identifiers.length) return "()";
-		const parameters = join$4([",", line$4], identifiers);
-		if (identifiers.length > 1 || willBreak(identifiers)) return group$4(indentInParentheses(parameters, options));
-		return options.arrowParens === "avoid" ? parameters : [
-			"(",
-			...parameters,
-			")"
+	local_variable_declaration: printVariableDeclaration,
+	labeled_statement(path, print, options) {
+		const [label, statement] = path.map(print, "namedChildren");
+		return [
+			label,
+			":",
+			printStatementSeparator(path.node.namedChildren[1].type, options),
+			statement
 		];
 	},
-	ternary_expression(path, print, options) {
-		const { node } = path;
-		const consequentNode = node.consequenceNode;
-		const parts = [];
-		const parent = path.parent;
-		const isParentTest = parent.type === node.type && parent.conditionNode === node;
-		const forceNoIndent = parent.type === node.type && !isParentTest;
-		let currentParent;
-		let previousParent;
-		let i = 0;
-		do {
-			previousParent = currentParent || node;
-			currentParent = path.getParentNode(i);
-			i++;
-		} while (currentParent && currentParent.type === node.type && currentParent.conditionNode !== previousParent);
-		const firstNonConditionalParent = currentParent || parent;
-		const printBranch = (nodePropertyName) => options.useTabs ? indent$4(path.call(print, nodePropertyName)) : align(2, path.call(print, nodePropertyName));
-		const part = [
-			line$4,
-			"? ",
-			consequentNode.type === node.type ? ifBreak("", "(") : "",
-			printBranch("consequenceNode"),
-			consequentNode.type === node.type ? ifBreak("", ")") : "",
-			line$4,
-			": ",
-			printBranch("alternativeNode")
+	expression_statement(path, print) {
+		const parentType = path.parent?.type;
+		const expressionType = path.node.namedChildren[0].type;
+		const expression = path.call(print, "namedChildren", 0);
+		return expressionType === "switch_expression" && parentType !== "assignment_expression" && parentType !== "switch_rule" ? expression : [expression, ";"];
+	},
+	if_statement(path, print, options) {
+		const statement = ["if ", path.call(print, "conditionNode")];
+		if (path.node.consequenceNode.type === ";") statement.push(";");
+		else statement.push(printStatementSeparator(path.node.consequenceNode.type, options), path.call(print, "consequenceNode"));
+		if (!hasChild(path, "alternativeNode")) return statement;
+		const danglingComments = printDanglingComments(path);
+		if (danglingComments) statement.push(hardline$5, danglingComments, hardline$5);
+		else if (options?.braceStyle === "next-line") statement.push(hardline$5);
+		else {
+			const ifHasBlock = path.node.consequenceNode.type === "block";
+			statement.push(ifHasBlock ? " " : hardline$5);
+		}
+		statement.push("else");
+		if (path.node.alternativeNode.type === ";") statement.push(";");
+		else statement.push(printStatementSeparator(path.node.alternativeNode.type, options), path.call(print, "alternativeNode"));
+		return statement;
+	},
+	assert_statement(path, print) {
+		return [
+			"assert ",
+			...join$6(" : ", path.map(print, "namedChildren")),
+			";"
 		];
-		parts.push(parent.type !== node.type || parent.alternativeNode === node || isParentTest ? part : options.useTabs ? dedent(indent$4(part)) : align(Math.max(0, options.tabWidth - 2), part));
-		const maybeGroup = (doc) => parent === firstNonConditionalParent ? group$4(doc) : doc;
-		const breakClosingParen = parent.type === "explicit_constructor_invocation" || parent.type === "field_access" || parent.type === "method_invocation" || parent.type === "method_reference" || parent.type === "object_creation_expression";
-		const shouldExtraIndent = shouldExtraIndentForTernaryExpression(path);
-		const result = maybeGroup([
-			printTernaryTest(path, print),
-			forceNoIndent ? parts : indent$4(parts),
-			breakClosingParen && !shouldExtraIndent ? closingBracketLine(options) : ""
-		]);
-		return isParentTest || shouldExtraIndent ? group$4([indent$4([softline$1, result]), closingBracketLine(options)]) : result;
 	},
-	assignment_expression(path, print) {
-		const { node } = path;
-		return printAssignment(path.call(print, "leftNode"), [" ", node.operatorNode.type], path.call(print, "rightNode"), node.rightNode);
+	switch_expression(path, print, options) {
+		return [
+			"switch ",
+			path.call(print, "conditionNode"),
+			printBlockSeparator(options),
+			path.call(print, "bodyNode")
+		];
 	},
-	binary_expression(path, print, options) {
-		const { node } = path;
-		const parent = path.parent;
-		const grandparent = path.grandparent;
-		const isInsideParentheses = (grandparent?.type === "if_statement" || grandparent?.type === "while_statement" || grandparent?.type === "switch_expression" || grandparent?.type === "do_statement") && grandparent.conditionNode === parent || grandparent?.type === "synchronized_statement" && grandparent.bodyNode !== parent;
-		const parts = printBinaryExpressions(path, print, options, isInsideParentheses);
-		if (isInsideParentheses) return parts;
-		if (parent?.type === "unary_expression" && !node.comments || (parent?.type === "explicit_constructor_invocation" || parent?.type === "field_access" || parent?.type === "method_invocation") && parent.objectNode === node || parent?.type === "method_reference" || parent?.type === "object_creation_expression") return group$4([indent$4([softline$1, ...parts]), closingBracketLine(options)]);
-		if (isReturnOrThrowStatement(parent) || parent?.type === "assignment_expression" || parent?.type === "variable_declarator" || parent?.type === "guard" || parent?.type === "lambda_expression" && parent.bodyNode === node || parent?.type === "for_statement" && parent.conditionNode === node || parent?.type === "ternary_expression" && !isReturnOrThrowStatement(grandparent) && grandparent?.type !== "parenthesized_expression" && grandparent?.type !== "argument_list" || parent?.type === "unary_expression" && parent.operandNode === node) return group$4(parts);
-		if (parts.length === 0) return "";
-		const firstGroupIndex = parts.findIndex((part) => typeof part !== "string" && !Array.isArray(part) && part.type === "group");
-		const headParts = parts.slice(0, firstGroupIndex === -1 ? 1 : firstGroupIndex + 1);
-		const rest = parts.slice(headParts.length);
-		return group$4([...headParts, indent$4(rest)]);
+	switch_block(path, print, options) {
+		return printBlock(path, path.map(print, "namedChildren"), options);
 	},
-	instanceof_expression(path, print, options) {
-		return group$4(indent$4(path.map((child) => {
-			const doc = print(child, { annotationMode: "noBreak" });
-			if (!child.previous) return doc;
-			return [(options.experimentalOperatorPosition === "start" ? child.node.type === "instanceof" : child.previous.type === "instanceof") ? line$4 : " ", doc];
-		}, "children")));
+	switch_block_statement_group(path, print, options) {
+		const parts = [];
+		path.each((child) => {
+			if (child.node.type === "switch_label") parts.push(print(child), ":");
+		}, "namedChildren");
+		const firstStatementIndex = path.node.namedChildren.findIndex(({ type }) => type !== "switch_label");
+		if (firstStatementIndex === path.node.namedChildren.length - 1 && path.node.namedChildren[firstStatementIndex].type === "block") parts.push(printBlockSeparator(options), path.call(print, "namedChildren", firstStatementIndex));
+		else if (firstStatementIndex !== -1) parts.push(indent$6([hardline$5, ...join$6(hardline$5, printBlockStatements(path, print))]));
+		return parts;
 	},
-	unary_expression(path, print, options) {
-		const parts = [path.call(print, "operatorNode")];
-		const operandDoc = path.call(print, "operandNode");
-		if (path.node.operandNode.comments) parts.push(group$4(indentInParentheses(operandDoc, options)));
-		else parts.push(operandDoc);
+	switch_label(path, print) {
+		if (!path.node.children.some(({ type }) => type === "case")) return "default";
+		const values = [];
+		path.each((child) => {
+			if (child.node.type !== "guard") values.push(print(child));
+		}, "namedChildren");
+		const hasMultipleValues = values.length > 1;
+		const label = hasMultipleValues ? ["case", indent$6([line$5, ...join$6([",", line$5], values)])] : ["case ", values[0]];
+		const guardIndex = path.node.namedChildren.findIndex(({ type }) => type === "guard");
+		return guardIndex !== -1 ? [group$6([...label, hasMultipleValues ? line$5 : " "]), path.call(print, "namedChildren", guardIndex)] : group$6(label);
+	},
+	switch_rule(path, print, options) {
+		const bodyIndex = path.node.namedChildren.findIndex(({ type }) => type === "block" || type === "expression_statement" || type === "throw_statement");
+		const body = path.call(print, "namedChildren", bodyIndex);
+		const switchLabelIndex = path.node.namedChildren.findIndex(({ type }) => type === "switch_label");
+		const parts = [path.call(print, "namedChildren", switchLabelIndex), " ->"];
+		const bodyNode = path.node.namedChildren[bodyIndex];
+		if (bodyNode.type !== "block" && hasLeadingComments(bodyNode)) parts.push(indent$6([hardline$5, body]));
+		else parts.push(printStatementSeparator(bodyNode.type, options), body);
 		return parts;
 	},
-	field_access: printMemberChain,
-	generic_type(path, print) {
-		const typeIdentifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "scoped_type_identifier" || type === "type_identifier");
-		const typeArgumentsIndex = path.node.namedChildren.findIndex(({ type }) => type === "type_arguments");
-		return [path.call(print, "namedChildren", typeIdentifierIndex), path.call(print, "namedChildren", typeArgumentsIndex)];
+	while_statement(path, print, options) {
+		const parts = ["while ", path.call(print, "conditionNode")];
+		const body = path.call(print, "bodyNode");
+		const bodyType = path.node.bodyNode.type;
+		if (bodyType === "block") {
+			parts.push(printBlockSeparator(options), body);
+			return parts;
+		} else if (bodyType === ";") {
+			parts.push(";");
+			return parts;
+		} else {
+			parts.push(line$5, body);
+			return group$6(indent$6(parts));
+		}
 	},
-	parenthesized_expression(path, print, options) {
-		const expression = path.call(print, "namedChildren", 0);
-		const parentType = path.parent?.type;
-		const grandparentType = path.grandparent?.type;
-		const expressionType = path.node.namedChildren[0].type;
-		const hasLambda = expressionType === "lambda_expression";
-		const hasTernary = expressionType === "ternary_expression";
-		const hasSuffix = parentType && (parentType === "array_access" || parentType === "explicit_constructor_invocation" || parentType === "field_access" || parentType === "method_invocation" || parentType === "method_reference" || parentType === "object_creation_expression");
-		const isAssignment = parentType && (parentType === "assignment_expression" || parentType === "variable_declarator") || hasSuffix && (grandparentType === "assignment_expression" || grandparentType === "variable_declarator");
-		if (!hasLambda && hasSuffix && (!hasTernary || isAssignment)) return group$4(indentInParentheses(hasTernary ? group$4(expression) : expression, options));
-		else if (parentType && (parentType === "guard" || parentType === "return_statement" || parentType === "unary_expression" && grandparentType === "return_statement" || path.node.fieldName === "condition" && (parentType === "do_statement" || parentType === "if_statement" || parentType === "switch_expression" || parentType === "while_statement") || path.node.fieldName !== "body" && parentType === "synchronized_statement")) return group$4(indentInParentheses(group$4(expression), options));
-		else if (hasTernary && hasSuffix && !isAssignment) return group$4([
-			"(",
-			expression,
-			closingBracketLine(options),
-			")"
-		]);
-		else return group$4([
-			"(",
-			hasLambda || hasTernary ? expression : indent$4(expression),
-			")"
-		]);
+	do_statement(path, print, options) {
+		const hasEmptyStatement = path.node.bodyNode.type === ";";
+		const whilePrefix = options?.braceStyle === "next-line" ? [hardline$5, "while "] : " while ";
+		return [
+			"do",
+			hasEmptyStatement ? ";" : [printStatementSeparator(path.node.bodyNode.type, options), path.call(print, "bodyNode")],
+			whilePrefix,
+			path.call(print, "conditionNode"),
+			";"
+		];
 	},
-	cast_expression(path, print) {
-		const { node } = path;
-		const parts = [
-			group$4(node.typeNodes.length === 1 ? [
-				"(",
-				path.call(print, "typeNodes", 0),
-				")"
-			] : [
-				"(",
-				indent$4([softline$1, join$4([" &", line$4], path.map(print, "typeNodes"))]),
-				softline$1,
-				")"
-			]),
-			" ",
-			path.call(print, "valueNode")
+	for_statement(path, print, options) {
+		const danglingComments = printDanglingComments(path);
+		const hasInit = path.node.initNodes.length > 0;
+		const hasCondition = hasChild(path, "conditionNode");
+		const hasUpdate = path.node.updateNodes.length > 0;
+		const expressions = [
+			!hasInit ? ";" : path.node.initNodes[0].type === "local_variable_declaration" ? path.call(print, "initNodes", 0) : [printExpressionList(path.map(print, "initNodes")), ";"],
+			hasCondition ? [path.call(print, "conditionNode"), ";"] : ";",
+			hasUpdate ? [line$5, printExpressionList(path.map(print, "updateNodes"))] : ifBreak$1("", " ")
+		];
+		const hasEmptyStatement = path.node.bodyNode.type === ";";
+		return [
+			danglingComments && [danglingComments, hardline$5],
+			"for ",
+			hasInit || hasCondition || hasUpdate ? group$6(indentInParentheses([join$6(line$5, expressions.slice(0, 2)), expressions[2]], options)) : "(;;)",
+			hasEmptyStatement ? ";" : [printStatementSeparator(path.node.bodyNode.type, options), path.call(print, "bodyNode")]
 		];
-		const parent = path.parent;
-		if (parent?.type === "unary_expression" && !node.comments || parent?.type === "array_access" && parent.arrayNode === node || (parent?.type === "explicit_constructor_invocation" || parent?.type === "field_access" || parent?.type === "method_invocation") && parent.objectNode === node || parent?.type === "method_reference" || parent?.type === "object_creation_expression") return group$4([indent$4([softline$1, ...parts]), softline$1]);
-		return parts;
 	},
-	object_creation_expression(path, print) {
-		const expression = [];
-		path.each((child) => {
-			if (child.node.type === "class_body") expression.push(" ");
-			expression.push(print(child));
-			if (child.node.type === "annotation" || child.node.type === "marker_annotation" || child.node.type === "new") expression.push(" ");
-		}, "children");
-		return expression;
+	update_expression(path, print) {
+		return path.map(print, "children");
 	},
-	method_invocation: printMemberChain,
-	argument_list(path, print, options) {
-		const args = path.node.namedChildren;
-		if (args.length === 0) {
-			const shouldBreak = path.node.comments?.some(({ type, leading, trailing }) => !leading && !trailing && type === "line_comment");
-			return group$4(indentInParentheses(printDanglingComments(path), options), { shouldBreak });
-		}
-		const lastArgIndex = args.length - 1;
-		let anyArgEmptyLine = false;
-		const printedArguments = [];
-		path.each((arg, index) => {
-			let argDoc = print(arg);
-			if (index === lastArgIndex) {} else if (isNextLineEmpty(options.originalText, arg.node.end.index)) {
-				anyArgEmptyLine = true;
-				argDoc = [
-					argDoc,
-					",",
-					hardline$4,
-					hardline$4
-				];
-			} else argDoc = [
-				argDoc,
-				",",
-				line$4
-			];
-			printedArguments.push(argDoc);
-		}, "namedChildren");
-		function allArgsBrokenOut() {
-			return group$4([
-				"(",
-				indent$4([line$4, ...printedArguments]),
-				closingBracketLine(options, line$4),
-				")"
-			], { shouldBreak: true });
-		}
-		if (anyArgEmptyLine) return allArgsBrokenOut();
-		if (shouldExpandFirstArg(args)) {
-			const tailArgs = printedArguments.slice(1);
-			if (tailArgs.some(willBreak)) return allArgsBrokenOut();
-			let firstArg;
-			try {
-				firstArg = path.call((arg) => print(arg, { expandFirstArg: true }), "namedChildren", 0);
-			} catch (caught) {
-				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
-				throw caught;
-			}
-			if (willBreak(firstArg)) return [breakParent$1, conditionalGroup([[
-				"(",
-				group$4(firstArg, { shouldBreak: true }),
-				", ",
-				...tailArgs,
-				")"
-			], allArgsBrokenOut()])];
-			return conditionalGroup([
-				[
-					"(",
-					firstArg,
-					", ",
-					...tailArgs,
-					")"
-				],
-				[
-					"(",
-					group$4(firstArg, { shouldBreak: true }),
-					", ",
-					...tailArgs,
-					")"
-				],
-				allArgsBrokenOut()
-			]);
-		}
-		if (shouldExpandLastArg(args)) {
-			const headArgs = printedArguments.slice(0, -1);
-			if (headArgs.some(willBreak)) return allArgsBrokenOut();
-			let lastArg;
-			try {
-				lastArg = path.call((arg) => print(arg, { expandLastArg: true }), "namedChildren", lastArgIndex);
-			} catch (caught) {
-				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
-				throw caught;
-			}
-			if (willBreak(lastArg)) return [breakParent$1, conditionalGroup([[
-				"(",
-				...headArgs,
-				group$4(lastArg, { shouldBreak: true }),
-				")"
-			], allArgsBrokenOut()])];
-			return conditionalGroup([
-				[
-					"(",
-					...headArgs,
-					lastArg,
-					")"
-				],
-				[
-					"(",
-					...headArgs,
-					group$4(lastArg, { shouldBreak: true }),
-					")"
-				],
-				allArgsBrokenOut()
-			]);
+	enhanced_for_statement(path, print, options) {
+		const danglingComments = printDanglingComments(path);
+		const forStatement = [
+			danglingComments && [danglingComments, hardline$5],
+			"for (",
+			...printModifiers(path, print, "noBreak"),
+			path.call(print, "typeNode"),
+			" ",
+			path.call(print, "nameNode")
+		];
+		if (hasChild(path, "dimensionsNode")) forStatement.push(path.call(print, "dimensionsNode"));
+		forStatement.push(" : ", path.call(print, "valueNode"), ")");
+		const bodyType = path.node.bodyNode.type;
+		if (bodyType === ";") forStatement.push(";");
+		else {
+			const body = path.call(print, "bodyNode");
+			forStatement.push(bodyType === "block" ? [printBlockSeparator(options), body] : indent$6([line$5, body]));
 		}
-		return group$4(indentInParentheses(printedArguments, options), { shouldBreak: printedArguments.some(willBreak) || anyArgEmptyLine });
+		return group$6(forStatement);
 	},
-	array_creation_expression(path, print) {
-		const parts = ["new "];
-		path.each((child) => {
-			if (child.node.type === "annotation" || child.node.type === "marker_annotation") parts.push(print(child), " ");
-		}, "namedChildren");
-		parts.push(path.call(print, "typeNode"), ...path.map(print, "dimensionsNodes"));
-		if (hasChild(path, "valueNode")) parts.push(" ", path.call(print, "valueNode"));
+	break_statement(path, print) {
+		const parts = ["break"];
+		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier");
+		if (identifierIndex !== -1) parts.push(" ", path.call(print, "namedChildren", identifierIndex));
+		parts.push(";");
 		return parts;
 	},
-	dimensions_expr(path, print) {
-		return path.map((child) => child.node.type === "annotation" || child.node.type === "marker_annotation" ? [print(child), " "] : [
-			"[",
-			print(child),
-			"]"
-		], "namedChildren");
+	continue_statement(path, print) {
+		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier");
+		return identifierIndex !== -1 ? [
+			"continue ",
+			path.call(print, "namedChildren", identifierIndex),
+			";"
+		] : "continue;";
 	},
-	class_literal(path, print) {
-		return [path.call(print, "namedChildren", 0), ".class"];
+	return_statement: printReturnOrThrowStatement,
+	throw_statement: printReturnOrThrowStatement,
+	synchronized_statement(path, print, options) {
+		const parenthesizedExpressionIndex = path.node.namedChildren.findIndex(({ type }) => type === "parenthesized_expression");
+		return [
+			"synchronized ",
+			path.call(print, "namedChildren", parenthesizedExpressionIndex),
+			printBlockSeparator(options),
+			path.call(print, "bodyNode")
+		];
 	},
-	array_access: printMemberChain,
-	method_reference(path, print) {
-		return group$4(path.map(print, "children"));
+	try_statement(path, print, options) {
+		return [
+			"try",
+			printBlockSeparator(options),
+			path.call(print, "bodyNode"),
+			...printCatchAndFinallyClauses(path, print, options)
+		];
 	},
-	template_expression(path, print) {
+	catch_clause(path, print, options) {
+		const catchFormalParameterIndex = path.node.namedChildren.findIndex(({ type }) => type === "catch_formal_parameter");
 		return [
-			path.call(print, "template_processorNode"),
-			".",
-			path.call(print, "template_argumentNode")
+			"catch ",
+			group$6(indentInParentheses(path.call(print, "namedChildren", catchFormalParameterIndex), options)),
+			printBlockSeparator(options),
+			path.call(print, "bodyNode")
 		];
 	},
-	pattern(path, print) {
-		return path.call(print, "namedChildren", 0);
+	catch_formal_parameter(path, print) {
+		const parts = printModifiers(path, print, "noBreak");
+		const catchTypeIndex = path.node.namedChildren.findIndex(({ type }) => type === "catch_type");
+		parts.push(path.call(print, "namedChildren", catchTypeIndex), " ", path.call(print, "nameNode"));
+		if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
+		return parts;
 	},
-	type_pattern(path, print) {
-		return join$4(" ", path.map(print, "children"));
+	catch_type(path, print) {
+		return join$6([line$5, "| "], path.map(print, "namedChildren"));
 	},
-	record_pattern(path, print) {
-		return path.map(print, "children");
+	finally_clause(path, print, options) {
+		return [
+			"finally",
+			printBlockSeparator(options),
+			path.call(print, "namedChildren", 0)
+		];
 	},
-	record_pattern_body(path, print, options) {
-		return group$4(indentInParentheses(join$4([",", line$4], path.map(print, "namedChildren")), options));
+	try_with_resources_statement(path, print, options) {
+		return [
+			"try ",
+			path.call(print, "resourcesNode"),
+			printBlockSeparator(options),
+			path.call(print, "bodyNode"),
+			...printCatchAndFinallyClauses(path, print, options)
+		];
 	},
-	record_pattern_component(path, print) {
-		return join$4(" ", path.map(print, "children"));
+	resource_specification(path, print, options) {
+		const resources = [];
+		let hasTrailingSemicolon = false;
+		path.each((child) => {
+			if (child.node.type === "resource") {
+				resources.push(print(child));
+				hasTrailingSemicolon = false;
+			} else if (child.node.type === ";") hasTrailingSemicolon = true;
+		}, "children");
+		const parts = join$6([";", line$5], resources);
+		if (hasTrailingSemicolon) parts.push(ifBreak$1(";"));
+		return group$6(indentInParentheses(parts, options));
 	},
-	guard(path, print) {
-		return ["when ", group$4([
-			ifBreak("("),
-			indent$4([softline$1, path.call(print, "namedChildren", 0)]),
-			softline$1,
-			ifBreak(")")
-		])];
-	}
-};
-function printLambdaExpressionSignature(path, options, print, args) {
-	const parts = [];
-	const parameters = path.call(print, "parametersNode");
-	if (shouldPrintParamsWithoutParens(path, options)) parts.push(parameters);
-	else {
-		if (args != null && typeof args === "object" && ("expandLastArg" in args && args.expandLastArg === true || "expandFirstArg" in args && args.expandFirstArg === true)) {
-			if (willBreak(parameters)) throw new ArgExpansionBailout();
-			parts.push(group$4(removeLines(parameters)));
-		} else parts.push(parameters);
-		if (path.node.parametersNode.type === "identifier") return path.node.parametersNode.comments ? group$4([
-			"(",
-			indent$4([softline$1, ...parts]),
-			lineSuffixBoundary,
-			")"
-		]) : [
-			"(",
-			...parts,
-			")"
+	resource(path, print) {
+		if (hasChild(path, "typeNode") && hasChild(path, "nameNode") && hasChild(path, "valueNode")) {
+			const parts = printModifiers(path, print, "noBreak");
+			parts.push(path.call(print, "typeNode"), " ", path.call(print, "nameNode"));
+			if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
+			parts.push(" =");
+			const value = path.call(print, "valueNode");
+			if (path.node.valueNode.type === "binary_expression" || hasLeadingComments(path.node.valueNode)) parts.push(group$6(indent$6([line$5, value])));
+			else {
+				const groupId = Symbol("assignment");
+				parts.push(group$6(indent$6(line$5), { id: groupId }), indentIfBreak$1(value, { groupId }));
+			}
+			return parts;
+		}
+		const resourceIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier" || type === "field_access");
+		return path.call(print, "namedChildren", resourceIndex);
+	},
+	yield_statement(path, print) {
+		return [
+			"yield ",
+			path.call(print, "namedChildren", 0),
+			";"
 		];
 	}
-	const dangling = printDanglingComments(path);
-	if (dangling) parts.push(" ", dangling);
-	return parts;
-}
-function mayBreakAfterShortPrefix(functionBody) {
-	return functionBody.type === "array_creation_expression" || functionBody.type === "lambda_expression" || functionBody.type === "block";
+};
+function printExpressionList(expressions) {
+	return group$6(expressions.map((expression, index) => index === 0 ? expression : [",", indent$6([line$5, expression])]));
 }
-function printArrowFunctionSignatures(path, { signatureDocs }) {
-	if (signatureDocs.length === 1) return signatureDocs[0];
-	const { node, parent } = path;
-	if (node.fieldName !== "object" && parent?.type === "method_invocation" || parent?.type === "binary_expression") return group$4([
-		signatureDocs[0],
-		" ->",
-		indent$4([line$4, join$4([" ->", line$4], signatureDocs.slice(1))])
+function printReturnOrThrowArgument(path, print, options) {
+	const { node } = path;
+	const argumentDoc = print(path);
+	if (returnArgumentHasLeadingComment(node)) return [
+		"(",
+		indent$6([hardline$5, argumentDoc]),
+		closingBracketLine(options, hardline$5),
+		")"
+	];
+	if (node.type === "binary_expression") return group$6([
+		ifBreak$1("("),
+		indent$6([softline$2, argumentDoc]),
+		closingBracketLine(options),
+		ifBreak$1(")")
 	]);
-	if (node.fieldName === "object" && parent?.type === "method_invocation") return group$4(join$4([" ->", line$4], signatureDocs));
-	return group$4(indent$4(join$4([" ->", line$4], signatureDocs)));
-}
-function printArrowFunctionBody(path, args, options, { bodyDoc, bodyComments, shouldPutBodyOnSameLine }) {
-	const trailingSpace = args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg && !path.node.comments ? closingBracketLine(options) : "";
-	return shouldPutBodyOnSameLine ? [
-		" ",
-		bodyDoc,
-		bodyComments
-	] : [indent$4([
-		line$4,
-		bodyDoc,
-		bodyComments
-	]), trailingSpace];
-}
-function shouldPrintParamsWithoutParens(path, options) {
-	if (options.arrowParens === "always") return false;
-	if (options.arrowParens === "avoid") {
-		const { node } = path;
-		return canPrintParamsWithoutParens(node);
-	}
-	return false;
-}
-function canPrintParamsWithoutParens(node) {
-	return node.parametersNode.type === "identifier" && !hasDanglingComments(node) && !node.parametersNode.comments;
+	return argumentDoc;
 }
-function printMemberChain(path, print, options) {
-	const isExpressionStatement = path.parent?.type === "expression_statement";
-	const printedNodes = [];
-	function shouldInsertEmptyLineAfter(node) {
-		const { originalText } = options;
-		const nextCharIndex = getNextNonSpaceNonCommentCharacterIndex(originalText, node.end.index);
-		if ((nextCharIndex ? originalText.charAt(nextCharIndex) : "") === ")") return nextCharIndex !== false && isNextLineEmpty(originalText, nextCharIndex + 1);
-		return isNextLineEmpty(originalText, node.end.index);
-	}
-	function rec(path) {
-		const { node } = path;
-		if (hasType(path, "method_invocation") && hasChild(path, "objectNode")) {
-			const hasTrailingEmptyLine = shouldInsertEmptyLineAfter(node);
-			printedNodes.unshift({
-				node,
-				hasTrailingEmptyLine,
-				printed: [printComments(path, printMethodInvocation(path, print)), hasTrailingEmptyLine ? hardline$4 : ""]
-			});
-			path.call(rec, "objectNode");
-		} else if (hasType(path, "array_access")) {
-			printedNodes.unshift({
-				node,
-				printed: printComments(path, printArrayAccess(path, print))
-			});
-			path.call(rec, "arrayNode");
-		} else if (hasType(path, "field_access")) {
-			printedNodes.unshift({
-				node,
-				printed: printComments(path, printFieldAccess(path, print))
-			});
-			path.call(rec, "objectNode");
-		} else printedNodes.unshift({
-			node,
-			printed: print(path)
-		});
-	}
+function printReturnOrThrowStatement(path, print, options) {
 	const { node } = path;
-	if (hasType(path, "method_invocation")) {
-		printedNodes.unshift({
-			node,
-			printed: printComments(path, printMethodInvocation(path, print))
-		});
-		if (hasChild(path, "objectNode")) path.call(rec, "objectNode");
-	} else if (hasType(path, "array_access")) {
-		printedNodes.unshift({
-			node,
-			printed: printComments(path, printArrayAccess(path, print))
-		});
-		if (hasChild(path, "arrayNode")) path.call(rec, "arrayNode");
-	} else if (hasType(path, "field_access")) {
-		printedNodes.unshift({
-			node,
-			printed: printComments(path, printFieldAccess(path, print))
-		});
-		if (hasChild(path, "objectNode")) path.call(rec, "objectNode");
-	}
-	const danglingComments = printDanglingComments(path);
-	if (danglingComments) printedNodes[0].printed = [
-		danglingComments,
-		hardline$4,
-		printedNodes[0].printed
-	];
-	const groups = [];
-	let currentGroup = [printedNodes[0]];
-	let i = 1;
-	for (; i < printedNodes.length; ++i) if (printedNodes[i].node.type === "array_access") currentGroup.push(printedNodes[i]);
-	else break;
-	if (printedNodes[0].node.type !== "method_invocation") for (; i + 1 < printedNodes.length; ++i) if (printedNodes[i].node.type !== "method_invocation") currentGroup.push(printedNodes[i]);
-	else break;
-	groups.push(currentGroup);
-	currentGroup = [];
-	let hasSeenMethodInvocation = false;
-	for (; i < printedNodes.length; ++i) {
-		if (hasSeenMethodInvocation) {
-			if (printedNodes[i].node.type === "array_access") {
-				currentGroup.push(printedNodes[i]);
-				continue;
-			}
-			groups.push(currentGroup);
-			currentGroup = [];
-			hasSeenMethodInvocation = false;
-		}
-		if (printedNodes[i].node.type === "method_invocation") hasSeenMethodInvocation = true;
-		currentGroup.push(printedNodes[i]);
-		if (printedNodes[i].node.comments?.some(({ trailing }) => trailing)) {
-			groups.push(currentGroup);
-			currentGroup = [];
-			hasSeenMethodInvocation = false;
-		}
-	}
-	if (currentGroup.length > 0) groups.push(currentGroup);
-	function isFactory(name) {
-		return /^[A-Z]|^[$_]+$/.test(name);
-	}
-	function isShort(name) {
-		return name.length <= options.tabWidth;
-	}
-	function shouldNotWrap(groups) {
-		const hasArrayAccess = groups[1][0]?.node.type === "array_access";
-		if (groups[0].length === 1) {
-			const firstNode = groups[0][0].node;
-			return firstNode.type === "this" || firstNode.type === "identifier" && (isFactory(firstNode.value) || isExpressionStatement && isShort(firstNode.value) || hasArrayAccess);
-		}
-		const lastNode = groups[0].at(-1).node;
-		return lastNode.type === "field_access" && lastNode.fieldNode.type === "identifier" && (isFactory(lastNode.fieldNode.value) || hasArrayAccess);
-	}
-	const shouldMerge = groups.length >= 2 && !groups[1][0].node.comments?.length && shouldNotWrap(groups);
-	function printGroup(printedGroup) {
-		return printedGroup.map((tuple) => tuple.printed);
-	}
-	function printIndentedGroup(groups) {
-		if (groups.length === 0) return "";
-		return indent$4([hardline$4, join$4(hardline$4, groups.map(printGroup))]);
-	}
-	const printedGroups = groups.map(printGroup);
-	const oneLine = printedGroups;
-	const cutoff = shouldMerge ? 3 : 2;
-	const flatGroups = groups.flat();
-	const nodeHasComment = flatGroups.some((node) => node.node.comments?.some(({ leading }) => leading)) || flatGroups.slice(0, -1).some((node) => node.node.comments?.some(({ trailing }) => trailing));
-	if (groups.length <= cutoff && !nodeHasComment && !groups.some((g) => g.at(-1).hasTrailingEmptyLine)) return group$4(oneLine);
-	const lastNodeBeforeIndent = groups[shouldMerge ? 1 : 0].at(-1).node;
-	const shouldHaveEmptyLineBeforeIndent = lastNodeBeforeIndent.type !== "method_invocation" && shouldInsertEmptyLineAfter(lastNodeBeforeIndent);
-	const expanded = [
-		printGroup(groups[0]),
-		shouldMerge ? groups.slice(1, 2).map(printGroup) : "",
-		shouldHaveEmptyLineBeforeIndent ? hardline$4 : "",
-		printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))
+	return [
+		node.type === "throw_statement" ? "throw" : "return",
+		node.namedChildren.length ? [" ", path.call(() => printReturnOrThrowArgument(path, print, options), "namedChildren", 0)] : "",
+		";"
 	];
-	const methodInvocations = printedNodes.map(({ node }) => node).filter((node) => node.type === "method_invocation");
-	function lastGroupWillBreakAndOtherCallsHaveFunctionArguments() {
-		const lastGroupNode = groups.at(-1).at(-1).node;
-		const lastGroupDoc = printedGroups.at(-1);
-		return lastGroupNode.type === "method_invocation" && willBreak(lastGroupDoc) && methodInvocations.slice(0, -1).some((node) => node.argumentsNode.namedChildren.some(({ type }) => type === "lambda_expression"));
-	}
-	let result;
-	if (nodeHasComment || methodInvocations.length > 2 && methodInvocations.some((inv) => !inv.argumentsNode.namedChildren.every((arg) => isSimpleCallArgument(arg))) || printedGroups.slice(0, -1).some(willBreak) || lastGroupWillBreakAndOtherCallsHaveFunctionArguments()) result = group$4(expanded);
-	else result = [willBreak(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent$1 : "", conditionalGroup([oneLine, expanded])];
-	return result;
-}
-function printMethodInvocation(path, print) {
-	const parts = [];
-	if (hasChild(path, "objectNode")) parts.push(".");
-	if (path.node.children.filter(({ type }) => type === ".").length === 2) parts.push("super", ".");
-	if (hasChild(path, "type_argumentsNode")) parts.push(path.call(print, "type_argumentsNode"));
-	parts.push(path.call(print, "nameNode"), path.call(print, "argumentsNode"));
-	return parts;
 }
-function printArrayAccess(path, print) {
-	const index = path.call(print, "indexNode");
-	return path.node.indexNode.type === "decimal_integer_literal" ? [
-		"[",
-		index,
-		"]"
-	] : group$4([
-		"[",
-		indent$4([softline$1, index]),
-		softline$1,
-		"]"
-	]);
+function printStatementSeparator(statementType, options) {
+	return statementType === "block" ? printBlockSeparator(options) : " ";
 }
-function printFieldAccess(path, print) {
-	const parts = ["."];
-	if (path.node.children.filter(({ type }) => type === ".").length === 2) parts.push("super.");
-	parts.push(path.call(print, "fieldNode"));
-	return parts;
+function printCatchAndFinallyClauses(path, print, options) {
+	const clauses = [];
+	path.each((child) => {
+		if (child.node.type === "catch_clause" || child.node.type === "finally_clause") clauses.push(printBlockSeparator(options), print(child));
+	}, "namedChildren");
+	return clauses;
 }
-/**
-* 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
-* onto new lines but not all. Operators with the same precedence
-* level should either all break or not. Because we group them by
-* precedence level and the AST is structured based on precedence
-* level, things are naturally broken up correctly, i.e. `&&` is
-* broken before `+`.
-*/
-function printBinaryExpressions(path, print, options, isInsideParentheses) {
-	if (!hasType(path, "binary_expression")) return [group$4(print(path))];
-	const { node } = path;
-	let parts = [];
-	if (node.leftNode.type === "binary_expression" && shouldFlatten(node.operatorNode.type, node.leftNode.operatorNode.type)) parts = path.call(() => printBinaryExpressions(path, print, options, isInsideParentheses), "leftNode");
-	else parts.push(group$4(path.call(print, "leftNode")));
-	const operator = node.operatorNode.type;
-	const operatorDoc = path.call(print, "operatorNode");
-	const rightContent = path.call(print, "rightNode");
-	let right = options.experimentalOperatorPosition === "start" ? [
-		line$4,
-		operatorDoc,
-		" ",
-		rightContent
-	] : [
-		" ",
-		operatorDoc,
-		line$4,
-		rightContent
-	];
-	const { parent } = path;
-	const shouldBreak = node.leftNode.comments?.some(({ trailing, type }) => trailing && type === "line_comment") ?? false;
-	if (shouldBreak || !(isInsideParentheses && logicalOperators.has(operator)) && (parent?.type !== node.type || logicalOperators.has(parent.operatorNode.value) !== logicalOperators.has(operator)) && node.leftNode.type !== node.type && node.rightNode.type !== node.type) right = group$4(right, { shouldBreak });
-	parts.push(right);
-	return parts;
-}
-const logicalOperators = /* @__PURE__ */ new Set(["||", "&&"]);
-function isSimpleCallArgument(node, depth = 2) {
-	if (depth <= 0) return false;
-	const isChildSimple = (child) => isSimpleCallArgument(child, depth - 1);
-	if (isLiteral(node) || isSingleWordType(node) || node.type === "class_literal") return true;
-	if (node.type === "object_creation_expression" || node.type === "method_invocation") {
-		if (node.type === "object_creation_expression" || !node.objectNode || isSimpleCallArgument(node.objectNode, depth)) {
-			const args = node.argumentsNode.namedChildren;
-			return args.length <= depth && args.every(isChildSimple);
-		}
-		return false;
-	}
-	if (node.type === "array_access") return isSimpleCallArgument(node.arrayNode, depth) && isSimpleCallArgument(node.indexNode, depth);
-	if (node.type === "field_access") return isSimpleCallArgument(node.objectNode, depth) && isSimpleCallArgument(node.fieldNode, depth);
-	if (node.type === "unary_expression") return isSimpleCallArgument(node.operandNode, depth);
-	if (node.type === "method_reference" || node.type === "update_expression") return isSimpleCallArgument(node.namedChildren[0], depth);
-	return false;
-}
-function isLiteral(node) {
-	return [
-		"true",
-		"false",
-		"null_literal",
-		"binary_integer_literal",
-		"decimal_floating_point_literal",
-		"decimal_integer_literal",
-		"hex_floating_point_literal",
-		"hex_integer_literal",
-		"octal_integer_literal",
-		"character_literal"
-	].includes(node.type) || isStringLiteral(node);
-}
-function isSingleWordType(node) {
-	return [
-		"identifier",
-		"this",
-		"super"
-	].includes(node.type);
-}
-function couldExpandArg(arg, lambdaChainRecursion = false) {
-	if (arg.type === "array_creation_expression" && arg.valueNode && (arg.valueNode.namedChildren.length > 0 || arg.valueNode.comments)) return true;
-	if (arg.type === "lambda_expression") {
-		const { bodyNode: body } = arg;
-		if (body.type === "block" || body.type === "array_creation_expression") return true;
-		if (body.type === "lambda_expression" && couldExpandArg(body, true)) return true;
-		if (!lambdaChainRecursion) {
-			if (body.type === "ternary_expression") return true;
-			if (body.type === "method_invocation" || body.type === "object_creation_expression") return true;
-		}
-	}
-	return false;
-}
-function shouldExpandLastArg(args) {
-	const lastArg = args.at(-1);
-	const penultimateArg = args.at(-2);
-	return !lastArg.comments?.some(({ leading }) => leading) && !lastArg.comments?.some(({ trailing }) => trailing) && couldExpandArg(lastArg) && (!penultimateArg || penultimateArg.type !== lastArg.type) && (args.length !== 2 || penultimateArg.type !== "lambda_expression");
-}
-function shouldExpandFirstArg(args) {
-	if (args.length !== 2) return false;
-	const [firstArg, secondArg] = args;
-	return !firstArg.comments && firstArg.type === "lambda_expression" && firstArg.bodyNode.type === "block" && secondArg.type !== "lambda_expression" && secondArg.type !== "ternary_expression" && isHopefullyShortCallArgument(secondArg) && !couldExpandArg(secondArg);
-}
-function isHopefullyShortCallArgument(node) {
-	if ((node.type === "method_invocation" || node.type === "object_creation_expression") && node.argumentsNode.namedChildren.length > 1) return false;
-	if (node.type === "binary_expression") return isSimpleCallArgument(node.leftNode, 1) && isSimpleCallArgument(node.rightNode, 1);
-	return isSimpleCallArgument(node);
-}
-function printTernaryTest(path, print) {
-	const { node, parent } = path;
-	const printed = path.call(print, "conditionNode");
-	/**
-	*     a
-	*       ? b
-	*       : multiline
-	*         test
-	*         node
-	*       ^^ align(2)
-	*       ? d
-	*       : e
-	*/
-	if (parent?.type === node.type && parent.alternativeNode === node) return align(2, printed);
-	return printed;
-}
-function getExpressionChild(node) {
-	switch (node.type) {
-		case "assignment_expression": return node.rightNode;
-		case "variable_declarator": return node.valueNode;
-		case "unary_expression": return node.operandNode;
-		case "return_statement":
-		case "throw_statement":
-		case "yield_statement": return node.namedChildren[0];
-		default: return null;
-	}
-}
-function shouldExtraIndentForTernaryExpression(path) {
-	const { node } = path;
-	let parent;
-	let child = node;
-	for (let ancestorCount = 0; !parent; ancestorCount++) {
-		const node = path.getParentNode(ancestorCount);
-		if (node.type === "array_access" && node.arrayNode === child || (node.type === "explicit_constructor_invocation" || node.type === "field_access" || node.type === "method_invocation") && node.objectNode === child || node.type === "method_reference" || node.type === "object_creation_expression") {
-			child = node;
-			continue;
-		}
-		if (node.type === "cast_expression" && node.valueNode === child) {
-			parent = path.getParentNode(ancestorCount + 1);
-			child = node;
-		} else parent = node;
-	}
-	if (child === node) return false;
-	return getExpressionChild(parent) === child;
-}
-function isStringLiteral(node) {
-	return node.type === "string_literal" && node.children[0].value === "\"";
-}
-var ArgExpansionBailout = class extends Error {
-	constructor(..._args) {
-		super(..._args);
-		this.name = "ArgExpansionBailout";
-	}
-};
-//#endregion
-//#region src/printers/interfaces.ts
-const { group: group$3, hardline: hardline$3, indent: indent$3, join: join$3, line: line$3 } = prettier_doc.builders;
-var interfaces_default = {
-	interface_declaration(path, print, options) {
-		const parts = ["interface ", path.call(print, "nameNode")];
-		const extendsInterfacesIndex = path.node.namedChildren.findIndex(({ type }) => type === "extends_interfaces");
-		const hasExtendsInterfaces = extendsInterfacesIndex !== -1;
-		const hasPermits = hasChild(path, "permitsNode");
-		const hasMultipleClauses = hasExtendsInterfaces && hasPermits;
+// src/printers/classes.ts
+const { group: group$5, hardline: hardline$4, indent: indent$5, join: join$5, line: line$4 } = prettier_doc.builders;
+var classes_default = {
+	class_declaration(path, print, options) {
+		const parts = ["class ", path.call(print, "nameNode")];
+		const definedClauses = definedKeys(path.node, [
+			"superclassNode",
+			"interfacesNode",
+			"permitsNode"
+		]);
+		const hasMultipleClauses = definedClauses.length > 1;
 		if (hasChild(path, "type_parametersNode")) {
 			const typeParameters = path.call(print, "type_parametersNode");
-			parts.push(hasMultipleClauses ? group$3(indent$3(typeParameters)) : options?.braceStyle === "next-line" ? group$3(typeParameters) : typeParameters);
+			parts.push(hasMultipleClauses ? group$5(indent$5(typeParameters)) : group$5(typeParameters));
+		}
+		const separators = printDeclarationBodySeparators(definedClauses.length > 0, path.node.bodyNode.namedChildren.length > 0, options);
+		if (definedClauses.length) {
+			const clauses = definedClauses.flatMap((clause) => {
+				if (!hasChild(path, clause)) return [];
+				return [clause === "superclassNode" || clause === "interfacesNode" ? hardline$4 : line$4, path.call(print, clause)];
+			});
+			const clauseGroup = [indent$5(clauses), separators.afterClauses];
+			parts.push(hasMultipleClauses ? clauseGroup : group$5(clauseGroup));
 		}
-		if (hasExtendsInterfaces || hasPermits) {
-			const clauses = [];
-			if (hasExtendsInterfaces) clauses.push(hardline$3, path.call(print, "namedChildren", extendsInterfacesIndex));
-			if (hasPermits) clauses.push(line$3, path.call(print, "permitsNode"));
-			const hasBody = path.node.bodyNode.namedChildren.length > 0;
-			const clauseGroup = [indent$3(clauses), options?.braceStyle === "next-line" ? "" : hasBody ? line$3 : " "];
-			parts.push(hasMultipleClauses ? clauseGroup : group$3(clauseGroup));
-		} else parts.push(" ");
 		return [
 			...printModifiers(path, print, "declarationOnly"),
-			group$3(parts),
+			group$5(parts),
+			separators.afterHeader,
 			path.call(print, "bodyNode")
 		];
 	},
-	extends_interfaces(path, print) {
-		const typeListIndex = path.node.namedChildren.findIndex(({ type }) => type === "type_list");
-		return group$3(["extends", indent$3([line$3, path.call(print, "namedChildren", typeListIndex)])]);
+	type_parameters: printTypeParameters,
+	superclass(path, print) {
+		return ["extends ", path.call(print, "namedChildren", 0)];
 	},
-	interface_body(path, print, options) {
-		return printBlock(path, printBodyDeclarations(path, print), options);
+	super_interfaces(path, print) {
+		return group$5(["implements", indent$5([line$4, path.call(print, "namedChildren", 0)])]);
 	},
-	constant_declaration: printVariableDeclaration,
-	annotation_type_declaration(path, print) {
-		const parts = printModifiers(path, print);
-		parts.push("@interface ", path.call(print, "nameNode"), " ", path.call(print, "bodyNode"));
-		return parts;
+	permits(path, print) {
+		return group$5(["permits", indent$5([line$4, path.call(print, "namedChildren", 0)])]);
 	},
-	annotation_type_body(path, print, options) {
-		return printBlock(path, printBodyDeclarations(path, print), options);
+	type_list(path, print) {
+		return join$5([",", line$4], path.map(print, "namedChildren"));
 	},
-	annotation_type_element_declaration(path, print) {
-		const parts = printModifiers(path, print);
-		parts.push(path.call(print, "typeNode"), " ", path.call(print, "nameNode"), "()");
-		if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
-		if (hasChild(path, "valueNode")) parts.push(" default ", path.call(print, "valueNode"));
-		parts.push(";");
-		return parts;
+	class_body(path, print, options) {
+		return printBlock(path, printBodyDeclarations(path, print, path.parent?.type === "class_declaration" && options?.braceStyle !== "next-line"), options);
 	},
-	annotation(path, print) {
-		return [
-			"@",
-			path.call(print, "nameNode"),
-			path.call(print, "argumentsNode")
+	field_declaration: printVariableDeclaration,
+	variable_declarator(path, print) {
+		const leftDoc = [path.call(print, "nameNode")];
+		if (hasChild(path, "dimensionsNode")) leftDoc.push(path.call(print, "dimensionsNode"));
+		return printAssignment(leftDoc, " =", hasChild(path, "valueNode") ? path.call(print, "valueNode") : void 0, path.node.valueNode);
+	},
+	method_declaration(path, print, options) {
+		const modifiers = printModifiers(path, print);
+		const declaration = [];
+		if (hasChild(path, "type_parametersNode")) declaration.push(group$5(path.call(print, "type_parametersNode")), " ");
+		path.each((child) => {
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") declaration.push(print(child), " ");
+		}, "children");
+		declaration.push(path.call(print, "typeNode"));
+		if (hasChild(path, "dimensionsNode")) declaration.push(path.call(print, "dimensionsNode"));
+		declaration.push(" ", path.call(print, "nameNode"), group$5(path.call(print, "parametersNode")));
+		const throwsIndex = path.node.namedChildren.findIndex(({ type }) => type === "throws");
+		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$4, path.call(print, "namedChildren", throwsIndex)])));
+		return hasChild(path, "bodyNode") ? [
+			modifiers,
+			group$5(declaration),
+			printBlockSeparator(options),
+			path.call(print, "bodyNode")
+		] : [
+			modifiers,
+			group$5(declaration),
+			";"
 		];
 	},
-	marker_annotation(path, print) {
-		return ["@", path.call(print, "nameNode")];
+	receiver_parameter(path, print) {
+		return path.map((child) => child.isLast ? print(child) : [print(child), child.node.type === "identifier" ? "." : " "], "namedChildren");
 	},
-	annotation_argument_list(path, print, options) {
-		const args = path.map(print, "namedChildren");
-		return args.length === 1 && path.node.namedChildren[0].type === "element_value_array_initializer" ? [
+	formal_parameters(path, print, options) {
+		const parameters = path.parent?.type === "record_declaration" ? printBodyDeclarations(path, print) : path.map(print, "namedChildren");
+		if (parameters.length === 0) return [
 			"(",
-			args[0],
+			printDanglingCommentsInList(path),
 			")"
-		] : group$3(indentInParentheses(join$3([",", line$3], args), options));
+		];
+		return indentInParentheses(join$5([",", line$4], parameters), options);
 	},
-	element_value_pair(path, print) {
-		return group$3([
-			path.call(print, "keyNode"),
-			" = ",
-			path.call(print, "valueNode")
-		]);
+	formal_parameter(path, print) {
+		const parameter = printModifiers(path, print, path.grandparent?.type === "record_declaration" ? "avoidBreak" : "noBreak");
+		parameter.push(path.call(print, "typeNode"));
+		if (hasChild(path, "dimensionsNode")) parameter.push(path.call(print, "dimensionsNode"));
+		parameter.push(" ", path.call(print, "nameNode"));
+		return group$5(parameter);
 	},
-	element_value_array_initializer: printArrayInitializer
-};
-//#endregion
-//#region src/printers/lexical-structure.ts
-const { group: group$2, hardline: hardline$2, indent: indent$2, join: join$2, softline } = prettier_doc.builders;
-var lexical_structure_default = {
-	string_literal(path, print) {
-		if (path.node.namedChildren.some(({ type }) => type === "string_interpolation") || path.node.children[0].value === "\"") return path.map(print, "children");
-		return printTextBlock(join$2(hardline$2, textBlockContents(path.node).split("\n")));
+	spread_parameter(path, print) {
+		const parts = printModifiers(path, print, "noBreak");
+		parts.push(path.call(print, "typeNode"));
+		if (hasChild(path, "annotationsNodes")) parts.push(...path.map((annotation) => [" ", print(annotation)], "annotationsNodes"));
+		parts.push("... ", path.call(print, "namedChildren", path.node.namedChildren.length - 1));
+		return parts;
 	},
-	string_fragment: printValue,
-	multiline_string_fragment: printValue,
-	string_interpolation(path, print) {
-		const expressionType = path.node.namedChildren[0].type;
-		const expression = path.call(print, "namedChildren", 0);
-		return expressionType === "binary_expression" || expressionType === "ternary_expression" ? group$2([
-			"\\{",
-			indent$2([softline, expression]),
-			softline,
-			"}"
-		]) : [
-			"\\{",
-			expression,
-			"}"
+	throws(path, print) {
+		const exceptions = path.map(print, "namedChildren");
+		return exceptions.length === 1 ? ["throws ", exceptions[0]] : ["throws", group$5(indent$5([line$4, ...join$5([",", line$4], exceptions)]))];
+	},
+	static_initializer(path, print, options) {
+		return [
+			"static",
+			printBlockSeparator(options),
+			path.call(print, "namedChildren", 0)
 		];
 	},
-	escape_sequence: printValue,
-	character_literal: printValue,
-	binary_integer_literal: printValue,
-	decimal_integer_literal: printValue,
-	hex_integer_literal: printValue,
-	octal_integer_literal: printValue,
-	decimal_floating_point_literal: printValue,
-	hex_floating_point_literal: printValue,
-	null_literal: printValue,
-	true: printValue,
-	false: printValue,
-	this: printValue,
-	super: printValue,
-	underscore_pattern: printValue,
-	asterisk: printValue
-};
-//#endregion
-//#region src/printers/names.ts
-var names_default = {
-	identifier: printValue,
-	type_identifier: printValue,
-	scoped_identifier(path, print) {
+	constructor_declaration(path, print, options) {
+		const modifiers = printModifiers(path, print, "declarationOnly");
+		const declaration = [];
+		if (hasChild(path, "type_parametersNode")) declaration.push(group$5(path.call(print, "type_parametersNode")), " ");
+		declaration.push(path.call(print, "nameNode"), group$5(path.call(print, "parametersNode")));
+		const throwsIndex = path.node.namedChildren.findIndex(({ type }) => type === "throws");
+		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$4, path.call(print, "namedChildren", throwsIndex)])));
 		return [
-			path.call(print, "scopeNode"),
-			".",
-			path.call(print, "nameNode")
+			modifiers,
+			group$5(declaration),
+			printBlockSeparator(options),
+			path.call(print, "bodyNode")
 		];
 	},
-	scoped_type_identifier(path, print) {
-		return path.map((child) => child.node.type === "annotation" || child.node.type === "marker_annotation" ? [print(child), " "] : print(child), "children");
-	}
-};
-//#endregion
-//#region src/printers/packages-and-modules.ts
-const { group: group$1, hardline: hardline$1, indent: indent$1, join: join$1, line: line$2 } = prettier_doc.builders;
-var packages_and_modules_default = {
-	program(path, print, options) {
-		if (!path.node.namedChildren.length) return [printDanglingComments(path), hardline$1];
-		const parts = [];
-		if (path.node.namedChildren[0].type !== "import_declaration") parts.push(path.call(print, "namedChildren", 0));
-		const moduleImports = [];
-		const imports = [];
-		const otherDeclarations = [];
-		path.each((child) => {
-			const doc = print(child);
-			if (child.node.type === "import_declaration") {
-				const names = extractNames(child.node.namedChildren[0]);
-				if (child.node.namedChildren.some(({ type }) => type === "asterisk")) names.push("*");
-				const modifier = child.node.children[1].type;
-				(modifier === "module" ? moduleImports : imports).push({
-					doc,
-					names,
-					isStatic: modifier === "static"
-				});
-			} else if (!child.isFirst) otherDeclarations.push(doc);
-		}, "namedChildren");
-		parts.push(...[moduleImports.sort(compareFqn), ...groupImports(imports, options.importOrder)].filter((group) => group.length).map((group) => join$1(hardline$1, group.map(({ doc }) => doc))), ...otherDeclarations);
-		return [...join$1([hardline$1, hardline$1], parts), hardline$1];
+	constructor_body(path, print, options) {
+		return printBlock(path, printBlockStatements(path, print), options);
 	},
-	package_declaration(path, print) {
-		const annotations = [];
-		const identifier = [];
+	explicit_constructor_invocation(path, print) {
+		const invocation = [];
+		if (hasChild(path, "objectNode")) invocation.push(path.call(print, "objectNode"), ".");
+		if (hasChild(path, "type_argumentsNode")) invocation.push(path.call(print, "type_argumentsNode"));
+		invocation.push(path.call(print, "constructorNode"), path.call(print, "argumentsNode"), ";");
+		return invocation;
+	},
+	visibility: printValue,
+	modifier: printValue,
+	modifiers(path, print, _, args) {
+		const parts = [];
+		const modifiers = [];
+		const typeAnnotations = [];
 		path.each((child) => {
-			switch (child.node.type) {
-				case "annotation":
-				case "marker_annotation":
-					annotations.push(print(child));
-					break;
-				case "identifier":
-				case "scoped_identifier": identifier.push(print(child));
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") (modifiers.length ? typeAnnotations : parts).push(print(child));
+			else {
+				modifiers.push(child.node.value);
+				parts.push(...typeAnnotations);
+				typeAnnotations.length = 0;
 			}
 		}, "namedChildren");
-		return join$1(hardline$1, [...annotations, [
-			"package ",
-			...identifier,
-			";"
-		]]);
+		const annotationMode = args && typeof args === "object" && "annotationMode" in args ? args.annotationMode : null;
+		if (annotationMode === "declarationOnly") {
+			parts.push(...typeAnnotations);
+			typeAnnotations.length = 0;
+		}
+		modifiers.sort((a, b) => (indexByModifier.get(a) ?? -1) - (indexByModifier.get(b) ?? -1));
+		if (modifiers.length || typeAnnotations.length) parts.push(join$5(" ", [...modifiers, ...typeAnnotations]));
+		return join$5(annotationMode === "avoidBreak" ? line$4 : annotationMode === "noBreak" ? " " : hardline$4, parts);
 	},
-	import_declaration(path, print) {
-		const declaration = ["import "];
-		const modifier = path.node.children[1].type;
-		if (modifier === "module" || modifier === "static") declaration.push(modifier, " ");
-		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier" || type === "scoped_identifier");
-		declaration.push(path.call(print, "namedChildren", identifierIndex));
-		if (path.node.namedChildren.some(({ type }) => type === "asterisk")) declaration.push(".*");
-		declaration.push(";");
-		return declaration;
+	enum_declaration(path, print, options) {
+		const modifiers = printModifiers(path, print, "declarationOnly");
+		const parts = ["enum ", path.call(print, "nameNode")];
+		const hasInterfaces = hasChild(path, "interfacesNode");
+		const separators = printDeclarationBodySeparators(hasInterfaces, path.node.bodyNode.namedChildren.length > 0, options);
+		if (hasInterfaces) parts.push(indent$5([hardline$4, path.call(print, "interfacesNode")]), separators.afterClauses);
+		return [
+			...modifiers,
+			group$5(parts),
+			separators.afterHeader,
+			path.call(print, "bodyNode")
+		];
 	},
-	module_declaration(path, print) {
-		const parts = [];
-		path.each((child) => {
-			if (child.node.type === "annotation" || child.node.type === "marker_annotation") parts.push(print(child));
-		}, "namedChildren");
-		if (path.node.children.some(({ type }) => type === "open")) parts.push("open");
-		parts.push("module", path.call(print, "nameNode"), path.call(print, "bodyNode"));
-		return join$1(" ", parts);
+	enum_body(path, print, options) {
+		const parts = printBodyDeclarations(path, print);
+		const enumBodyDeclarationsIndex = path.node.namedChildren.findIndex(({ type }) => type === "enum_body_declarations");
+		const declarations = [];
+		if (enumBodyDeclarationsIndex !== -1) {
+			const hasDeclarations = path.node.namedChildren[enumBodyDeclarationsIndex].namedChildren.length > 0;
+			const enumBodyDeclarations = parts.pop();
+			if (hasDeclarations) {
+				if (!parts.length) declarations.push(hardline$4);
+				declarations.push(enumBodyDeclarations);
+			}
+		}
+		const contents = [];
+		if (parts.length) {
+			contents.push(join$5([",", hardline$4], parts));
+			if (!declarations.length && options.trailingComma !== "none") contents.push(",");
+		}
+		if (declarations.length) contents.push(";", hardline$4, ...declarations);
+		return printBlock(path, contents.length ? [contents] : [], options);
 	},
-	module_body(path, print, options) {
-		return printBlock(path, path.map((child) => child.previous && child.node.start.row > child.previous.end.row + 1 ? [hardline$1, print(child)] : print(child), "namedChildren"), options);
+	enum_constant(path, print, options) {
+		const initializer = printModifiers(path, print);
+		initializer.push(path.call(print, "nameNode"));
+		if (hasChild(path, "argumentsNode")) initializer.push(path.call(print, "argumentsNode"));
+		if (hasChild(path, "bodyNode")) initializer.push(printBlockSeparator(options), path.call(print, "bodyNode"));
+		return initializer;
 	},
-	requires_module_directive(path, print) {
-		const parts = ["requires"];
-		path.each((child) => {
-			if (child.node.type === "requires_modifier") parts.push(print(child));
-		}, "namedChildren");
-		parts.push(path.call(print, "moduleNode"));
-		return [...join$1(" ", parts), ";"];
+	enum_body_declarations(path, print) {
+		return join$5(hardline$4, printBodyDeclarations(path, print));
 	},
-	exports_module_directive: printToModuleNamesDirective,
-	opens_module_directive: printToModuleNamesDirective,
-	uses_module_directive(path, print) {
+	record_declaration(path, print, options) {
+		const modifiers = printModifiers(path, print, "declarationOnly");
+		const parts = ["record ", path.call(print, "nameNode")];
+		if (hasChild(path, "type_parametersNode")) parts.push(group$5(path.call(print, "type_parametersNode")));
+		parts.push(group$5(path.call(print, "parametersNode")));
+		const hasInterfaces = hasChild(path, "interfacesNode");
+		const separators = printDeclarationBodySeparators(hasInterfaces, path.node.bodyNode.namedChildren.length > 0, options);
+		if (hasInterfaces) {
+			const interfaces = [hardline$4, path.call(print, "interfacesNode")];
+			parts.push(group$5([indent$5(interfaces), separators.afterClauses]));
+		}
 		return [
-			"uses ",
-			path.call(print, "typeNode"),
-			";"
+			...modifiers,
+			group$5(parts),
+			separators.afterHeader,
+			path.call(print, "bodyNode")
 		];
 	},
-	provides_module_directive(path, print) {
-		const [provided, ...providers] = path.map(print, "namedChildren");
-		return [
-			"provides ",
-			provided,
-			group$1(indent$1([line$2, group$1(indent$1([
-				"with",
-				line$2,
-				...join$1([",", line$2], providers)
-			]))])),
-			";"
+	compact_constructor_declaration(path, print, options) {
+		const parts = printModifiers(path, print, "declarationOnly");
+		parts.push(path.call(print, "nameNode"), printBlockSeparator(options), path.call(print, "bodyNode"));
+		return parts;
+	}
+};
+const indexByModifier = [
+	"public",
+	"protected",
+	"private",
+	"abstract",
+	"default",
+	"static",
+	"final",
+	"transient",
+	"volatile",
+	"synchronized",
+	"native",
+	"sealed",
+	"non-sealed",
+	"strictfp"
+].reduce((map, name, index) => map.set(name, index), /* @__PURE__ */ new Map());
+// src/printers/expressions.ts
+const { align, breakParent, conditionalGroup, dedent, group: group$4, hardline: hardline$3, ifBreak, indent: indent$4, indentIfBreak, join: join$4, line: line$3, lineSuffixBoundary, softline: softline$1 } = prettier_doc.builders;
+const { getNextNonSpaceNonCommentCharacterIndex, hasNewline, isNextLineEmpty } = prettier.util;
+const { removeLines, willBreak } = prettier_doc.utils;
+var expressions_default = {
+	lambda_expression(path, print, options, args) {
+		const signatureDocs = [];
+		let bodyDoc;
+		const bodyComments = [];
+		const shouldPrintAsChain = !(args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg) && path.node.bodyNode.type === "lambda_expression";
+		let functionBody;
+		(function rec() {
+			const { node } = path;
+			const signatureDoc = printLambdaExpressionSignature(path, options, print, args);
+			if (signatureDocs.length === 0) signatureDocs.push(signatureDoc);
+			else {
+				const { leading, trailing } = printCommentsSeparately(path);
+				signatureDocs.push([leading, signatureDoc]);
+				bodyComments.unshift(trailing);
+			}
+			if (!shouldPrintAsChain || node.bodyNode.type !== "lambda_expression") {
+				bodyDoc = path.call((child) => print(child, args), "bodyNode");
+				functionBody = node.bodyNode;
+			} else path.call(rec, "bodyNode");
+		})();
+		const shouldPutBodyOnSameLine = !functionBody.comments?.some((comment) => comment.leading && hasNewline(options.originalText, comment.end.index)) && mayBreakAfterShortPrefix(functionBody);
+		const chainGroupId = Symbol("arrow-chain");
+		const signaturesDoc = printArrowFunctionSignatures(path, { signatureDocs });
+		bodyDoc = printArrowFunctionBody(path, args, options, {
+			bodyDoc,
+			bodyComments,
+			bodySeparator: functionBody.type === "block" ? printBlockSeparator(options) : " ",
+			shouldPutBodyOnSameLine
+		});
+		return group$4([
+			group$4(signaturesDoc, { id: chainGroupId }),
+			" ->",
+			shouldPrintAsChain ? indentIfBreak(bodyDoc, { groupId: chainGroupId }) : group$4(bodyDoc)
+		]);
+	},
+	inferred_parameters(path, print, options) {
+		const identifiers = [];
+		path.each((child) => {
+			if (child.node.type === "identifier") identifiers.push(print(child));
+		}, "namedChildren");
+		if (!identifiers.length) return "()";
+		const parameters = join$4([",", line$3], identifiers);
+		if (identifiers.length > 1 || willBreak(identifiers)) return group$4(indentInParentheses(parameters, options));
+		return options.arrowParens === "avoid" ? parameters : [
+			"(",
+			...parameters,
+			")"
 		];
 	},
-	requires_modifier: printValue
-};
-function extractNames(node) {
-	return node.type === "identifier" ? [node.value] : [...extractNames(node.scopeNode), node.nameNode.value];
-}
-const STATIC_PREFIX = "static ";
-const CATCH_ALL_PREFIX = "";
-function groupImports(imports, importOrder) {
-	if (!importOrder) return [imports.filter(({ isStatic }) => isStatic), imports.filter(({ isStatic }) => !isStatic)].filter((group) => group.length).map((group) => group.sort(compareFqn));
-	const groups = parseImportOrder(importOrder);
-	const prefixes = groups.flat();
-	const importsByPrefix = /* @__PURE__ */ new Map();
-	for (const entry of imports) {
-		const key = importKey(entry);
-		const prefix = prefixes.filter((candidate) => key.startsWith(candidate)).reduce((best, candidate) => candidate.length > best.length ? candidate : best);
-		importsByPrefix.set(prefix, [...importsByPrefix.get(prefix) ?? [], {
-			key,
-			entry
-		}]);
-	}
-	return groups.map((group) => group.flatMap((prefix) => (importsByPrefix.get(prefix) ?? []).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0).map(({ entry }) => entry))).filter((group) => group.length);
-}
-/**
-* Parses an import order in Spotless's format: groups separated by `,` are
-* printed with blank lines between them, prefixes joined by `|` share a group,
-* `#` marks a static prefix, and an empty prefix catches everything else.
-* Each import belongs to its longest matching prefix.
-*/
-function parseImportOrder(importOrder) {
-	const knownPrefixes = /* @__PURE__ */ new Set();
-	const groups = importOrder.split(",").map((group) => group.split("|").map((prefix) => prefix.startsWith("#") ? STATIC_PREFIX + prefix.slice(1) : prefix).filter((prefix) => {
-		if (knownPrefixes.has(prefix)) return false;
-		knownPrefixes.add(prefix);
-		return true;
-	}));
-	if (!knownPrefixes.has(STATIC_PREFIX)) {
-		const lastStaticGroupIndex = groups.findLastIndex((group) => group.some((prefix) => prefix.startsWith(STATIC_PREFIX)));
-		groups.splice(Math.max(lastStaticGroupIndex, 0), 0, [STATIC_PREFIX]);
-	}
-	if (!knownPrefixes.has(CATCH_ALL_PREFIX)) groups.push([CATCH_ALL_PREFIX]);
-	return groups;
-}
-function importKey({ names, isStatic }) {
-	return (isStatic ? STATIC_PREFIX : "") + names.join(".");
-}
-function compareFqn({ names: a }, { names: b }) {
-	const minParts = Math.min(a.length, b.length);
-	for (let i = 0; i < minParts; i++) {
-		const imageA = a[i];
-		const imageB = b[i];
-		if (imageA < imageB) return -1;
-		else if (imageA > imageB) return 1;
-	}
-	return a.length - b.length;
-}
-function printToModuleNamesDirective(path, print) {
-	const directive = [
-		path.node.type === "exports_module_directive" ? "exports" : "opens",
-		" ",
-		path.call(print, "packageNode")
-	];
-	if (path.node.modulesNodes.length) {
-		const moduleNames = join$1([",", line$2], path.map(print, "modulesNodes"));
-		directive.push(group$1(indent$1([line$2, group$1(indent$1([
-			"to",
-			line$2,
-			...moduleNames
-		]))])));
-	}
-	directive.push(";");
-	return directive;
-}
-//#endregion
-//#region src/printers/types-values-and-variables.ts
-const { group, indent, join, line: line$1 } = prettier_doc.builders;
-var types_values_and_variables_default = {
-	boolean_type: printValue,
-	integral_type: printValue,
-	floating_point_type: printValue,
-	void_type: printValue,
-	array_type(path, print) {
-		return [path.call(print, "elementNode"), path.call(print, "dimensionsNode")];
+	ternary_expression(path, print, options) {
+		const { node } = path;
+		const consequentNode = node.consequenceNode;
+		const parts = [];
+		const parent = path.parent;
+		const isParentTest = parent.type === node.type && parent.conditionNode === node;
+		const forceNoIndent = parent.type === node.type && !isParentTest;
+		let currentParent;
+		let previousParent;
+		let i = 0;
+		do {
+			previousParent = currentParent || node;
+			currentParent = path.getParentNode(i);
+			i++;
+		} while (currentParent && currentParent.type === node.type && currentParent.conditionNode !== previousParent);
+		const firstNonConditionalParent = currentParent || parent;
+		const operatorAtEnd = options.experimentalOperatorPosition === "end";
+		const printBranch = (nodePropertyName) => operatorAtEnd || isTextBlock(node[nodePropertyName]) ? path.call(print, nodePropertyName) : options.useTabs ? indent$4(path.call(print, nodePropertyName)) : align(2, path.call(print, nodePropertyName));
+		const openParen = consequentNode.type === node.type ? ifBreak("", "(") : "";
+		const closeParen = consequentNode.type === node.type ? ifBreak("", ")") : "";
+		const part = operatorAtEnd ? [
+			" ?",
+			line$3,
+			openParen,
+			printBranch("consequenceNode"),
+			closeParen,
+			" :",
+			line$3,
+			printBranch("alternativeNode")
+		] : [
+			line$3,
+			"? ",
+			openParen,
+			printBranch("consequenceNode"),
+			closeParen,
+			line$3,
+			": ",
+			printBranch("alternativeNode")
+		];
+		parts.push(operatorAtEnd || parent.type !== node.type || parent.alternativeNode === node || isParentTest ? part : options.useTabs ? dedent(indent$4(part)) : align(Math.max(0, options.tabWidth - 2), part));
+		const maybeGroup = (doc) => parent === firstNonConditionalParent ? group$4(doc) : doc;
+		const breakClosingParen = parent.type === "explicit_constructor_invocation" || parent.type === "field_access" || parent.type === "method_invocation" || parent.type === "method_reference" || parent.type === "object_creation_expression";
+		const shouldExtraIndent = shouldExtraIndentForTernaryExpression(path);
+		const result = maybeGroup([
+			printTernaryTest(path, print, operatorAtEnd),
+			forceNoIndent && !operatorAtEnd ? parts : indent$4(parts),
+			breakClosingParen && !shouldExtraIndent ? closingBracketLine(options) : ""
+		]);
+		return isParentTest || shouldExtraIndent ? group$4([indent$4([softline$1, result]), closingBracketLine(options)]) : result;
 	},
-	annotated_type(path, print) {
-		return join(" ", path.map(print, "children"));
+	assignment_expression(path, print) {
+		const { node } = path;
+		return printAssignment(path.call(print, "leftNode"), [" ", node.operatorNode.type], path.call(print, "rightNode"), node.rightNode);
 	},
-	dimensions(path, print) {
-		return path.map((child) => {
-			if (child.node.isNamed) return [
-				...child.isFirst ? [" "] : [],
-				print(child),
-				" "
-			];
-			return child.node.value;
-		}, "children");
+	binary_expression(path, print, options) {
+		const { node } = path;
+		const parent = path.parent;
+		const grandparent = path.grandparent;
+		const isInsideParentheses = (grandparent?.type === "if_statement" || grandparent?.type === "while_statement" || grandparent?.type === "switch_expression" || grandparent?.type === "do_statement") && grandparent.conditionNode === parent || grandparent?.type === "synchronized_statement" && grandparent.bodyNode !== parent;
+		const parts = printBinaryExpressions(path, print, options, isInsideParentheses);
+		if (isInsideParentheses) return parts;
+		if (parent?.type === "unary_expression" && !node.comments || (parent?.type === "explicit_constructor_invocation" || parent?.type === "field_access" || parent?.type === "method_invocation") && parent.objectNode === node || parent?.type === "method_reference" || parent?.type === "object_creation_expression") return group$4([indent$4([softline$1, ...parts]), closingBracketLine(options)]);
+		if (isReturnOrThrowStatement(parent) || parent?.type === "assignment_expression" || parent?.type === "variable_declarator" || parent?.type === "guard" || parent?.type === "lambda_expression" && parent.bodyNode === node || parent?.type === "for_statement" && parent.conditionNode === node || parent?.type === "ternary_expression" && !isReturnOrThrowStatement(grandparent) && grandparent?.type !== "parenthesized_expression" && grandparent?.type !== "argument_list" || parent?.type === "unary_expression" && parent.operandNode === node) return group$4(parts);
+		if (parts.length === 0) return "";
+		const firstGroupIndex = parts.findIndex((part) => typeof part !== "string" && !Array.isArray(part) && part.type === "group");
+		const headParts = parts.slice(0, firstGroupIndex === -1 ? 1 : firstGroupIndex + 1);
+		const rest = parts.slice(headParts.length);
+		return group$4([...headParts, indent$4(rest)]);
 	},
-	type_parameter(path, print) {
-		return join(" ", path.map(print, "children"));
+	instanceof_expression(path, print, options) {
+		return group$4(indent$4(path.map((child) => {
+			const doc = print(child, { annotationMode: "noBreak" });
+			if (!child.previous) return doc;
+			return [(options.experimentalOperatorPosition === "start" ? child.node.type === "instanceof" : child.previous.type === "instanceof") ? line$3 : " ", doc];
+		}, "children")));
 	},
-	type_bound(path, print) {
-		const [firstType, ...restTypes] = path.map(print, "namedChildren");
-		const bound = ["extends ", firstType];
-		if (restTypes.length) bound.push(group(indent([
-			line$1,
-			"& ",
-			...join([line$1, "& "], restTypes)
-		])));
-		return bound;
+	unary_expression(path, print, options) {
+		const parts = [path.call(print, "operatorNode")];
+		const operandDoc = path.call(print, "operandNode");
+		if (path.node.operandNode.comments) parts.push(group$4(indentInParentheses(operandDoc, options)));
+		else parts.push(operandDoc);
+		return parts;
 	},
-	type_arguments: printTypeParameters,
-	wildcard(path, print) {
-		return join(" ", path.map(print, "children"));
-	}
-};
-//#endregion
-//#region src/printers/index.ts
-const printersByNodeType = {
-	ERROR(path) {
-		throw new Error(`Failed to parse: "${printValue(path)}"`);
+	field_access: printMemberChain,
+	generic_type(path, print) {
+		const typeIdentifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "scoped_type_identifier" || type === "type_identifier");
+		const typeArgumentsIndex = path.node.namedChildren.findIndex(({ type }) => type === "type_arguments");
+		return [path.call(print, "namedChildren", typeIdentifierIndex), path.call(print, "namedChildren", typeArgumentsIndex)];
 	},
-	...arrays_default,
-	...blocks_and_statements_default,
-	...classes_default,
-	...expressions_default,
-	...interfaces_default,
-	...lexical_structure_default,
-	...names_default,
-	...packages_and_modules_default,
-	...types_values_and_variables_default
-};
-function printerForNodeType(type) {
-	return printersByNodeType[type];
-}
-//#endregion
-//#region src/printer.ts
-var printer_default = {
-	print(path, options, print, args) {
-		if (!hasNamedNode(path)) return printValue(path);
-		const doc = printerForNodeType(path.node.type)(path, print, options, args);
-		return needsParentheses(path) ? [
+	parenthesized_expression(path, print, options) {
+		const expression = path.call(print, "namedChildren", 0);
+		const parentType = path.parent?.type;
+		const grandparentType = path.grandparent?.type;
+		const expressionType = path.node.namedChildren[0].type;
+		const hasLambda = expressionType === "lambda_expression";
+		const hasTernary = expressionType === "ternary_expression";
+		const hasSuffix = parentType && (parentType === "array_access" || parentType === "explicit_constructor_invocation" || parentType === "field_access" || parentType === "method_invocation" || parentType === "method_reference" || parentType === "object_creation_expression");
+		const isAssignment = parentType && (parentType === "assignment_expression" || parentType === "variable_declarator") || hasSuffix && (grandparentType === "assignment_expression" || grandparentType === "variable_declarator");
+		if (!hasLambda && hasSuffix && (!hasTernary || isAssignment)) return group$4(indentInParentheses(hasTernary ? group$4(expression) : expression, options));
+		else if (parentType && (parentType === "guard" || parentType === "return_statement" || parentType === "unary_expression" && grandparentType === "return_statement" || path.node.fieldName === "condition" && (parentType === "do_statement" || parentType === "if_statement" || parentType === "switch_expression" || parentType === "while_statement") || path.node.fieldName !== "body" && parentType === "synchronized_statement")) return group$4(indentInParentheses(group$4(expression), options));
+		else if (hasTernary && hasSuffix && !isAssignment) return group$4([
 			"(",
-			doc,
+			expression,
+			closingBracketLine(options),
 			")"
-		] : doc;
-	},
-	embed(path, options) {
-		return hasType(path, "string_literal") ? embedTextBlock(path, options) : null;
-	},
-	hasPrettierIgnore(path) {
-		return path.node.comments?.some(isPrettierIgnore) === true || canAttachComment(path.node, path.parent ? [path.parent] : []) && isFullyBetweenPrettierIgnore(path);
-	},
-	canAttachComment,
-	isBlockComment(node) {
-		return node.type === "block_comment";
-	},
-	willPrintOwnComments,
-	printComment(commentPath) {
-		return printComment(commentPath.node);
+		]);
+		else return group$4([
+			"(",
+			hasLambda || hasTernary ? expression : indent$4(expression),
+			")"
+		]);
 	},
-	getCommentChildNodes(node) {
-		return node.isNamed ? node.children : [];
+	cast_expression(path, print, options) {
+		const { node } = path;
+		const parts = [
+			group$4(node.typeNodes.length === 1 ? [
+				"(",
+				path.call(print, "typeNodes", 0),
+				")"
+			] : [
+				"(",
+				indent$4([softline$1, join$4([" &", line$3], path.map(print, "typeNodes"))]),
+				closingBracketLine(options),
+				")"
+			]),
+			" ",
+			path.call(print, "valueNode")
+		];
+		const parent = path.parent;
+		if (parent?.type === "unary_expression" && !node.comments || parent?.type === "array_access" && parent.arrayNode === node || (parent?.type === "explicit_constructor_invocation" || parent?.type === "field_access" || parent?.type === "method_invocation") && parent.objectNode === node || parent?.type === "method_reference" || parent?.type === "object_creation_expression") return group$4([indent$4([softline$1, ...parts]), closingBracketLine(options)]);
+		return parts;
 	},
-	handleComments: {
-		ownLine: handleLineComment,
-		endOfLine: handleLineComment,
-		remaining: handleRemainingComment
+	object_creation_expression(path, print, options) {
+		const expression = [];
+		path.each((child) => {
+			if (child.node.type === "class_body") expression.push(printBlockSeparator(options));
+			expression.push(print(child));
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation" || child.node.type === "new") expression.push(" ");
+		}, "children");
+		return expression;
 	},
-	getVisitorKeys() {
-		return ["namedChildren"];
-	}
-};
-function hasNamedNode(path) {
-	return path.node.isNamed;
-}
-//#endregion
-//#region src/comments.ts
-const { hasNewline, isPreviousLineEmpty, skipNewline, skipSpaces } = prettier.util;
-const { breakParent, hardline, line, lineSuffix } = prettier_doc.builders;
-const prettierIgnoreRangesByTree = /* @__PURE__ */ new WeakMap();
-function determinePrettierIgnoreRanges(tree) {
-	const { comments } = tree;
-	if (!comments) return;
-	const ranges = comments.filter(({ value }) => /^\/(?:\/\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*|\*\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*\*\/)$/.test(value)).reduce((ranges, { value, start }) => {
-		const previous = ranges.at(-1);
-		if (value.includes("start") || value.includes("off")) {
-			if (previous?.end !== Infinity) ranges.push({
-				start: start.index,
-				end: Infinity
-			});
-		} else if (previous?.end === Infinity) previous.end = start.index;
-		return ranges;
-	}, new Array());
-	prettierIgnoreRangesByTree.set(tree, ranges);
+	method_invocation: printMemberChain,
+	argument_list(path, print, options) {
+		const args = path.node.namedChildren;
+		if (args.length === 0) {
+			const shouldBreak = path.node.comments?.some(({ type, leading, trailing }) => !leading && !trailing && type === "line_comment");
+			return group$4([
+				"(",
+				printDanglingCommentsInList(path),
+				")"
+			], { shouldBreak });
+		}
+		const lastArgIndex = args.length - 1;
+		let anyArgEmptyLine = false;
+		const printedArguments = [];
+		path.each((arg, index) => {
+			let argDoc = print(arg);
+			if (index === lastArgIndex) {} else if (isNextLineEmpty(options.originalText, arg.node.end.index)) {
+				anyArgEmptyLine = true;
+				argDoc = [
+					argDoc,
+					",",
+					hardline$3,
+					hardline$3
+				];
+			} else argDoc = [
+				argDoc,
+				",",
+				line$3
+			];
+			printedArguments.push(argDoc);
+		}, "namedChildren");
+		function allArgsBrokenOut() {
+			return group$4([
+				"(",
+				indent$4([line$3, ...printedArguments]),
+				closingBracketLine(options, line$3),
+				")"
+			], { shouldBreak: true });
+		}
+		if (anyArgEmptyLine) return allArgsBrokenOut();
+		if (shouldExpandFirstArg(args)) {
+			const tailArgs = printedArguments.slice(1);
+			if (tailArgs.some(willBreak)) return allArgsBrokenOut();
+			let firstArg;
+			try {
+				firstArg = path.call((arg) => print(arg, { expandFirstArg: true }), "namedChildren", 0);
+			} catch (caught) {
+				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
+				throw caught;
+			}
+			if (willBreak(firstArg)) return [breakParent, conditionalGroup([[
+				"(",
+				group$4(firstArg, { shouldBreak: true }),
+				", ",
+				...tailArgs,
+				")"
+			], allArgsBrokenOut()])];
+			return conditionalGroup([
+				[
+					"(",
+					firstArg,
+					", ",
+					...tailArgs,
+					")"
+				],
+				[
+					"(",
+					group$4(firstArg, { shouldBreak: true }),
+					", ",
+					...tailArgs,
+					")"
+				],
+				allArgsBrokenOut()
+			]);
+		}
+		if (shouldExpandLastArg(args, options)) {
+			const headArgs = printedArguments.slice(0, -1);
+			if (headArgs.some(willBreak)) return allArgsBrokenOut();
+			let lastArg;
+			try {
+				lastArg = path.call((arg) => print(arg, { expandLastArg: true }), "namedChildren", lastArgIndex);
+			} catch (caught) {
+				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
+				throw caught;
+			}
+			if (willBreak(lastArg)) return [breakParent, conditionalGroup([[
+				"(",
+				...headArgs,
+				group$4(lastArg, { shouldBreak: true }),
+				")"
+			], allArgsBrokenOut()])];
+			return conditionalGroup([
+				[
+					"(",
+					...headArgs,
+					lastArg,
+					")"
+				],
+				[
+					"(",
+					...headArgs,
+					group$4(lastArg, { shouldBreak: true }),
+					")"
+				],
+				allArgsBrokenOut()
+			]);
+		}
+		return group$4(indentInParentheses(printedArguments, options), { shouldBreak: printedArguments.some(willBreak) || anyArgEmptyLine });
+	},
+	array_creation_expression(path, print) {
+		const parts = ["new "];
+		path.each((child) => {
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") parts.push(print(child), " ");
+		}, "namedChildren");
+		parts.push(path.call(print, "typeNode"), ...path.map(print, "dimensionsNodes"));
+		if (hasChild(path, "valueNode")) parts.push(" ", path.call(print, "valueNode"));
+		return parts;
+	},
+	dimensions_expr(path, print) {
+		return path.map((child) => child.node.type === "annotation" || child.node.type === "marker_annotation" ? [print(child), " "] : [
+			"[",
+			print(child),
+			"]"
+		], "namedChildren");
+	},
+	class_literal(path, print) {
+		return [path.call(print, "namedChildren", 0), ".class"];
+	},
+	array_access: printMemberChain,
+	method_reference(path, print) {
+		return group$4(path.map(print, "children"));
+	},
+	template_expression(path, print) {
+		return [
+			path.call(print, "template_processorNode"),
+			".",
+			path.call(print, "template_argumentNode")
+		];
+	},
+	pattern(path, print) {
+		return path.call(print, "namedChildren", 0);
+	},
+	type_pattern(path, print) {
+		return join$4(" ", path.map(print, "children"));
+	},
+	record_pattern(path, print) {
+		return path.map(print, "children");
+	},
+	record_pattern_body(path, print, options) {
+		return group$4(indentInParentheses(join$4([",", line$3], path.map(print, "namedChildren")), options));
+	},
+	record_pattern_component(path, print) {
+		return join$4(" ", path.map(print, "children"));
+	},
+	guard(path, print, options) {
+		return ["when ", group$4([
+			ifBreak("("),
+			indent$4([softline$1, path.call(print, "namedChildren", 0)]),
+			closingBracketLine(options),
+			ifBreak(")")
+		])];
+	}
+};
+function printLambdaExpressionSignature(path, options, print, args) {
+	const parts = [];
+	const parameters = path.call(print, "parametersNode");
+	if (shouldPrintParamsWithoutParens(path, options)) parts.push(parameters);
+	else {
+		if (args != null && typeof args === "object" && ("expandLastArg" in args && args.expandLastArg === true || "expandFirstArg" in args && args.expandFirstArg === true)) {
+			if (willBreak(parameters)) throw new ArgExpansionBailout();
+			parts.push(group$4(removeLines(parameters)));
+		} else parts.push(parameters);
+		if (path.node.parametersNode.type === "identifier") return path.node.parametersNode.comments ? group$4([
+			"(",
+			indent$4([softline$1, ...parts]),
+			lineSuffixBoundary,
+			")"
+		]) : [
+			"(",
+			...parts,
+			")"
+		];
+	}
+	const dangling = printDanglingComments(path);
+	if (dangling) parts.push(" ", dangling);
+	return parts;
 }
-function isFullyBetweenPrettierIgnore(path) {
-	const { node, root } = path;
-	const start = parser_default.locStart(node);
-	const end = parser_default.locEnd(node);
-	return prettierIgnoreRangesByTree.get(root)?.some((range) => range.start < start && end < range.end) === true;
+function mayBreakAfterShortPrefix(functionBody) {
+	return functionBody.type === "array_creation_expression" || functionBody.type === "lambda_expression" || functionBody.type === "block";
 }
-function isPrettierIgnore(comment) {
-	return /^(\/\/\s*prettier-ignore|\/\*\s*prettier-ignore\s*\*\/)$/.test(comment.value);
+function printArrowFunctionSignatures(path, { signatureDocs }) {
+	if (signatureDocs.length === 1) return signatureDocs[0];
+	const { node, parent } = path;
+	if (node.fieldName !== "object" && parent?.type === "method_invocation" || parent?.type === "binary_expression") return group$4([
+		signatureDocs[0],
+		" ->",
+		indent$4([line$3, join$4([" ->", line$3], signatureDocs.slice(1))])
+	]);
+	if (node.fieldName === "object" && parent?.type === "method_invocation") return group$4(join$4([" ->", line$3], signatureDocs));
+	return group$4(indent$4(join$4([" ->", line$3], signatureDocs)));
 }
-function willPrintOwnComments(path) {
-	return isMember(path.node) && !printer_default.hasPrettierIgnore(path);
+function printArrowFunctionBody(path, args, options, { bodyDoc, bodyComments, bodySeparator, shouldPutBodyOnSameLine }) {
+	const trailingSpace = args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg && !path.node.comments ? closingBracketLine(options) : "";
+	return shouldPutBodyOnSameLine ? [
+		bodySeparator,
+		bodyDoc,
+		bodyComments
+	] : [indent$4([
+		line$3,
+		bodyDoc,
+		bodyComments
+	]), trailingSpace];
 }
-function canAttachComment(node, ancestors) {
-	if (!node.isNamed) return isBinaryOperator(node);
-	switch (node.type) {
-		case "enum_body_declarations":
-		case "escape_sequence":
-		case "modifier":
-		case "multiline_string_fragment":
-		case "program":
-		case "string_fragment":
-		case "visibility": return false;
-		case "parenthesized_expression": {
-			const [parent] = ancestors;
-			return !(parent.isNamed && [
-				"do_statement",
-				"if_statement",
-				"switch_expression",
-				"synchronized_statement",
-				"try_statement",
-				"try_with_resources_statement",
-				"while_statement"
-			].includes(parent.type));
-		}
-		default: return true;
+function shouldPrintParamsWithoutParens(path, options) {
+	if (options.arrowParens === "always") return false;
+	if (options.arrowParens === "avoid") {
+		const { node } = path;
+		return canPrintParamsWithoutParens(node);
 	}
+	return false;
 }
-function handleLineComment(commentNode, _, options) {
-	return [
-		handleBinaryExpressionComments,
-		handleFormalParametersComments,
-		handleFqnOrRefTypeComments,
-		handleIfStatementComments,
-		handleJumpStatementComments,
-		handleLabeledStatementComments,
-		handleLambdaExpressionComments,
-		handleMemberChainComments,
-		handleModifiersComments,
-		handleNameComments,
-		handleTernaryExpressionComments,
-		handleTryStatementComments
-	].some((fn) => fn(commentNode, options));
-}
-function handleRemainingComment(commentNode) {
-	return [
-		handleFqnOrRefTypeComments,
-		handleNameComments,
-		handleJumpStatementComments
-	].some((fn) => fn(commentNode));
+function canPrintParamsWithoutParens(node) {
+	return node.parametersNode.type === "identifier" && !hasDanglingComments(node) && !node.parametersNode.comments;
 }
-function handleBinaryExpressionComments(commentNode, options) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "binary_expression") {
-		if (isBinaryOperator(followingNode)) {
-			if (options.experimentalOperatorPosition === "start") prettier.util.addLeadingComment(followingNode, commentNode);
-			else prettier.util.addTrailingComment(followingNode, commentNode);
-			return true;
-		} else if (options.experimentalOperatorPosition === "start" && isBinaryOperator(precedingNode)) {
-			prettier.util.addLeadingComment(precedingNode, commentNode);
-			return true;
-		}
+function printMemberChain(path, print, options) {
+	const isExpressionStatement = path.parent?.type === "expression_statement";
+	const printedNodes = [];
+	function shouldInsertEmptyLineAfter(node) {
+		const { originalText } = options;
+		const nextCharIndex = getNextNonSpaceNonCommentCharacterIndex(originalText, node.end.index);
+		if ((nextCharIndex ? originalText.charAt(nextCharIndex) : "") === ")") return nextCharIndex !== false && isNextLineEmpty(originalText, nextCharIndex + 1);
+		return isNextLineEmpty(originalText, node.end.index);
 	}
-	return false;
-}
-function handleFormalParametersComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "formal_parameters" && !precedingNode && !followingNode) {
-		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
-		return true;
+	function rec(path) {
+		const { node } = path;
+		if (hasType(path, "method_invocation") && hasChild(path, "objectNode")) {
+			const hasTrailingEmptyLine = shouldInsertEmptyLineAfter(node);
+			printedNodes.unshift({
+				node,
+				hasTrailingEmptyLine,
+				printed: [printComments(path, printMethodInvocation(path, print)), hasTrailingEmptyLine ? hardline$3 : ""]
+			});
+			path.call(rec, "objectNode");
+		} else if (hasType(path, "array_access")) {
+			printedNodes.unshift({
+				node,
+				printed: printComments(path, printArrayAccess(path, print))
+			});
+			path.call(rec, "arrayNode");
+		} else if (hasType(path, "field_access")) {
+			printedNodes.unshift({
+				node,
+				printed: printComments(path, printFieldAccess(path, print))
+			});
+			path.call(rec, "objectNode");
+		} else printedNodes.unshift({
+			node,
+			printed: print(path)
+		});
 	}
-	return false;
-}
-function handleFqnOrRefTypeComments(commentNode) {
-	const { enclosingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "scoped_type_identifier" && followingNode) {
-		prettier.util.addLeadingComment(followingNode, commentNode);
-		return true;
+	const { node } = path;
+	if (hasType(path, "method_invocation")) {
+		printedNodes.unshift({
+			node,
+			printed: printMethodInvocation(path, print)
+		});
+		if (hasChild(path, "objectNode")) path.call(rec, "objectNode");
+	} else if (hasType(path, "array_access")) {
+		printedNodes.unshift({
+			node,
+			printed: printArrayAccess(path, print)
+		});
+		if (hasChild(path, "arrayNode")) path.call(rec, "arrayNode");
+	} else if (hasType(path, "field_access")) {
+		printedNodes.unshift({
+			node,
+			printed: printFieldAccess(path, print)
+		});
+		if (hasChild(path, "objectNode")) path.call(rec, "objectNode");
 	}
-	return false;
-}
-function handleIfStatementComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode?.type === "if_statement" && precedingNode?.fieldName === "consequence") {
-		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
-		return true;
+	node.comments?.filter(({ leading }) => leading).filter(({ start }) => start.index >= node.start.index).filter(({ end }) => end.index <= node.end.index).map((comment) => comment.leading = false);
+	const danglingComments = printDanglingComments(path);
+	if (danglingComments) {
+		const lastNode = printedNodes.at(-1);
+		lastNode.printed = [
+			danglingComments,
+			hardline$3,
+			lastNode.printed
+		];
 	}
-	return false;
-}
-function handleJumpStatementComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode && !precedingNode && !followingNode && (enclosingNode.type === "break_statement" || enclosingNode.type === "continue_statement" || enclosingNode.type === "return_statement")) {
-		prettier.util.addTrailingComment(enclosingNode, commentNode);
-		return true;
+	const groups = [];
+	let currentGroup = [printedNodes[0]];
+	let i = 1;
+	for (; i < printedNodes.length; ++i) if (printedNodes[i].node.type === "array_access") currentGroup.push(printedNodes[i]);
+	else break;
+	if (printedNodes[0].node.type !== "method_invocation") for (; i + 1 < printedNodes.length; ++i) if (printedNodes[i].node.type !== "method_invocation") currentGroup.push(printedNodes[i]);
+	else break;
+	groups.push(currentGroup);
+	currentGroup = [];
+	let hasSeenMethodInvocation = false;
+	for (; i < printedNodes.length; ++i) {
+		if (hasSeenMethodInvocation) {
+			if (printedNodes[i].node.type === "array_access") {
+				currentGroup.push(printedNodes[i]);
+				continue;
+			}
+			groups.push(currentGroup);
+			currentGroup = [];
+			hasSeenMethodInvocation = false;
+		}
+		if (printedNodes[i].node.type === "method_invocation") hasSeenMethodInvocation = true;
+		currentGroup.push(printedNodes[i]);
+		if (printedNodes[i].node.comments?.some(({ trailing }) => trailing)) {
+			groups.push(currentGroup);
+			currentGroup = [];
+			hasSeenMethodInvocation = false;
+		}
 	}
-	return false;
-}
-function handleLabeledStatementComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode?.type === "labeled_statement" && precedingNode?.type === "identifier") {
-		prettier.util.addLeadingComment(precedingNode, commentNode);
-		return true;
+	if (currentGroup.length > 0) groups.push(currentGroup);
+	function isFactory(name) {
+		return /^[A-Z]|^[$_]+$/.test(name);
 	}
-	return false;
-}
-function handleLambdaExpressionComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "lambda_expression" && precedingNode && followingNode && enclosingNode.children.find(({ type }) => type === "->").end.index < commentNode.start.index) {
-		if (followingNode.type === "block") {
-			if (followingNode.namedChildren.length) prettier.util.addLeadingComment(followingNode.namedChildren[0], commentNode);
-			else prettier.util.addDanglingComment(followingNode, commentNode, void 0);
-		} else prettier.util.addLeadingComment(followingNode, commentNode);
-		return true;
+	function isShort(name) {
+		return name.length <= options.tabWidth;
 	}
-}
-function handleMemberChainComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (precedingNode && (enclosingNode?.type === "field_access" || enclosingNode?.type === "method_invocation" && precedingNode.end.row < commentNode.start.row) && precedingNode === enclosingNode.objectNode) {
-		prettier.util.addLeadingComment(enclosingNode, commentNode);
-		return true;
-	} else if (isMember(followingNode) && (!precedingNode || precedingNode !== getMemberObject(followingNode) && precedingNode.end.row < commentNode.start.row) && !isPrettierIgnore(commentNode)) {
-		prettier.util.addDanglingComment(followingNode, commentNode, void 0);
-		return true;
+	function shouldNotWrap(groups) {
+		const hasArrayAccess = groups[1][0]?.node.type === "array_access";
+		if (groups[0].length === 1) {
+			const firstNode = groups[0][0].node;
+			return firstNode.type === "this" || firstNode.type === "identifier" && (isFactory(firstNode.value) || isExpressionStatement && isShort(firstNode.value) || hasArrayAccess);
+		}
+		const lastNode = groups[0].at(-1).node;
+		return lastNode.type === "field_access" && lastNode.fieldNode.type === "identifier" && (isFactory(lastNode.fieldNode.value) || hasArrayAccess);
 	}
-	return false;
-}
-function handleModifiersComments(commentNode) {
-	const { precedingNode } = commentNode;
-	if (precedingNode?.type === "annotation" || precedingNode?.type === "marker_annotation" || precedingNode?.type === "modifiers") {
-		prettier.util.addTrailingComment(precedingNode, commentNode);
-		return true;
+	const shouldMerge = groups.length >= 2 && !groups[1][0].node.comments?.length && shouldNotWrap(groups);
+	function printGroup(printedGroup) {
+		return printedGroup.map((tuple) => tuple.printed);
 	}
-	return false;
-}
-function handleNameComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode && precedingNode?.type === "identifier" && (enclosingNode.type === "scoped_identifier" || enclosingNode.type === "module_declaration" || enclosingNode.type === "package_declaration" || enclosingNode.type === "scoped_type_identifier")) {
-		prettier.util.addTrailingComment(precedingNode, commentNode);
-		return true;
+	function printIndentedGroup(groups) {
+		if (groups.length === 0) return "";
+		return indent$4([hardline$3, join$4(hardline$3, groups.map(printGroup))]);
 	}
-	return false;
-}
-function handleTernaryExpressionComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "ternary_expression" && precedingNode?.isNamed && followingNode?.isNamed && precedingNode.end.row < commentNode.start.row && commentNode.end.row < followingNode.start.row) {
-		prettier.util.addLeadingComment(followingNode, commentNode);
-		return true;
+	const printedGroups = groups.map(printGroup);
+	const oneLine = printedGroups;
+	const cutoff = shouldMerge ? 3 : 2;
+	const flatGroups = groups.flat();
+	const nodeHasComment = flatGroups.at(-1).node.comments?.some(({ leading, trailing }) => !leading && !trailing) || flatGroups.slice(1, -1).some((node) => node.node.comments?.some(({ leading }) => leading)) || flatGroups.slice(0, -1).some((node) => node.node.comments?.some(({ trailing }) => trailing));
+	if (groups.length <= cutoff && !nodeHasComment && !groups.some((g) => g.at(-1).hasTrailingEmptyLine)) return group$4(oneLine);
+	const lastNodeBeforeIndent = groups[shouldMerge ? 1 : 0].at(-1).node;
+	const shouldHaveEmptyLineBeforeIndent = lastNodeBeforeIndent.type !== "method_invocation" && shouldInsertEmptyLineAfter(lastNodeBeforeIndent);
+	const expanded = [
+		printGroup(groups[0]),
+		shouldMerge ? groups.slice(1, 2).map(printGroup) : "",
+		shouldHaveEmptyLineBeforeIndent ? hardline$3 : "",
+		printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))
+	];
+	const methodInvocations = printedNodes.map(({ node }) => node).filter((node) => node.type === "method_invocation");
+	function lastGroupWillBreakAndOtherCallsHaveFunctionArguments() {
+		const lastGroupNode = groups.at(-1).at(-1).node;
+		const lastGroupDoc = printedGroups.at(-1);
+		return lastGroupNode.type === "method_invocation" && willBreak(lastGroupDoc) && methodInvocations.slice(0, -1).some((node) => node.argumentsNode.namedChildren.some(({ type }) => type === "lambda_expression"));
 	}
-	return false;
+	let result;
+	if (nodeHasComment || methodInvocations.length > 2 && methodInvocations.some((inv) => !inv.argumentsNode.namedChildren.every((arg) => isSimpleCallArgument(arg))) || printedGroups.slice(0, -1).some(willBreak) || lastGroupWillBreakAndOtherCallsHaveFunctionArguments()) result = group$4(expanded);
+	else result = [willBreak(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent : "", conditionalGroup([oneLine, expanded])];
+	return result;
 }
-function handleTryStatementComments(commentNode) {
-	const { enclosingNode, followingNode } = commentNode;
-	if (enclosingNode && (enclosingNode.type === "catch_clause" || enclosingNode.type === "try_statement" || enclosingNode.type === "try_with_resources_statement") && followingNode?.isNamed) {
-		const block = followingNode.type === "catch_clause" ? followingNode.bodyNode : followingNode.type === "finally_clause" ? followingNode.namedChildren[0] : null;
-		if (!block) return false;
-		const blockStatement = block.namedChildren.at(0);
-		if (blockStatement) prettier.util.addLeadingComment(blockStatement, commentNode);
-		else prettier.util.addDanglingComment(block, commentNode, void 0);
-		return true;
-	}
-	return false;
+function printMethodInvocation(path, print) {
+	const parts = [];
+	if (hasChild(path, "objectNode")) parts.push(".");
+	if (path.node.children.filter(({ type }) => type === ".").length === 2) parts.push("super", ".");
+	if (hasChild(path, "type_argumentsNode")) parts.push(path.call(print, "type_argumentsNode"));
+	parts.push(path.call(print, "nameNode"), path.call(print, "argumentsNode"));
+	return parts;
 }
-function getMemberObject(node) {
-	return node.type === "array_access" ? node.arrayNode : node.objectNode;
+function printArrayAccess(path, print) {
+	const index = path.call(print, "indexNode");
+	return path.node.indexNode.type === "decimal_integer_literal" ? [
+		"[",
+		index,
+		"]"
+	] : group$4([
+		"[",
+		indent$4([softline$1, index]),
+		softline$1,
+		"]"
+	]);
 }
-const binaryOperators = /* @__PURE__ */ new Set([
-	"<<",
-	">>",
-	">>>",
-	"instanceof",
-	"<=",
-	">=",
-	"==",
-	"-",
-	"+",
-	"&&",
-	"&",
-	"^",
-	"!=",
-	"||",
-	"|",
-	"*",
-	"/",
-	"%"
-]);
-function isBinaryOperator(node) {
-	return node !== void 0 && binaryOperators.has(node.type);
+function printFieldAccess(path, print) {
+	const parts = ["."];
+	if (path.node.children.filter(({ type }) => type === ".").length === 2) parts.push("super.");
+	parts.push(path.call(print, "fieldNode"));
+	return parts;
 }
-function printLeadingComment(path) {
-	const comment = path.node;
-	const parts = [printComment(comment)];
-	const originalText = path.root.value;
-	if (comment.type === "block_comment") {
-		let lineBreak = " ";
-		if (hasNewline(originalText, parser_default.locEnd(comment))) {
-			if (hasNewline(originalText, parser_default.locStart(comment), { backwards: true })) lineBreak = hardline;
-			else lineBreak = line;
-		}
-		parts.push(lineBreak);
-	} else parts.push(hardline);
-	const index = skipNewline(originalText, skipSpaces(originalText, parser_default.locEnd(comment)));
-	if (index !== false && hasNewline(originalText, index)) parts.push(hardline);
+/**
+* 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
+* onto new lines but not all. Operators with the same precedence
+* level should either all break or not. Because we group them by
+* precedence level and the AST is structured based on precedence
+* level, things are naturally broken up correctly, i.e. `&&` is
+* broken before `+`.
+*/
+function printBinaryExpressions(path, print, options, isInsideParentheses) {
+	if (!hasType(path, "binary_expression")) return [group$4(print(path))];
+	const { node } = path;
+	let parts = [];
+	if (node.leftNode.type === "binary_expression" && shouldFlatten(node.operatorNode.type, node.leftNode.operatorNode.type)) parts = path.call(() => printBinaryExpressions(path, print, options, isInsideParentheses), "leftNode");
+	else parts.push(group$4(path.call(print, "leftNode")));
+	const operator = node.operatorNode.type;
+	const operatorDoc = path.call(print, "operatorNode");
+	const rightContent = path.call(print, "rightNode");
+	let right = options.experimentalOperatorPosition === "start" ? [
+		line$3,
+		operatorDoc,
+		" ",
+		rightContent
+	] : [
+		" ",
+		operatorDoc,
+		line$3,
+		rightContent
+	];
+	const { parent } = path;
+	const shouldBreak = node.leftNode.comments?.some(({ trailing, type }) => trailing && type === "line_comment") ?? false;
+	if (shouldBreak || !(isInsideParentheses && logicalOperators.has(operator)) && (parent?.type !== node.type || logicalOperators.has(parent.operatorNode.value) !== logicalOperators.has(operator)) && node.leftNode.type !== node.type && node.rightNode.type !== node.type) right = group$4(right, { shouldBreak });
+	parts.push(right);
 	return parts;
 }
-function printTrailingComment(path, previousComment) {
-	const comment = path.node;
-	const printed = printComment(comment);
-	const originalText = path.root.value;
-	const isBlock = comment.type === "block_comment";
-	if (previousComment?.hasLineSuffix && !previousComment?.isBlock || hasNewline(originalText, parser_default.locStart(comment), { backwards: true })) {
-		const isLineBeforeEmpty = isPreviousLineEmpty(originalText, parser_default.locStart(comment));
-		return {
-			doc: lineSuffix([
-				hardline,
-				isLineBeforeEmpty ? hardline : "",
-				printed
-			]),
-			isBlock,
-			hasLineSuffix: true
-		};
+const logicalOperators = /* @__PURE__ */ new Set(["||", "&&"]);
+const isType = createTypeCheckFunction([
+	"void_type",
+	"integral_type",
+	"floating_point_type",
+	"floating_point_type",
+	"boolean_type",
+	"type_identifier",
+	"scoped_type_identifier",
+	"generic_type",
+	"array_type",
+	"annotated_type"
+]);
+function isSimpleCallArgument(node, depth = 2) {
+	if (depth <= 0) return false;
+	const isChildSimple = (child) => isSimpleCallArgument(child, depth - 1);
+	if (isLiteral(node) || isSingleWordType(node) || node.type === "class_literal") return true;
+	if (node.type === "object_creation_expression" || node.type === "method_invocation") {
+		if (node.type === "object_creation_expression" || !node.objectNode || isSimpleCallArgument(node.objectNode, depth)) {
+			const args = node.argumentsNode.namedChildren;
+			return args.length <= depth && args.every(isChildSimple);
+		}
+		return false;
+	}
+	if (node.type === "array_access") return isSimpleCallArgument(node.arrayNode, depth) && isSimpleCallArgument(node.indexNode, depth);
+	if (node.type === "field_access") return isSimpleCallArgument(node.objectNode, depth) && isSimpleCallArgument(node.fieldNode, depth);
+	if (node.type === "unary_expression") return isSimpleCallArgument(node.operandNode, depth);
+	if (node.type === "method_reference" || node.type === "update_expression") {
+		const [qualifierNode] = node.namedChildren;
+		return isType(qualifierNode) || isSimpleCallArgument(qualifierNode, depth);
+	}
+	return false;
+}
+function isLiteral(node) {
+	return [
+		"true",
+		"false",
+		"null_literal",
+		"binary_integer_literal",
+		"decimal_floating_point_literal",
+		"decimal_integer_literal",
+		"hex_floating_point_literal",
+		"hex_integer_literal",
+		"octal_integer_literal",
+		"character_literal"
+	].includes(node.type) || isStringLiteral(node);
+}
+const isSingleWordType = createTypeCheckFunction([
+	"identifier",
+	"this",
+	"super"
+]);
+function couldExpandArg(arg, lambdaChainRecursion = false) {
+	if (arg.type === "array_creation_expression" && arg.valueNode && (arg.valueNode.namedChildren.length > 0 || arg.valueNode.comments)) return true;
+	if (arg.type === "lambda_expression") {
+		const { bodyNode: body } = arg;
+		if (body.type === "block" || body.type === "array_creation_expression") return true;
+		if (body.type === "lambda_expression" && couldExpandArg(body, true)) return true;
+		if (!lambdaChainRecursion) {
+			if (body.type === "ternary_expression") return true;
+			if (body.type === "method_invocation" || body.type === "object_creation_expression") return true;
+		}
+	}
+	return false;
+}
+function shouldExpandLastArg(args, options) {
+	const lastArg = args.at(-1);
+	const penultimateArg = args.at(-2);
+	return !lastArg.comments?.some(({ leading, trailing }) => leading || trailing) && couldExpandArg(lastArg) && (!penultimateArg || penultimateArg.type !== lastArg.type) && (args.length !== 2 || penultimateArg.type !== "lambda_expression" || lastArg.type !== "array_creation_expression") && !(args.length > 1 && lastArg.type === "array_creation_expression" && lastArg.valueNode && isConciselyPrintedArray(lastArg.valueNode, options));
+}
+function shouldExpandFirstArg(args) {
+	if (args.length !== 2) return false;
+	const [firstArg, secondArg] = args;
+	return !firstArg.comments && firstArg.type === "lambda_expression" && firstArg.bodyNode.type === "block" && secondArg.type !== "lambda_expression" && secondArg.type !== "ternary_expression" && isHopefullyShortCallArgument(secondArg) && !couldExpandArg(secondArg);
+}
+function isHopefullyShortCallArgument(node) {
+	if ((node.type === "method_invocation" || node.type === "object_creation_expression") && node.argumentsNode.namedChildren.length > 1) return false;
+	if (node.type === "binary_expression") return isSimpleCallArgument(node.leftNode, 1) && isSimpleCallArgument(node.rightNode, 1);
+	return isSimpleCallArgument(node);
+}
+function printTernaryTest(path, print, operatorAtEnd) {
+	const { node, parent } = path;
+	const printed = path.call(print, "conditionNode");
+	/**
+	*     a
+	*       ? b
+	*       : multiline
+	*         test
+	*         node
+	*       ^^ align(2)
+	*       ? d
+	*       : e
+	*
+	* With operators at the end there is no `: ` prefix to align under.
+	*/
+	if (!operatorAtEnd && parent?.type === node.type && parent.alternativeNode === node) return align(2, printed);
+	return printed;
+}
+function getExpressionChild(node) {
+	switch (node.type) {
+		case "assignment_expression": return node.rightNode;
+		case "variable_declarator": return node.valueNode;
+		case "unary_expression": return node.operandNode;
+		case "return_statement":
+		case "throw_statement":
+		case "yield_statement": return node.namedChildren[0];
+		default: return null;
+	}
+}
+function shouldExtraIndentForTernaryExpression(path) {
+	const { node } = path;
+	let parent;
+	let child = node;
+	for (let ancestorCount = 0; !parent; ancestorCount++) {
+		const node = path.getParentNode(ancestorCount);
+		if (node.type === "array_access" && node.arrayNode === child || (node.type === "explicit_constructor_invocation" || node.type === "field_access" || node.type === "method_invocation") && node.objectNode === child || node.type === "method_reference" || node.type === "object_creation_expression") {
+			child = node;
+			continue;
+		}
+		if (node.type === "cast_expression" && node.valueNode === child) {
+			parent = path.getParentNode(ancestorCount + 1);
+			child = node;
+		} else parent = node;
+	}
+	if (child === node) return false;
+	return getExpressionChild(parent) === child;
+}
+function isStringLiteral(node) {
+	return node.type === "string_literal" && !isTextBlock(node);
+}
+var ArgExpansionBailout = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "ArgExpansionBailout";
+	}
+};
+// src/printers/interfaces.ts
+const { group: group$3, hardline: hardline$2, indent: indent$3, join: join$3, line: line$2 } = prettier_doc.builders;
+var interfaces_default = {
+	interface_declaration(path, print, options) {
+		const parts = ["interface ", path.call(print, "nameNode")];
+		const extendsInterfacesIndex = path.node.namedChildren.findIndex(({ type }) => type === "extends_interfaces");
+		const hasExtendsInterfaces = extendsInterfacesIndex !== -1;
+		const hasPermits = hasChild(path, "permitsNode");
+		const hasMultipleClauses = hasExtendsInterfaces && hasPermits;
+		if (hasChild(path, "type_parametersNode")) {
+			const typeParameters = path.call(print, "type_parametersNode");
+			parts.push(hasMultipleClauses ? group$3(indent$3(typeParameters)) : group$3(typeParameters));
+		}
+		const separators = printDeclarationBodySeparators(hasExtendsInterfaces || hasPermits, path.node.bodyNode.namedChildren.length > 0, options);
+		if (hasExtendsInterfaces || hasPermits) {
+			const clauses = [];
+			if (hasExtendsInterfaces) clauses.push(hardline$2, path.call(print, "namedChildren", extendsInterfacesIndex));
+			if (hasPermits) clauses.push(line$2, path.call(print, "permitsNode"));
+			const clauseGroup = [indent$3(clauses), separators.afterClauses];
+			parts.push(hasMultipleClauses ? clauseGroup : group$3(clauseGroup));
+		}
+		return [
+			...printModifiers(path, print, "declarationOnly"),
+			group$3(parts),
+			separators.afterHeader,
+			path.call(print, "bodyNode")
+		];
+	},
+	extends_interfaces(path, print) {
+		const typeListIndex = path.node.namedChildren.findIndex(({ type }) => type === "type_list");
+		return group$3(["extends", indent$3([line$2, path.call(print, "namedChildren", typeListIndex)])]);
+	},
+	interface_body(path, print, options) {
+		return printBlock(path, printBodyDeclarations(path, print), options);
+	},
+	constant_declaration: printVariableDeclaration,
+	annotation_type_declaration(path, print, options) {
+		const parts = printModifiers(path, print);
+		parts.push("@interface ", path.call(print, "nameNode"), printBlockSeparator(options), path.call(print, "bodyNode"));
+		return parts;
+	},
+	annotation_type_body(path, print, options) {
+		return printBlock(path, printBodyDeclarations(path, print), options);
+	},
+	annotation_type_element_declaration(path, print) {
+		const parts = printModifiers(path, print);
+		parts.push(path.call(print, "typeNode"), " ", path.call(print, "nameNode"), "()");
+		if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
+		if (hasChild(path, "valueNode")) parts.push(" default ", path.call(print, "valueNode"));
+		parts.push(";");
+		return parts;
+	},
+	annotation(path, print) {
+		return [
+			"@",
+			path.call(print, "nameNode"),
+			path.call(print, "argumentsNode")
+		];
+	},
+	marker_annotation(path, print) {
+		return ["@", path.call(print, "nameNode")];
+	},
+	annotation_argument_list(path, print, options) {
+		const args = path.map(print, "namedChildren");
+		return args.length === 1 && path.node.namedChildren[0].type === "element_value_array_initializer" ? [
+			"(",
+			args[0],
+			")"
+		] : group$3(indentInParentheses(join$3([",", line$2], args), options));
+	},
+	element_value_pair(path, print) {
+		return group$3([
+			path.call(print, "keyNode"),
+			" = ",
+			path.call(print, "valueNode")
+		]);
+	},
+	element_value_array_initializer: printArrayInitializer
+};
+// src/printers/lexical-structure.ts
+const { group: group$2, hardline: hardline$1, indent: indent$2, join: join$2, softline } = prettier_doc.builders;
+var lexical_structure_default = {
+	string_literal(path, print) {
+		if (path.node.namedChildren.some(({ type }) => type === "string_interpolation") || !isTextBlock(path.node)) return path.map(print, "children");
+		return printTextBlock(join$2(hardline$1, textBlockContents(path.node).split("\n")));
+	},
+	string_fragment: printValue,
+	multiline_string_fragment: printValue,
+	string_interpolation(path, print) {
+		const expressionType = path.node.namedChildren[0].type;
+		const expression = path.call(print, "namedChildren", 0);
+		return expressionType === "binary_expression" || expressionType === "ternary_expression" ? group$2([
+			"\\{",
+			indent$2([softline, expression]),
+			softline,
+			"}"
+		]) : [
+			"\\{",
+			expression,
+			"}"
+		];
+	},
+	escape_sequence: printValue,
+	character_literal: printValue,
+	binary_integer_literal: printValue,
+	decimal_integer_literal: printValue,
+	hex_integer_literal: printValue,
+	octal_integer_literal: printValue,
+	decimal_floating_point_literal: printValue,
+	hex_floating_point_literal: printValue,
+	null_literal: printValue,
+	true: printValue,
+	false: printValue,
+	this: printValue,
+	super: printValue,
+	underscore_pattern: printValue,
+	asterisk: printValue
+};
+// src/printers/names.ts
+var names_default = {
+	identifier: printValue,
+	type_identifier: printValue,
+	scoped_identifier(path, print) {
+		return [
+			path.call(print, "scopeNode"),
+			".",
+			path.call(print, "nameNode")
+		];
+	},
+	scoped_type_identifier(path, print) {
+		return path.map((child) => child.node.type === "annotation" || child.node.type === "marker_annotation" ? [print(child), " "] : print(child), "children");
+	}
+};
+// src/printers/packages-and-modules.ts
+const { group: group$1, hardline, indent: indent$1, join: join$1, line: line$1 } = prettier_doc.builders;
+var packages_and_modules_default = {
+	program(path, print, options) {
+		if (!path.node.namedChildren.length) return [printDanglingComments(path), hardline];
+		const parts = [];
+		if (path.node.namedChildren[0].type !== "import_declaration") parts.push(path.call(print, "namedChildren", 0));
+		const moduleImports = [];
+		const imports = [];
+		const otherDeclarations = [];
+		path.each((child) => {
+			const doc = print(child);
+			if (child.node.type === "import_declaration") {
+				const names = extractNames(child.node.namedChildren[0]);
+				if (child.node.namedChildren.some(({ type }) => type === "asterisk")) names.push("*");
+				const modifier = child.node.children[1].type;
+				(modifier === "module" ? moduleImports : imports).push({
+					doc,
+					names,
+					isStatic: modifier === "static"
+				});
+			} else if (!child.isFirst) otherDeclarations.push(doc);
+		}, "namedChildren");
+		parts.push(...[moduleImports.sort(compareFqn), ...groupImports(imports, options.importOrder)].filter((group) => group.length).map((group) => join$1(hardline, group.map(({ doc }) => doc))), ...otherDeclarations);
+		return [...join$1([hardline, hardline], parts), hardline];
+	},
+	package_declaration(path, print) {
+		const annotations = [];
+		const identifier = [];
+		path.each((child) => {
+			switch (child.node.type) {
+				case "annotation":
+				case "marker_annotation":
+					annotations.push(print(child));
+					break;
+				case "identifier":
+				case "scoped_identifier": identifier.push(print(child));
+			}
+		}, "namedChildren");
+		return join$1(hardline, [...annotations, [
+			"package ",
+			...identifier,
+			";"
+		]]);
+	},
+	import_declaration(path, print) {
+		const declaration = ["import "];
+		const modifier = path.node.children[1].type;
+		if (modifier === "module" || modifier === "static") declaration.push(modifier, " ");
+		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier" || type === "scoped_identifier");
+		declaration.push(path.call(print, "namedChildren", identifierIndex));
+		if (path.node.namedChildren.some(({ type }) => type === "asterisk")) declaration.push(".*");
+		declaration.push(";");
+		return declaration;
+	},
+	module_declaration(path, print, options) {
+		const parts = [];
+		path.each((child) => {
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") parts.push(print(child));
+		}, "namedChildren");
+		if (path.node.children.some(({ type }) => type === "open")) parts.push("open");
+		parts.push("module", path.call(print, "nameNode"));
+		return [
+			join$1(" ", parts),
+			printBlockSeparator(options),
+			path.call(print, "bodyNode")
+		];
+	},
+	module_body(path, print, options) {
+		return printBlock(path, path.map((child) => child.previous && child.node.start.row > child.previous.end.row + 1 ? [hardline, print(child)] : print(child), "namedChildren"), options);
+	},
+	requires_module_directive(path, print) {
+		const parts = ["requires"];
+		path.each((child) => {
+			if (child.node.type === "requires_modifier") parts.push(print(child));
+		}, "namedChildren");
+		parts.push(path.call(print, "moduleNode"));
+		return [...join$1(" ", parts), ";"];
+	},
+	exports_module_directive: printToModuleNamesDirective,
+	opens_module_directive: printToModuleNamesDirective,
+	uses_module_directive(path, print) {
+		return [
+			"uses ",
+			path.call(print, "typeNode"),
+			";"
+		];
+	},
+	provides_module_directive(path, print) {
+		const [provided, ...providers] = path.map(print, "namedChildren");
+		return [
+			"provides ",
+			provided,
+			group$1(indent$1([line$1, group$1(indent$1([
+				"with",
+				line$1,
+				...join$1([",", line$1], providers)
+			]))])),
+			";"
+		];
+	},
+	requires_modifier: printValue
+};
+function extractNames(node) {
+	return node.type === "identifier" ? [node.value] : [...extractNames(node.scopeNode), node.nameNode.value];
+}
+const STATIC_PREFIX = "static ";
+const CATCH_ALL_PREFIX = "";
+function groupImports(imports, importOrder) {
+	if (!importOrder) return [imports.filter(({ isStatic }) => isStatic), imports.filter(({ isStatic }) => !isStatic)].filter((group) => group.length).map((group) => group.sort(compareFqn));
+	const groups = parseImportOrder(importOrder);
+	const prefixes = groups.flat();
+	const importsByPrefix = /* @__PURE__ */ new Map();
+	for (const entry of imports) {
+		const key = importKey(entry);
+		const prefix = prefixes.filter((candidate) => key.startsWith(candidate)).reduce((best, candidate) => candidate.length > best.length ? candidate : best);
+		const bucket = importsByPrefix.get(prefix);
+		if (bucket) bucket.push({
+			key,
+			entry
+		});
+		else importsByPrefix.set(prefix, [{
+			key,
+			entry
+		}]);
 	}
-	if (!isBlock || previousComment?.hasLineSuffix) return {
-		doc: [lineSuffix([" ", printed]), breakParent],
-		isBlock,
-		hasLineSuffix: true
-	};
-	return {
-		doc: [" ", printed],
-		isBlock,
-		hasLineSuffix: false
-	};
+	return groups.map((group) => group.flatMap((prefix) => (importsByPrefix.get(prefix) ?? []).sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0).map(({ entry }) => entry))).filter((group) => group.length);
 }
-function printLeadingComments(path) {
-	if (!hasChild(path, "comments")) return [];
-	const docs = [];
-	path.each((path) => {
-		const { node: comment } = path;
-		if (!comment.leading) return;
-		docs.push(printLeadingComment(path));
-	}, "comments");
-	return docs;
+/**
+* Parses an import order in Spotless's format: groups separated by `,` are
+* printed with blank lines between them, prefixes joined by `|` share a group,
+* `#` marks a static prefix, and an empty prefix catches everything else.
+* Each import belongs to its longest matching prefix.
+*/
+function parseImportOrder(importOrder) {
+	const knownPrefixes = /* @__PURE__ */ new Set();
+	const groups = importOrder.split(",").map((group) => group.split("|").map((prefix) => prefix.startsWith("#") ? STATIC_PREFIX + prefix.slice(1) : prefix).filter((prefix) => {
+		if (knownPrefixes.has(prefix)) return false;
+		knownPrefixes.add(prefix);
+		return true;
+	}));
+	if (!knownPrefixes.has(STATIC_PREFIX)) {
+		const lastStaticGroupIndex = groups.findLastIndex((group) => group.some((prefix) => prefix.startsWith(STATIC_PREFIX)));
+		groups.splice(Math.max(lastStaticGroupIndex, 0), 0, [STATIC_PREFIX]);
+	}
+	if (!knownPrefixes.has(CATCH_ALL_PREFIX)) groups.push([CATCH_ALL_PREFIX]);
+	return groups;
 }
-function printTrailingComments(path) {
-	if (!hasChild(path, "comments")) return [];
-	const docs = [];
-	let printedTrailingComment;
-	path.each((path) => {
-		const { node: comment } = path;
-		if (!comment.trailing) return;
-		printedTrailingComment = printTrailingComment(path, printedTrailingComment);
-		docs.push(printedTrailingComment.doc);
-	}, "comments");
-	return docs;
+function importKey({ names, isStatic }) {
+	return (isStatic ? STATIC_PREFIX : "") + names.join(".");
 }
-function printCommentsSeparately(path) {
-	return {
-		leading: printLeadingComments(path),
-		trailing: printTrailingComments(path)
-	};
+function compareFqn({ names: a }, { names: b }) {
+	const minParts = Math.min(a.length, b.length);
+	for (let i = 0; i < minParts; i++) {
+		const imageA = a[i];
+		const imageB = b[i];
+		if (imageA < imageB) return -1;
+		else if (imageA > imageB) return 1;
+	}
+	return a.length - b.length;
 }
-function printComments(path, doc) {
-	const leading = printLeadingComments(path);
-	const trailing = printTrailingComments(path);
-	return leading.length || trailing.length ? [
-		leading,
-		doc,
-		trailing
-	] : doc;
+function printToModuleNamesDirective(path, print) {
+	const directive = [
+		path.node.type === "exports_module_directive" ? "exports" : "opens",
+		" ",
+		path.call(print, "packageNode")
+	];
+	if (path.node.modulesNodes.length) {
+		const moduleNames = join$1([",", line$1], path.map(print, "modulesNodes"));
+		directive.push(group$1(indent$1([line$1, group$1(indent$1([
+			"to",
+			line$1,
+			...moduleNames
+		]))])));
+	}
+	directive.push(";");
+	return directive;
 }
-//#endregion
-//#region src/parser.ts
-var parser_default = {
-	async parse(text) {
-		const tree = (await parser).parse(text);
-		const { rootNode } = tree;
-		if (rootNode.hasError) throw new Error("Failed to parse: " + rootNode);
-		const ast = processTree(rootNode);
-		determinePrettierIgnoreRanges(ast);
-		tree.delete();
-		return ast;
+// src/printers/types-values-and-variables.ts
+const { group, indent, join, line } = prettier_doc.builders;
+var types_values_and_variables_default = {
+	boolean_type: printValue,
+	integral_type: printValue,
+	floating_point_type: printValue,
+	void_type: printValue,
+	array_type(path, print) {
+		return [path.call(print, "elementNode"), path.call(print, "dimensionsNode")];
 	},
-	astFormat: "java",
-	hasPragma(text) {
-		return /^\/\*\*\n\s+\*\s@(format|prettier)\n\s+\*\//.test(text);
+	annotated_type(path, print) {
+		return join(" ", path.map(print, "children"));
 	},
-	locStart(node) {
-		return node.start.index;
+	dimensions(path, print) {
+		return path.map((child) => {
+			if (child.node.isNamed) return [
+				...child.isFirst ? [" "] : [],
+				print(child),
+				" "
+			];
+			return child.node.value;
+		}, "children");
 	},
-	locEnd(node) {
-		return node.end.index;
+	type_parameter(path, print) {
+		return join(" ", path.map(print, "children"));
+	},
+	type_bound(path, print) {
+		const [firstType, ...restTypes] = path.map(print, "namedChildren");
+		const bound = ["extends ", firstType];
+		if (restTypes.length) bound.push(group(indent([
+			line,
+			"& ",
+			...join([line, "& "], restTypes)
+		])));
+		return bound;
+	},
+	type_arguments: printTypeParameters,
+	wildcard(path, print) {
+		return join(" ", path.map(print, "children"));
 	}
 };
-const parser = (async () => {
-	await web_tree_sitter.Parser.init();
-	const parser = new web_tree_sitter.Parser();
-	const Java = await web_tree_sitter.Language.load(new URL("./tree-sitter-java_orchard.wasm", require("url").pathToFileURL(__filename).href));
-	parser.setLanguage(Java);
-	return parser;
-})();
-const isParenthesizedParent = createTypeCheckFunction([
-	"do_statement",
-	"if_statement",
-	"switch_expression",
-	"synchronized_statement",
-	"try_statement",
-	"try_with_resources_statement",
-	"while_statement"
-]);
-function processTree(node, fieldName = null, comments) {
-	const { type, isNamed, text: value, startPosition, endPosition } = node;
-	const javaNode = {
-		type,
-		isNamed,
-		value,
-		start: {
-			index: node.startIndex,
-			row: startPosition.row,
-			column: startPosition.column
-		},
-		end: {
-			index: node.endIndex,
-			row: endPosition.row,
-			column: endPosition.column
-		},
-		children: [],
-		namedChildren: [],
-		fieldName
-	};
-	if (!comments) comments = javaNode.comments = [];
-	if (!javaNode.isNamed) return javaNode;
-	const multiFields = multiFieldsByType[node.type];
-	if (multiFields) Object.keys(multiFields).forEach((name) => javaNode[`${name}Nodes`] = []);
-	node.children.forEach((child, index) => {
-		const fieldName = node.fieldNameForChild(index);
-		(child.type === "parenthesized_expression" && !isParenthesizedParent(javaNode) ? child.namedChildren : [child]).forEach((child) => {
-			const { type, text: value, startPosition, endPosition } = child;
-			if (type === "block_comment" || type === "line_comment") comments.push({
-				type,
-				value,
-				start: {
-					index: child.startIndex,
-					row: startPosition.row,
-					column: startPosition.column
-				},
-				end: {
-					index: child.endIndex,
-					row: endPosition.row,
-					column: endPosition.column
-				},
-				leading: false,
-				trailing: false,
-				printed: false
-			});
-			else {
-				const javaChild = processTree(child, fieldName, comments);
-				javaNode.children.push(javaChild);
-				if (javaChild.isNamed) javaNode.namedChildren.push(javaChild);
-				if (fieldName) {
-					if (multiFields?.[fieldName]) javaNode[`${fieldName}Nodes`].push(javaChild);
-					else javaNode[`${fieldName}Node`] = javaChild;
-				}
-			}
-		});
-	});
-	return javaNode;
+// src/printers/index.ts
+const printersByNodeType = {
+	ERROR(path) {
+		throw new Error(`Failed to parse: "${printValue(path)}"`);
+	},
+	...arrays_default,
+	...blocks_and_statements_default,
+	...classes_default,
+	...expressions_default,
+	...interfaces_default,
+	...lexical_structure_default,
+	...names_default,
+	...packages_and_modules_default,
+	...types_values_and_variables_default
+};
+function printerForNodeType(type) {
+	return printersByNodeType[type];
+}
+// src/printer.ts
+var printer_default = {
+	print(path, options, print, args) {
+		if (!hasNamedNode(path)) return printValue(path);
+		const doc = printerForNodeType(path.node.type)(path, print, options, args);
+		return needsParentheses(path) ? [
+			"(",
+			doc,
+			")"
+		] : doc;
+	},
+	embed(path, options) {
+		return hasType(path, "string_literal") ? embedTextBlock(path, options) : null;
+	},
+	hasPrettierIgnore(path) {
+		return path.node.comments?.some(isPrettierIgnore) === true || canAttachComment(path.node, path.parent ? [path.parent] : []) && isFullyBetweenPrettierIgnore(path);
+	},
+	canAttachComment,
+	isBlockComment(node) {
+		return node.type === "block_comment";
+	},
+	printComment(commentPath) {
+		return printComment(commentPath.node);
+	},
+	getCommentChildNodes(node) {
+		return node.isNamed ? node.children : [];
+	},
+	handleComments: {
+		ownLine: handleLineComment,
+		endOfLine: handleLineComment,
+		remaining: handleRemainingComment
+	},
+	getVisitorKeys() {
+		return ["namedChildren"];
+	}
+};
+function hasNamedNode(path) {
+	return path.node.isNamed;
 }
-//#endregion
-//#region src/index.ts
+// src/index.ts
 var src_default = {
 	languages: [{
 		name: "Java",
@@ -2664,5 +2796,4 @@ var src_default = {
 	options: options_default,
 	defaultOptions: { arrowParens: "avoid" }
 };
-//#endregion
 module.exports = src_default;