prettier-java-next-line 2.11.0 → 2.11.2

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { Language, Parser } from "web-tree-sitter";
 import { util } from "prettier";
 import { builders, utils } from "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",
@@ -62,6 +62,32 @@ var options_default = {
 		}],
 		description: "Placement of opening braces."
 	},
+	arrayInitializerLayout: {
+		type: "choice",
+		category: "Java",
+		default: "always-break",
+		choices: [{
+			value: "always-break",
+			description: "Put each array element on its own line"
+		}, {
+			value: "fit",
+			description: "Keep array initializers on one line when they fit"
+		}],
+		description: "Layout of array initializers when braceStyle is next-line."
+	},
+	closingBracket: {
+		type: "choice",
+		category: "Java",
+		default: "next-line",
+		choices: [{
+			value: "next-line",
+			description: "Put the closing parenthesis or angle bracket of a wrapped list on its own line"
+		}, {
+			value: "same-line",
+			description: "Keep the closing parenthesis or angle bracket on the last line of a wrapped list"
+		}],
+		description: "Placement of the closing parenthesis or angle bracket when a list wraps."
+	},
 	importOrder: {
 		type: "string",
 		category: "Java",
@@ -69,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 },
@@ -87,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 } = builders;
+// src/printers/helpers.ts
+const { hasNewline: hasNewline$2, isNextLineEmpty: isNextLineEmpty$1, skipInlineComment, skipTrailingComment } = 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 } = builders;
 const { mapDoc } = utils;
 function hasType(path, type) {
 	return path.node.type === type;
@@ -123,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());
@@ -134,43 +163,119 @@ function hasLeadingComments(node) {
 function hasDanglingComments(node) {
 	return node.comments?.some(({ leading, trailing }) => !leading && !trailing) ?? false;
 }
-function indentInParentheses(contents) {
+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]),
-		softline$4,
+		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);
+	if (elements.length === 0) {
+		const danglingComments = printDanglingCommentsInList(path);
 		if (!danglingComments) return "{}";
-		const block = [
+		const block = group$7([
 			"{",
 			danglingComments,
-			hardline$7,
+			"}"
+		]);
+		return options.braceStyle === "next-line" && !isNested ? [hardline$7, block] : block;
+	}
+	const groupId = Symbol("array");
+	const nextLineLayout = options.braceStyle === "next-line" && node.type === "array_initializer" ? options.arrayInitializerLayout : void 0;
+	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 options.braceStyle === "next-line" && !isNestedArray(path) ? [hardline$7, ...block] : block;
+		return group$7(isNested ? block : [softline$3, ...block], {
+			shouldBreak,
+			id: groupId
+		});
 	}
-	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 (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";
@@ -219,12 +324,18 @@ function printBlock(path, contents, options) {
 }
 function printBlockNextLine(path, contents) {
 	const parentType = path.parent?.type;
-	const prefix = parentType != null && [
+	const isChildOfBodyDeclaration = parentType != null && [
 		"annotation_type_body",
 		"class_body",
 		"enum_body",
 		"interface_body"
-	].includes(parentType) ? [] : [hardline$7];
+	].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,
 		"{",
@@ -261,7 +372,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;
@@ -275,7 +386,7 @@ function printBodyDeclarations(path, print, padFirst = false) {
 		return blankLine ? [separator, declaration] : declaration;
 	}, "namedChildren");
 }
