prettier-plugin-multiline-arrays-2 1.0.0

package/dist/printer/insert-new-lines.js

@@ -0,0 +1,580 @@
+import { getObjectTypedKeys, stringify, } from "@augment-vir/common";
+import { doc } from "prettier";
+import { isDocCommand } from "../augments/doc.js";
+import {} from "../options.js";
+import { walkDoc } from "./child-docs.js";
+import { getCommentTriggers, parseNextLineCounts, } from "./comment-triggers.js";
+import { containsLeadingNewline } from "./leading-new-line.js";
+import { getArrayLikeElements, isArrayLikeNode, } from "./supported-node-types.js";
+import { containsTrailingComma } from "./trailing-comma.js";
+const nestingSyntaxOpen = "[{(`";
+const nestingSyntaxClose = "]})`";
+const matchingNestingSyntaxClose = {
+    "[": "]",
+    "{": "}",
+    "(": ")",
+    "`": "`",
+};
+const found = 'Found "[" but:';
+function isMatchingNestingSyntaxClose({ maybeClose, openingSyntax, }) {
+    const closingSyntax = matchingNestingSyntaxClose[openingSyntax];
+    const firstCharacter = maybeClose.trimStart()[0];
+    return !!firstCharacter && closingSyntax === firstCharacter;
+}
+function extractIndentDoc({ maybeIndentDoc, }) {
+    if (isDocCommand(maybeIndentDoc) && maybeIndentDoc.type === "indent") {
+        return maybeIndentDoc;
+    }
+    else if (Array.isArray(maybeIndentDoc)) {
+        const firstDoc = maybeIndentDoc[0];
+        if (isDocCommand(firstDoc) && firstDoc.type === "indent") {
+            return firstDoc;
+        }
+    }
+    return undefined;
+}
+export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThreshold, debug, }) {
+    /**
+     * Each call to `insertLinesIntoArray` corresponds to a single array-like
+     * AST node, but its Doc can contain additional `[` characters that belong
+     * to sibling nodes (for example, the tuple type annotation on a
+     * destructuring pattern). Only the first `[` is our own array; skip the
+     * rest so we don't rewrite unrelated brackets.
+     */
+    let hasProcessedOwnArray = false;
+    walkDoc({
+        startDoc: inputDoc,
+        debug,
+        callback: (currentDoc, parentDocs, childIndex) => {
+            const currentParent = parentDocs[0];
+            const parentDoc = currentParent?.parent;
+            if (typeof currentDoc === "string" && currentDoc.trim() === "[") {
+                if (hasProcessedOwnArray) {
+                    return true;
+                }
+                const undoMutations = [];
+                let finalLineBreakExists = false;
+                function undoAllMutations() {
+                    undoMutations.toReversed().forEach((undoMutation) => {
+                        undoMutation();
+                    });
+                }
+                if (!Array.isArray(parentDoc)) {
+                    if (debug) {
+                        console.error({
+                            brokenParent: parentDoc,
+                            currentDoc,
+                        });
+                    }
+                    throw new Error(`${found} parentDoc is not an array.`);
+                }
+                if (debug) {
+                    console.info({
+                        currentDoc,
+                        parentDoc,
+                    });
+                    console.info(stringify(parentDoc));
+                }
+                if (childIndex !== 0) {
+                    /**
+                     * This happens in some situations which we don't want to
+                     * format in this plugin, like in type accessors:
+                     *
+                     * ```typescript
+                     * type mockType = exampleObject["property"];
+                     * ```
+                     */
+                    return true;
+                }
+                const maybeBreak = parentDoc[childIndex + 2];
+                if (isDocCommand(maybeBreak) &&
+                    maybeBreak.type === "if-break") {
+                    undoMutations.push(() => {
+                        parentDoc[childIndex + 2] = maybeBreak;
+                    });
+                    parentDoc[childIndex + 2] = maybeBreak.breakContents;
+                }
+                const indentIndex = childIndex + 1;
+                const maybeBracketSibling = parentDoc[indentIndex] === ""
+                    ? parentDoc[indentIndex + 1]
+                    : parentDoc[indentIndex];
+                const bracketSibling = extractIndentDoc({
+                    maybeIndentDoc: maybeBracketSibling,
+                });
+                if (debug) {
+                    console.info({
+                        bracketSibling,
+                    });
+                }
+                if (maybeBracketSibling === "]") {
+                    return false;
+                }
+                else if (!bracketSibling) {
+                    throw new Error(`${found} its sibling was not an indent Doc.: ${stringify(maybeBracketSibling)}`);
+                }
+                const indentContents = bracketSibling.contents;
+                if (debug) {
+                    console.info({
+                        indentContents,
+                    });
+                }
+                if (!Array.isArray(indentContents)) {
+                    throw new TypeError(`${found} indent didn't have array contents.`);
+                }
+                else if (indentContents.length < 2) {
+                    if (debug) {
+                        console.error(stringify(indentContents));
+                    }
+                    throw new Error(`${found} indent contents did not have at least 2 children`);
+                }
+                const startingLine = indentContents[0];
+                if (debug) {
+                    console.info({
+                        firstIndentContentsChild: startingLine,
+                    });
+                }
+                if (!isDocCommand(startingLine) ||
+                    startingLine.type !== "line") {
+                    if (Array.isArray(startingLine)) {
+                        undoAllMutations();
+                        return false;
+                    }
+                    else {
+                        throw new TypeError(`${found} first indent child was not a line.`);
+                    }
+                }
+                indentContents[0] = "";
+                undoMutations.push(() => {
+                    indentContents[0] = startingLine;
+                });
+                const indentedContent = indentContents[1];
+                if (debug) {
+                    console.info({
+                        secondIndentContentsChild: indentedContent,
+                        itsFirstChild: indentedContent[0],
+                    });
+                }
+                if (!indentedContent) {
+                    console.error("second indent child (indentedContent) is not defined:", {
+                        indentContents,
+                        indentedContent,
+                    });
+                    throw new Error(`${found} second indent child is not a fill.`);
+                }
+                else if (!Array.isArray(indentedContent) &&
+                    !(isDocCommand(indentedContent) &&
+                        indentedContent.type === "fill")) {
+                    console.error("second indent child (indentCode) is not a fill doc or an array:", {
+                        indentContents,
+                        indentCode: indentedContent,
+                    });
+                    throw new Error(`${found} second indent child is not a fill doc or an array.`);
+                }
+                else if (Array.isArray(indentedContent)
+                    ? indentedContent.length === 0
+                    : indentedContent.parts.length === 0) {
+                    throw new Error(`${found} indentedContent has no length.`);
+                }
+                // lineIndex is 0 indexed
+                let lineIndex = 0;
+                // columnCount is 1 indexed
+                let columnCount = 1;
+                if (debug) {
+                    console.info(">>>>>>>>>>>>>> Walking children for commas");
+                }
+                let arrayChildCount = 0;
+                let forceFinalLineBreakExists = false;
+                if (!finalLineBreakExists) {
+                    walkDoc({
+                        startDoc: indentedContent,
+                        debug,
+                        callback: (currentDoc, commaParents, commaChildIndex) => {
+                            finalLineBreakExists = false;
+                            const innerCurrentParent = commaParents[0];
+                            const innerCurrentParentDoc = innerCurrentParent?.parent;
+                            if (isDocCommand(currentDoc) &&
+                                currentDoc.type === "if-break" &&
+                                currentDoc.breakContents === ",") {
+                                /**
+                                 * Only treat a trailing-comma if-break (whose
+                                 * `breakContents` is `,`) as the array's final
+                                 * line-break marker. Other if-break commands —
+                                 * like the leading `| ` Prettier emits when a
+                                 * union type wraps — appear inside element docs
+                                 * (e.g. `[A | B | C]`) and must not be forced
+                                 * open, otherwise the inner union breaks
+                                 * unnecessarily.
+                                 */
+                                if (debug) {
+                                    console.info("found final line break inside of if-break");
+                                }
+                                finalLineBreakExists = true;
+                                if (!innerCurrentParentDoc) {
+                                    throw new Error("Found if-break without a parent");
+                                }
+                                else if (!Array.isArray(innerCurrentParentDoc)) {
+                                    throw new TypeError("if-break parent is not an array");
+                                }
+                                else if (commaChildIndex == undefined) {
+                                    throw new Error("if-break child index is undefined");
+                                }
+                                innerCurrentParentDoc[commaChildIndex] =
+                                    currentDoc.breakContents;
+                                innerCurrentParentDoc.splice(commaChildIndex + 1, 0, doc.builders.breakParent);
+                                undoMutations.push(() => {
+                                    innerCurrentParentDoc.splice(commaChildIndex + 1, 1);
+                                    innerCurrentParentDoc[commaChildIndex] =
+                                        currentDoc;
+                                });
+                            }
+                            else if (typeof currentDoc === "string") {
+                                if (!innerCurrentParentDoc) {
+                                    console.error({
+                                        innerParentDoc: innerCurrentParentDoc,
+                                    });
+                                    throw new Error("Found string but innerParentDoc is not defined.");
+                                }
+                                else if (currentDoc === "<" &&
+                                    Array.isArray(innerCurrentParentDoc) &&
+                                    commaChildIndex != undefined &&
+                                    innerCurrentParentDoc
+                                        .slice(commaChildIndex + 1)
+                                        .includes(">")) {
+                                    /**
+                                     * A paired `<...>` in the same Doc array is
+                                     * a generic type-argument group (e.g.
+                                     * `Omit<MyType, 'field'>`). Skip walking
+                                     * its siblings so commas inside the generic
+                                     * aren't mistaken for array-element
+                                     * separators. A lone `<` or `>` without a
+                                     * match in the same array is a comparison
+                                     * operator and handled by the default
+                                     * walk.
+                                     */
+                                    return false;
+                                }
+                                else if (currentDoc &&
+                                    nestingSyntaxOpen.includes(currentDoc)) {
+                                    if (!Array.isArray(innerCurrentParentDoc)) {
+                                        throw new TypeError("Found opening syntax but parent is not an array.");
+                                    }
+                                    const closingIndex = innerCurrentParentDoc.findIndex((sibling) => typeof sibling === "string" &&
+                                        sibling &&
+                                        isMatchingNestingSyntaxClose({
+                                            maybeClose: sibling,
+                                            openingSyntax: currentDoc,
+                                        }));
+                                    if (closingIndex < 0) {
+                                        throw new Error(`Could not find closing match for ${currentDoc}`);
+                                    }
+                                    return false;
+                                }
+                                else if (currentDoc &&
+                                    nestingSyntaxClose.includes(currentDoc)) {
+                                    throw new Error("Found closing syntax which shouldn't be walked");
+                                }
+                                else if (currentDoc === ",") {
+                                    if (debug) {
+                                        console.info({
+                                            foundCommaIn: innerCurrentParentDoc,
+                                        });
+                                    }
+                                    if (!Array.isArray(innerCurrentParentDoc)) {
+                                        console.error({
+                                            innerParentDoc: innerCurrentParentDoc,
+                                        });
+                                        throw new Error("Found comma but innerParentDoc is not an array.");
+                                    }
+                                    else if (commaChildIndex == undefined) {
+                                        throw new Error("Found comma but childIndex is undefined.");
+                                    }
+                                    let siblingIndex = commaChildIndex + 1;
+                                    let parentToMutate = innerCurrentParentDoc;
+                                    if (commaChildIndex ===
+                                        innerCurrentParentDoc.length - 1) {
+                                        const commaGrandParent = commaParents[1];
+                                        if (commaGrandParent == undefined) {
+                                            throw new Error("Could not find grandparent of comma group.");
+                                        }
+                                        else if (commaGrandParent.childIndexInThisParent ==
+                                            undefined) {
+                                            throw new Error("Could not find index of comma group parent");
+                                        }
+                                        else if (!Array.isArray(commaGrandParent.parent)) {
+                                            throw new TypeError("Comma group grandparent is not an array.");
+                                        }
+                                        siblingIndex =
+                                            commaGrandParent.childIndexInThisParent +
+                                                1;
+                                        parentToMutate =
+                                            commaGrandParent.parent;
+                                    }
+                                    if (debug) {
+                                        console.info({
+                                            commaParentDoc: innerCurrentParentDoc,
+                                            parentToMutate,
+                                            siblingIndex,
+                                        });
+                                    }
+                                    let maybeCommaSibling = parentToMutate[siblingIndex];
+                                    if (debug) {
+                                        console.info(`Trying to find comma sibling at index ${siblingIndex}`, stringify({
+                                            parentToMutate,
+                                            maybeCommaSibling,
+                                        }));
+                                    }
+                                    function isCommaSibling(maybe) {
+                                        return ((isDocCommand(maybe) &&
+                                            maybe.type === "line") ||
+                                            (Array.isArray(maybe) &&
+                                                isDocCommand(maybe[0]) &&
+                                                maybe[0].type === "line"));
+                                    }
+                                    while (!isCommaSibling(maybeCommaSibling) &&
+                                        siblingIndex < parentToMutate.length) {
+                                        siblingIndex++;
+                                        maybeCommaSibling =
+                                            parentToMutate[siblingIndex];
+                                        if (debug) {
+                                            console.info(`Trying to find comma sibling at index ${siblingIndex}`, parentToMutate, maybeCommaSibling);
+                                        }
+                                    }
+                                    if (debug) {
+                                        console.info(`Found comma sibling at index ${siblingIndex}`, parentToMutate, maybeCommaSibling);
+                                    }
+                                    if (!isCommaSibling(maybeCommaSibling)) {
+                                        throw new Error(`Found comma but its following sibling is not a line: ${stringify(maybeCommaSibling)}`);
+                                    }
+                                    const commaSibling = maybeCommaSibling;
+                                    const currentLineCountIndex = lineIndex % lineCounts.length;
+                                    const currentLineCount = lineCounts.length
+                                        ? lineCounts[currentLineCountIndex]
+                                        : undefined;
+                                    arrayChildCount++;
+                                    if ((currentLineCount &&
+                                        columnCount === currentLineCount) ||
+                                        !currentLineCount) {
+                                        // if we're on the last element of the line then increment to the next line
+                                        lineIndex++;
+                                        columnCount = 1;
+                                        /**
+                                         * Don't use doc.builders.hardline here.
+                                         * It causes "invalid size error" which
+                                         * I don't understand and which has no
+                                         * other useful information or stack
+                                         * trace.
+                                         */
+                                        if (debug) {
+                                            console.info({
+                                                breakingAfter: parentToMutate[siblingIndex - 1],
+                                            });
+                                        }
+                                        parentToMutate[siblingIndex] =
+                                            doc.builders.hardlineWithoutBreakParent;
+                                    }
+                                    else {
+                                        parentToMutate[siblingIndex] = " ";
+                                        columnCount++;
+                                    }
+                                    undoMutations.push(() => {
+                                        parentToMutate[siblingIndex] =
+                                            commaSibling;
+                                    });
+                                }
+                            }
+                            else if (Array.isArray(currentDoc)) {
+                                const firstPart = currentDoc[0];
+                                const secondPart = currentDoc[1];
+                                if (debug) {
+                                    console.info("got concat child doc");
+                                    console.info(currentDoc, {
+                                        firstPart,
+                                        secondPart,
+                                    });
+                                    console.info(isDocCommand(firstPart), isDocCommand(secondPart), firstPart?.type === "line", firstPart?.hard, secondPart?.type ===
+                                        "break-parent");
+                                }
+                                if (isDocCommand(firstPart) &&
+                                    isDocCommand(secondPart) &&
+                                    firstPart.type === "line" &&
+                                    firstPart.hard &&
+                                    secondPart.type === "break-parent") {
+                                    if (debug) {
+                                        console.info("concat child was indeed a line break");
+                                    }
+                                    forceFinalLineBreakExists = true;
+                                    return false;
+                                }
+                                else if (debug) {
+                                    console.info("concat child doc was not a line break");
+                                }
+                            }
+                            return true;
+                        },
+                    });
+                }
+                if (forceFinalLineBreakExists) {
+                    finalLineBreakExists = true;
+                }
+                if (!finalLineBreakExists) {
+                    if (debug) {
+                        console.info(`Parsed all array children but finalBreakHappened = ${finalLineBreakExists}`);
+                    }
+                    const closingBracketIndex = parentDoc.indexOf("]");
+                    const preBracketChild = parentDoc[closingBracketIndex - 1];
+                    if (isDocCommand(preBracketChild) &&
+                        preBracketChild.type === "line") {
+                        parentDoc.splice(closingBracketIndex - 1, 1);
+                        undoMutations.push(() => {
+                            parentDoc.splice(closingBracketIndex - 1, 0, preBracketChild);
+                        });
+                    }
+                    parentDoc.splice(closingBracketIndex - 1, 0, doc.builders.hardlineWithoutBreakParent);
+                    undoMutations.push(() => {
+                        parentDoc.splice(closingBracketIndex - 1, 1);
+                    });
+                }
+                if (Array.isArray(indentedContent)) {
+                    const oldIndentContentChild = indentContents[1];
+                    indentContents.splice(1, 1, doc.builders.group([
+                        doc.builders.hardlineWithoutBreakParent,
+                        ...indentedContent,
+                    ]));
+                    undoMutations.push(() => {
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        indentContents[1] = oldIndentContentChild;
+                    });
+                }
+                else {
+                    const oldParts = indentedContent.parts;
+                    indentedContent.parts = [
+                        doc.builders.group([
+                            doc.builders.hardlineWithoutBreakParent,
+                            ...indentedContent.parts,
+                        ]),
+                    ];
+                    undoMutations.push(() => {
+                        indentedContent.parts = oldParts;
+                    });
+                }
+                if (arrayChildCount < wrapThreshold &&
+                    !lineCounts.length &&
+                    !manualWrap) {
+                    undoAllMutations();
+                }
+                hasProcessedOwnArray = true;
+                // don't walk any deeper
+                return false;
+            }
+            else if (debug) {
+                console.info({
+                    ignoring: currentDoc,
+                });
+            }
+            return true;
+        },
+    });
+    if (debug) {
+        console.info("final doc:", stringify(inputDoc));
+    }
+    // return what is input because we perform mutations on it
+    return inputDoc;
+}
+function getLatestSetValue(currentLine, triggers) {
+    const relevantSetLineCountsKey = getObjectTypedKeys(triggers)
+        .sort()
+        .reduce((closestKey, currentKey) => {
+        if (Number(currentKey) < currentLine) {
+            const currentData = triggers[currentKey];
+            if (currentData && currentData.lineEnd > currentLine) {
+                return currentKey;
+            }
+        }
+        return closestKey;
+    }, "");
+    const relevantSetLineCount = triggers[relevantSetLineCountsKey]?.data;
+    return relevantSetLineCount;
+}
+export function printWithMultilineArrays({ originalFormattedOutput, path, inputOptions, debug, }) {
+    const rootNode = path.stack[0];
+    if (!rootNode) {
+        throw new Error(`Could not find valid root node in ${path.stack.map((entry) => entry.type).join(",")}`);
+    }
+    const node = path.getNode();
+    if (debug) {
+        console.info("[multiline-arrays] printWithMultilineArrays node type:", node?.type);
+    }
+    if (node && isArrayLikeNode(node)) {
+        if (!node.loc) {
+            throw new Error(`Could not find location of node ${node.type}`);
+        }
+        const currentLineNumber = node.loc.start.line;
+        const commentTriggers = getCommentTriggers(rootNode, debug);
+        const originalText = inputOptions.originalText;
+        const splitOriginalText = originalText.split("\n");
+        /**
+         * ArrayPattern nodes in Babel-TS include their `typeAnnotation` in the
+         * node's `loc`, so the node's end location can be well past the array's
+         * `]`. Use the typeAnnotation's start (when present) as the effective
+         * end so trailing-comma / leading-newline detection only inspects text
+         * inside the actual array brackets.
+         */
+        const typeAnnotationStart = node.typeAnnotation?.loc?.start;
+        const arrayLoc = typeAnnotationStart
+            ? {
+                start: node.loc.start,
+                end: typeAnnotationStart,
+            }
+            : node.loc;
+        const elements = getArrayLikeElements(node);
+        const includesLeadingNewline = containsLeadingNewline({
+            nodeLocation: arrayLoc,
+            children: elements,
+            originalLines: splitOriginalText,
+            debug,
+        });
+        const includesTrailingComma = containsTrailingComma({
+            nodeLocation: arrayLoc,
+            children: elements,
+            originalLines: splitOriginalText,
+        });
+        const relevantSetLineCount = getLatestSetValue(currentLineNumber, commentTriggers.setLineCounts);
+        const lineCounts = commentTriggers.nextLineCounts[currentLineNumber] ??
+            relevantSetLineCount ??
+            parseNextLineCounts({
+                input: inputOptions.multilineArraysLinePattern,
+                nextOnly: false,
+                debug,
+            });
+        const relevantSetWrapCommentThreshold = getLatestSetValue(currentLineNumber, commentTriggers.setWrapThresholds);
+        const wrapThreshold = commentTriggers.nextWrapThresholds[currentLineNumber] ??
+            relevantSetWrapCommentThreshold ??
+            (inputOptions.multilineArraysWrapThreshold < 0
+                ? Infinity
+                : inputOptions.multilineArraysWrapThreshold);
+        const includesCommentTrigger = (commentTriggers.nextWrapThresholds[currentLineNumber] ??
+            relevantSetWrapCommentThreshold) != undefined ||
+            !!lineCounts.length;
+        if (debug) {
+            console.info(`======= Starting call to ${insertLinesIntoArray.name}: =======`);
+            console.info({
+                options: {
+                    lineCounts,
+                    wrapThreshold,
+                },
+            });
+        }
+        const manualWrap = includesCommentTrigger
+            ? false
+            : includesTrailingComma || includesLeadingNewline;
+        const newDoc = insertLinesIntoArray({
+            inputDoc: originalFormattedOutput,
+            manualWrap,
+            lineCounts,
+            wrapThreshold,
+            debug,
+        });
+        return newDoc;
+    }
+    return originalFormattedOutput;
+}

