prettier-java-next-line 2.11.1 → 2.11.2

package/dist/index.cjs

@@ -1,7 +1,7 @@
 let web_tree_sitter = require("web-tree-sitter");
 let prettier = require("prettier");
 let prettier_doc = require("prettier/doc");
-//#region src/options.ts
+// src/options.ts
 var options_default = {
 	arrowParens: {
 		type: "choice",
@@ -47,7 +47,7 @@ var options_default = {
 			value: "end",
 			description: ""
 		}],
-		description: "Where to print operators when binary expressions wrap lines."
+		description: "Where to print operators when binary and ternary expressions wrap lines."
 	},
 	braceStyle: {
 		type: "choice",
@@ -95,8 +95,7 @@ var options_default = {
 		description: "Import groups in Spotless's format, such as `java,javax,,#java|#javax,#`. Module imports always come first. Empty puts static imports next, then all others."
 	}
 };
-//#endregion
-//#region src/node-types.ts
+// src/node-types.ts
 const multiFieldsByType = {
 	array_creation_expression: { dimensions: true },
 	cast_expression: { type: true },
@@ -113,9 +112,9 @@ const multiFieldsByType = {
 	requires_module_directive: { modifiers: true },
 	spread_parameter: { annotations: true }
 };
-//#endregion
-//#region src/printers/helpers.ts
-const { group: group$7, hardline: hardline$7, ifBreak: ifBreak$2, indent: indent$7, indentIfBreak: indentIfBreak$2, join: join$7, line: line$7, lineSuffixBoundary: lineSuffixBoundary$1, softline: softline$4 } = prettier_doc.builders;
+// src/printers/helpers.ts
+const { hasNewline: hasNewline$2, isNextLineEmpty: isNextLineEmpty$1, skipInlineComment, skipTrailingComment } = prettier.util;
+const { breakParent: breakParent$2, fill, group: group$7, hardline: hardline$7, ifBreak: ifBreak$2, indent: indent$7, indentIfBreak: indentIfBreak$2, join: join$7, line: line$7, lineSuffixBoundary: lineSuffixBoundary$1, softline: softline$3 } = prettier_doc.builders;
 const { mapDoc } = prettier_doc.utils;
 function hasType(path, type) {
 	return path.node.type === type;
@@ -149,6 +148,10 @@ function printDanglingComments(path, danglingCommentsPrintOptions = {}) {
 	const doc = join$7(hardline$7, parts);
 	return shouldIndent ? indent$7([hardline$7, doc]) : doc;
 }
+function printDanglingCommentsInList(path) {
+	const { node } = path;
+	return node.comments?.some(({ leading, trailing }) => !leading && !trailing) ? [indent$7([softline$3, printDanglingComments(path)]), node.comments?.some(({ type, leading, trailing }) => !leading && !trailing && type === "line_comment") ? hardline$7 : softline$3] : "";
+}
 function printComment(comment) {
 	comment.printed = true;
 	const lines = comment.value.split("\n").map((line) => line.trim());
@@ -160,56 +163,119 @@ function hasLeadingComments(node) {
 function hasDanglingComments(node) {
 	return node.comments?.some(({ leading, trailing }) => !leading && !trailing) ?? false;
 }
-function closingBracketLine(options, lineDoc = softline$4) {
+function closingBracketLine(options, lineDoc = softline$3) {
 	return options?.closingBracket === "same-line" ? "" : lineDoc;
 }
 function indentInParentheses(contents, options) {
 	return contents && !Array.isArray(contents) || contents.length ? [
 		"(",
-		indent$7([softline$4, contents]),
+		indent$7([softline$3, contents]),
 		closingBracketLine(options),
 		")"
 	] : "()";
 }
 function printArrayInitializer(path, print, options) {
-	if (!path.node.namedChildren.length) {
-		const danglingComments = printDanglingComments(path, { indent: true });
+	const { node } = path;
+	const elements = node.namedChildren;
+	const isNested = isNestedArray(path);
+	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 (options.arrayInitializerLayout === "fit") {
-			const bracketLine = options.bracketSpacing ? line$7 : softline$4;
-			const block = [
-				"{",
-				indent$7([bracketLine, ...list]),
-				bracketLine,
-				"}"
-			];
-			return group$7(isNestedArray(path) ? block : [softline$4, ...block]);
-		}
+	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";
@@ -306,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;
@@ -329,7 +395,7 @@ function printTypeParameters(path, print, options) {
 	];
 	const parts = [
 		"<",
-		indent$7([softline$4, join$7([",", line$7], path.map(print, "namedChildren"))]),
+		indent$7([softline$3, join$7([",", line$7], path.map(print, "namedChildren"))]),
 		closingBracketLine(options),
 		">"
 	];
@@ -346,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]))
@@ -367,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;
@@ -567,169 +635,570 @@ function unescapeTextBlockContents(text) {
 		}
 	});
 }
-//#endregion
-//#region src/printers/arrays.ts
-var arrays_default = { array_initializer: printArrayInitializer };
-//#endregion
-//#region src/printers/blocks-and-statements.ts
-const { group: group$6, hardline: hardline$6, ifBreak: ifBreak$1, indent: indent$6, indentIfBreak: indentIfBreak$1, join: join$6, line: line$6, softline: softline$3 } = prettier_doc.builders;
-var blocks_and_statements_default = {
-	block(path, print, options) {
-		return printBlock(path, printBlockStatements(path, print), options);
-	},
-	local_variable_declaration: printVariableDeclaration,
-	labeled_statement(path, print) {
-		return join$6(": ", path.map(print, "namedChildren"));
-	},
-	expression_statement(path, print) {
-		const parentType = path.parent?.type;
-		const expressionType = path.node.namedChildren[0].type;
-		const expression = path.call(print, "namedChildren", 0);
-		return expressionType === "switch_expression" && parentType !== "assignment_expression" && parentType !== "switch_rule" ? expression : [expression, ";"];
-	},
-	if_statement(path, print, options) {
-		const statement = ["if ", path.call(print, "conditionNode")];
-		if (path.node.consequenceNode.type === ";") statement.push(";");
-		else statement.push(" ", path.call(print, "consequenceNode"));
-		if (!hasChild(path, "alternativeNode")) return statement;
-		const danglingComments = printDanglingComments(path);
-		if (danglingComments) statement.push(hardline$6, danglingComments, hardline$6);
-		else if (options?.braceStyle === "next-line") statement.push(hardline$6);
-		else {
-			const ifHasBlock = path.node.consequenceNode.type === "block";
-			statement.push(ifHasBlock ? " " : hardline$6);
-		}
-		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));
+// src/comments.ts
+const { hasNewline: hasNewline$1, isPreviousLineEmpty, skipNewline, skipSpaces } = prettier.util;
+const { breakParent: breakParent$1, hardline: hardline$6, line: line$6, lineSuffix } = prettier_doc.builders;
+const prettierIgnoreRangesByTree = /* @__PURE__ */ new WeakMap();
+function determinePrettierIgnoreRanges(tree) {
+	const { comments } = tree;
+	if (!comments) return;
+	const ranges = comments.filter(({ value }) => /^\/(?:\/\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*|\*\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*\*\/)$/.test(value)).reduce((ranges, { value, start }) => {
+		const previous = ranges.at(-1);
+		if (value.includes("start") || value.includes("off")) {
+			if (previous?.end !== Infinity) ranges.push({
+				start: start.index,
+				end: Infinity
+			});
+		} else if (previous?.end === Infinity) previous.end = start.index;
+		return ranges;
+	}, new Array());
+	prettierIgnoreRangesByTree.set(tree, ranges);
+}
+function isFullyBetweenPrettierIgnore(path) {
+	const { node, root } = path;
+	const start = parser_default.locStart(node);
+	const end = parser_default.locEnd(node);
+	return prettierIgnoreRangesByTree.get(root)?.some((range) => range.start < start && end < range.end) === true;
+}
+function isPrettierIgnore(comment) {
+	return /^(\/\/\s*prettier-ignore|\/\*\s*prettier-ignore\s*\*\/)$/.test(comment.value);
+}
+function canAttachComment(node, ancestors) {
+	if (!node.isNamed) return isBinaryOperator(node);
+	switch (node.type) {
+		case "enum_body_declarations":
+		case "escape_sequence":
+		case "modifier":
+		case "multiline_string_fragment":
+		case "program":
+		case "string_fragment":
+		case "visibility": return false;
+		case "parenthesized_expression": {
+			const [parent] = ancestors;
+			return !(parent.isNamed && [
+				"do_statement",
+				"if_statement",
+				"switch_expression",
+				"synchronized_statement",
+				"try_statement",
+				"try_with_resources_statement",
+				"while_statement"
+			].includes(parent.type));
 		}
-	},
-	do_statement(path, print, options) {
-		const hasEmptyStatement = path.node.bodyNode.type === ";";
-		const isNextLine = options?.braceStyle === "next-line";
-		const whilePrefix = isNextLine ? [hardline$6, "while "] : " while ";
-		return [
-			"do",
-			hasEmptyStatement ? ";" : isNextLine ? path.call(print, "bodyNode") : [" ", path.call(print, "bodyNode")],
-			whilePrefix,
-			path.call(print, "conditionNode"),
-			";"
-		];
-	},
-	for_statement(path, print, options) {
-		const danglingComments = printDanglingComments(path);
-		const hasInit = path.node.initNodes.length > 0;
-		const hasCondition = hasChild(path, "conditionNode");
-		const hasUpdate = path.node.updateNodes.length > 0;
-		const expressions = [
-			!hasInit ? ";" : path.node.initNodes[0].type === "local_variable_declaration" ? path.call(print, "initNodes", 0) : [printExpressionList(path.map(print, "initNodes")), ";"],
-			hasCondition ? [path.call(print, "conditionNode"), ";"] : ";",
-			hasUpdate ? [line$6, printExpressionList(path.map(print, "updateNodes"))] : ifBreak$1("", " ")
-		];
-		const hasEmptyStatement = path.node.bodyNode.type === ";";
-		return [
-			danglingComments && [danglingComments, hardline$6],
-			"for ",
-			hasInit || hasCondition || hasUpdate ? group$6(indentInParentheses([join$6(line$6, expressions.slice(0, 2)), expressions[2]], options)) : "(;;)",
-			hasEmptyStatement ? ";" : [" ", path.call(print, "bodyNode")]
-		];
-	},
-	update_expression(path, print) {
-		return path.map(print, "children");
-	},
-	enhanced_for_statement(path, print) {
-		const danglingComments = printDanglingComments(path);
-		const forStatement = [
-			danglingComments && [danglingComments, hardline$6],
-			"for (",
-			...printModifiers(path, print),
-			path.call(print, "typeNode"),
-			" ",
-			path.call(print, "nameNode")
-		];
-		if (hasChild(path, "dimensionsNode")) forStatement.push(path.call(print, "dimensionsNode"));
-		forStatement.push(" : ", path.call(print, "valueNode"), ")");
-		const bodyType = path.node.bodyNode.type;
-		if (bodyType === ";") forStatement.push(";");
-		else {
-			const body = path.call(print, "bodyNode");
-			forStatement.push(bodyType === "block" ? [" ", body] : indent$6([line$6, body]));
+		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") prettier.util.addLeadingComment(followingNode, commentNode);
+			else prettier.util.addTrailingComment(followingNode, commentNode);
+			return true;
+		} else if (options.experimentalOperatorPosition === "start" && isBinaryOperator(precedingNode)) {
+			prettier.util.addLeadingComment(precedingNode, commentNode);
+			return true;
 		}
-		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 ? [
+	}
+	return false;
+}
+function handleFormalParametersComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "formal_parameters" && !precedingNode && !followingNode) {
+		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
+		return true;
+	}
+	return false;
+}
+function handleFqnOrRefTypeComments(commentNode) {
+	const { enclosingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "scoped_type_identifier" && followingNode) {
+		prettier.util.addLeadingComment(followingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleIfStatementComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode?.type === "if_statement" && precedingNode?.fieldName === "consequence") {
+		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
+		return true;
+	}
+	return false;
+}
+function handleJumpStatementComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode && !precedingNode && !followingNode && (enclosingNode.type === "break_statement" || enclosingNode.type === "continue_statement" || enclosingNode.type === "return_statement")) {
+		prettier.util.addTrailingComment(enclosingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleLabeledStatementComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode?.type === "labeled_statement" && precedingNode?.type === "identifier") {
+		prettier.util.addLeadingComment(precedingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleLambdaExpressionComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "lambda_expression" && precedingNode && followingNode && enclosingNode.children.find(({ type }) => type === "->").end.index < commentNode.start.index) {
+		if (followingNode.type === "block") {
+			if (followingNode.namedChildren.length) prettier.util.addLeadingComment(followingNode.namedChildren[0], commentNode);
+			else prettier.util.addDanglingComment(followingNode, commentNode, void 0);
+		} else prettier.util.addLeadingComment(followingNode, commentNode);
+		return true;
+	}
+}
+function handleMemberChainComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (isMember(enclosingNode)) {
+		if (commentNode.end.index <= enclosingNode.start.index) {
+			const memberChainRoot = getMemberChainRoot(enclosingNode);
+			prettier.util.addLeadingComment(memberChainRoot, commentNode);
+			return true;
+		}
+		if (precedingNode && (enclosingNode.type === "field_access" || precedingNode.end.row < commentNode.start.row) && precedingNode === getMemberObject(enclosingNode)) {
+			prettier.util.addLeadingComment(enclosingNode, commentNode);
+			return true;
+		}
+	}
+	return false;
+}
+function getMemberChainRoot(node) {
+	let current = node;
+	while (isMember(current)) {
+		const next = getMemberObject(current);
+		if (!next) return current;
+		else current = next;
+	}
+	return current;
+}
+function handleModifiersComments(commentNode) {
+	const { precedingNode } = commentNode;
+	if (precedingNode?.type === "annotation" || precedingNode?.type === "marker_annotation" || precedingNode?.type === "modifiers") {
+		prettier.util.addTrailingComment(precedingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleNameComments(commentNode) {
+	const { enclosingNode, precedingNode } = commentNode;
+	if (enclosingNode && precedingNode?.type === "identifier" && (enclosingNode.type === "scoped_identifier" || enclosingNode.type === "module_declaration" || enclosingNode.type === "package_declaration" || enclosingNode.type === "scoped_type_identifier")) {
+		prettier.util.addTrailingComment(precedingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleTernaryExpressionComments(commentNode) {
+	const { enclosingNode, precedingNode, followingNode } = commentNode;
+	if (enclosingNode?.type === "ternary_expression" && precedingNode?.isNamed && followingNode?.isNamed && precedingNode.end.row < commentNode.start.row && commentNode.end.row < followingNode.start.row) {
+		prettier.util.addLeadingComment(followingNode, commentNode);
+		return true;
+	}
+	return false;
+}
+function handleTryStatementComments(commentNode) {
+	const { enclosingNode, followingNode } = commentNode;
+	if (enclosingNode && (enclosingNode.type === "catch_clause" || enclosingNode.type === "try_statement" || enclosingNode.type === "try_with_resources_statement") && followingNode?.isNamed) {
+		const block = followingNode.type === "catch_clause" ? followingNode.bodyNode : followingNode.type === "finally_clause" ? followingNode.namedChildren[0] : null;
+		if (!block) return false;
+		const blockStatement = block.namedChildren.at(0);
+		if (blockStatement) prettier.util.addLeadingComment(blockStatement, commentNode);
+		else prettier.util.addDanglingComment(block, commentNode, void 0);
+		return true;
+	}
+	return false;
+}
+function getMemberObject(node) {
+	return node.type === "array_access" ? node.arrayNode : node.objectNode;
+}
+const binaryOperators = /* @__PURE__ */ new Set([
+	"<<",
+	">>",
+	">>>",
+	"instanceof",
+	"<=",
+	">=",
+	"==",
+	"-",
+	"+",
+	"&&",
+	"&",
+	"^",
+	"!=",
+	"||",
+	"|",
+	"*",
+	"/",
+	"%"
+]);
+function isBinaryOperator(node) {
+	return node !== void 0 && binaryOperators.has(node.type);
+}
+function printLeadingComment(path) {
+	const comment = path.node;
+	const parts = [printComment(comment)];
+	const originalText = path.root.value;
+	if (comment.type === "block_comment") {
+		let lineBreak = " ";
+		if (hasNewline$1(originalText, parser_default.locEnd(comment))) {
+			if (hasNewline$1(originalText, parser_default.locStart(comment), { backwards: true })) lineBreak = hardline$6;
+			else lineBreak = line$6;
+		}
+		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 web_tree_sitter.Parser.init();
+	const parser = new web_tree_sitter.Parser();
+	const Java = await web_tree_sitter.Language.load(new URL("./tree-sitter-java_orchard.wasm", require("url").pathToFileURL(__filename).href));
+	parser.setLanguage(Java);
+	return parser;
+})();
+const isParenthesizedParent = createTypeCheckFunction([
+	"do_statement",
+	"if_statement",
+	"switch_expression",
+	"synchronized_statement",
+	"try_statement",
+	"try_with_resources_statement",
+	"while_statement"
+]);
+function processTree(node, fieldName = null, comments) {
+	const { type, isNamed, text: value, startPosition, endPosition } = node;
+	const javaNode = {
+		type,
+		isNamed,
+		value,
+		start: {
+			index: node.startIndex,
+			row: startPosition.row,
+			column: startPosition.column
+		},
+		end: {
+			index: node.endIndex,
+			row: endPosition.row,
+			column: endPosition.column
+		},
+		children: [],
+		namedChildren: [],
+		fieldName
+	};
+	if (!comments) comments = javaNode.comments = [];
+	if (!javaNode.isNamed) return javaNode;
+	const multiFields = multiFieldsByType[node.type];
+	if (multiFields) Object.keys(multiFields).forEach((name) => javaNode[`${name}Nodes`] = []);
+	node.children.forEach((child, index) => {
+		const fieldName = node.fieldNameForChild(index);
+		(child.type === "parenthesized_expression" && !isParenthesizedParent(javaNode) ? child.namedChildren : [child]).forEach((child) => {
+			const { type, text: value, startPosition, endPosition } = child;
+			if (type === "block_comment" || type === "line_comment") comments.push({
+				type,
+				value,
+				start: {
+					index: child.startIndex,
+					row: startPosition.row,
+					column: startPosition.column
+				},
+				end: {
+					index: child.endIndex,
+					row: endPosition.row,
+					column: endPosition.column
+				},
+				leading: false,
+				trailing: false,
+				printed: false
+			});
+			else {
+				const javaChild = processTree(child, fieldName, comments);
+				javaNode.children.push(javaChild);
+				if (javaChild.isNamed) javaNode.namedChildren.push(javaChild);
+				if (fieldName) {
+					if (multiFields?.[fieldName]) javaNode[`${fieldName}Nodes`].push(javaChild);
+					else javaNode[`${fieldName}Node`] = javaChild;
+				}
+			}
+		});
+	});
+	return javaNode;
+}
+// src/printers/arrays.ts
+var arrays_default = { array_initializer: printArrayInitializer };
+// src/printers/blocks-and-statements.ts
+const { group: group$6, hardline: hardline$5, ifBreak: ifBreak$1, indent: indent$6, indentIfBreak: indentIfBreak$1, join: join$6, line: line$5, softline: softline$2 } = prettier_doc.builders;
+var blocks_and_statements_default = {
+	block(path, print, options) {
+		return printBlock(path, printBlockStatements(path, print), options);
+	},
+	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),
 			";"
@@ -759,7 +1228,7 @@ var blocks_and_statements_default = {
 		const params = group$6(indentInParentheses(path.call(print, "namedChildren", catchFormalParameterIndex), options));
 		const body = path.call(print, "bodyNode");
 		if (options?.braceStyle === "next-line") return [
-			hardline$6,
+			hardline$5,
 			"catch ",
 			params,
 			body
@@ -779,11 +1248,11 @@ var blocks_and_statements_default = {
 		return parts;
 	},
 	catch_type(path, print) {
-		return join$6([line$6, "| "], path.map(print, "namedChildren"));
+		return join$6([line$5, "| "], path.map(print, "namedChildren"));
 	},
 	finally_clause(path, print, options) {
 		if (options?.braceStyle === "next-line") return [
-			hardline$6,
+			hardline$5,
 			"finally",
 			path.call(print, "namedChildren", 0)
 		];
@@ -818,7 +1287,7 @@ var blocks_and_statements_default = {
 				hasTrailingSemicolon = false;
 			} else if (child.node.type === ";") hasTrailingSemicolon = true;
 		}, "children");
-		const parts = join$6([";", line$6], resources);
+		const parts = join$6([";", line$5], resources);
 		if (hasTrailingSemicolon) parts.push(ifBreak$1(";"));
 		return group$6(indentInParentheses(parts, options));
 	},
@@ -829,10 +1298,10 @@ var blocks_and_statements_default = {
 			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])));
+			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$6), { id: groupId }), indentIfBreak$1(value, { groupId }));
+				parts.push(group$6(indent$6(line$5), { id: groupId }), indentIfBreak$1(value, { groupId }));
 			}
 			return parts;
 		}