-function printTypeParameters(path, print) {
+function printTypeParameters(path, print, options) {
 	const parameters = path.node.namedChildren;
 	if (parameters.length === 0 || parameters.length === 1 && isSimpleType(parameters[0]) && !parameters.some(({ comments }) => comments?.length && comments.some(({ type }) => type === "line_comment"))) return [
 		"<",
@@ -284,8 +395,8 @@ function printTypeParameters(path, print) {
 	];
 	const parts = [
 		"<",
-		indent$7([softline$4, join$7([",", line$7], path.map(print, "namedChildren"))]),
-		softline$4,
+		indent$7([softline$3, join$7([",", line$7], path.map(print, "namedChildren"))]),
+		closingBracketLine(options),
 		">"
 	];
 	return path.node.type === "type_arguments" ? group$7(parts) : parts;
@@ -301,7 +412,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]))
@@ -322,12 +433,14 @@ 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;
@@ -522,380 +635,780 @@ 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 } = 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 } = util;
+const { breakParent: breakParent$1, hardline: hardline$6, line: line$6, lineSuffix } = 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,
+		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") util.addLeadingComment(followingNode, commentNode);
+			else util.addTrailingComment(followingNode, commentNode);
+			return true;
+		} else if (options.experimentalOperatorPosition === "start" && isBinaryOperator(precedingNode)) {
+			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) {
-		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 ? printExpressionList(path.map(print, "updateNodes")) : ""
-		];
-		const hasEmptyStatement = path.node.bodyNode.type === ";";
-		return [
-			danglingComments && [danglingComments, hardline$6],
-			"for ",
-			hasInit || hasCondition || hasUpdate ? group$6(indentInParentheses(join$6(line$6, expressions))) : "(;;)",
-			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) {
+		util.addDanglingComment(enclosingNode, commentNode, void 0);
+		return true;
+	}
+	return false;
+}
+function handleFqnOrRefTypeComments(commentNode) {
+	const { enclosingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "scoped_type_identifier" && followingNode) {
+		util.addLeadingComment(followingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleIfStatementComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode?.type === "if_statement" && precedingNode?.fieldName === "consequence") {
+		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")) {
+		util.addTrailingComment(enclosingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleLabeledStatementComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode?.type === "labeled_statement" && precedingNode?.type === "identifier") {
+		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) util.addLeadingComment(followingNode.namedChildren[0], commentNode);
+			else util.addDanglingComment(followingNode, commentNode, void 0);
+		} else 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);
+			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)));
-		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) {
-		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));
-	},
-	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)) {
+			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) {
-	const { node } = path;
-	const argumentDoc = print(path);
-	if (returnArgumentHasLeadingComment(node)) return [
-		"(",
-		indent$6([hardline$6, argumentDoc]),
-		hardline$6,
-		")"
-	];
-	if (node.type === "binary_expression") return group$6([
-		ifBreak$1("("),
-		indent$6([softline$3, argumentDoc]),
-		softline$3,
-		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) {
-	const { node } = path;
-	return [
-		node.type === "throw_statement" ? "throw" : "return",
-		node.namedChildren.length ? [" ", path.call(() => printReturnOrThrowArgument(path, print), "namedChildren", 0)] : "",
-		";"
-	];
+function handleModifiersComments(commentNode) {
+	const { precedingNode } = commentNode;
+	if (precedingNode?.type === "annotation" || precedingNode?.type === "marker_annotation" || precedingNode?.type === "modifiers") {
+		util.addTrailingComment(precedingNode, commentNode);
+		return true;
+	}
+	return false;
 }
-//#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 } = 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)) : 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"));
+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")) {
+		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) {
+		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) util.addLeadingComment(blockStatement, commentNode);
+		else 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;
+		}
+		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);
+		const { rootNode } = tree;
+		if (rootNode.hasError) throw new Error("Failed to parse: " + rootNode);
+		const ast = processTree(rootNode);
+		determinePrettierIgnoreRanges(ast);
+		tree.delete();
+		return ast;
+	},
+	astFormat: "java",
+	hasPragma(text) {
+		return /^\/\*\*\n\s+\*\s@(format|prettier)\n\s+\*\//.test(text);
+	},
+	locStart(node) {
+		return node.start.index;
+	},
+	locEnd(node) {
+		return node.end.index;
+	}
+};
+const parser = (async () => {
+	await Parser.init();
+	const parser = new Parser();
+	const Java = await Language.load(new URL("./tree-sitter-java_orchard.wasm", import.meta.url));
+	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/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 } = 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$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(" ", 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$5, ...join$6(hardline$5, 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$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) {
+		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(" ", 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$5, body);
+			return group$6(indent$6(parts));
+		}
+	},
+	do_statement(path, print, options) {
+		const hasEmptyStatement = path.node.bodyNode.type === ";";
+		const isNextLine = options?.braceStyle === "next-line";
+		const whilePrefix = isNextLine ? [hardline$5, "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$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 ? ";" : [" ", 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$5],
+			"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$5, body]));
+		}
+		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$5,
+			"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$5, "| "], path.map(print, "namedChildren"));
+	},
+	finally_clause(path, print, options) {
+		if (options?.braceStyle === "next-line") return [
+			hardline$5,
+			"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$5], 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$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),
+			";"
+		];
+	}
+};
+function printExpressionList(expressions) {
+	return group$6(expressions.map((expression, index) => index === 0 ? expression : [",", indent$6([line$5, expression])]));
+}
+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(")")
+	]);
+	return argumentDoc;
+}
+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)] : "",
+		";"
+	];
+}
+// src/printers/classes.ts
+const { group: group$5, hardline: hardline$4, indent: indent$5, join: join$5, line: line$4 } = 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$4 : line$4, path.call(print, clause)];
+			});
+			const hasBody = path.node.bodyNode.namedChildren.length > 0;
+			const afterClauses = options?.braceStyle === "next-line" ? "" : hasBody ? line$4 : " ";
+			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$4, path.call(print, "namedChildren", 0)])]);
+	},
+	permits(path, print) {
+		return group$5(["permits", indent$5([line$4, path.call(print, "namedChildren", 0)])]);
+	},
+	type_list(path, print) {
+		return join$5([",", line$4], 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)])));
+		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$4, path.call(print, "namedChildren", throwsIndex)])));
 		return hasChild(path, "bodyNode") ? [
 			modifiers,
 			group$5(declaration),
@@ -910,14 +1423,14 @@ var classes_default = {
 	receiver_parameter(path, print) {
 		return path.map((child) => child.isLast ? print(child) : [print(child), child.node.type === "identifier" ? "." : " "], "namedChildren");
 	},
-	formal_parameters(path, print) {
+	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));
+		return indentInParentheses(join$5([",", line$4], parameters), options);
 	},
 	formal_parameter(path, print) {
 		const parameter = printModifiers(path, print, path.grandparent?.type === "record_declaration" ? "avoidBreak" : "noBreak");
@@ -934,7 +1447,8 @@ var classes_default = {
 		return parts;
 	},
 	throws(path, print) {
-		return ["throws ", ...join$5(", ", path.map(print, "namedChildren"))];
+		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) {
 		return ["static ", path.call(print, "namedChildren", 0)];
@@ -945,7 +1459,7 @@ var classes_default = {
 		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)])));
