prettier-plugin-java 2.6.8 → 2.7.1

package/dist/printers/interfaces.js

@@ -1,222 +1,157 @@
-import { concat, group, indent } from "./prettier-builder.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { handleCommentsParameters } from "./comments/handle-comments.js";
-import { displaySemicolon, getInterfaceBodyDeclarationsSeparator, isStatementEmptyStatement, printArrayList, putIntoBraces, rejectAndConcat, rejectAndJoin, rejectAndJoinSeps, sortModifiers } from "./printer-utils.js";
 import { builders } from "prettier/doc";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-const { line, softline, hardline } = builders;
-export class InterfacesPrettierVisitor extends BaseCstPrettierPrinter {
-    interfaceDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.interfaceModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const declaration = ctx.normalInterfaceDeclaration
-            ? this.visit(ctx.normalInterfaceDeclaration)
-            : this.visit(ctx.annotationInterfaceDeclaration);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [rejectAndJoin(" ", otherModifiers), declaration])
+import { call, each, hasDeclarationAnnotations, indentInParentheses, lineEndWithComments, lineStartWithComments, onlyDefinedKey, printArrayInitializer, printBlock, printClassPermits, printList, printSingle, printWithModifiers } from "./helpers.js";
+const { group, hardline, indent, join, line } = builders;
+export default {
+    interfaceDeclaration(path, print) {
+        const declarationKey = onlyDefinedKey(path.node.children, [
+            "annotationInterfaceDeclaration",
+            "normalInterfaceDeclaration"
         ]);
-    }
-    normalInterfaceDeclaration(ctx) {
-        const typeIdentifier = this.visit(ctx.typeIdentifier);
-        const typeParameters = this.visit(ctx.typeParameters);
-        const interfaceExtends = this.visit(ctx.interfaceExtends);
-        const optionalInterfacePermits = this.visit(ctx.interfacePermits);
-        const interfaceBody = this.visit(ctx.interfaceBody);
-        let interfaceExtendsPart = "";
+        return printWithModifiers(path, print, "interfaceModifier", call(path, print, declarationKey), true);
+    },
+    normalInterfaceDeclaration(path, print) {
+        const { interfaceExtends, interfacePermits, typeParameters } = path.node.children;
+        const header = ["interface ", call(path, print, "typeIdentifier")];
+        if (typeParameters) {
+            header.push(call(path, print, "typeParameters"));
+        }
         if (interfaceExtends) {
-            interfaceExtendsPart = indent(rejectAndConcat([softline, interfaceExtends]));
+            header.push(indent([line, call(path, print, "interfaceExtends")]));
         }
-        let interfacePermits = "";
-        if (optionalInterfacePermits) {
-            interfacePermits = indent(rejectAndConcat([softline, optionalInterfacePermits]));
+        if (interfacePermits) {
+            header.push(indent([line, call(path, print, "interfacePermits")]));
         }
-        return rejectAndJoin(" ", [
-            group(rejectAndJoin(" ", [
-                ctx.Interface[0],
-                concat([typeIdentifier, typeParameters]),
-                interfaceExtendsPart,
-                interfacePermits
-            ])),
-            interfaceBody
+        return [group(header), " ", call(path, print, "interfaceBody")];
+    },
+    interfaceModifier: printSingle,
+    interfaceExtends(path, print) {
+        return group([
+            "extends",
+            indent([line, call(path, print, "interfaceTypeList")])
         ]);
-    }
-    interfaceModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
-        }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    interfaceExtends(ctx) {
-        const interfaceTypeList = this.visit(ctx.interfaceTypeList);
-        return group(rejectAndConcat([
-            ctx.Extends[0],
-            indent(rejectAndConcat([line, interfaceTypeList]))
-        ]));
-    }
-    interfacePermits(ctx) {
-        return this.classPermits(ctx);
-    }
-    interfaceBody(ctx) {
-        let joinedInterfaceMemberDeclaration = "";
-        if (ctx.interfaceMemberDeclaration !== undefined) {
-            const interfaceMemberDeclaration = this.mapVisit(ctx.interfaceMemberDeclaration);
-            const separators = getInterfaceBodyDeclarationsSeparator(ctx.interfaceMemberDeclaration);
-            joinedInterfaceMemberDeclaration = rejectAndJoinSeps(separators, interfaceMemberDeclaration);
-        }
-        return putIntoBraces(joinedInterfaceMemberDeclaration, hardline, ctx.LCurly[0], ctx.RCurly[0]);
-    }
-    interfaceMemberDeclaration(ctx) {
-        if (ctx.Semicolon) {
-            return displaySemicolon(ctx.Semicolon[0]);
-        }
-        return this.visitSingle(ctx);
-    }
-    constantDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.constantModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const unannType = this.visit(ctx.unannType);
-        const variableDeclaratorList = this.visit(ctx.variableDeclaratorList);
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                unannType,
-                rejectAndConcat([variableDeclaratorList, ctx.Semicolon[0]])
-            ])
+    },
+    interfacePermits: printClassPermits,
+    interfaceBody(path, print) {
+        const declarations = [];
+        let previousRequiresPadding = false;
+        each(path, declarationPath => {
+            var _a, _b, _c, _d;
+            const declaration = print(declarationPath);
+            if (declaration === "") {
+                return;
+            }
+            const { node, previous } = declarationPath;
+            const constantDeclaration = (_a = node.children.constantDeclaration) === null || _a === void 0 ? void 0 : _a[0].children;
+            const methodDeclaration = (_b = node.children.interfaceMethodDeclaration) === null || _b === void 0 ? void 0 : _b[0].children;
+            const currentRequiresPadding = (!constantDeclaration && !methodDeclaration) ||
+                (methodDeclaration === null || methodDeclaration === void 0 ? void 0 : methodDeclaration.methodBody[0].children.block) !== undefined ||
+                hasDeclarationAnnotations((_d = (_c = constantDeclaration === null || constantDeclaration === void 0 ? void 0 : constantDeclaration.constantModifier) !== null && _c !== void 0 ? _c : methodDeclaration === null || methodDeclaration === void 0 ? void 0 : methodDeclaration.interfaceMethodModifier) !== null && _d !== void 0 ? _d : []);
+            const blankLine = declarations.length > 0 &&
+                (previousRequiresPadding ||
+                    currentRequiresPadding ||
+                    lineStartWithComments(node) > lineEndWithComments(previous) + 1);
+            declarations.push(blankLine ? [hardline, declaration] : declaration);
+            previousRequiresPadding = currentRequiresPadding;
+        }, "interfaceMemberDeclaration");
+        return printBlock(path, declarations);
+    },
+    interfaceMemberDeclaration(path, print) {
+        const { children } = path.node;
+        return children.Semicolon
+            ? ""
+            : call(path, print, onlyDefinedKey(children));
+    },
+    constantDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "unannType"),
+            " ",
+            call(path, print, "variableDeclaratorList"),
+            ";"
+        ];
+        return printWithModifiers(path, print, "constantModifier", declaration);
+    },
+    constantModifier: printSingle,
+    interfaceMethodDeclaration(path, print) {
+        const declaration = [
+            call(path, print, "methodHeader"),
+            path.node.children.methodBody[0].children.Semicolon ? "" : " ",
+            call(path, print, "methodBody")
+        ];
+        return printWithModifiers(path, print, "interfaceMethodModifier", declaration);
+    },
+    interfaceMethodModifier: printSingle,
+    annotationInterfaceDeclaration(path, print) {
+        return join(" ", [
+            "@interface",
+            call(path, print, "typeIdentifier"),
+            call(path, print, "annotationInterfaceBody")
         ]);
-    }
-    constantModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
+    },
+    annotationInterfaceBody(path, print) {
+        const declarations = [];
+        each(path, declarationPath => {
+            const declaration = print(declarationPath);
+            if (declaration === "") {
+                return;
+            }
+            declarations.push(declarationPath.isFirst ? declaration : [hardline, declaration]);
+        }, "annotationInterfaceMemberDeclaration");
+        return printBlock(path, declarations);
+    },
+    annotationInterfaceMemberDeclaration(path, print) {
+        const { children } = path.node;
+        return children.Semicolon
+            ? ""
+            : call(path, print, onlyDefinedKey(children));
+    },
+    annotationInterfaceElementDeclaration(path, print) {
+        const { dims, defaultValue } = path.node.children;
+        const declaration = [
+            call(path, print, "unannType"),
+            " ",
+            call(path, print, "Identifier"),
+            "()"
+        ];
+        if (dims) {
+            declaration.push(call(path, print, "dims"));
         }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    interfaceMethodDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.interfaceMethodModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const methodHeader = this.visit(ctx.methodHeader);
-        const methodBody = this.visit(ctx.methodBody);
-        const separator = isStatementEmptyStatement(methodBody) ? "" : " ";
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                rejectAndJoin(separator, [methodHeader, methodBody])
-            ])
-        ]);
-    }
-    interfaceMethodModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
+        if (defaultValue) {
+            declaration.push(" ", call(path, print, "defaultValue"));
         }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    annotationInterfaceDeclaration(ctx) {
-        const typeIdentifier = this.visit(ctx.typeIdentifier);
-        const annotationInterfaceBody = this.visit(ctx.annotationInterfaceBody);
-        return rejectAndJoin(" ", [
-            concat([ctx.At[0], ctx.Interface[0]]),
-            typeIdentifier,
-            annotationInterfaceBody
-        ]);
-    }
-    annotationInterfaceBody(ctx) {
-        const annotationInterfaceMemberDeclaration = this.mapVisit(ctx.annotationInterfaceMemberDeclaration);
-        return rejectAndJoin(line, [
-            indent(rejectAndJoin(line, [
-                ctx.LCurly[0],
-                rejectAndJoin(concat([line, line]), annotationInterfaceMemberDeclaration)
-            ])),
-            ctx.RCurly[0]
-        ]);
-    }
-    annotationInterfaceMemberDeclaration(ctx) {
-        if (ctx.Semicolon) {
-            return printTokenWithComments(this.getSingle(ctx));
+        declaration.push(";");
+        return printWithModifiers(path, print, "annotationInterfaceElementModifier", declaration);
+    },
+    annotationInterfaceElementModifier: printSingle,
+    defaultValue(path, print) {
+        return ["default ", call(path, print, "elementValue")];
+    },
+    annotation(path, print) {
+        const { children } = path.node;
+        const annotation = ["@", call(path, print, "typeName")];
+        if (children.elementValue || children.elementValuePairList) {
+            const valuesKey = onlyDefinedKey(children, [
+                "elementValue",
+                "elementValuePairList"
+            ]);
+            annotation.push(indentInParentheses(call(path, print, valuesKey)));
         }
-        return this.visitSingle(ctx);
-    }
-    annotationInterfaceElementDeclaration(ctx) {
-        const modifiers = sortModifiers(ctx.annotationInterfaceElementModifier);
-        const firstAnnotations = this.mapVisit(modifiers[0]);
-        const otherModifiers = this.mapVisit(modifiers[1]);
-        const unannType = this.visit(ctx.unannType);
-        const identifier = ctx.Identifier[0];
-        const dims = this.visit(ctx.dims);
-        const defaultValue = ctx.defaultValue
-            ? concat([" ", this.visit(ctx.defaultValue)])
-            : "";
-        return rejectAndJoin(hardline, [
-            rejectAndJoin(hardline, firstAnnotations),
-            rejectAndJoin(" ", [
-                rejectAndJoin(" ", otherModifiers),
-                unannType,
-                rejectAndConcat([
-                    identifier,
-                    concat([ctx.LBrace[0], ctx.RBrace[0]]),
-                    dims,
-                    defaultValue,
-                    ctx.Semicolon[0]
-                ])
-            ])
+        return annotation;
+    },
+    elementValuePairList(path, print) {
+        return printList(path, print, "elementValuePair");
+    },
+    elementValuePair(path, print) {
+        return join(" ", [
+            call(path, print, "Identifier"),
+            call(path, print, "Equals"),
+            call(path, print, "elementValue")
         ]);
-    }
-    annotationInterfaceElementModifier(ctx) {
-        if (ctx.annotation) {
-            return this.visitSingle(ctx);
-        }
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    defaultValue(ctx) {
-        const elementValue = this.visit(ctx.elementValue);
-        return rejectAndJoin(" ", [ctx.Default[0], elementValue]);
-    }
-    annotation(ctx) {
-        var _a, _b, _c;
-        const fqn = this.visit(ctx.typeName);
-        let annoArgs = "";
-        if (ctx.LBrace) {
-            const elementValues = (_c = (_b = (_a = ctx.elementValuePairList) === null || _a === void 0 ? void 0 : _a[0].children.elementValuePair) !== null && _b !== void 0 ? _b : ctx.elementValue) !== null && _c !== void 0 ? _c : [];
-            handleCommentsParameters(ctx.LBrace[0], elementValues, ctx.RBrace[0]);
-            if (ctx.elementValuePairList) {
-                annoArgs = putIntoBraces(this.visit(ctx.elementValuePairList), softline, ctx.LBrace[0], ctx.RBrace[0]);
-            }
-            else if (ctx.elementValue) {
-                annoArgs = putIntoBraces(this.visit(ctx.elementValue), softline, ctx.LBrace[0], ctx.RBrace[0]);
-            }
-        }
-        return group(rejectAndConcat([ctx.At[0], fqn, annoArgs]));
-    }
-    elementValuePairList(ctx) {
-        const elementValuePairs = this.mapVisit(ctx.elementValuePair);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return rejectAndJoinSeps(commas, elementValuePairs);
-    }
-    elementValuePair(ctx) {
-        const identifier = ctx.Identifier[0];
-        const elementValue = this.visit(ctx.elementValue);
-        return rejectAndJoin(" ", [identifier, ctx.Equals[0], elementValue]);
-    }
-    elementValue(ctx) {
-        return this.visitSingle(ctx);
-    }
-    elementValueArrayInitializer(ctx) {
-        const elementValueList = this.visit(ctx.elementValueList);
-        return printArrayList({
-            list: elementValueList,
-            extraComma: ctx.Comma,
-            LCurly: ctx.LCurly[0],
-            RCurly: ctx.RCurly[0],
-            trailingComma: this.prettierOptions.trailingComma
-        });
-    }
-    elementValueList(ctx) {
-        const elementValues = this.mapVisit(ctx.elementValue);
-        const commas = ctx.Comma ? ctx.Comma.map(elt => concat([elt, line])) : [];
-        return group(rejectAndConcat([rejectAndJoinSeps(commas, elementValues)]));
-    }
-}
+    },
+    elementValue: printSingle,
+    elementValueArrayInitializer(path, print, options) {
+        return printArrayInitializer(path, print, options, "elementValueList");
+    },
+    elementValueList(path, print) {
+        return group(printList(path, print, "elementValue"));
+    }
+};

package/dist/printers/lexical-structure.d.ts

@@ -0,0 +1,14 @@
+import { builders } from "prettier/doc";
+import { printSingle } from "./helpers.js";
+declare const _default: {
+    literal(path: import("prettier").AstPath<import("../../../java-parser/api.js").LiteralCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc;
+    integerLiteral: typeof printSingle;
+    floatingPointLiteral: typeof printSingle;
+    booleanLiteral: typeof printSingle;
+    shiftOperator(path: import("prettier").AstPath<import("../../../java-parser/api.js").ShiftOperatorCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: import("./helpers.js").JavaPrintFn): builders.Doc[];
+};
+export default _default;

package/dist/printers/lexical-structure.js

@@ -1,31 +1,29 @@
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { join } from "./prettier-builder.js";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
 import { builders } from "prettier/doc";
-const { hardline } = builders;
-export class LexicalStructurePrettierVisitor extends BaseCstPrettierPrinter {
-    literal(ctx) {
-        if (ctx.TextBlock) {
-            const lines = ctx.TextBlock[0].image.split("\n");
-            const open = lines.shift();
-            const baseIndent = Math.min(...lines.map(line => line.search(/\S/)).filter(indent => indent >= 0));
-            return join(hardline, [
-                open,
-                ...lines.map(line => line.slice(baseIndent))
-            ]);
+import { findBaseIndent, map, onlyDefinedKey, printSingle } from "./helpers.js";
+const { hardline, indent, join } = builders;
+export default {
+    literal(path, print) {
+        const { TextBlock } = path.node.children;
+        if (!TextBlock) {
+            return printSingle(path, print);
         }
-        if (ctx.CharLiteral || ctx.StringLiteral || ctx.Null) {
-            return printTokenWithComments(this.getSingle(ctx));
-        }
-        return this.visitSingle(ctx);
-    }
-    integerLiteral(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    floatingPointLiteral(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
-    }
-    booleanLiteral(ctx) {
-        return printTokenWithComments(this.getSingle(ctx));
+        const [open, ...lines] = TextBlock[0].image.split("\n");
+        const baseIndent = findBaseIndent(lines);
+        const textBlock = join(hardline, [
+            open,
+            ...lines.map(line => line.slice(baseIndent))
+        ]);
+        const ancestor = path.getNode(14);
+        return (ancestor === null || ancestor === void 0 ? void 0 : ancestor.name) === "variableInitializer" ||
+            ((ancestor === null || ancestor === void 0 ? void 0 : ancestor.name) === "binaryExpression" &&
+                ancestor.children.AssignmentOperator)
+            ? indent(textBlock)
+            : textBlock;
+    },
+    integerLiteral: printSingle,
+    floatingPointLiteral: printSingle,
+    booleanLiteral: printSingle,
+    shiftOperator(path, print) {
+        return map(path, print, onlyDefinedKey(path.node.children));
     }
-}
+};

package/dist/printers/names.d.ts

@@ -0,0 +1,12 @@
+import { printName, printSingle } from "./helpers.js";
+declare const _default: {
+    typeIdentifier: typeof printSingle;
+    moduleName: typeof printName;
+    packageName: typeof printName;
+    typeName: typeof printName;
+    expressionName: typeof printName;
+    methodName: typeof printSingle;
+    packageOrTypeName: typeof printName;
+    ambiguousName: typeof printName;
+};
+export default _default;

package/dist/printers/names.js

@@ -1,29 +1,11 @@
-import { buildFqn } from "./printer-utils.js";
-import { printTokenWithComments } from "./comments/format-comments.js";
-import { BaseCstPrettierPrinter } from "../base-cst-printer.js";
-export class NamesPrettierVisitor extends BaseCstPrettierPrinter {
-    typeIdentifier(ctx) {
-        return printTokenWithComments(ctx.Identifier[0]);
-    }
-    moduleName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    packageName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    typeName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    expressionName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    methodName(ctx) {
-        return printTokenWithComments(ctx.Identifier[0]);
-    }
-    packageOrTypeName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-    ambiguousName(ctx) {
-        return buildFqn(ctx.Identifier, ctx.Dot);
-    }
-}
+import { printName, printSingle } from "./helpers.js";
+export default {
+    typeIdentifier: printSingle,
+    moduleName: printName,
+    packageName: printName,
+    typeName: printName,
+    expressionName: printName,
+    methodName: printSingle,
+    packageOrTypeName: printName,
+    ambiguousName: printName
+};

package/dist/printers/packages-and-modules.d.ts

@@ -0,0 +1,46 @@
+import type { ExportsModuleDirectiveCstNode, ImportDeclarationCstNode, OpensModuleDirectiveCstNode } from "java-parser";
+import type { AstPath } from "prettier";
+import { builders } from "prettier/doc";
+import { printSingle, type JavaPrintFn } from "./helpers.js";
+declare const _default: {
+    compilationUnit(path: AstPath<import("java-parser").CompilationUnitCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    ordinaryCompilationUnit(path: AstPath<import("java-parser").OrdinaryCompilationUnitCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    modularCompilationUnit(path: AstPath<import("java-parser").ModularCompilationUnitCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    packageDeclaration(path: AstPath<import("java-parser").PackageDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    packageModifier: typeof printSingle;
+    importDeclaration(path: AstPath<ImportDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    typeDeclaration(path: AstPath<import("java-parser").TypeDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc;
+    moduleDeclaration(path: AstPath<import("java-parser").ModuleDeclarationCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    moduleDirective: typeof printSingle;
+    requiresModuleDirective(path: AstPath<import("java-parser").RequiresModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    exportsModuleDirective(path: AstPath<ExportsModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    opensModuleDirective(path: AstPath<OpensModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    usesModuleDirective(path: AstPath<import("java-parser").UsesModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    providesModuleDirective(path: AstPath<import("java-parser").ProvidesModuleDirectiveCstNode & {
+        comments?: import("../comments.js").JavaComment[];
+    }>, print: JavaPrintFn): builders.Doc[];
+    requiresModifier: typeof printSingle;
+};
+export default _default;