@@ -848,20 +1317,20 @@ var blocks_and_statements_default = {
 	}
 };
 function printExpressionList(expressions) {
-	return group$6(expressions.map((expression, index) => index === 0 ? expression : [",", indent$6([line$6, expression])]));
+	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$6, argumentDoc]),
-		closingBracketLine(options, hardline$6),
+		indent$6([hardline$5, argumentDoc]),
+		closingBracketLine(options, hardline$5),
 		")"
 	];
 	if (node.type === "binary_expression") return group$6([
 		ifBreak$1("("),
-		indent$6([softline$3, argumentDoc]),
+		indent$6([softline$2, argumentDoc]),
 		closingBracketLine(options),
 		ifBreak$1(")")
 	]);
@@ -875,9 +1344,8 @@ function printReturnOrThrowStatement(path, print, options) {
 		";"
 	];
 }
-//#endregion
-//#region src/printers/classes.ts
-const { group: group$5, hardline: hardline$5, indent: indent$5, join: join$5, line: line$5, softline: softline$2 } = prettier_doc.builders;
+// src/printers/classes.ts
+const { group: group$5, hardline: hardline$4, indent: indent$5, join: join$5, line: line$4 } = prettier_doc.builders;
 var classes_default = {
 	class_declaration(path, print, options) {
 		const parts = ["class ", path.call(print, "nameNode")];
@@ -894,10 +1362,10 @@ var classes_default = {
 		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)];
+				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$5 : " ";
+			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(" ");
@@ -912,13 +1380,13 @@ var classes_default = {
 		return ["extends ", path.call(print, "namedChildren", 0)];
 	},
 	super_interfaces(path, print) {
-		return group$5(["implements", indent$5([line$5, path.call(print, "namedChildren", 0)])]);
+		return group$5(["implements", indent$5([line$4, path.call(print, "namedChildren", 0)])]);
 	},
 	permits(path, print) {
-		return group$5(["permits", indent$5([line$5, path.call(print, "namedChildren", 0)])]);
+		return group$5(["permits", indent$5([line$4, path.call(print, "namedChildren", 0)])]);
 	},
 	type_list(path, print) {
-		return join$5([",", line$5], path.map(print, "namedChildren"));
+		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);
@@ -940,7 +1408,7 @@ var classes_default = {
 		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),
@@ -962,7 +1430,7 @@ var classes_default = {
 			printDanglingCommentsInList(path),
 			")"
 		];
-		return indentInParentheses(join$5([",", line$5], parameters), options);
+		return indentInParentheses(join$5([",", line$4], parameters), options);
 	},
 	formal_parameter(path, print) {
 		const parameter = printModifiers(path, print, path.grandparent?.type === "record_declaration" ? "avoidBreak" : "noBreak");
@@ -979,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)];
@@ -990,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),
@@ -1029,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, options) {
 		const modifiers = printModifiers(path, print, "declarationOnly");
 		const parts = ["enum ", path.call(print, "nameNode")];
 		if (hasChild(path, "interfacesNode")) {
 			const hasBody = path.node.bodyNode.namedChildren.length > 0;
-			parts.push(indent$5([hardline$5, path.call(print, "interfacesNode")]), options?.braceStyle === "next-line" ? "" : hasBody ? line$5 : " ");
+			parts.push(indent$5([hardline$4, path.call(print, "interfacesNode")]), options?.braceStyle === "next-line" ? "" : hasBody ? line$4 : " ");
 		} else parts.push(" ");
 		return [
 			...modifiers,
@@ -1052,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) {
@@ -1072,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");
@@ -1081,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,
@@ -1112,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 } = prettier_doc.builders;
-const { getNextNonSpaceNonCommentCharacterIndex, hasNewline: hasNewline$1, isNextLineEmpty } = prettier.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 } = prettier_doc.builders;
+const { getNextNonSpaceNonCommentCharacterIndex, hasNewline, isNextLineEmpty } = prettier.util;
 const { removeLines, willBreak } = prettier_doc.utils;
 var expressions_default = {
 	lambda_expression(path, print, options, args) {
@@ -1142,7 +1606,7 @@ 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, options, {
@@ -1162,7 +1626,7 @@ var expressions_default = {
 			if (child.node.type === "identifier") identifiers.push(print(child));
 		}, "namedChildren");
 		if (!identifiers.length) return "()";
-		const parameters = join$4([",", line$4], identifiers);
+		const parameters = join$4([",", line$3], identifiers);
 		if (identifiers.length > 1 || willBreak(identifiers)) return group$4(indentInParentheses(parameters, options));
 		return options.arrowParens === "avoid" ? parameters : [
 			"(",
@@ -1186,24 +1650,36 @@ 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),
+			forceNoIndent && !operatorAtEnd ? parts : indent$4(parts),
 			breakClosingParen && !shouldExtraIndent ? closingBracketLine(options) : ""
 		]);
 		return isParentTest || shouldExtraIndent ? group$4([indent$4([softline$1, result]), closingBracketLine(options)]) : result;