+		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$4, path.call(print, "namedChildren", throwsIndex)])));
 		return [
 			modifiers,
 			group$5(declaration),
@@ -984,14 +1498,14 @@ var classes_default = {
 		}
 		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);
+		return join$5(annotationMode === "avoidBreak" ? line$4 : annotationMode === "noBreak" ? " " : hardline$4, parts);
 	},
-	enum_declaration(path, print) {
+	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")]), hasBody ? line$5 : " ");
+			parts.push(indent$5([hardline$4, path.call(print, "interfacesNode")]), options?.braceStyle === "next-line" ? "" : hasBody ? line$4 : " ");
 		} else parts.push(" ");
 		return [
 			...modifiers,
@@ -1007,16 +1521,16 @@ var classes_default = {
 			const hasDeclarations = path.node.namedChildren[enumBodyDeclarationsIndex].namedChildren.length > 0;
 			const enumBodyDeclarations = parts.pop();
 			if (hasDeclarations) {
-				if (!parts.length) declarations.push(hardline$5);
+				if (!parts.length) declarations.push(hardline$4);
 				declarations.push(enumBodyDeclarations);
 			}
 		}
 		const contents = [];
 		if (parts.length) {
-			contents.push(join$5([",", hardline$5], parts));
+			contents.push(join$5([",", hardline$4], parts));
 			if (!declarations.length && options.trailingComma !== "none") contents.push(",");
 		}
-		if (declarations.length) contents.push(";", hardline$5, ...declarations);
+		if (declarations.length) contents.push(";", hardline$4, ...declarations);
 		return printBlock(path, contents.length ? [contents] : [], options);
 	},
 	enum_constant(path, print) {
@@ -1027,7 +1541,7 @@ var classes_default = {
 		return initializer;
 	},
 	enum_body_declarations(path, print) {
-		return join$5(hardline$5, printBodyDeclarations(path, print));
+		return join$5(hardline$4, printBodyDeclarations(path, print));
 	},
 	record_declaration(path, print) {
 		const modifiers = printModifiers(path, print, "declarationOnly");
@@ -1036,8 +1550,8 @@ var classes_default = {
 		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 : " "]));
