prettier-java-next-line 2.10.3

package/dist/index.cjs

@@ -0,0 +1,2558 @@
+let web_tree_sitter = require("web-tree-sitter");
+let prettier = require("prettier");
+let prettier_doc = require("prettier/doc");
+//#region src/options.ts
+var options_default = {
+	arrowParens: {
+		type: "choice",
+		category: "Java",
+		default: "always",
+		choices: [{
+			value: "always",
+			description: ""
+		}, {
+			value: "avoid",
+			description: ""
+		}],
+		description: "Include parentheses around a sole arrow function parameter."
+	},
+	trailingComma: {
+		type: "choice",
+		category: "Java",
+		default: "all",
+		choices: [
+			{
+				value: "all",
+				description: ""
+			},
+			{
+				value: "es5",
+				description: ""
+			},
+			{
+				value: "none",
+				description: ""
+			}
+		],
+		description: "Print trailing commas wherever possible when multi-line."
+	},
+	experimentalOperatorPosition: {
+		type: "choice",
+		category: "Java",
+		default: "end",
+		choices: [{
+			value: "start",
+			description: ""
+		}, {
+			value: "end",
+			description: ""
+		}],
+		description: "Where to print operators when binary expressions wrap lines."
+	},
+	braceStyle: {
+		type: "choice",
+		category: "Java",
+		default: "next-line",
+		choices: [{
+			value: "same-line",
+			description: "Put opening braces on same line (K&R style)"
+		}, {
+			value: "next-line",
+			description: "Put opening braces on new lines (Allman style)"
+		}],
+		description: "Placement of opening braces."
+	}
+};
+//#endregion
+//#region src/node-types.ts
+const multiFieldsByType = {
+	array_creation_expression: { dimensions: true },
+	cast_expression: { type: true },
+	constant_declaration: { declarator: true },
+	exports_module_directive: { modules: true },
+	field_declaration: { declarator: true },
+	for_statement: {
+		init: true,
+		update: true
+	},
+	local_variable_declaration: { declarator: true },
+	opens_module_directive: { modules: true },
+	provides_module_directive: { provider: true },
+	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;
+const { mapDoc } = prettier_doc.utils;
+function hasType(path, type) {
+	return path.node.type === type;
+}
+function hasChild(path, fieldName) {
+	return path.node[fieldName] != null;
+}
+function definedKeys(obj, options) {
+	return (options ?? Object.keys(obj)).filter((key) => obj[key] !== void 0);
+}
+function printModifiers(path, print, annotationMode) {
+	const modifiersIndex = path.node.namedChildren.findIndex(({ type }) => type === "modifiers");
+	if (modifiersIndex === -1) return [];
+	const separator = annotationMode === "avoidBreak" ? line$7 : annotationMode === "noBreak" || path.node.namedChildren[modifiersIndex].children.some(({ type }) => type !== "annotation" && type !== "marker_annotation") ? " " : hardline$7;
+	return [path.call((modifiers) => print(modifiers, { annotationMode }), "namedChildren", modifiersIndex), separator];
+}
+function printValue(path) {
+	return path.node.value;
+}
+function lineStartWithComments(node) {
+	return node.comments?.length ? Math.min(node.start.row, node.comments[0].start.row) : node.start.row;
+}
+function lineEndWithComments(node) {
+	return node.comments?.length ? Math.max(node.end.row, node.comments.at(-1).end.row) : node.end.row;
+}
+function printDanglingComments(path, danglingCommentsPrintOptions = {}) {
+	const { indent: shouldIndent = false } = danglingCommentsPrintOptions;
+	const danglingComments = new Set(path.node.comments?.filter((comment) => !(comment.leading || comment.trailing)));
+	if (danglingComments.size === 0) return "";
+	const parts = path.map(({ node: comment }) => danglingComments.has(comment) ? printComment(comment) : "", "comments").filter(Boolean);
+	const doc = join$7(hardline$7, parts);
+	return shouldIndent ? indent$7([hardline$7, doc]) : doc;
+}
+function printComment(comment) {
+	comment.printed = true;
+	const lines = comment.value.split("\n").map((line) => line.trim());
+	return lines.length > 1 && lines[0].startsWith("/*") && lines.slice(1).every((line) => line.startsWith("*")) && lines.at(-1).endsWith("*/") ? join$7(hardline$7, lines.map((line, index) => index === 0 ? line : ` ${line}`)) : comment.value;
+}
+function hasLeadingComments(node) {
+	return node.comments?.some(({ leading }) => leading) ?? false;
+}
+function indentInParentheses(contents) {
+	return contents && !Array.isArray(contents) || contents.length ? [
+		"(",
+		indent$7([softline$4, contents]),
+		softline$4,
+		")"
+	] : "()";
+}
+function printArrayInitializer(path, print, options) {
+	if (!path.node.namedChildren.length) {
+		const danglingComments = printDanglingComments(path, { indent: true });
+		if (!danglingComments) return "{}";
+		const block = [
+			"{",
+			danglingComments,
+			hardline$7,
+			"}"
+		];
+		return options.braceStyle === "next-line" && !isNestedArray(path) ? [hardline$7, ...block] : block;
+	}
+	const list = join$7([",", line$7], path.map(print, "namedChildren"));
+	if (list.length && options.trailingComma !== "none") list.push(ifBreak$2(","));
+	if (options.braceStyle === "next-line" && path.node.type === "array_initializer") {
+		const block = [
+			"{",
+			indent$7([line$7, ...list]),
+			line$7,
+			"}"
+		];
+		return isNestedArray(path) ? block : [hardline$7, ...block];
+	}
+	return group$7([
+		"{",
+		indent$7([line$7, ...list]),
+		line$7,
+		"}"
+	]);
+}
+function isNestedArray(path) {
+	return path.parent?.type === "array_initializer" || path.parent?.type === "element_value_array_initializer";
+}
+function printBlock(path, contents, options) {
+	if (options?.braceStyle === "next-line") return printBlockNextLine(path, contents);
+	if (contents.length) return group$7([
+		"{",
+		indent$7([hardline$7, ...join$7(hardline$7, contents)]),
+		hardline$7,
+		"}"
+	]);
+	const danglingComments = printDanglingComments(path, { indent: true });
+	if (danglingComments) return [
+		"{",
+		danglingComments,
+		hardline$7,
+		"}"
+	];
+	const parent = path.parent;
+	const grandparent = path.grandparent;
+	return parent?.type === "catch_clause" && (grandparent?.type === "try_statement" || grandparent?.type === "try_with_resources_statement") && grandparent.namedChildren.filter(({ type }) => type === "catch_clause").length === 1 && !grandparent.namedChildren.some(({ type }) => type === "finally_clause") || parent && [
+		"for_statement",
+		"do_statement",
+		"enhanced_for_statement",
+		"while_statement"
+	].includes(parent.type) || [
+		"annotation_type_body",
+		"class_body",
+		"constructor_body",
+		"enum_body",
+		"interface_body",
+		"module_body",
+		"record_pattern_body"
+	].includes(path.node.type) || parent && [
+		"block",
+		"lambda_expression",
+		"method_declaration",
+		"static_initializer",
+		"synchronized_statement"
+	].includes(parent.type) ? "{}" : [
+		"{",
+		hardline$7,
+		"}"
+	];
+}
+function printBlockNextLine(path, contents) {
+	const parentType = path.parent?.type;
+	const prefix = parentType != null && [
+		"annotation_type_body",
+		"class_body",
+		"enum_body",
+		"interface_body"
+	].includes(parentType) ? [] : [hardline$7];
+	if (contents.length) return [
+		...prefix,
+		"{",
+		indent$7([hardline$7, ...join$7(hardline$7, contents)]),
+		hardline$7,
+		"}"
+	];
+	const danglingComments = printDanglingComments(path, { indent: true });
+	if (danglingComments) return [
+		...prefix,
+		"{",
+		danglingComments,
+		hardline$7,
+		"}"
+	];
+	return [
+		...prefix,
+		"{",
+		hardline$7,
+		"}"
+	];
+}
+function printBlockStatements(path, print) {
+	const parts = [];
+	path.each((child) => {
+		const { node, previous } = child;
+		if (node.type === "switch_label") return;
+		const blankLine = parts.length && previous && lineStartWithComments(node) > lineEndWithComments(previous) + 1;
+		const declaration = print(child);
+		parts.push(blankLine ? [hardline$7, declaration] : declaration);
+	}, "namedChildren");
+	return parts;
+}
+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;
+	let previousRequiresPadding = padFirst;
+	return path.map((child) => {
+		const { node, previous } = child;
+		const modifiers = node.namedChildren.find(({ type }) => type === "modifiers")?.children ?? [];
+		const firstAnnotationIndex = modifiers.findIndex(({ type }) => type === "annotation" || type === "marker_annotation");
+		const lastNonAnnotationIndex = modifiers.findLastIndex(({ type }) => type !== "annotation" && type !== "marker_annotation");
+		const currentRequiresPadding = firstAnnotationIndex !== -1 && (!isFormalParameters && lastNonAnnotationIndex === -1 || firstAnnotationIndex < lastNonAnnotationIndex) || !isFormalParameters && node.type !== "constant_declaration" && node.type !== "enum_constant" && node.type !== "field_declaration" && !(isInterfaceBody && node.type === "method_declaration" && !node.bodyNode);
+		const blankLine = previousRequiresPadding || previous && (currentRequiresPadding || lineStartWithComments(node) > lineEndWithComments(previous) + 1);
+		previousRequiresPadding = currentRequiresPadding;
+		const declaration = print(child);
+		return blankLine ? [separator, declaration] : declaration;
+	}, "namedChildren");
+}
+function printTypeParameters(path, print) {
+	const parameters = path.node.namedChildren;
+	if (parameters.length === 0 || parameters.length === 1 && isSimpleType(parameters[0]) && !parameters.some(({ comments }) => comments?.length && comments.some(({ type }) => type === "line_comment"))) return [
+		"<",
+		join$7(", ", path.map(print, "namedChildren")),
+		">"
+	];
+	const parts = [
+		"<",
+		indent$7([softline$4, join$7([",", line$7], path.map(print, "namedChildren"))]),
+		softline$4,
+		">"
+	];
+	return path.node.type === "type_arguments" ? group$7(parts) : parts;
+}
+function printVariableDeclaration(path, print) {
+	const declaration = printModifiers(path, print);
+	declaration.push(path.call(print, "typeNode"), " ");
+	const declarators = path.map(print, "declaratorNodes");
+	if (declarators.length > 1 && path.node.declaratorNodes.some(({ valueNode }) => valueNode)) declaration.push(group$7(indent$7(join$7([",", line$7], declarators)), { shouldBreak: path.parent?.type !== "for_statement" }));
+	else declaration.push(join$7(", ", declarators));
+	declaration.push(";");
+	return declaration;
+}
+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") || hasLeadingComments(rightNode)) return group$7([
+		leftDoc,
+		operator,
+		group$7(indent$7([line$7, rightDoc]))
+	]);
+	const groupId = Symbol("assignment");
+	return group$7([
+		leftDoc,
+		operator,
+		group$7(indent$7(line$7), { id: groupId }),
+		lineSuffixBoundary$1,
+		indentIfBreak$2(rightDoc, { groupId })
+	]);
+}
+function printTextBlock(contents) {
+	return [
+		"\"\"\"",
+		hardline$7,
+		contents,
+		"\"\"\""
+	];
+}
+function embedTextBlock(path) {
+	if (path.node.namedChildren.some(({ type }) => type === "string_interpolation") || path.node.children[0].value === "\"") return null;
+	const language = findEmbeddedLanguage(path);
+	if (!language) return null;
+	const text = unescapeTextBlockContents(textBlockContents(path.node));
+	return async (textToDoc) => {
+		return printTextBlock([escapeDocForTextBlock(await textToDoc(text, { parser: language })), hardline$7]);
+	};
+}
+function textBlockContents(node) {
+	const lines = node.value.split("\n").slice(1);
+	const baseIndent = findBaseIndent(lines);
+	return lines.map((line) => line.slice(baseIndent)).join("\n").slice(0, -3);
+}
+const PRECEDENCE = new Map([
+	["||"],
+	["&&"],
+	["|"],
+	["^"],
+	["&"],
+	["==", "!="],
+	[
+		"<",
+		">",
+		"<=",
+		">=",
+		"instanceof"
+	],
+	[
+		"<<",
+		">>",
+		">>>"
+	],
+	["+", "-"],
+	[
+		"*",
+		"/",
+		"%"
+	]
+].flatMap((operators, index) => operators.map((operator) => [operator, index])));
+function getPrecedence(operator) {
+	return PRECEDENCE.get(operator) ?? -1;
+}
+const equalityOperators = /* @__PURE__ */ new Set(["==", "!="]);
+const multiplicativeOperators = /* @__PURE__ */ new Set([
+	"*",
+	"/",
+	"%"
+]);
+const bitshiftOperators = /* @__PURE__ */ new Set([
+	">>",
+	">>>",
+	"<<"
+]);
+function isBitwiseOperator(operator) {
+	return bitshiftOperators.has(operator) || operator === "|" || operator === "^" || operator === "&";
+}
+function shouldFlatten(parentOp, nodeOp) {
+	if (getPrecedence(nodeOp) !== getPrecedence(parentOp)) return false;
+	if (equalityOperators.has(parentOp) && equalityOperators.has(nodeOp)) return false;
+	if (nodeOp === "%" && multiplicativeOperators.has(parentOp) || parentOp === "%" && multiplicativeOperators.has(nodeOp)) return false;
+	if (nodeOp !== parentOp && multiplicativeOperators.has(nodeOp) && multiplicativeOperators.has(parentOp)) return false;
+	if (bitshiftOperators.has(parentOp) && bitshiftOperators.has(nodeOp)) return false;
+	return true;
+}
+function createTypeCheckFunction(typesArray) {
+	const types = new Set(typesArray);
+	return (node) => node != null && types.has(node.type);
+}
+const isMember = createTypeCheckFunction([
+	"array_access",
+	"field_access",
+	"method_invocation"
+]);
+function needsParentheses(path) {
+	if (path.isRoot) return false;
+	const { node, parent } = path;
+	const parentCheckResult = parentNeedsParentheses(path);
+	if (typeof parentCheckResult === "boolean") return parentCheckResult;
+	switch (node.type) {
+		case "switch_expression": return isMember(parent) || parent?.type === "explicit_constructor_invocation" || parent?.type === "method_reference" || parent?.type === "object_creation_expression";
+		case "update_expression": if (parent?.type === "unary_expression") return node.children[0].type.startsWith(parent.operatorNode.type);
+		case "unary_expression": switch (parent?.type) {
+			case "unary_expression": return node.type === "unary_expression" && node.operatorNode.type === parent.operatorNode.type && (node.operatorNode.type === "+" || node.operatorNode.type === "-");
+			case "instanceof_expression": return parent.leftNode === node && node.type === "unary_expression";
+			default: return false;
+		}
+		case "binary_expression":
+		case "instanceof_expression": if (parent?.type === "update_expression") return true;
+		case "cast_expression":
+			switch (parent?.type) {
+				case "cast_expression": return node.type !== "cast_expression";
+				case "method_reference":
+				case "object_creation_expression":
+				case "update_expression": return true;
+				case "unary_expression":
+					if (!node.comments) return true;
+					break;
+				case "explicit_constructor_invocation":
+				case "field_access":
+				case "method_invocation": return parent.objectNode === node;
+				case "array_access": return parent.arrayNode === node;
+				case "binary_expression":
+				case "instanceof_expression": {
+					if (node.type === "cast_expression") return false;
+					if (parent.type === "binary_expression" && isLogicalOperator(parent.operatorNode) && node.type === "binary_expression" && isLogicalOperator(node.operatorNode)) return parent.operatorNode.type !== node.operatorNode.type;
+					const operator = node.type === "instanceof_expression" ? "instanceof" : node.operatorNode.type;
+					const precedence = getPrecedence(operator);
+					const parentOperator = parent.type === "instanceof_expression" ? "instanceof" : parent.operatorNode.type;
+					const parentPrecedence = getPrecedence(parentOperator);
+					if (parentPrecedence > precedence) return true;
+					if (parent.rightNode === node && parentPrecedence === precedence) return true;
+					if (parentPrecedence === precedence && !shouldFlatten(parentOperator, operator)) return true;
+					if (parentPrecedence < precedence && operator === "%" && (parentOperator === "+" || parentOperator === "-")) return true;
+					if (isBitwiseOperator(parentOperator)) return true;
+					return false;
+				}
+				default: return false;
+			}
+			break;
+		case "assignment_expression":
+			if (parent?.type === "for_statement" && (parent.initNodes.includes(node) || parent.updateNodes.includes(node))) return false;
+			if (parent?.type === "expression_statement" && parent.namedChildren[0] === node) return false;
+			if (parent?.type === "assignment_expression" || parent?.type === "lambda_expression" && parent.bodyNode === node) return false;
+			return true;
+		case "ternary_expression": switch (parent?.type) {
+			case "unary_expression":
+			case "binary_expression":
+			case "cast_expression":
+			case "method_reference":
+			case "object_creation_expression": return true;
+			case "ternary_expression": return parent.conditionNode === node;
+			case "explicit_constructor_invocation":
+			case "field_access":
+			case "method_invocation": return parent.objectNode === node;
+			case "array_access": return parent.arrayNode === node;
+			default: return false;
+		}
+	}
+	return false;
+}
+function returnArgumentHasLeadingComment(node) {
+	return node.comments?.some((comment) => comment.leading && (comment.type === "line_comment" || comment.start < comment.end));
+}
+const isReturnOrThrowStatement = createTypeCheckFunction(["return_statement", "throw_statement"]);
+function parentNeedsParentheses(path) {
+	const { parent } = path;
+	switch (parent?.type) {
+		case "return_statement":
+		case "throw_statement":
+			if (willReturnOrThrowStatementBreak(path)) return false;
+			break;
+	}
+}
+function willReturnOrThrowStatementBreak(path) {
+	const { parent } = path;
+	if (!isReturnOrThrowStatement(parent)) return false;
+	const { node } = path;
+	if (node.type === "assignment_expression" && returnArgumentHasLeadingComment(node)) return true;
+	return false;
+}
+const isLogicalOperator = createTypeCheckFunction(["||", "&&"]);
+function isSimpleType(node) {
+	const { type, children, namedChildren } = node;
+	const lastNamedChild = namedChildren.at(-1);
+	return [
+		"boolean_type",
+		"floating_point_type",
+		"integral_type",
+		"type_identifier",
+		"void_type"
+	].includes(type) || type === "annotated_type" && lastNamedChild && isSimpleType(lastNamedChild) || type === "array_type" && isSimpleType(node.elementNode) || type === "scoped_type_identifier" && lastNamedChild && isSimpleType(namedChildren[0]) && isSimpleType(lastNamedChild) || type === "type_parameter" && (lastNamedChild?.type !== "type_bound" || lastNamedChild.namedChildren.length === 1) || type === "wildcard" && (children.at(-1).type === "?" || isSimpleType(namedChildren.at(-1)));
+}
+function findBaseIndent(lines) {
+	return Math.min(...lines.map((line) => line.search(/\S/)).filter((indent) => indent >= 0));
+}
+function findEmbeddedLanguage(path) {
+	return path.ancestors.find(({ type, comments }) => type === "block" || comments?.some(({ leading }) => leading))?.comments?.filter(({ leading }) => leading).map(({ value }) => value.match(/^(?:\/\/|\/\*)\s*language\s*=\s*(\S+)/)?.[1]).findLast((language) => language)?.toLowerCase();
+}
+function escapeDocForTextBlock(doc) {
+	return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" ? currentDoc.replace(/\\|"""/g, (match) => match === "\\" ? "\\\\" : "\"\"\\\"") : currentDoc);
+}
+function unescapeTextBlockContents(text) {
+	return text.replace(/\\(?:([stnr"'\\])|\n|\r\n?)/g, (_, escaped) => {
+		switch (escaped) {
+			case "s": return " ";
+			case "t": return "	";
+			case "n": return "\n";
+			case "r": return "\r";
+			default: return escaped ?? "";
+		}
+	});
+}
+//#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));
+		}
+	},
+	do_statement(path, print, options) {
+		const hasEmptyStatement = path.node.bodyNode.type === ";";
+		const isNextLine = options?.braceStyle === "next-line";
+		const whilePrefix = isNextLine ? [hardline$6, "while "] : " while ";
+		return [
+			"do",
+			hasEmptyStatement ? ";" : isNextLine ? path.call(print, "bodyNode") : [" ", path.call(print, "bodyNode")],
+			whilePrefix,
+			path.call(print, "conditionNode"),
+			";"
+		];
+	},
+	for_statement(path, print) {
+		const danglingComments = printDanglingComments(path);
+		const hasInit = path.node.initNodes.length > 0;
+		const hasCondition = hasChild(path, "conditionNode");
+		const hasUpdate = path.node.updateNodes.length > 0;
+		const expressions = [
+			!hasInit ? ";" : path.node.initNodes[0].type === "local_variable_declaration" ? path.call(print, "initNodes", 0) : [printExpressionList(path.map(print, "initNodes")), ";"],
+			hasCondition ? [path.call(print, "conditionNode"), ";"] : ";",
+			hasUpdate ? printExpressionList(path.map(print, "updateNodes")) : ""
+		];
+		const hasEmptyStatement = path.node.bodyNode.type === ";";
+		return [
+			danglingComments && [danglingComments, hardline$6],
+			"for ",
+			hasInit || hasCondition || hasUpdate ? group$6(indentInParentheses(join$6(line$6, expressions))) : "(;;)",
+			hasEmptyStatement ? ";" : [" ", path.call(print, "bodyNode")]
+		];
+	},
+	update_expression(path, print) {
+		return path.map(print, "children");
+	},
+	enhanced_for_statement(path, print) {
+		const danglingComments = printDanglingComments(path);
+		const forStatement = [
+			danglingComments && [danglingComments, hardline$6],
+			"for (",
+			...printModifiers(path, print),
+			path.call(print, "typeNode"),
+			" ",
+			path.call(print, "nameNode")
+		];
+		if (hasChild(path, "dimensionsNode")) forStatement.push(path.call(print, "dimensionsNode"));
+		forStatement.push(" : ", path.call(print, "valueNode"), ")");
+		const bodyType = path.node.bodyNode.type;
+		if (bodyType === ";") forStatement.push(";");
+		else {
+			const body = path.call(print, "bodyNode");
+			forStatement.push(bodyType === "block" ? [" ", body] : indent$6([line$6, body]));
+		}
+		return group$6(forStatement);
+	},
+	break_statement(path, print) {
+		const parts = ["break"];
+		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier");
+		if (identifierIndex !== -1) parts.push(" ", path.call(print, "namedChildren", identifierIndex));
+		parts.push(";");
+		return parts;
+	},
+	continue_statement(path, print) {
+		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier");
+		return identifierIndex !== -1 ? [
+			"continue ",
+			path.call(print, "namedChildren", identifierIndex),
+			";"
+		] : "continue;";
+	},
+	return_statement: printReturnOrThrowStatement,
+	throw_statement: printReturnOrThrowStatement,
+	synchronized_statement(path, print) {
+		const parenthesizedExpressionIndex = path.node.namedChildren.findIndex(({ type }) => type === "parenthesized_expression");
+		return [
+			"synchronized ",
+			path.call(print, "namedChildren", parenthesizedExpressionIndex),
+			" ",
+			path.call(print, "bodyNode")
+		];
+	},
+	try_statement(path, print, options) {
+		const parts = ["try", path.call(print, "bodyNode")];
+		path.each((child) => {
+			if (child.node.type === "catch_clause" || child.node.type === "finally_clause") parts.push(print(child));
+		}, "namedChildren");
+		if (options?.braceStyle === "next-line") return parts;
+		return join$6(" ", parts);
+	},
+	catch_clause(path, print, options) {
+		const catchFormalParameterIndex = path.node.namedChildren.findIndex(({ type }) => type === "catch_formal_parameter");
+		const params = group$6(indentInParentheses(path.call(print, "namedChildren", catchFormalParameterIndex)));
+		const body = path.call(print, "bodyNode");
+		if (options?.braceStyle === "next-line") return [
+			hardline$6,
+			"catch ",
+			params,
+			body
+		];
+		return [
+			"catch ",
+			params,
+			" ",
+			body
+		];
+	},
+	catch_formal_parameter(path, print) {
+		const parts = printModifiers(path, print, "noBreak");
+		const catchTypeIndex = path.node.namedChildren.findIndex(({ type }) => type === "catch_type");
+		parts.push(path.call(print, "namedChildren", catchTypeIndex), " ", path.call(print, "nameNode"));
+		if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
+		return parts;
+	},
+	catch_type(path, print) {
+		return join$6([line$6, "| "], path.map(print, "namedChildren"));
+	},
+	finally_clause(path, print, options) {
+		if (options?.braceStyle === "next-line") return [
+			hardline$6,
+			"finally",
+			path.call(print, "namedChildren", 0)
+		];
+		return ["finally ", path.call(print, "namedChildren", 0)];
+	},
+	try_with_resources_statement(path, print, options) {
+		const resources = path.call(print, "resourcesNode");
+		const body = path.call(print, "bodyNode");
+		const clauses = [];
+		path.each((child) => {
+			if (child.node.type === "catch_clause" || child.node.type === "finally_clause") clauses.push(print(child));
+		}, "namedChildren");
+		if (options?.braceStyle === "next-line") return [
+			"try ",
+			resources,
+			body,
+			...clauses
+		];
+		return join$6(" ", [
+			"try",
+			resources,
+			body,
+			...clauses
+		]);
+	},
+	resource_specification(path, print) {
+		const resources = [];
+		let hasTrailingSemicolon = false;
+		path.each((child) => {
+			if (child.node.type === "resource") {
+				resources.push(print(child));
+				hasTrailingSemicolon = false;
+			} else if (child.node.type === ";") hasTrailingSemicolon = true;
+		}, "children");
+		const parts = join$6([";", line$6], resources);
+		if (hasTrailingSemicolon) parts.push(ifBreak$1(";"));
+		return group$6(indentInParentheses(parts));
+	},
+	resource(path, print) {
+		if (hasChild(path, "typeNode") && hasChild(path, "nameNode") && hasChild(path, "valueNode")) {
+			const parts = printModifiers(path, print);
+			parts.push(path.call(print, "typeNode"), " ", path.call(print, "nameNode"));
+			if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
+			parts.push(" =");
+			const value = path.call(print, "valueNode");
+			if (path.node.valueNode.type === "binary_expression" || hasLeadingComments(path.node.valueNode)) parts.push(group$6(indent$6([line$6, value])));
+			else {
+				const groupId = Symbol("assignment");
+				parts.push(group$6(indent$6(line$6), { id: groupId }), indentIfBreak$1(value, { groupId }));
+			}
+			return parts;
+		}
+		const resourceIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier" || type === "field_access");
+		return path.call(print, "namedChildren", resourceIndex);
+	},
+	yield_statement(path, print) {
+		return [
+			"yield ",
+			path.call(print, "namedChildren", 0),
+			";"
+		];
+	}
+};
+function printExpressionList(expressions) {
+	return group$6(expressions.map((expression, index) => index === 0 ? expression : [",", indent$6([line$6, expression])]));
+}
+function printReturnOrThrowArgument(path, print) {
+	const { node } = path;
+	const argumentDoc = print(path);
+	if (returnArgumentHasLeadingComment(node)) return [
+		"(",
+		indent$6([hardline$6, argumentDoc]),
+		hardline$6,
+		")"
+	];
+	if (node.type === "binary_expression") return group$6([
+		ifBreak$1("("),
+		indent$6([softline$3, argumentDoc]),
+		softline$3,
+		ifBreak$1(")")
+	]);
+	return argumentDoc;
+}
+function printReturnOrThrowStatement(path, print) {
+	const { node } = path;
+	return [
+		node.type === "throw_statement" ? "throw" : "return",
+		node.namedChildren.length ? [" ", path.call(() => printReturnOrThrowArgument(path, print), "namedChildren", 0)] : "",
+		";"
+	];
+}
+//#endregion
+//#region src/printers/classes.ts
+const { group: group$5, hardline: hardline$5, indent: indent$5, join: join$5, line: line$5, softline: softline$2 } = prettier_doc.builders;
+var classes_default = {
+	class_declaration(path, print, options) {
+		const parts = ["class ", path.call(print, "nameNode")];
+		const definedClauses = definedKeys(path.node, [
+			"superclassNode",
+			"interfacesNode",
+			"permitsNode"
+		]);
+		const hasMultipleClauses = definedClauses.length > 1;
+		if (hasChild(path, "type_parametersNode")) {
+			const typeParameters = path.call(print, "type_parametersNode");
+			parts.push(hasMultipleClauses ? group$5(indent$5(typeParameters)) : typeParameters);
+		}
+		if (definedClauses.length) {
+			const clauses = definedClauses.flatMap((clause) => {
+				if (!hasChild(path, clause)) return [];
+				return [clause === "superclassNode" || clause === "interfacesNode" ? hardline$5 : line$5, path.call(print, clause)];
+			});
+			const hasBody = path.node.bodyNode.namedChildren.length > 0;
+			const afterClauses = options?.braceStyle === "next-line" ? "" : hasBody ? line$5 : " ";
+			const clauseGroup = [indent$5(clauses), afterClauses];
+			parts.push(hasMultipleClauses ? clauseGroup : group$5(clauseGroup));
+		} else if (options?.braceStyle !== "next-line") parts.push(" ");
+		return [
+			...printModifiers(path, print, "declarationOnly"),
+			group$5(parts),
+			path.call(print, "bodyNode")
+		];
+	},
+	type_parameters: printTypeParameters,
+	superclass(path, print) {
+		return ["extends ", path.call(print, "namedChildren", 0)];
+	},
+	super_interfaces(path, print) {
+		return group$5(["implements", indent$5([line$5, path.call(print, "namedChildren", 0)])]);
+	},
+	permits(path, print) {
+		return group$5(["permits", indent$5([line$5, path.call(print, "namedChildren", 0)])]);
+	},
+	type_list(path, print) {
+		return join$5([",", line$5], path.map(print, "namedChildren"));
+	},
+	class_body(path, print, options) {
+		return printBlock(path, printBodyDeclarations(path, print, path.parent?.type === "class_declaration" && options?.braceStyle !== "next-line"), options);
+	},
+	field_declaration: printVariableDeclaration,
+	variable_declarator(path, print) {
+		const leftDoc = [path.call(print, "nameNode")];
+		if (hasChild(path, "dimensionsNode")) leftDoc.push(path.call(print, "dimensionsNode"));
+		return printAssignment(leftDoc, " =", hasChild(path, "valueNode") ? path.call(print, "valueNode") : void 0, path.node.valueNode);
+	},
+	method_declaration(path, print) {
+		const modifiers = printModifiers(path, print);
+		const declaration = [];
+		if (hasChild(path, "type_parametersNode")) declaration.push(group$5(path.call(print, "type_parametersNode")), " ");
+		path.each((child) => {
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") declaration.push(print(child), " ");
+		}, "children");
+		declaration.push(path.call(print, "typeNode"));
+		if (hasChild(path, "dimensionsNode")) declaration.push(path.call(print, "dimensionsNode"));
+		declaration.push(" ", path.call(print, "nameNode"), group$5(path.call(print, "parametersNode")));
+		const throwsIndex = path.node.namedChildren.findIndex(({ type }) => type === "throws");
+		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$5, path.call(print, "namedChildren", throwsIndex)])));
+		return hasChild(path, "bodyNode") ? [
+			modifiers,
+			group$5(declaration),
+			" ",
+			path.call(print, "bodyNode")
+		] : [
+			modifiers,
+			group$5(declaration),
+			";"
+		];
+	},
+	receiver_parameter(path, print) {
+		return path.map((child) => child.isLast ? print(child) : [print(child), child.node.type === "identifier" ? "." : " "], "namedChildren");
+	},
+	formal_parameters(path, print) {
+		const parameters = path.parent?.type === "record_declaration" ? printBodyDeclarations(path, print) : path.map(print, "namedChildren");
+		if (parameters.length === 0) return [
+			"(",
+			printDanglingCommentsInList(path),
+			")"
+		];
+		return indentInParentheses(join$5([",", line$5], parameters));
+	},
+	formal_parameter(path, print) {
+		const parameter = printModifiers(path, print, path.grandparent?.type === "record_declaration" ? "avoidBreak" : "noBreak");
+		parameter.push(path.call(print, "typeNode"));
+		if (hasChild(path, "dimensionsNode")) parameter.push(path.call(print, "dimensionsNode"));
+		parameter.push(" ", path.call(print, "nameNode"));
+		return group$5(parameter);
+	},
+	spread_parameter(path, print) {
+		const parts = printModifiers(path, print, "noBreak");
+		parts.push(path.call(print, "typeNode"));
+		if (hasChild(path, "annotationsNodes")) parts.push(...path.map((annotation) => [" ", print(annotation)], "annotationsNodes"));
+		parts.push("... ", path.call(print, "namedChildren", path.node.namedChildren.length - 1));
+		return parts;
+	},
+	throws(path, print) {
+		return ["throws ", ...join$5(", ", path.map(print, "namedChildren"))];
+	},
+	static_initializer(path, print) {
+		return ["static ", path.call(print, "namedChildren", 0)];
+	},
+	constructor_declaration(path, print) {
+		const modifiers = printModifiers(path, print, "declarationOnly");
+		const declaration = [];
+		if (hasChild(path, "type_parametersNode")) declaration.push(group$5(path.call(print, "type_parametersNode")), " ");
+		declaration.push(path.call(print, "nameNode"), group$5(path.call(print, "parametersNode")));
+		const throwsIndex = path.node.namedChildren.findIndex(({ type }) => type === "throws");
+		if (throwsIndex !== -1) declaration.push(group$5(indent$5([hardline$5, path.call(print, "namedChildren", throwsIndex)])));
+		return [
+			modifiers,
+			group$5(declaration),
+			" ",
+			path.call(print, "bodyNode")
+		];
+	},
+	constructor_body(path, print, options) {
+		return printBlock(path, printBlockStatements(path, print), options);
+	},
+	explicit_constructor_invocation(path, print) {
+		const invocation = [];
+		if (hasChild(path, "objectNode")) invocation.push(path.call(print, "objectNode"), ".");
+		if (hasChild(path, "type_argumentsNode")) invocation.push(path.call(print, "type_argumentsNode"));
+		invocation.push(path.call(print, "constructorNode"), path.call(print, "argumentsNode"), ";");
+		return invocation;
+	},
+	visibility: printValue,
+	modifier: printValue,
+	modifiers(path, print, _, args) {
+		const parts = [];
+		const modifiers = [];
+		const typeAnnotations = [];
+		path.each((child) => {
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") (modifiers.length ? typeAnnotations : parts).push(print(child));
+			else {
+				modifiers.push(child.node.value);
+				parts.push(...typeAnnotations);
+				typeAnnotations.length = 0;
+			}
+		}, "namedChildren");
+		const annotationMode = args && typeof args === "object" && "annotationMode" in args ? args.annotationMode : null;
+		if (annotationMode === "declarationOnly") {
+			parts.push(...typeAnnotations);
+			typeAnnotations.length = 0;
+		}
+		modifiers.sort((a, b) => (indexByModifier.get(a) ?? -1) - (indexByModifier.get(b) ?? -1));
+		if (modifiers.length || typeAnnotations.length) parts.push(join$5(" ", [...modifiers, ...typeAnnotations]));
+		return join$5(annotationMode === "avoidBreak" ? line$5 : annotationMode === "noBreak" ? " " : hardline$5, parts);
+	},
+	enum_declaration(path, print) {
+		const modifiers = printModifiers(path, print, "declarationOnly");
+		const parts = ["enum ", path.call(print, "nameNode")];
+		if (hasChild(path, "interfacesNode")) {
+			const hasBody = path.node.bodyNode.namedChildren.length > 0;
+			parts.push(indent$5([hardline$5, path.call(print, "interfacesNode")]), hasBody ? line$5 : " ");
+		} else parts.push(" ");
+		return [
+			...modifiers,
+			group$5(parts),
+			path.call(print, "bodyNode")
+		];
+	},
+	enum_body(path, print, options) {
+		const parts = printBodyDeclarations(path, print);
+		const enumBodyDeclarationsIndex = path.node.namedChildren.findIndex(({ type }) => type === "enum_body_declarations");
+		const declarations = [];
+		if (enumBodyDeclarationsIndex !== -1) {
+			const hasDeclarations = path.node.namedChildren[enumBodyDeclarationsIndex].namedChildren.length > 0;
+			const enumBodyDeclarations = parts.pop();
+			if (hasDeclarations) {
+				if (!parts.length) declarations.push(hardline$5);
+				declarations.push(enumBodyDeclarations);
+			}
+		}
+		const contents = [];
+		if (parts.length) {
+			contents.push(join$5([",", hardline$5], parts));
+			if (!declarations.length && options.trailingComma !== "none") contents.push(",");
+		}
+		if (declarations.length) contents.push(";", hardline$5, ...declarations);
+		return printBlock(path, contents.length ? [contents] : [], options);
+	},
+	enum_constant(path, print) {
+		const initializer = printModifiers(path, print);
+		initializer.push(path.call(print, "nameNode"));
+		if (hasChild(path, "argumentsNode")) initializer.push(path.call(print, "argumentsNode"));
+		if (hasChild(path, "bodyNode")) initializer.push(" ", path.call(print, "bodyNode"));
+		return initializer;
+	},
+	enum_body_declarations(path, print) {
+		return join$5(hardline$5, printBodyDeclarations(path, print));
+	},
+	record_declaration(path, print) {
+		const modifiers = printModifiers(path, print, "declarationOnly");
+		const parts = ["record ", path.call(print, "nameNode")];
+		if (hasChild(path, "type_parametersNode")) parts.push(group$5(path.call(print, "type_parametersNode")));
+		parts.push(group$5(path.call(print, "parametersNode")));
+		if (hasChild(path, "interfacesNode")) {
+			const hasBody = path.node.bodyNode.namedChildren.length > 0;
+			const interfaces = [hardline$5, path.call(print, "interfacesNode")];
+			parts.push(group$5([indent$5(interfaces), hasBody ? line$5 : " "]));
+		} else parts.push(" ");
+		return [
+			...modifiers,
+			group$5(parts),
+			path.call(print, "bodyNode")
+		];
+	},
+	compact_constructor_declaration(path, print) {
+		const parts = printModifiers(path, print, "declarationOnly");
+		parts.push(path.call(print, "nameNode"), " ", path.call(print, "bodyNode"));
+		return parts;
+	}
+};
+const indexByModifier = [
+	"public",
+	"protected",
+	"private",
+	"abstract",
+	"default",
+	"static",
+	"final",
+	"transient",
+	"volatile",
+	"synchronized",
+	"native",
+	"sealed",
+	"non-sealed",
+	"strictfp"
+].reduce((map, name, index) => map.set(name, index), /* @__PURE__ */ new Map());
+function printDanglingCommentsInList(path) {
+	const { node } = path;
+	return node.comments?.some((comment) => !(comment.leading || comment.trailing)) ? [indent$5([softline$2, printDanglingComments(path)]), node.comments.some(({ type, leading, trailing }) => !(leading || trailing) && type === "line_comment") ? hardline$5 : softline$2] : "";
+}
+//#endregion
+//#region src/printers/expressions.ts
+const { align, breakParent: breakParent$1, conditionalGroup, dedent, group: group$4, hardline: hardline$4, ifBreak, indent: indent$4, indentIfBreak, join: join$4, line: line$4, lineSuffixBoundary, softline: softline$1 } = prettier_doc.builders;
+const { getNextNonSpaceNonCommentCharacterIndex, hasNewline: hasNewline$1, isNextLineEmpty } = prettier.util;
+const { removeLines, willBreak } = prettier_doc.utils;
+var expressions_default = {
+	lambda_expression(path, print, options, args) {
+		const signatureDocs = [];
+		let bodyDoc;
+		const bodyComments = [];
+		const shouldPrintAsChain = !(args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg) && path.node.bodyNode.type === "lambda_expression";
+		let functionBody;
+		(function rec() {
+			const { node } = path;
+			const signatureDoc = printLambdaExpressionSignature(path, options, print, args);
+			if (signatureDocs.length === 0) signatureDocs.push(signatureDoc);
+			else {
+				const { leading, trailing } = printCommentsSeparately(path);
+				signatureDocs.push([leading, signatureDoc]);
+				bodyComments.unshift(trailing);
+			}
+			if (!shouldPrintAsChain || node.bodyNode.type !== "lambda_expression") {
+				bodyDoc = path.call((child) => print(child, args), "bodyNode");
+				functionBody = node.bodyNode;
+			} else path.call(rec, "bodyNode");
+		})();
+		const shouldPutBodyOnSameLine = !functionBody.comments?.some((comment) => comment.leading && hasNewline$1(options.originalText, comment.end.index)) && mayBreakAfterShortPrefix(functionBody);
+		const chainGroupId = Symbol("arrow-chain");
+		const signaturesDoc = printArrowFunctionSignatures(path, { signatureDocs });
+		bodyDoc = printArrowFunctionBody(path, args, {
+			bodyDoc,
+			bodyComments,
+			shouldPutBodyOnSameLine
+		});
+		return group$4([
+			group$4(signaturesDoc, { id: chainGroupId }),
+			" ->",
+			shouldPrintAsChain ? indentIfBreak(bodyDoc, { groupId: chainGroupId }) : group$4(bodyDoc)
+		]);
+	},
+	inferred_parameters(path, print, options) {
+		const identifiers = [];
+		path.each((child) => {
+			if (child.node.type === "identifier") identifiers.push(print(child));
+		}, "namedChildren");
+		if (!identifiers.length) return "()";
+		const parameters = join$4([",", line$4], identifiers);
+		if (identifiers.length > 1 || willBreak(identifiers)) return group$4(indentInParentheses(parameters));
+		return options.arrowParens === "avoid" ? parameters : [
+			"(",
+			...parameters,
+			")"
+		];
+	},
+	ternary_expression(path, print, options) {
+		const { node } = path;
+		const consequentNode = node.consequenceNode;
+		const parts = [];
+		const parent = path.parent;
+		const isParentTest = parent.type === node.type && parent.conditionNode === node;
+		const forceNoIndent = parent.type === node.type && !isParentTest;
+		let currentParent;
+		let previousParent;
+		let i = 0;
+		do {
+			previousParent = currentParent || node;
+			currentParent = path.getParentNode(i);
+			i++;
+		} while (currentParent && currentParent.type === node.type && currentParent.conditionNode !== previousParent);
+		const firstNonConditionalParent = currentParent || parent;
+		const printBranch = (nodePropertyName) => options.useTabs ? indent$4(path.call(print, nodePropertyName)) : align(2, path.call(print, nodePropertyName));
+		const part = [
+			line$4,
+			"? ",
+			consequentNode.type === node.type ? ifBreak("", "(") : "",
+			printBranch("consequenceNode"),
+			consequentNode.type === node.type ? ifBreak("", ")") : "",
+			line$4,
+			": ",
+			printBranch("alternativeNode")
+		];
+		parts.push(parent.type !== node.type || parent.alternativeNode === node || isParentTest ? part : options.useTabs ? dedent(indent$4(part)) : align(Math.max(0, options.tabWidth - 2), part));
+		const maybeGroup = (doc) => parent === firstNonConditionalParent ? group$4(doc) : doc;
+		const breakClosingParen = parent.type === "explicit_constructor_invocation" || parent.type === "field_access" || parent.type === "method_invocation" || parent.type === "method_reference" || parent.type === "object_creation_expression";
+		const shouldExtraIndent = shouldExtraIndentForTernaryExpression(path);
+		const result = maybeGroup([
+			printTernaryTest(path, print),
+			forceNoIndent ? parts : indent$4(parts),
+			breakClosingParen && !shouldExtraIndent ? softline$1 : ""
+		]);
+		return isParentTest || shouldExtraIndent ? group$4([indent$4([softline$1, result]), softline$1]) : result;
+	},
+	assignment_expression(path, print) {
+		const { node } = path;
+		return printAssignment(path.call(print, "leftNode"), [" ", node.operatorNode.type], path.call(print, "rightNode"), node.rightNode);
+	},
+	binary_expression(path, print, options) {
+		const { node } = path;
+		const parent = path.parent;
+		const grandparent = path.grandparent;
+		const isInsideParentheses = (grandparent?.type === "if_statement" || grandparent?.type === "while_statement" || grandparent?.type === "switch_expression" || grandparent?.type === "do_statement") && grandparent.conditionNode === parent || grandparent?.type === "synchronized_statement" && grandparent.bodyNode !== parent;
+		const parts = printBinaryExpressions(path, print, options, isInsideParentheses);
+		if (isInsideParentheses) return parts;
+		if (parent?.type === "unary_expression" && !node.comments || (parent?.type === "explicit_constructor_invocation" || parent?.type === "field_access" || parent?.type === "method_invocation") && parent.objectNode === node || parent?.type === "method_reference" || parent?.type === "object_creation_expression") return group$4([indent$4([softline$1, ...parts]), softline$1]);
+		if (isReturnOrThrowStatement(parent) || parent?.type === "assignment_expression" || parent?.type === "variable_declarator" || parent?.type === "guard" || parent?.type === "lambda_expression" && parent.bodyNode === node || parent?.type === "for_statement" && parent.conditionNode === node || parent?.type === "ternary_expression" && !isReturnOrThrowStatement(grandparent) && grandparent?.type !== "parenthesized_expression" && grandparent?.type !== "argument_list" || parent?.type === "unary_expression" && parent.operandNode === node) return group$4(parts);
+		if (parts.length === 0) return "";
+		const firstGroupIndex = parts.findIndex((part) => typeof part !== "string" && !Array.isArray(part) && part.type === "group");
+		const headParts = parts.slice(0, firstGroupIndex === -1 ? 1 : firstGroupIndex + 1);
+		const rest = parts.slice(headParts.length);
+		return group$4([...headParts, indent$4(rest)]);
+	},
+	instanceof_expression(path, print, options) {
+		return group$4(indent$4(path.map((child) => {
+			const doc = print(child, { annotationMode: "noBreak" });
+			if (!child.previous) return doc;
+			return [(options.experimentalOperatorPosition === "start" ? child.node.type === "instanceof" : child.previous.type === "instanceof") ? line$4 : " ", doc];
+		}, "children")));
+	},
+	unary_expression(path, print) {
+		return path.map(print, "children");
+	},
+	field_access: printMemberChain,
+	generic_type(path, print) {
+		const typeIdentifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "scoped_type_identifier" || type === "type_identifier");
+		const typeArgumentsIndex = path.node.namedChildren.findIndex(({ type }) => type === "type_arguments");
+		return [path.call(print, "namedChildren", typeIdentifierIndex), path.call(print, "namedChildren", typeArgumentsIndex)];
+	},
+	parenthesized_expression(path, print) {
+		const expression = path.call(print, "namedChildren", 0);
+		const parentType = path.parent?.type;
+		const grandparentType = path.grandparent?.type;
+		const expressionType = path.node.namedChildren[0].type;
+		const hasLambda = expressionType === "lambda_expression";
+		const hasTernary = expressionType === "ternary_expression";
+		const hasSuffix = parentType && (parentType === "array_access" || parentType === "explicit_constructor_invocation" || parentType === "field_access" || parentType === "method_invocation" || parentType === "method_reference" || parentType === "object_creation_expression");
+		const isAssignment = parentType && (parentType === "assignment_expression" || parentType === "variable_declarator") || hasSuffix && (grandparentType === "assignment_expression" || grandparentType === "variable_declarator");
+		if (!hasLambda && hasSuffix && (!hasTernary || isAssignment)) return group$4(indentInParentheses(hasTernary ? group$4(expression) : expression));
+		else if (parentType && (parentType === "guard" || parentType === "return_statement" || parentType === "unary_expression" && grandparentType === "return_statement" || path.node.fieldName === "condition" && (parentType === "do_statement" || parentType === "if_statement" || parentType === "switch_expression" || parentType === "while_statement") || path.node.fieldName !== "body" && parentType === "synchronized_statement")) return group$4(indentInParentheses(group$4(expression)));
+		else if (hasTernary && hasSuffix && !isAssignment) return group$4([
+			"(",
+			expression,
+			softline$1,
+			")"
+		]);
+		else return group$4([
+			"(",
+			hasLambda || hasTernary ? expression : indent$4(expression),
+			")"
+		]);
+	},
+	cast_expression(path, print) {
+		const { node } = path;
+		const parts = [
+			group$4(node.typeNodes.length === 1 ? [
+				"(",
+				path.call(print, "typeNodes", 0),
+				")"
+			] : [
+				"(",
+				indent$4([softline$1, join$4([" &", line$4], path.map(print, "typeNodes"))]),
+				softline$1,
+				")"
+			]),
+			" ",
+			path.call(print, "valueNode")
+		];
+		const parent = path.parent;
+		if (parent?.type === "unary_expression" && !node.comments || parent?.type === "array_access" && parent.arrayNode === node || (parent?.type === "explicit_constructor_invocation" || parent?.type === "field_access" || parent?.type === "method_invocation") && parent.objectNode === node || parent?.type === "method_reference" || parent?.type === "object_creation_expression") return group$4([indent$4([softline$1, ...parts]), softline$1]);
+		return parts;
+	},
+	object_creation_expression(path, print) {
+		const expression = [];
+		path.each((child) => {
+			if (child.node.type === "class_body") expression.push(" ");
+			expression.push(print(child));
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation" || child.node.type === "new") expression.push(" ");
+		}, "children");
+		return expression;
+	},
+	method_invocation: printMemberChain,
+	argument_list(path, print, options) {
+		const args = path.node.namedChildren;
+		if (args.length === 0) {
+			const shouldBreak = path.node.comments?.some(({ type, leading, trailing }) => !leading && !trailing && type === "line_comment");
+			return group$4(indentInParentheses(printDanglingComments(path)), { shouldBreak });
+		}
+		const lastArgIndex = args.length - 1;
+		let anyArgEmptyLine = false;
+		const printedArguments = [];
+		path.each((arg, index) => {
+			let argDoc = print(arg);
+			if (index === lastArgIndex) {} else if (isNextLineEmpty(options.originalText, arg.node.end.index)) {
+				anyArgEmptyLine = true;
+				argDoc = [
+					argDoc,
+					",",
+					hardline$4,
+					hardline$4
+				];
+			} else argDoc = [
+				argDoc,
+				",",
+				line$4
+			];
+			printedArguments.push(argDoc);
+		}, "namedChildren");
+		function allArgsBrokenOut() {
+			return group$4([
+				"(",
+				indent$4([line$4, ...printedArguments]),
+				line$4,
+				")"
+			], { shouldBreak: true });
+		}
+		if (anyArgEmptyLine) return allArgsBrokenOut();
+		if (shouldExpandFirstArg(args)) {
+			const tailArgs = printedArguments.slice(1);
+			if (tailArgs.some(willBreak)) return allArgsBrokenOut();
+			let firstArg;
+			try {
+				firstArg = path.call((arg) => print(arg, { expandFirstArg: true }), "namedChildren", 0);
+			} catch (caught) {
+				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
+				throw caught;
+			}
+			if (willBreak(firstArg)) return [breakParent$1, conditionalGroup([[
+				"(",
+				group$4(firstArg, { shouldBreak: true }),
+				", ",
+				...tailArgs,
+				")"
+			], allArgsBrokenOut()])];
+			return conditionalGroup([
+				[
+					"(",
+					firstArg,
+					", ",
+					...tailArgs,
+					")"
+				],
+				[
+					"(",
+					group$4(firstArg, { shouldBreak: true }),
+					", ",
+					...tailArgs,
+					")"
+				],
+				allArgsBrokenOut()
+			]);
+		}
+		if (shouldExpandLastArg(args)) {
+			const headArgs = printedArguments.slice(0, -1);
+			if (headArgs.some(willBreak)) return allArgsBrokenOut();
+			let lastArg;
+			try {
+				lastArg = path.call((arg) => print(arg, { expandLastArg: true }), "namedChildren", lastArgIndex);
+			} catch (caught) {
+				if (caught instanceof ArgExpansionBailout) return allArgsBrokenOut();
+				throw caught;
+			}
+			if (willBreak(lastArg)) return [breakParent$1, conditionalGroup([[
+				"(",
+				...headArgs,
+				group$4(lastArg, { shouldBreak: true }),
+				")"
+			], allArgsBrokenOut()])];
+			return conditionalGroup([
+				[
+					"(",
+					...headArgs,
+					lastArg,
+					")"
+				],
+				[
+					"(",
+					...headArgs,
+					group$4(lastArg, { shouldBreak: true }),
+					")"
+				],
+				allArgsBrokenOut()
+			]);
+		}
+		return group$4(indentInParentheses(printedArguments), { shouldBreak: printedArguments.some(willBreak) || anyArgEmptyLine });
+	},
+	array_creation_expression(path, print) {
+		const parts = ["new "];
+		path.each((child) => {
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") parts.push(print(child), " ");
+		}, "namedChildren");
+		parts.push(path.call(print, "typeNode"), ...path.map(print, "dimensionsNodes"));
+		if (hasChild(path, "valueNode")) parts.push(" ", path.call(print, "valueNode"));
+		return parts;
+	},
+	dimensions_expr(path, print) {
+		return path.map((child) => child.node.type === "annotation" || child.node.type === "marker_annotation" ? [print(child), " "] : [
+			"[",
+			print(child),
+			"]"
+		], "namedChildren");
+	},
+	class_literal(path, print) {
+		return [path.call(print, "namedChildren", 0), ".class"];
+	},
+	array_access: printMemberChain,
+	method_reference(path, print) {
+		return group$4(path.map(print, "children"));
+	},
+	template_expression(path, print) {
+		return [
+			path.call(print, "template_processorNode"),
+			".",
+			path.call(print, "template_argumentNode")
+		];
+	},
+	pattern(path, print) {
+		return path.call(print, "namedChildren", 0);
+	},
+	type_pattern(path, print) {
+		return join$4(" ", path.map(print, "children"));
+	},
+	record_pattern(path, print) {
+		return path.map(print, "children");
+	},
+	record_pattern_body(path, print) {
+		return group$4(indentInParentheses(join$4([",", line$4], path.map(print, "namedChildren"))));
+	},
+	record_pattern_component(path, print) {
+		return join$4(" ", path.map(print, "children"));
+	},
+	guard(path, print) {
+		return ["when ", group$4([
+			ifBreak("("),
+			indent$4([softline$1, path.call(print, "namedChildren", 0)]),
+			softline$1,
+			ifBreak(")")
+		])];
+	}
+};
+function printLambdaExpressionSignature(path, options, print, args) {
+	const parts = [];
+	const parameters = path.call(print, "parametersNode");
+	if (shouldPrintParamsWithoutParens(path, options)) parts.push(parameters);
+	else {
+		if (args != null && typeof args === "object" && ("expandLastArg" in args && args.expandLastArg === true || "expandFirstArg" in args && args.expandFirstArg === true)) {
+			if (willBreak(parameters)) throw new ArgExpansionBailout();
+			parts.push(group$4(removeLines(parameters)));
+		} else parts.push(parameters);
+		if (path.node.parametersNode.type === "identifier") return path.node.parametersNode.comments ? group$4([
+			"(",
+			indent$4([softline$1, ...parts]),
+			lineSuffixBoundary,
+			")"
+		]) : [
+			"(",
+			...parts,
+			")"
+		];
+	}
+	const dangling = printDanglingComments(path);
+	if (dangling) parts.push(" ", dangling);
+	return parts;
+}
+function mayBreakAfterShortPrefix(functionBody) {
+	return functionBody.type === "array_creation_expression" || functionBody.type === "lambda_expression" || functionBody.type === "block";
+}
+function printArrowFunctionSignatures(path, { signatureDocs }) {
+	if (signatureDocs.length === 1) return signatureDocs[0];
+	const { node, parent } = path;
+	if (node.fieldName !== "object" && parent?.type === "method_invocation" || parent?.type === "binary_expression") return group$4([
+		signatureDocs[0],
+		" ->",
+		indent$4([line$4, join$4([" ->", line$4], signatureDocs.slice(1))])
+	]);
+	if (node.fieldName === "object" && parent?.type === "method_invocation") return group$4(join$4([" ->", line$4], signatureDocs));
+	return group$4(indent$4(join$4([" ->", line$4], signatureDocs)));
+}
+function printArrowFunctionBody(path, args, { bodyDoc, bodyComments, shouldPutBodyOnSameLine }) {
+	const trailingSpace = args && typeof args === "object" && "expandLastArg" in args && args.expandLastArg && !path.node.comments ? softline$1 : "";
+	return shouldPutBodyOnSameLine ? [
+		" ",
+		bodyDoc,
+		bodyComments
+	] : [indent$4([
+		line$4,
+		bodyDoc,
+		bodyComments
+	]), trailingSpace];
+}
+function shouldPrintParamsWithoutParens(path, options) {
+	if (options.arrowParens === "always") return false;
+	if (options.arrowParens === "avoid") {
+		const { node } = path;
+		return canPrintParamsWithoutParens(node);
+	}
+	return false;
+}
+function canPrintParamsWithoutParens(node) {
+	return node.parametersNode.type === "identifier" && !node.comments?.some(({ leading, trailing }) => !leading && !trailing) && !node.parametersNode.comments;
+}
+function printMemberChain(path, print, options) {
+	const isExpressionStatement = path.parent?.type === "expression_statement";
+	const printedNodes = [];
+	function shouldInsertEmptyLineAfter(node) {
+		const { originalText } = options;
+		const nextCharIndex = getNextNonSpaceNonCommentCharacterIndex(originalText, node.end.index);
+		if ((nextCharIndex ? originalText.charAt(nextCharIndex) : "") === ")") return nextCharIndex !== false && isNextLineEmpty(originalText, nextCharIndex + 1);
+		return isNextLineEmpty(originalText, node.end.index);
+	}
+	function rec(path) {
+		const { node } = path;
+		if (hasType(path, "method_invocation") && hasChild(path, "objectNode")) {
+			const hasTrailingEmptyLine = shouldInsertEmptyLineAfter(node);
+			printedNodes.unshift({
+				node,
+				hasTrailingEmptyLine,
+				printed: [printComments(path, printMethodInvocation(path, print)), hasTrailingEmptyLine ? hardline$4 : ""]
+			});
+			path.call(rec, "objectNode");
+		} else if (hasType(path, "array_access")) {
+			printedNodes.unshift({
+				node,
+				printed: printComments(path, printArrayAccess(path, print))
+			});
+			path.call(rec, "arrayNode");
+		} else if (hasType(path, "field_access")) {
+			printedNodes.unshift({
+				node,
+				printed: printComments(path, printFieldAccess(path, print))
+			});
+			path.call(rec, "objectNode");
+		} else printedNodes.unshift({
+			node,
+			printed: print(path)
+		});
+	}
+	const { node } = path;
+	if (hasType(path, "method_invocation")) {
+		printedNodes.unshift({
+			node,
+			printed: printComments(path, printMethodInvocation(path, print))
+		});
+		if (hasChild(path, "objectNode")) path.call(rec, "objectNode");
+	} else if (hasType(path, "array_access")) {
+		printedNodes.unshift({
+			node,
+			printed: printComments(path, printArrayAccess(path, print))
+		});
+		if (hasChild(path, "arrayNode")) path.call(rec, "arrayNode");
+	} else if (hasType(path, "field_access")) {
+		printedNodes.unshift({
+			node,
+			printed: printComments(path, printFieldAccess(path, print))
+		});
+		if (hasChild(path, "objectNode")) path.call(rec, "objectNode");
+	}
+	const danglingComments = printDanglingComments(path);
+	if (danglingComments) printedNodes[0].printed = [
+		danglingComments,
+		hardline$4,
+		printedNodes[0].printed
+	];
+	const groups = [];
+	let currentGroup = [printedNodes[0]];
+	let i = 1;
+	for (; i < printedNodes.length; ++i) if (printedNodes[i].node.type === "array_access") currentGroup.push(printedNodes[i]);
+	else break;
+	if (printedNodes[0].node.type !== "method_invocation") for (; i + 1 < printedNodes.length; ++i) if (printedNodes[i].node.type !== "method_invocation") currentGroup.push(printedNodes[i]);
+	else break;
+	groups.push(currentGroup);
+	currentGroup = [];
+	let hasSeenMethodInvocation = false;
+	for (; i < printedNodes.length; ++i) {
+		if (hasSeenMethodInvocation) {
+			if (printedNodes[i].node.type === "array_access") {
+				currentGroup.push(printedNodes[i]);
+				continue;
+			}
+			groups.push(currentGroup);
+			currentGroup = [];
+			hasSeenMethodInvocation = false;
+		}
+		if (printedNodes[i].node.type === "method_invocation") hasSeenMethodInvocation = true;
+		currentGroup.push(printedNodes[i]);
+		if (printedNodes[i].node.comments?.some(({ trailing }) => trailing)) {
+			groups.push(currentGroup);
+			currentGroup = [];
+			hasSeenMethodInvocation = false;
+		}
+	}
+	if (currentGroup.length > 0) groups.push(currentGroup);
+	function isFactory(name) {
+		return /^[A-Z]|^[$_]+$/.test(name);
+	}
+	function isShort(name) {
+		return name.length <= options.tabWidth;
+	}
+	function shouldNotWrap(groups) {
+		const hasArrayAccess = groups[1][0]?.node.type === "array_access";
+		if (groups[0].length === 1) {
+			const firstNode = groups[0][0].node;
+			return firstNode.type === "this" || firstNode.type === "identifier" && (isFactory(firstNode.value) || isExpressionStatement && isShort(firstNode.value) || hasArrayAccess);
+		}
+		const lastNode = groups[0].at(-1).node;
+		return lastNode.type === "field_access" && lastNode.fieldNode.type === "identifier" && (isFactory(lastNode.fieldNode.value) || hasArrayAccess);
+	}
+	const shouldMerge = groups.length >= 2 && !groups[1][0].node.comments?.length && shouldNotWrap(groups);
+	function printGroup(printedGroup) {
+		return printedGroup.map((tuple) => tuple.printed);
+	}
+	function printIndentedGroup(groups) {
+		if (groups.length === 0) return "";
+		return indent$4([hardline$4, join$4(hardline$4, groups.map(printGroup))]);
+	}
+	const printedGroups = groups.map(printGroup);
+	const oneLine = printedGroups;
+	const cutoff = shouldMerge ? 3 : 2;
+	const flatGroups = groups.flat();
+	const nodeHasComment = flatGroups.some((node) => node.node.comments?.some(({ leading }) => leading)) || flatGroups.slice(0, -1).some((node) => node.node.comments?.some(({ trailing }) => trailing));
+	if (groups.length <= cutoff && !nodeHasComment && !groups.some((g) => g.at(-1).hasTrailingEmptyLine)) return group$4(oneLine);
+	const lastNodeBeforeIndent = groups[shouldMerge ? 1 : 0].at(-1).node;
+	const shouldHaveEmptyLineBeforeIndent = lastNodeBeforeIndent.type !== "method_invocation" && shouldInsertEmptyLineAfter(lastNodeBeforeIndent);
+	const expanded = [
+		printGroup(groups[0]),
+		shouldMerge ? groups.slice(1, 2).map(printGroup) : "",
+		shouldHaveEmptyLineBeforeIndent ? hardline$4 : "",
+		printIndentedGroup(groups.slice(shouldMerge ? 2 : 1))
+	];
+	const methodInvocations = printedNodes.map(({ node }) => node).filter((node) => node.type === "method_invocation");
+	function lastGroupWillBreakAndOtherCallsHaveFunctionArguments() {
+		const lastGroupNode = groups.at(-1).at(-1).node;
+		const lastGroupDoc = printedGroups.at(-1);
+		return lastGroupNode.type === "method_invocation" && willBreak(lastGroupDoc) && methodInvocations.slice(0, -1).some((node) => node.argumentsNode.namedChildren.some(({ type }) => type === "lambda_expression"));
+	}
+	let result;
+	if (nodeHasComment || methodInvocations.length > 2 && methodInvocations.some((inv) => !inv.argumentsNode.namedChildren.every((arg) => isSimpleCallArgument(arg))) || printedGroups.slice(0, -1).some(willBreak) || lastGroupWillBreakAndOtherCallsHaveFunctionArguments()) result = group$4(expanded);
+	else result = [willBreak(oneLine) || shouldHaveEmptyLineBeforeIndent ? breakParent$1 : "", conditionalGroup([oneLine, expanded])];
+	return result;
+}
+function printMethodInvocation(path, print) {
+	const parts = [];
+	if (hasChild(path, "objectNode")) parts.push(".");
+	if (path.node.children.filter(({ type }) => type === ".").length === 2) parts.push("super", ".");
+	if (hasChild(path, "type_argumentsNode")) parts.push(path.call(print, "type_argumentsNode"));
+	parts.push(path.call(print, "nameNode"), path.call(print, "argumentsNode"));
+	return parts;
+}
+function printArrayAccess(path, print) {
+	const index = path.call(print, "indexNode");
+	return path.node.indexNode.type === "decimal_integer_literal" ? [
+		"[",
+		index,
+		"]"
+	] : group$4([
+		"[",
+		indent$4([softline$1, index]),
+		softline$1,
+		"]"
+	]);
+}
+function printFieldAccess(path, print) {
+	const parts = ["."];
+	if (path.node.children.filter(({ type }) => type === ".").length === 2) parts.push("super.");
+	parts.push(path.call(print, "fieldNode"));
+	return parts;
+}
+/**
+* For binary expressions to be consistent, we need to group
+* subsequent operators with the same precedence level under a single
+* group. Otherwise they will be nested such that some of them break
+* onto new lines but not all. Operators with the same precedence
+* level should either all break or not. Because we group them by
+* precedence level and the AST is structured based on precedence
+* level, things are naturally broken up correctly, i.e. `&&` is
+* broken before `+`.
+*/
+function printBinaryExpressions(path, print, options, isInsideParentheses) {
+	if (!hasType(path, "binary_expression")) return [group$4(print(path))];
+	const { node } = path;
+	let parts = [];
+	if (node.leftNode.type === "binary_expression" && shouldFlatten(node.operatorNode.type, node.leftNode.operatorNode.type)) parts = path.call(() => printBinaryExpressions(path, print, options, isInsideParentheses), "leftNode");
+	else parts.push(group$4(path.call(print, "leftNode")));
+	const operator = node.operatorNode.type;
+	const operatorDoc = path.call(print, "operatorNode");
+	const rightContent = path.call(print, "rightNode");
+	let right = options.experimentalOperatorPosition === "start" ? [
+		line$4,
+		operatorDoc,
+		" ",
+		rightContent
+	] : [
+		" ",
+		operatorDoc,
+		line$4,
+		rightContent
+	];
+	const { parent } = path;
+	const shouldBreak = node.leftNode.comments?.some(({ trailing, type }) => trailing && type === "line_comment") ?? false;
+	if (shouldBreak || !(isInsideParentheses && logicalOperators.has(operator)) && (parent?.type !== node.type || logicalOperators.has(parent.operatorNode.value) !== logicalOperators.has(operator)) && node.leftNode.type !== node.type && node.rightNode.type !== node.type) right = group$4(right, { shouldBreak });
+	parts.push(right);
+	return parts;
+}
+const logicalOperators = /* @__PURE__ */ new Set(["||", "&&"]);
+function isSimpleCallArgument(node, depth = 2) {
+	if (depth <= 0) return false;
+	const isChildSimple = (child) => isSimpleCallArgument(child, depth - 1);
+	if (isLiteral(node) || isSingleWordType(node) || node.type === "class_literal") return true;
+	if (node.type === "object_creation_expression" || node.type === "method_invocation") {
+		if (node.type === "object_creation_expression" || !node.objectNode || isSimpleCallArgument(node.objectNode, depth)) {
+			const args = node.argumentsNode.namedChildren;
+			return args.length <= depth && args.every(isChildSimple);
+		}
+		return false;
+	}
+	if (node.type === "array_access") return isSimpleCallArgument(node.arrayNode, depth) && isSimpleCallArgument(node.indexNode, depth);
+	if (node.type === "field_access") return isSimpleCallArgument(node.objectNode, depth) && isSimpleCallArgument(node.fieldNode, depth);
+	if (node.type === "unary_expression") return isSimpleCallArgument(node.operandNode, depth);
+	if (node.type === "method_reference" || node.type === "update_expression") return isSimpleCallArgument(node.namedChildren[0], depth);
+	return false;
+}
+function isLiteral(node) {
+	return [
+		"true",
+		"false",
+		"null_literal",
+		"binary_integer_literal",
+		"decimal_floating_point_literal",
+		"decimal_integer_literal",
+		"hex_floating_point_literal",
+		"hex_integer_literal",
+		"octal_integer_literal",
+		"character_literal"
+	].includes(node.type) || isStringLiteral(node);
+}
+function isSingleWordType(node) {
+	return [
+		"identifier",
+		"this",
+		"super"
+	].includes(node.type);
+}
+function couldExpandArg(arg, lambdaChainRecursion = false) {
+	if (arg.type === "array_creation_expression" && arg.valueNode && (arg.valueNode.namedChildren.length > 0 || arg.valueNode.comments)) return true;
+	if (arg.type === "lambda_expression") {
+		const { bodyNode: body } = arg;
+		if (body.type === "block" || body.type === "array_creation_expression") return true;
+		if (body.type === "lambda_expression" && couldExpandArg(body, true)) return true;
+		if (!lambdaChainRecursion) {
+			if (body.type === "ternary_expression") return true;
+			if (body.type === "method_invocation" || body.type === "object_creation_expression") return true;
+		}
+	}
+	return false;
+}
+function shouldExpandLastArg(args) {
+	const lastArg = args.at(-1);
+	const penultimateArg = args.at(-2);
+	return !lastArg.comments?.some(({ leading }) => leading) && !lastArg.comments?.some(({ trailing }) => trailing) && couldExpandArg(lastArg) && (!penultimateArg || penultimateArg.type !== lastArg.type) && (args.length !== 2 || penultimateArg.type !== "lambda_expression");
+}
+function shouldExpandFirstArg(args) {
+	if (args.length !== 2) return false;
+	const [firstArg, secondArg] = args;
+	return !firstArg.comments && firstArg.type === "lambda_expression" && firstArg.bodyNode.type === "block" && secondArg.type !== "lambda_expression" && secondArg.type !== "ternary_expression" && isHopefullyShortCallArgument(secondArg) && !couldExpandArg(secondArg);
+}
+function isHopefullyShortCallArgument(node) {
+	if ((node.type === "method_invocation" || node.type === "object_creation_expression") && node.argumentsNode.namedChildren.length > 1) return false;
+	if (node.type === "binary_expression") return isSimpleCallArgument(node.leftNode, 1) && isSimpleCallArgument(node.rightNode, 1);
+	return isSimpleCallArgument(node);
+}
+function printTernaryTest(path, print) {
+	const { node, parent } = path;
+	const printed = path.call(print, "conditionNode");
+	/**
+	*     a
+	*       ? b
+	*       : multiline
+	*         test
+	*         node
+	*       ^^ align(2)
+	*       ? d
+	*       : e
+	*/
+	if (parent?.type === node.type && parent.alternativeNode === node) return align(2, printed);
+	return printed;
+}
+function getExpressionChild(node) {
+	switch (node.type) {
+		case "assignment_expression": return node.rightNode;
+		case "variable_declarator": return node.valueNode;
+		case "unary_expression": return node.operandNode;
+		case "return_statement":
+		case "throw_statement":
+		case "yield_statement": return node.namedChildren[0];
+		default: return null;
+	}
+}
+function shouldExtraIndentForTernaryExpression(path) {
+	const { node } = path;
+	let parent;
+	let child = node;
+	for (let ancestorCount = 0; !parent; ancestorCount++) {
+		const node = path.getParentNode(ancestorCount);
+		if (node.type === "array_access" && node.arrayNode === child || (node.type === "explicit_constructor_invocation" || node.type === "field_access" || node.type === "method_invocation") && node.objectNode === child || node.type === "method_reference" || node.type === "object_creation_expression") {
+			child = node;
+			continue;
+		}
+		if (node.type === "cast_expression" && node.valueNode === child) {
+			parent = path.getParentNode(ancestorCount + 1);
+			child = node;
+		} else parent = node;
+	}
+	if (child === node) return false;
+	return getExpressionChild(parent) === child;
+}
+function isStringLiteral(node) {
+	return node.type === "string_literal" && node.children[0].value === "\"";
+}
+var ArgExpansionBailout = class extends Error {
+	constructor(..._args) {
+		super(..._args);
+		this.name = "ArgExpansionBailout";
+	}
+};
+//#endregion
+//#region src/printers/interfaces.ts
+const { group: group$3, hardline: hardline$3, indent: indent$3, join: join$3, line: line$3 } = prettier_doc.builders;
+var interfaces_default = {
+	interface_declaration(path, print, options) {
+		const parts = ["interface ", path.call(print, "nameNode")];
+		const extendsInterfacesIndex = path.node.namedChildren.findIndex(({ type }) => type === "extends_interfaces");
+		const hasExtendsInterfaces = extendsInterfacesIndex !== -1;
+		const hasPermits = hasChild(path, "permitsNode");
+		const hasMultipleClauses = hasExtendsInterfaces && hasPermits;
+		if (hasChild(path, "type_parametersNode")) {
+			const typeParameters = path.call(print, "type_parametersNode");
+			parts.push(hasMultipleClauses ? group$3(indent$3(typeParameters)) : typeParameters);
+		}
+		if (hasExtendsInterfaces || hasPermits) {
+			const clauses = [];
+			if (hasExtendsInterfaces) clauses.push(hardline$3, path.call(print, "namedChildren", extendsInterfacesIndex));
+			if (hasPermits) clauses.push(line$3, path.call(print, "permitsNode"));
+			const hasBody = path.node.bodyNode.namedChildren.length > 0;
+			const clauseGroup = [indent$3(clauses), options?.braceStyle === "next-line" ? "" : hasBody ? line$3 : " "];
+			parts.push(hasMultipleClauses ? clauseGroup : group$3(clauseGroup));
+		} else parts.push(" ");
+		return [
+			...printModifiers(path, print, "declarationOnly"),
+			group$3(parts),
+			path.call(print, "bodyNode")
+		];
+	},
+	extends_interfaces(path, print) {
+		const typeListIndex = path.node.namedChildren.findIndex(({ type }) => type === "type_list");
+		return group$3(["extends", indent$3([line$3, path.call(print, "namedChildren", typeListIndex)])]);
+	},
+	interface_body(path, print, options) {
+		return printBlock(path, printBodyDeclarations(path, print), options);
+	},
+	constant_declaration: printVariableDeclaration,
+	annotation_type_declaration(path, print) {
+		const parts = printModifiers(path, print);
+		parts.push("@interface ", path.call(print, "nameNode"), " ", path.call(print, "bodyNode"));
+		return parts;
+	},
+	annotation_type_body(path, print, options) {
+		return printBlock(path, printBodyDeclarations(path, print), options);
+	},
+	annotation_type_element_declaration(path, print) {
+		const parts = printModifiers(path, print);
+		parts.push(path.call(print, "typeNode"), " ", path.call(print, "nameNode"), "()");
+		if (hasChild(path, "dimensionsNode")) parts.push(path.call(print, "dimensionsNode"));
+		if (hasChild(path, "valueNode")) parts.push(" default ", path.call(print, "valueNode"));
+		parts.push(";");
+		return parts;
+	},
+	annotation(path, print) {
+		return [
+			"@",
+			path.call(print, "nameNode"),
+			path.call(print, "argumentsNode")
+		];
+	},
+	marker_annotation(path, print) {
+		return ["@", path.call(print, "nameNode")];
+	},
+	annotation_argument_list(path, print) {
+		const args = path.map(print, "namedChildren");
+		return args.length === 1 && path.node.namedChildren[0].type === "element_value_array_initializer" ? [
+			"(",
+			args[0],
+			")"
+		] : group$3(indentInParentheses(join$3([",", line$3], args)));
+	},
+	element_value_pair(path, print) {
+		return group$3([
+			path.call(print, "keyNode"),
+			" = ",
+			path.call(print, "valueNode")
+		]);
+	},
+	element_value_array_initializer: printArrayInitializer
+};
+//#endregion
+//#region src/printers/lexical-structure.ts
+const { group: group$2, hardline: hardline$2, indent: indent$2, join: join$2, softline } = prettier_doc.builders;
+var lexical_structure_default = {
+	string_literal(path, print) {
+		if (path.node.namedChildren.some(({ type }) => type === "string_interpolation") || path.node.children[0].value === "\"") return path.map(print, "children");
+		return printTextBlock(join$2(hardline$2, textBlockContents(path.node).split("\n")));
+	},
+	string_fragment: printValue,
+	multiline_string_fragment: printValue,
+	string_interpolation(path, print) {
+		const expressionType = path.node.namedChildren[0].type;
+		const expression = path.call(print, "namedChildren", 0);
+		return expressionType === "binary_expression" || expressionType === "ternary_expression" ? group$2([
+			"\\{",
+			indent$2([softline, expression]),
+			softline,
+			"}"
+		]) : [
+			"\\{",
+			expression,
+			"}"
+		];
+	},
+	escape_sequence: printValue,
+	character_literal: printValue,
+	binary_integer_literal: printValue,
+	decimal_integer_literal: printValue,
+	hex_integer_literal: printValue,
+	octal_integer_literal: printValue,
+	decimal_floating_point_literal: printValue,
+	hex_floating_point_literal: printValue,
+	null_literal: printValue,
+	true: printValue,
+	false: printValue,
+	this: printValue,
+	super: printValue,
+	underscore_pattern: printValue,
+	asterisk: printValue
+};
+//#endregion
+//#region src/printers/names.ts
+var names_default = {
+	identifier: printValue,
+	type_identifier: printValue,
+	scoped_identifier(path, print) {
+		return [
+			path.call(print, "scopeNode"),
+			".",
+			path.call(print, "nameNode")
+		];
+	},
+	scoped_type_identifier(path, print) {
+		return path.map((child) => child.node.type === "annotation" || child.node.type === "marker_annotation" ? [print(child), " "] : print(child), "children");
+	}
+};
+//#endregion
+//#region src/printers/packages-and-modules.ts
+const { group: group$1, hardline: hardline$1, indent: indent$1, join: join$1, line: line$2 } = prettier_doc.builders;
+var packages_and_modules_default = {
+	program(path, print) {
+		if (!path.node.namedChildren.length) return [printDanglingComments(path), hardline$1];
+		const parts = [];
+		if (path.node.namedChildren[0].type !== "import_declaration") parts.push(path.call(print, "namedChildren", 0));
+		const staticImports = [];
+		const imports = [];
+		const otherDeclarations = [];
+		path.each((child) => {
+			const doc = print(child);
+			if (child.node.type === "import_declaration") {
+				const names = extractNames(child.node.namedChildren[0]);
+				if (child.node.namedChildren.some(({ type }) => type === "asterisk")) names.push("*");
+				(child.node.children[1].type === "static" ? staticImports : imports).push({
+					doc,
+					names
+				});
+			} else if (!child.isFirst) otherDeclarations.push(doc);
+		}, "namedChildren");
+		parts.push(...[staticImports, imports].filter((imports) => imports.length).map((imports) => join$1(hardline$1, imports.sort(compareFqn).map(({ doc }) => doc))), ...otherDeclarations);
+		return [...join$1([hardline$1, hardline$1], parts), hardline$1];
+	},
+	package_declaration(path, print) {
+		const annotations = [];
+		const identifier = [];
+		path.each((child) => {
+			switch (child.node.type) {
+				case "annotation":
+				case "marker_annotation":
+					annotations.push(print(child));
+					break;
+				case "identifier":
+				case "scoped_identifier":
+					identifier.push(print(child));
+					break;
+			}
+		}, "namedChildren");
+		return join$1(hardline$1, [...annotations, [
+			"package ",
+			...identifier,
+			";"
+		]]);
+	},
+	import_declaration(path, print) {
+		const declaration = ["import "];
+		if (path.node.children.some(({ type }) => type === "static")) declaration.push("static ");
+		const identifierIndex = path.node.namedChildren.findIndex(({ type }) => type === "identifier" || type === "scoped_identifier");
+		declaration.push(path.call(print, "namedChildren", identifierIndex));
+		if (path.node.namedChildren.some(({ type }) => type === "asterisk")) declaration.push(".*");
+		declaration.push(";");
+		return declaration;
+	},
+	module_declaration(path, print) {
+		const parts = [];
+		path.each((child) => {
+			if (child.node.type === "annotation" || child.node.type === "marker_annotation") parts.push(print(child));
+		}, "namedChildren");
+		if (path.node.children.some(({ type }) => type === "open")) parts.push("open");
+		parts.push("module", path.call(print, "nameNode"), path.call(print, "bodyNode"));
+		return join$1(" ", parts);
+	},
+	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);
+	},
+	requires_module_directive(path, print) {
+		const parts = ["requires"];
+		path.each((child) => {
+			if (child.node.type === "requires_modifier") parts.push(print(child));
+		}, "namedChildren");
+		parts.push(path.call(print, "moduleNode"));
+		return [...join$1(" ", parts), ";"];
+	},
+	exports_module_directive: printToModuleNamesDirective,
+	opens_module_directive: printToModuleNamesDirective,
+	uses_module_directive(path, print) {
+		return [
+			"uses ",
+			path.call(print, "typeNode"),
+			";"
+		];
+	},
+	provides_module_directive(path, print) {
+		const [provided, ...providers] = path.map(print, "namedChildren");
+		return [
+			"provides ",
+			provided,
+			group$1(indent$1([line$2, group$1(indent$1([
+				"with",
+				line$2,
+				...join$1([",", line$2], providers)
+			]))])),
+			";"
+		];
+	},
+	requires_modifier: printValue
+};
+function extractNames(node) {
+	return node.type === "identifier" ? [node.value] : [...extractNames(node.scopeNode), node.nameNode.value];
+}
+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) {
+		return hasType(path, "string_literal") ? embedTextBlock(path) : 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"];
+	}
+};
+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 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(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;
+}
+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
+		};
+	}
+	if (!isBlock || previousComment?.hasLineSuffix) return {
+		doc: [lineSuffix([" ", printed]), breakParent],
+		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;
+}
+//#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;
+	},
+	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;
+}
+//#endregion
+//#region src/index.ts
+var src_default = {
+	languages: [{
+		name: "Java",
+		parsers: ["java"],
+		group: "Java",
+		tmScope: "source.java",
+		aceMode: "java",
+		codemirrorMode: "clike",
+		codemirrorMimeType: "text/x-java",
+		extensions: [".java"],
+		linguistLanguageId: 181,
+		vscodeLanguageIds: ["java"]
+	}],
+	parsers: { java: parser_default },
+	printers: { java: printer_default },
+	options: options_default,
+	defaultOptions: { arrowParens: "avoid" }
+};
+//#endregion
+module.exports = src_default;