package/dist/printer/insert-new-lines.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/printer/insert-new-lines.test.js

@@ -0,0 +1,36 @@
+import { assert } from '@augment-vir/assert';
+import { describe, it } from '@augment-vir/test';
+import { doc } from 'prettier';
+import { insertLinesIntoArray } from './insert-new-lines.js';
+describe(insertLinesIntoArray.name, () => {
+    it('handles comment-only array doc emitted by Prettier GitHub Issue #75', () => {
+        const commentOnlyArrayDoc = [
+            '[',
+            [
+                doc.builders.indent([
+                    doc.builders.softline,
+                    [
+                        '// "source.fixAll.eslint",',
+                        [
+                            doc.builders.hardline,
+                            doc.builders.breakParent,
+                        ],
+                        '// "source.fixAll.prettier",',
+                    ],
+                ]),
+                [
+                    doc.builders.hardline,
+                    doc.builders.breakParent,
+                ],
+            ],
+            ']',
+        ];
+        assert.strictEquals(insertLinesIntoArray({
+            inputDoc: commentOnlyArrayDoc,
+            manualWrap: false,
+            lineCounts: [],
+            wrapThreshold: Infinity,
+            debug: false,
+        }), commentOnlyArrayDoc);
+    });
+});

package/dist/printer/leading-new-line.d.ts