+			const interfaces = [hardline$4, path.call(print, "interfacesNode")];
+			parts.push(group$5([indent$5(interfaces), hasBody ? line$4 : " "]));
 		} else parts.push(" ");
 		return [
 			...modifiers,
@@ -1067,14 +1581,9 @@ const indexByModifier = [
 	"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 } = builders;
-const { getNextNonSpaceNonCommentCharacterIndex, hasNewline: hasNewline$1, isNextLineEmpty } = util;
+// 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 } = builders;
+const { getNextNonSpaceNonCommentCharacterIndex, hasNewline, isNextLineEmpty } = util;
 const { removeLines, willBreak } = utils;
 var expressions_default = {
 	lambda_expression(path, print, options, args) {
@@ -1097,10 +1606,10 @@ var expressions_default = {
 				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 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, {
+		bodyDoc = printArrowFunctionBody(path, args, options, {
 			bodyDoc,
 			bodyComments,
 			shouldPutBodyOnSameLine
@@ -1117,8 +1626,8 @@ var expressions_default = {
 			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));
+		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,
@@ -1141,27 +1650,39 @@ var expressions_default = {
 			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,
+		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,
 			"? ",
-			consequentNode.type === node.type ? ifBreak("", "(") : "",
+			openParen,
 			printBranch("consequenceNode"),
-			consequentNode.type === node.type ? ifBreak("", ")") : "",
-			line$4,
+			closeParen,
+			line$3,
 			": ",
 			printBranch("alternativeNode")
 		];
-		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));
+		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),
-			forceNoIndent ? parts : indent$4(parts),
-			breakClosingParen && !shouldExtraIndent ? softline$1 : ""
+			forceNoIndent && !operatorAtEnd ? parts : indent$4(parts),
+			breakClosingParen && !shouldExtraIndent ? closingBracketLine(options) : ""
 		]);
-		return isParentTest || shouldExtraIndent ? group$4([indent$4([softline$1, result]), softline$1]) : result;
+		return isParentTest || shouldExtraIndent ? group$4([indent$4([softline$1, result]), closingBracketLine(options)]) : result;
 	},
 	assignment_expression(path, print) {
 		const { node } = path;
@@ -1174,7 +1695,7 @@ var expressions_default = {
 		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]), softline$1]);
+		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");
@@ -1186,13 +1707,13 @@ var expressions_default = {
 		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];
+			return [(options.experimentalOperatorPosition === "start" ? child.node.type === "instanceof" : child.previous.type === "instanceof") ? line$3 : " ", doc];
 		}, "children")));
 	},
-	unary_expression(path, print) {
+	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)));
+		if (path.node.operandNode.comments) parts.push(group$4(indentInParentheses(operandDoc, options)));
 		else parts.push(operandDoc);
 		return parts;
 	},
@@ -1202,7 +1723,7 @@ var expressions_default = {
 		const typeArgumentsIndex = path.node.namedChildren.findIndex(({ type }) => type === "type_arguments");
 		return [path.call(print, "namedChildren", typeIdentifierIndex), path.call(print, "namedChildren", typeArgumentsIndex)];
 	},
-	parenthesized_expression(path, print) {
+	parenthesized_expression(path, print, options) {
 		const expression = path.call(print, "namedChildren", 0);
 		const parentType = path.parent?.type;
 		const grandparentType = path.grandparent?.type;
@@ -1211,12 +1732,12 @@ var expressions_default = {
 		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));
-		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)));
+		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,
-			softline$1,
+			closingBracketLine(options),
 			")"
 		]);
 		else return group$4([
@@ -1234,7 +1755,7 @@ var expressions_default = {
 				")"
 			] : [
 				"(",
-				indent$4([softline$1, join$4([" &", line$4], path.map(print, "typeNodes"))]),
+				indent$4([softline$1, join$4([" &", line$3], path.map(print, "typeNodes"))]),
 				softline$1,
 				")"
 			]),
@@ -1259,7 +1780,11 @@ var expressions_default = {
 		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)), { shouldBreak });
+			return group$4([
+				"(",
+				printDanglingCommentsInList(path),
+				")"
+			], { shouldBreak });
 		}
 		const lastArgIndex = args.length - 1;
 		let anyArgEmptyLine = false;
@@ -1271,21 +1796,21 @@ var expressions_default = {
 				argDoc = [
 					argDoc,
 					",",
-					hardline$4,
-					hardline$4
+					hardline$3,
+					hardline$3
 				];
 			} else argDoc = [
 				argDoc,
 				",",
-				line$4
+				line$3
 			];
 			printedArguments.push(argDoc);
 		}, "namedChildren");
 		function allArgsBrokenOut() {
 			return group$4([
 				"(",
-				indent$4([line$4, ...printedArguments]),
-				line$4,
+				indent$4([line$3, ...printedArguments]),
+				closingBracketLine(options, line$3),
 				")"
 			], { shouldBreak: true });
 		}