@@ -1231,7 +1707,7 @@ 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, options) {
@@ -1279,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,
 				")"
 			]),
@@ -1304,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), options), { shouldBreak });
+			return group$4([
+				"(",
+				printDanglingCommentsInList(path),
+				")"
+			], { shouldBreak });
 		}
 		const lastArgIndex = args.length - 1;
 		let anyArgEmptyLine = false;
@@ -1316,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]),
-				closingBracketLine(options, line$4),
+				indent$4([line$3, ...printedArguments]),
+				closingBracketLine(options, line$3),
 				")"
 			], { shouldBreak: true });
 		}
@@ -1345,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 }),
 				", ",
@@ -1370,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;
@@ -1380,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 }),
@@ -1444,7 +1924,7 @@ var expressions_default = {
 		return path.map(print, "children");
 	},
 	record_pattern_body(path, print, options) {
-		return group$4(indentInParentheses(join$4([",", line$4], path.map(print, "namedChildren")), 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"));
@@ -1491,10 +1971,10 @@ 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, options, { bodyDoc, bodyComments, shouldPutBodyOnSameLine }) {
 	const trailingSpace = args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg && !path.node.comments ? closingBracketLine(options) : "";
@@ -1503,7 +1983,7 @@ function printArrowFunctionBody(path, args, options, { bodyDoc, bodyComments, sh
 		bodyDoc,
 		bodyComments
 	] : [indent$4([
-		line$4,
+		line$3,
 		bodyDoc,
 		bodyComments
 	]), trailingSpace];
@@ -1535,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")) {
@@ -1559,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;
@@ -1631,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");
@@ -1655,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) {
@@ -1705,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;
@@ -1722,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);
@@ -1736,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) {
@@ -1753,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") {
@@ -1773,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;
@@ -1842,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 } = prettier_doc.builders;
+// src/printers/interfaces.ts
+const { group: group$3, hardline: hardline$2, indent: indent$3, join: join$3, line: line$2 } = prettier_doc.builders;
 var interfaces_default = {
 	interface_declaration(path, print, options) {
 		const parts = ["interface ", path.call(print, "nameNode")];
@@ -1858,10 +2354,10 @@ var interfaces_default = {
 		}
 		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 [
@@ -1872,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);
@@ -1910,7 +2406,7 @@ var interfaces_default = {
 			"(",
 			args[0],
 			")"
-		] : group$3(indentInParentheses(join$3([",", line$3], args), options));
+		] : group$3(indentInParentheses(join$3([",", line$2], args), options));
 	},
 	element_value_pair(path, print) {
 		return group$3([
@@ -1921,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 } = prettier_doc.builders;
+// src/printers/lexical-structure.ts
+const { group: group$2, hardline: hardline$1, indent: indent$2, join: join$2, softline } = prettier_doc.builders;
 var lexical_structure_default = {
 	string_literal(path, print) {
 		if (path.node.namedChildren.some(({ type }) => type === "string_interpolation") || 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,
@@ -1961,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,
@@ -1977,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 } = prettier_doc.builders;
+// src/printers/packages-and-modules.ts
+const { group: group$1, hardline, indent: indent$1, join: join$1, line: line$1 } = prettier_doc.builders;
 var packages_and_modules_default = {
 	program(path, print, options) {
-		if (!path.node.namedChildren.length) return [printDanglingComments(path), hardline$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 = [];
@@ -2001,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 = [];
@@ -2017,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,
 			";"
@@ -2043,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"];
@@ -2067,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 } = prettier_doc.builders;
-var types_values_and_variables_default = {
-	boolean_type: printValue,
-	integral_type: printValue,
-	floating_point_type: printValue,
-	void_type: printValue,
-	array_type(path, print) {
-		return [path.call(print, "elementNode"), path.call(print, "dimensionsNode")];
-	},
-	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 } = prettier.util;
-const { breakParent, hardline, line, lineSuffix } = prettier_doc.builders;
-const prettierIgnoreRangesByTree = /* @__PURE__ */ new WeakMap();
-function determinePrettierIgnoreRanges(tree) {
-	const { comments } = tree;
-	if (!comments) return;
-	const ranges = comments.filter(({ value }) => /^\/(?:\/\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*|\*\s*(?:prettier-ignore-(?:start|end)|@formatter:(?:off|on))\s*\*\/)$/.test(value)).reduce((ranges, { value, start }) => {
-		const previous = ranges.at(-1);
-		if (value.includes("start") || value.includes("off")) {
-			if (previous?.end !== Infinity) ranges.push({
-				start: start.index,
-				end: Infinity
-			});
-		} else if (previous?.end === Infinity) previous.end = start.index;
-		return ranges;
-	}, new Array());
-	prettierIgnoreRangesByTree.set(tree, ranges);
-}
-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") prettier.util.addLeadingComment(followingNode, commentNode);
-			else prettier.util.addTrailingComment(followingNode, commentNode);
-			return true;
-		} else if (options.experimentalOperatorPosition === "start" && isBinaryOperator(precedingNode)) {
-			prettier.util.addLeadingComment(precedingNode, commentNode);
-			return true;
-		}
-	}
-	return false;
-}
-function handleFormalParametersComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "formal_parameters" && !precedingNode && !followingNode) {
-		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
-		return true;
-	}
-	return false;
-}
-function handleFqnOrRefTypeComments(commentNode) {
-	const { enclosingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "scoped_type_identifier" && followingNode) {
-		prettier.util.addLeadingComment(followingNode, commentNode);
-		return true;
-	}
-	return false;
-}
-function handleIfStatementComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode?.type === "if_statement" && precedingNode?.fieldName === "consequence") {
-		prettier.util.addDanglingComment(enclosingNode, commentNode, void 0);
-		return true;
-	}
-	return false;
-}
-function handleJumpStatementComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode && !precedingNode && !followingNode && (enclosingNode.type === "break_statement" || enclosingNode.type === "continue_statement" || enclosingNode.type === "return_statement")) {
-		prettier.util.addTrailingComment(enclosingNode, commentNode);
-		return true;
-	}
-	return false;
-}
-function handleLabeledStatementComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode?.type === "labeled_statement" && precedingNode?.type === "identifier") {
-		prettier.util.addLeadingComment(precedingNode, commentNode);
-		return true;
-	}
-	return false;
-}
-function handleLambdaExpressionComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "lambda_expression" && precedingNode && followingNode && enclosingNode.children.find(({ type }) => type === "->").end.index < commentNode.start.index) {
-		if (followingNode.type === "block") {
-			if (followingNode.namedChildren.length) prettier.util.addLeadingComment(followingNode.namedChildren[0], commentNode);
-			else prettier.util.addDanglingComment(followingNode, commentNode, void 0);
-		} else prettier.util.addLeadingComment(followingNode, commentNode);
-		return true;
-	}
-}
-function handleMemberChainComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (precedingNode && (enclosingNode?.type === "field_access" || enclosingNode?.type === "method_invocation" && precedingNode.end.row < commentNode.start.row) && precedingNode === enclosingNode.objectNode) {
-		prettier.util.addLeadingComment(enclosingNode, commentNode);
-		return true;
-	} else if (isMember(followingNode) && (!precedingNode || precedingNode !== getMemberObject(followingNode) && precedingNode.end.row < commentNode.start.row) && !isPrettierIgnore(commentNode)) {
-		prettier.util.addDanglingComment(followingNode, commentNode, void 0);
-		return true;
-	}
-	return false;
-}
-function handleModifiersComments(commentNode) {
-	const { precedingNode } = commentNode;
-	if (precedingNode?.type === "annotation" || precedingNode?.type === "marker_annotation" || precedingNode?.type === "modifiers") {
-		prettier.util.addTrailingComment(precedingNode, commentNode);
-		return true;
-	}
-	return false;
-}
-function handleNameComments(commentNode) {
-	const { enclosingNode, precedingNode } = commentNode;
-	if (enclosingNode && precedingNode?.type === "identifier" && (enclosingNode.type === "scoped_identifier" || enclosingNode.type === "module_declaration" || enclosingNode.type === "package_declaration" || enclosingNode.type === "scoped_type_identifier")) {
-		prettier.util.addTrailingComment(precedingNode, commentNode);
-		return true;
-	}
-	return false;
-}
-function handleTernaryExpressionComments(commentNode) {
-	const { enclosingNode, precedingNode, followingNode } = commentNode;
-	if (enclosingNode?.type === "ternary_expression" && precedingNode?.isNamed && followingNode?.isNamed && precedingNode.end.row < commentNode.start.row && commentNode.end.row < followingNode.start.row) {
-		prettier.util.addLeadingComment(followingNode, commentNode);
-		return true;
-	}
-	return false;
+function 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) prettier.util.addLeadingComment(blockStatement, commentNode);
-		else prettier.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 } = prettier_doc.builders;
+var types_values_and_variables_default = {
+	boolean_type: printValue,
+	integral_type: printValue,
+	floating_point_type: printValue,
+	void_type: printValue,
+	array_type(path, print) {
+		return [path.call(print, "elementNode"), path.call(print, "dimensionsNode")];
+	},
+	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 web_tree_sitter.Parser.init();
-	const parser = new web_tree_sitter.Parser();
-	const Java = await web_tree_sitter.Language.load(new URL("./tree-sitter-java_orchard.wasm", require("url").pathToFileURL(__filename).href));
-	parser.setLanguage(Java);
-	return parser;
-})();
-const isParenthesizedParent = createTypeCheckFunction([
-	"do_statement",
-	"if_statement",
-	"switch_expression",
-	"synchronized_statement",
-	"try_statement",
-	"try_with_resources_statement",
-	"while_statement"
-]);
-function processTree(node, fieldName = null, comments) {
-	const { type, isNamed, text: value, startPosition, endPosition } = node;
-	const javaNode = {
-		type,
-		isNamed,
-		value,
-		start: {
-			index: node.startIndex,
-			row: startPosition.row,
-			column: startPosition.column
-		},
-		end: {
-			index: node.endIndex,
-			row: endPosition.row,
-			column: endPosition.column
-		},
-		children: [],
-		namedChildren: [],
-		fieldName
-	};
-	if (!comments) comments = javaNode.comments = [];
-	if (!javaNode.isNamed) return javaNode;
-	const multiFields = multiFieldsByType[node.type];
-	if (multiFields) Object.keys(multiFields).forEach((name) => javaNode[`${name}Nodes`] = []);
-	node.children.forEach((child, index) => {
-		const fieldName = node.fieldNameForChild(index);
-		(child.type === "parenthesized_expression" && !isParenthesizedParent(javaNode) ? child.namedChildren : [child]).forEach((child) => {
-			const { type, text: value, startPosition, endPosition } = child;
-			if (type === "block_comment" || type === "line_comment") comments.push({
-				type,
-				value,
-				start: {
-					index: child.startIndex,
-					row: startPosition.row,
-					column: startPosition.column
-				},
-				end: {
-					index: child.endIndex,
-					row: endPosition.row,
-					column: endPosition.column
-				},
-				leading: false,
-				trailing: false,
-				printed: false
-			});
-			else {
-				const javaChild = processTree(child, fieldName, comments);
-				javaNode.children.push(javaChild);
-				if (javaChild.isNamed) javaNode.namedChildren.push(javaChild);
-				if (fieldName) {
-					if (multiFields?.[fieldName]) javaNode[`${fieldName}Nodes`].push(javaChild);
-					else javaNode[`${fieldName}Node`] = javaChild;
-				}
-			}
-		});
-	});
-	return javaNode;
+function hasNamedNode(path) {
+	return path.node.isNamed;
 }
-//#endregion
-//#region src/index.ts
+// src/index.ts
 var src_default = {
 	languages: [{
 		name: "Java",
@@ -2664,5 +2757,4 @@ var src_default = {
 	options: options_default,
 	defaultOptions: { arrowParens: "avoid" }
 };
-//#endregion
 module.exports = src_default;