@@ -0,0 +1,7 @@
+import type { BaseNode } from "estree";
+export declare function containsLeadingNewline({ nodeLocation, children, originalLines, debug, }: Readonly<{
+    nodeLocation: BaseNode["loc"];
+    children: (BaseNode | null)[];
+    originalLines: string[];
+    debug: boolean;
+}>): boolean;

package/dist/printer/leading-new-line.js

@@ -0,0 +1,31 @@
+import { extractTextBetweenRanges } from "../augments/array.js";
+export function containsLeadingNewline({ nodeLocation, children, originalLines, debug, }) {
+    const firstElement = children[0];
+    if (firstElement) {
+        const startLocation = nodeLocation?.start;
+        if (!startLocation) {
+            return false;
+        }
+        const endLocation = firstElement.loc?.start;
+        if (!endLocation) {
+            return false;
+        }
+        const textBeforeFirstElement = extractTextBetweenRanges(originalLines, {
+            start: {
+                column: startLocation.column - 1,
+                line: startLocation.line - 1,
+            },
+            end: {
+                column: endLocation.column - 1,
+                line: endLocation.line - 1,
+            },
+        });
+        if (debug) {
+            console.info(`containsLeadingNewline textBeforeFirstElement: ${textBeforeFirstElement}`);
+        }
+        if (textBeforeFirstElement.includes("\n")) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/printer/multiline-array-printer.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from "estree";
+import type { Printer } from "prettier";
+export declare function createMultilineArrayPrinter(basePrinter: Printer<Node>): Printer<Node>;
+export declare const multilineArrayPrinter: Printer<Node>;