@@ -1300,7 +1825,7 @@ var expressions_default = {
 				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
 				throw caught;
 			}
-			if (willBreak(firstArg)) return [breakParent$1, conditionalGroup([[
+			if (willBreak(firstArg)) return [breakParent, conditionalGroup([[
 				"(",
 				group$4(firstArg, { shouldBreak: true }),
 				", ",
@@ -1325,7 +1850,7 @@ var expressions_default = {
 				allArgsBrokenOut()
 			]);
 		}
-		if (shouldExpandLastArg(args)) {
+		if (shouldExpandLastArg(args, options)) {
 			const headArgs = printedArguments.slice(0, -1);
 			if (headArgs.some(willBreak)) return allArgsBrokenOut();
 			let lastArg;
@@ -1335,7 +1860,7 @@ var expressions_default = {
 				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
 				throw caught;
 			}
-			if (willBreak(lastArg)) return [breakParent$1, conditionalGroup([[
+			if (willBreak(lastArg)) return [breakParent, conditionalGroup([[
 				"(",
 				...headArgs,
 				group$4(lastArg, { shouldBreak: true }),
@@ -1357,7 +1882,7 @@ var expressions_default = {
 				allArgsBrokenOut()
 			]);
 		}
-		return group$4(indentInParentheses(printedArguments), { shouldBreak: printedArguments.some(willBreak) || anyArgEmptyLine });
+		return group$4(indentInParentheses(printedArguments, options), { shouldBreak: printedArguments.some(willBreak) || anyArgEmptyLine });
 	},
 	array_creation_expression(path, print) {
 		const parts = ["new "];
@@ -1398,8 +1923,8 @@ var expressions_default = {
 	record_pattern(path, print) {
 		return path.map(print, "children");
 	},
-	record_pattern_body(path, print) {
-		return group$4(indentInParentheses(join$4([",", line$4], path.map(print, "namedChildren"))));
+	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"));
@@ -1446,19 +1971,19 @@ function printArrowFunctionSignatures(path, { signatureDocs }) {
 	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))])
+		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$4], signatureDocs));
-	return group$4(indent$4(join$4([" ->", line$4], signatureDocs)));
+	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 printArrowFunctionBody(path, args, { bodyDoc, bodyComments, shouldPutBodyOnSameLine }) {
-	const trailingSpace = args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg && !path.node.comments ? softline$1 : "";
+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,
+		line$3,
 		bodyDoc,
 		bodyComments
 	]), trailingSpace];
@@ -1490,7 +2015,7 @@ function printMemberChain(path, print, options) {
 			printedNodes.unshift({
 				node,
 				hasTrailingEmptyLine,
-				printed: [printComments(path, printMethodInvocation(path, print)), hasTrailingEmptyLine ? hardline$4 : ""]
+				printed: [printComments(path, printMethodInvocation(path, print)), hasTrailingEmptyLine ? hardline$3 : ""]
 			});
 			path.call(rec, "objectNode");
 		} else if (hasType(path, "array_access")) {
@@ -1514,28 +2039,32 @@ function printMemberChain(path, print, options) {
 	if (hasType(path, "method_invocation")) {
 		printedNodes.unshift({
 			node,
-			printed: printComments(path, printMethodInvocation(path, print))
+			printed: 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))
+			printed: 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))
+			printed: printFieldAccess(path, print)
 		});
 		if (hasChild(path, "objectNode")) path.call(rec, "objectNode");
 	}
+	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) printedNodes[0].printed = [
-		danglingComments,
-		hardline$4,
-		printedNodes[0].printed
-	];
+	if (danglingComments) {
+		const lastNode = printedNodes.at(-1);
+		lastNode.printed = [
+			danglingComments,
+			hardline$3,
+			lastNode.printed
+		];
+	}
 	const groups = [];
 	let currentGroup = [printedNodes[0]];
 	let i = 1;
@@ -1586,20 +2115,20 @@ function printMemberChain(path, print, options) {
 	}
 	function printIndentedGroup(groups) {
 		if (groups.length === 0) return "";
-		return indent$4([hardline$4, join$4(hardline$4, groups.map(printGroup))]);
+		return indent$4([hardline$3, join$4(hardline$3, 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));
+	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$4 : "",
+		shouldHaveEmptyLineBeforeIndent ? hardline$3 : "",
 		printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))
 	];
 	const methodInvocations = printedNodes.map(({ node }) => node).filter((node) => node.type === "method_invocation");
@@ -1610,7 +2139,7 @@ function printMemberChain(path, print, options) {
 	}
 	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])];
+	else result = [willBreak(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent : "", conditionalGroup([oneLine, expanded])];
 	return result;
 }
 function printMethodInvocation(path, print) {
@@ -1660,14 +2189,14 @@ function printBinaryExpressions(path, print, options, isInsideParentheses) {
 	const operatorDoc = path.call(print, "operatorNode");
 	const rightContent = path.call(print, "rightNode");
 	let right = options.experimentalOperatorPosition === "start" ? [
-		line$4,
+		line$3,
 		operatorDoc,
 		" ",
 		rightContent
 	] : [
 		" ",
 		operatorDoc,
-		line$4,
+		line$3,
 		rightContent
 	];
 	const { parent } = path;
@@ -1677,6 +2206,18 @@ function printBinaryExpressions(path, print, options, isInsideParentheses) {
 	return parts;
 }
 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);
@@ -1691,7 +2232,10 @@ function isSimpleCallArgument(node, depth = 2) {
 	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);
+	if (node.type === "method_reference" || node.type === "update_expression") {
+		const [qualifierNode] = node.namedChildren;
+		return isType(qualifierNode) || isSimpleCallArgument(qualifierNode, depth);
+	}
 	return false;
 }
 function isLiteral(node) {
@@ -1708,13 +2252,11 @@ function isLiteral(node) {
 		"character_literal"
 	].includes(node.type) || isStringLiteral(node);
 }
-function isSingleWordType(node) {
-	return [
-		"identifier",
-		"this",
-		"super"
-	].includes(node.type);
-}
+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") {
@@ -1728,10 +2270,10 @@ function couldExpandArg(arg, lambdaChainRecursion = false) {
 	}
 	return false;
 }
-function shouldExpandLastArg(args) {
+function shouldExpandLastArg(args, options) {
 	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");
+	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;
@@ -1797,9 +2339,8 @@ var ArgExpansionBailout = class extends Error {
 		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 } = builders;
+// src/printers/interfaces.ts
+const { group: group$3, hardline: hardline$2, indent: indent$3, join: join$3, line: line$2 } = builders;
 var interfaces_default = {
 	interface_declaration(path, print, options) {
 		const parts = ["interface ", path.call(print, "nameNode")];
@@ -1809,14 +2350,14 @@ var interfaces_default = {
 		const hasMultipleClauses = hasExtendsInterfaces && hasPermits;
 		if (hasChild(path, "type_parametersNode")) {
 			const typeParameters = path.call(print, "type_parametersNode");
-			parts.push(hasMultipleClauses ? group$3(indent$3(typeParameters)) : typeParameters);
+			parts.push(hasMultipleClauses ? group$3(indent$3(typeParameters)) : options?.braceStyle === "next-line" ? group$3(typeParameters) : typeParameters);
 		}
 		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"));
+			if (hasExtendsInterfaces) clauses.push(hardline$2, path.call(print, "namedChildren", extendsInterfacesIndex));
+			if (hasPermits) clauses.push(line$2, path.call(print, "permitsNode"));
 			const hasBody = path.node.bodyNode.namedChildren.length > 0;
-			const clauseGroup = [indent$3(clauses), options?.braceStyle === "next-line" ? "" : hasBody ? line$3 : " "];
+			const clauseGroup = [indent$3(clauses), options?.braceStyle === "next-line" ? "" : hasBody ? line$2 : " "];
 			parts.push(hasMultipleClauses ? clauseGroup : group$3(clauseGroup));
 		} else parts.push(" ");
 		return [
@@ -1827,7 +2368,7 @@ var interfaces_default = {
 	},
 	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)])]);
+		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);
@@ -1859,13 +2400,13 @@ var interfaces_default = {
 	marker_annotation(path, print) {
 		return ["@", path.call(print, "nameNode")];
 	},
-	annotation_argument_list(path, print) {
+	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$3], args)));
+		] : group$3(indentInParentheses(join$3([",", line$2], args), options));
 	},
 	element_value_pair(path, print) {
 		return group$3([
@@ -1876,13 +2417,12 @@ var interfaces_default = {
 	},
 	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 } = builders;
+// src/printers/lexical-structure.ts
+const { group: group$2, hardline: hardline$1, indent: indent$2, join: join$2, softline } = 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")));
+		return printTextBlock(join$2(hardline$1, textBlockContents(path.node).split("\n")));
 	},
 	string_fragment: printValue,
 	multiline_string_fragment: printValue,
@@ -1916,8 +2456,7 @@ var lexical_structure_default = {
 	underscore_pattern: printValue,
 	asterisk: printValue
 };
-//#endregion
-//#region src/printers/names.ts
+// src/printers/names.ts
 var names_default = {
 	identifier: printValue,
 	type_identifier: printValue,
@@ -1932,12 +2471,11 @@ var names_default = {
 		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 } = builders;
+// src/printers/packages-and-modules.ts
+const { group: group$1, hardline, indent: indent$1, join: join$1, line: line$1 } = builders;
 var packages_and_modules_default = {
 	program(path, print, options) {
-		if (!path.node.namedChildren.length) return [printDanglingComments(path), hardline$1];
+		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 = [];
@@ -1956,8 +2494,8 @@ var packages_and_modules_default = {
 				});
 			} 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];
+		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 = [];
@@ -1972,7 +2510,7 @@ var packages_and_modules_default = {
 				case "scoped_identifier": identifier.push(print(child));
 			}
 		}, "namedChildren");
-		return join$1(hardline$1, [...annotations, [
+		return join$1(hardline, [...annotations, [
 			"package ",
 			...identifier,
 			";"
@@ -1998,7 +2536,7 @@ var packages_and_modules_default = {
 		return join$1(" ", parts);
 	},
 	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);
+		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"];
@@ -2022,585 +2560,185 @@ var packages_and_modules_default = {
 		return [
 			"provides ",
 			provided,
-			group$1(indent$1([line$2, group$1(indent$1([
+			group$1(indent$1([line$1, group$1(indent$1([
 				"with",
-				line$2,
-				...join$1([",", line$2], providers)
+				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);
-		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 } = 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")];
-	},
-	annotated_type(path, print) {
-		return join(" ", path.map(print, "children"));
-	},
-	dimensions(path, print) {
-		return path.map((child) => {
-			if (child.node.isNamed) return [
-				...child.isFirst ? [" "] : [],
-				print(child),
-				" "
-			];
-			return child.node.value;
-		}, "children");
-	},
-	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$1,
-			"& ",
-			...join([line$1, "& "], restTypes)
-		])));
-		return bound;
-	},
-	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)}"`);
-	},
-	...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) ? [
-			"(",
-			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";
-	},
-	willPrintOwnComments,
-	printComment(commentPath) {
-		return printComment(commentPath.node);
-	},
-	getCommentChildNodes(node) {
-		return node.isNamed ? node.children : [];
-	},
-	handleComments: {
-		ownLine: handleLineComment,
-		endOfLine: handleLineComment,
-		remaining: handleRemainingComment
+		];
 	},
-	getVisitorKeys() {
-		return ["namedChildren"];
-	}
+	requires_modifier: printValue
 };
-function hasNamedNode(path) {
-	return path.node.isNamed;
-}
-//#endregion
-//#region src/comments.ts
-const { hasNewline, isPreviousLineEmpty, skipNewline, skipSpaces } = util;
-const { breakParent, hardline, line, lineSuffix } = 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 willPrintOwnComments(path) {
-	return isMember(path.node) && !printer_default.hasPrettierIgnore(path);
-}
-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 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 handleBinaryExpressionComments(commentNode, options) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "binary_expression") {
-		if (isBinaryOperator(followingNode)) {
-			if (options.experimentalOperatorPosition === "start") util.addLeadingComment(followingNode, commentNode);
-			else util.addTrailingComment(followingNode, commentNode);
-			return true;
-		} else if (options.experimentalOperatorPosition === "start" && isBinaryOperator(precedingNode)) {
-			util.addLeadingComment(precedingNode, commentNode);
-			return true;
-		}
-	}
-	return false;
-}
-function handleFormalParametersComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "formal_parameters" && !precedingNode && !followingNode) {
-		util.addDanglingComment(enclosingNode, commentNode, void 0);
-		return true;
-	}
-	return false;
-}
-function handleFqnOrRefTypeComments(commentNode) {
-	const { enclosingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "scoped_type_identifier" && followingNode) {
-		util.addLeadingComment(followingNode, commentNode);
-		return true;
-	}
-	return false;
-}
-function handleIfStatementComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode?.type === "if_statement" && precedingNode?.fieldName === "consequence") {
-		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")) {
-		util.addTrailingComment(enclosingNode, commentNode);
-		return true;
-	}
-	return false;
-}
-function handleLabeledStatementComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode?.type === "labeled_statement" && precedingNode?.type === "identifier") {
-		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) util.addLeadingComment(followingNode.namedChildren[0], commentNode);
-			else util.addDanglingComment(followingNode, commentNode, void 0);
-		} else util.addLeadingComment(followingNode, commentNode);
-		return true;
-	}
-}
-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) {
-		util.addLeadingComment(enclosingNode, commentNode);
-		return true;
-	} else if (isMember(followingNode) && (!precedingNode || precedingNode !== getMemberObject(followingNode) && precedingNode.end.row < commentNode.start.row) && !isPrettierIgnore(commentNode)) {
-		util.addDanglingComment(followingNode, commentNode, void 0);
-		return true;
-	}
-	return false;
-}
-function handleModifiersComments(commentNode) {
-	const { precedingNode } = commentNode;
-	if (precedingNode?.type === "annotation" || precedingNode?.type === "marker_annotation" || precedingNode?.type === "modifiers") {
-		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")) {
-		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) {
-		util.addLeadingComment(followingNode, commentNode);
-		return true;
-	}
-	return false;
+function extractNames(node) {
+	return node.type === "identifier" ? [node.value] : [...extractNames(node.scopeNode), node.nameNode.value];
 }
-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) util.addLeadingComment(blockStatement, commentNode);
-		else util.addDanglingComment(block, commentNode, void 0);
-		return true;
+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 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(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);
-	return parts;
+	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 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
-		};
+/**
+* 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 (!isBlock || previousComment?.hasLineSuffix) return {
-		doc: [lineSuffix([" ", printed]), breakParent],
-		isBlock,
-		hasLineSuffix: true
-	};
-	return {
-		doc: [" ", printed],
-		isBlock,
-		hasLineSuffix: false
-	};
+	if (!knownPrefixes.has(CATCH_ALL_PREFIX)) groups.push([CATCH_ALL_PREFIX]);
+	return groups;
 }
-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 importKey({ names, isStatic }) {
+	return (isStatic ? STATIC_PREFIX : "") + names.join(".");
 }
-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 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 printCommentsSeparately(path) {
-	return {
-		leading: printLeadingComments(path),
-		trailing: printTrailingComments(path)
-	};
+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;
 }
-function printComments(path, doc) {
-	const leading = printLeadingComments(path);
-	const trailing = printTrailingComments(path);
-	return leading.length || trailing.length ? [
-		leading,
-		doc,
-		trailing
-	] : doc;
+// src/printers/types-values-and-variables.ts
+const { group, indent, join, line } = 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")];
+	},
+	annotated_type(path, print) {
+		return join(" ", path.map(print, "children"));
+	},
+	dimensions(path, print) {
+		return path.map((child) => {
+			if (child.node.isNamed) return [
+				...child.isFirst ? [" "] : [],
+				print(child),
+				" "
+			];
+			return child.node.value;
+		}, "children");
+	},
+	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"));
+	}
+};
+// 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];
 }
-//#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/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;
 	},
-	astFormat: "java",
-	hasPragma(text) {
-		return /^\/\*\*\n\s+\*\s@(format|prettier)\n\s+\*\//.test(text);
+	embed(path, options) {
+		return hasType(path, "string_literal") ? embedTextBlock(path, options) : null;
 	},
-	locStart(node) {
-		return node.start.index;
+	hasPrettierIgnore(path) {
+		return path.node.comments?.some(isPrettierIgnore) === true || canAttachComment(path.node, path.parent ? [path.parent] : []) && isFullyBetweenPrettierIgnore(path);
 	},
-	locEnd(node) {
-		return node.end.index;
+	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"];
 	}
 };
-const parser = (async () => {
-	await Parser.init();
-	const parser = new Parser();
-	const Java = await Language.load(new URL("./tree-sitter-java_orchard.wasm", import.meta.url));
-	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;
+function hasNamedNode(path) {
+	return path.node.isNamed;
 }
-//#endregion
-//#region src/index.ts
+// src/index.ts
 var src_default = {
 	languages: [{
 		name: "Java",
@@ -2619,5 +2757,4 @@ var src_default = {
 	options: options_default,
 	defaultOptions: { arrowParens: "avoid" }
 };
-//#endregion
 export { src_default as default };