prettier-plugin-multiline-arrays-2 1.0.0 → 5.0.0

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

@@ -1,7 +1,7 @@
 import { getObjectTypedKeys, stringify, } from "@augment-vir/common";
-import { doc } from "prettier";
+import * as prettier from "prettier";
+import { arrayFirst, arrayIncludes, arrayJoin, assertDefined, isEmpty, objectHasIn, safeCastTo, stringSplit, } from "ts-extras";
 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";
@@ -19,14 +19,14 @@ const found = 'Found "[" but:';
 function isMatchingNestingSyntaxClose({ maybeClose, openingSyntax, }) {
     const closingSyntax = matchingNestingSyntaxClose[openingSyntax];
     const firstCharacter = maybeClose.trimStart()[0];
-    return !!firstCharacter && closingSyntax === firstCharacter;
+    return Boolean(firstCharacter) && closingSyntax === firstCharacter;
 }
 function extractIndentDoc({ maybeIndentDoc, }) {
     if (isDocCommand(maybeIndentDoc) && maybeIndentDoc.type === "indent") {
         return maybeIndentDoc;
     }
-    else if (Array.isArray(maybeIndentDoc)) {
-        const firstDoc = maybeIndentDoc[0];
+    if (Array.isArray(maybeIndentDoc)) {
+        const firstDoc = arrayFirst(maybeIndentDoc);
         if (isDocCommand(firstDoc) && firstDoc.type === "indent") {
             return firstDoc;
         }
@@ -46,19 +46,12 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
         startDoc: inputDoc,
         debug,
         callback: (currentDoc, parentDocs, childIndex) => {
-            const currentParent = parentDocs[0];
+            const currentParent = arrayFirst(parentDocs);
             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({
@@ -86,6 +79,12 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                      */
                     return true;
                 }
+                const undoMutations = [];
+                function undoAllMutations() {
+                    for (const undoMutation of undoMutations.toReversed()) {
+                        undoMutation();
+                    }
+                }
                 const maybeBreak = parentDoc[childIndex + 2];
                 if (isDocCommand(maybeBreak) &&
                     maybeBreak.type === "if-break") {
@@ -95,9 +94,7 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                     parentDoc[childIndex + 2] = maybeBreak.breakContents;
                 }
                 const indentIndex = childIndex + 1;
-                const maybeBracketSibling = parentDoc[indentIndex] === ""
-                    ? parentDoc[indentIndex + 1]
-                    : parentDoc[indentIndex];
+                const maybeBracketSibling = parentDoc[indentIndex + (parentDoc[indentIndex] === "" ? 1 : 0)];
                 const bracketSibling = extractIndentDoc({
                     maybeIndentDoc: maybeBracketSibling,
                 });
@@ -109,9 +106,12 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                 if (maybeBracketSibling === "]") {
                     return false;
                 }
-                else if (!bracketSibling) {
+                if (!bracketSibling) {
                     throw new Error(`${found} its sibling was not an indent Doc.: ${stringify(maybeBracketSibling)}`);
                 }
+                const finalLineBreak = {
+                    exists: false,
+                };
                 const indentContents = bracketSibling.contents;
                 if (debug) {
                     console.info({
@@ -121,13 +121,13 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                 if (!Array.isArray(indentContents)) {
                     throw new TypeError(`${found} indent didn't have array contents.`);
                 }
-                else if (indentContents.length < 2) {
+                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];
+                const startingLine = arrayFirst(indentContents);
                 if (debug) {
                     console.info({
                         firstIndentContentsChild: startingLine,
@@ -139,9 +139,7 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                         undoAllMutations();
                         return false;
                     }
-                    else {
-                        throw new TypeError(`${found} first indent child was not a line.`);
-                    }
+                    throw new TypeError(`${found} first indent child was not a line.`);
                 }
                 indentContents[0] = "";
                 undoMutations.push(() => {
@@ -151,7 +149,9 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                 if (debug) {
                     console.info({
                         secondIndentContentsChild: indentedContent,
-                        itsFirstChild: indentedContent[0],
+                        itsFirstChild: Array.isArray(indentedContent)
+                            ? arrayFirst(indentedContent)
+                            : undefined,
                     });
                 }
                 if (!indentedContent) {
@@ -161,264 +161,249 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                     });
                     throw new Error(`${found} second indent child is not a fill.`);
                 }
-                else if (!Array.isArray(indentedContent) &&
-                    !(isDocCommand(indentedContent) &&
-                        indentedContent.type === "fill")) {
+                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) {
+                if (isEmpty(Array.isArray(indentedContent)
+                    ? indentedContent
+                    : indentedContent.parts)) {
                     throw new Error(`${found} indentedContent has no length.`);
                 }
-                // lineIndex is 0 indexed
+                // LineIndex is 0 indexed
                 let lineIndex = 0;
-                // columnCount is 1 indexed
+                // 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 === ",") {
+                walkDoc({
+                    startDoc: indentedContent,
+                    debug,
+                    callback: (commaDoc, commaParents, commaChildIndex) => {
+                        const innerCurrentParent = arrayFirst(commaParents);
+                        const innerCurrentParentDoc = innerCurrentParent?.parent;
+                        if (isDocCommand(commaDoc) &&
+                            commaDoc.type === "if-break" &&
+                            commaDoc.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 pipe Prettier emits when a union type
+                             * wraps, appear inside element docs and must not be
+                             * forced open, otherwise the inner union breaks
+                             * unnecessarily.
+                             */
+                            if (debug) {
+                                console.info("found final line break inside of if-break");
+                            }
+                            finalLineBreak.exists = true;
+                            if (!innerCurrentParentDoc) {
+                                throw new Error("Found if-break without a parent");
+                            }
+                            if (!Array.isArray(innerCurrentParentDoc)) {
+                                throw new TypeError("if-break parent is not an array");
+                            }
+                            assertDefined(commaChildIndex);
+                            innerCurrentParentDoc[commaChildIndex] =
+                                commaDoc.breakContents;
+                            innerCurrentParentDoc.splice(commaChildIndex + 1, 0, prettier.doc.builders.breakParent);
+                            undoMutations.push(() => {
+                                innerCurrentParentDoc.splice(commaChildIndex + 1, 1);
+                                innerCurrentParentDoc[commaChildIndex] =
+                                    commaDoc;
+                            });
+                        }
+                        else if (typeof commaDoc === "string") {
+                            if (!innerCurrentParentDoc) {
+                                console.error({
+                                    innerParentDoc: innerCurrentParentDoc,
+                                });
+                                throw new Error("Found string but innerParentDoc is not defined.");
+                            }
+                            if (commaDoc === "<" &&
+                                Array.isArray(innerCurrentParentDoc) &&
+                                commaChildIndex != undefined &&
+                                arrayIncludes(innerCurrentParentDoc.slice(commaChildIndex + 1), ">")) {
                                 /**
-                                 * 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.
+                                 * 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.
                                  */
-                                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");
+                                return false;
+                            }
+                            if (commaDoc &&
+                                nestingSyntaxOpen.includes(commaDoc)) {
+                                if (!Array.isArray(innerCurrentParentDoc)) {
+                                    throw new TypeError("Found opening syntax but parent is not an array.");
                                 }
-                                else if (commaChildIndex == undefined) {
-                                    throw new Error("if-break child index is undefined");
+                                const closingIndex = innerCurrentParentDoc.findIndex((sibling) => typeof sibling === "string" &&
+                                    sibling &&
+                                    isMatchingNestingSyntaxClose({
+                                        maybeClose: sibling,
+                                        openingSyntax: commaDoc,
+                                    }));
+                                if (closingIndex === -1) {
+                                    throw new Error(`Could not find closing match for ${commaDoc}`);
                                 }
-                                innerCurrentParentDoc[commaChildIndex] =
-                                    currentDoc.breakContents;
-                                innerCurrentParentDoc.splice(commaChildIndex + 1, 0, doc.builders.breakParent);
-                                undoMutations.push(() => {
-                                    innerCurrentParentDoc.splice(commaChildIndex + 1, 1);
-                                    innerCurrentParentDoc[commaChildIndex] =
-                                        currentDoc;
-                                });
+                                return false;
+                            }
+                            if (commaDoc &&
+                                nestingSyntaxClose.includes(commaDoc)) {
+                                throw new Error("Found closing syntax which shouldn't be walked");
                             }
-                            else if (typeof currentDoc === "string") {
-                                if (!innerCurrentParentDoc) {
+                            if (commaDoc === ",") {
+                                if (debug) {
+                                    console.info({
+                                        foundCommaIn: innerCurrentParentDoc,
+                                    });
+                                }
+                                if (!Array.isArray(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;
+                                    throw new Error("Found comma but innerParentDoc is not an array.");
                                 }
-                                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}`);
+                                assertDefined(commaChildIndex);
+                                let siblingIndex = commaChildIndex + 1;
+                                let parentToMutate = innerCurrentParentDoc;
+                                if (commaChildIndex ===
+                                    innerCurrentParentDoc.length - 1) {
+                                    const commaGrandParent = commaParents[1];
+                                    assertDefined(commaGrandParent);
+                                    assertDefined(commaGrandParent.childIndexInThisParent);
+                                    if (!Array.isArray(commaGrandParent.parent)) {
+                                        throw new TypeError("Comma group grandparent is not an array.");
                                     }
-                                    return false;
+                                    siblingIndex =
+                                        commaGrandParent.childIndexInThisParent +
+                                            1;
+                                    parentToMutate = commaGrandParent.parent;
+                                }
+                                if (debug) {
+                                    console.info({
+                                        commaParentDoc: innerCurrentParentDoc,
+                                        parentToMutate,
+                                        siblingIndex,
+                                    });
                                 }
-                                else if (currentDoc &&
-                                    nestingSyntaxClose.includes(currentDoc)) {
-                                    throw new Error("Found closing syntax which shouldn't be walked");
+                                let maybeCommaSibling = parentToMutate[siblingIndex];
+                                if (debug) {
+                                    console.info(`Trying to find comma sibling at index ${siblingIndex}`, stringify({
+                                        parentToMutate,
+                                        maybeCommaSibling,
+                                    }));
+                                }
+                                function isCommaSibling(maybe) {
+                                    const firstMaybe = Array.isArray(maybe)
+                                        ? arrayFirst(maybe)
+                                        : undefined;
+                                    return ((isDocCommand(maybe) &&
+                                        maybe.type === "line") ||
+                                        (Array.isArray(maybe) &&
+                                            isDocCommand(firstMaybe) &&
+                                            firstMaybe.type === "line"));
                                 }
-                                else if (currentDoc === ",") {
+                                while (!isCommaSibling(maybeCommaSibling) &&
+                                    siblingIndex < parentToMutate.length) {
+                                    siblingIndex += 1;
+                                    maybeCommaSibling =
+                                        parentToMutate[siblingIndex];
                                     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;
+                                        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 > 0
+                                    ? lineCounts[currentLineCountIndex]
+                                    : undefined;
+                                const hasCurrentLineCount = currentLineCount != undefined &&
+                                    currentLineCount !== 0;
+                                arrayChildCount += 1;
+                                if ((hasCurrentLineCount &&
+                                    columnCount === currentLineCount) ||
+                                    !hasCurrentLineCount) {
+                                    // If we're on the last element of the line then increment to the next line
+                                    lineIndex += 1;
+                                    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({
-                                            commaParentDoc: innerCurrentParentDoc,
-                                            parentToMutate,
-                                            siblingIndex,
+                                            breakingAfter: parentToMutate[siblingIndex - 1],
                                         });
                                     }
-                                    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;
-                                    });
+                                    parentToMutate[siblingIndex] =
+                                        prettier.doc.builders.hardlineWithoutBreakParent;
+                                }
+                                else {
+                                    parentToMutate[siblingIndex] = " ";
+                                    columnCount += 1;
                                 }
+                                undoMutations.push(() => {
+                                    parentToMutate[siblingIndex] = commaSibling;
+                                });
+                            }
+                        }
+                        else if (Array.isArray(currentDoc)) {
+                            const firstPart = safeCastTo(arrayFirst(currentDoc));
+                            const secondPart = safeCastTo(currentDoc[1]);
+                            if (debug) {
+                                console.info("got concat child doc");
+                                console.info(currentDoc, {
+                                    firstPart,
+                                    secondPart,
+                                });
+                                console.info(isDocCommand(firstPart), isDocCommand(secondPart), isDocCommand(firstPart) &&
+                                    firstPart.type === "line", isDocCommand(firstPart) &&
+                                    objectHasIn(firstPart, "hard") &&
+                                    firstPart.hard === true, isDocCommand(secondPart) &&
+                                    secondPart.type === "break-parent");
                             }
-                            else if (Array.isArray(currentDoc)) {
-                                const firstPart = currentDoc[0];
-                                const secondPart = currentDoc[1];
+                            if (isDocCommand(firstPart) &&
+                                isDocCommand(secondPart) &&
+                                firstPart.type === "line" &&
+                                firstPart.hard &&
+                                secondPart.type === "break-parent") {
                                 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");
+                                    console.info("concat child was indeed a line break");
                                 }
+                                finalLineBreak.exists = true;
+                                return false;
                             }
-                            return true;
-                        },
-                    });
-                }
-                if (forceFinalLineBreakExists) {
-                    finalLineBreakExists = true;
-                }
-                if (!finalLineBreakExists) {
+                            if (debug) {
+                                console.info("concat child doc was not a line break");
+                            }
+                        }
+                        return true;
+                    },
+                });
+                if (!finalLineBreak.exists) {
                     if (debug) {
-                        console.info(`Parsed all array children but finalBreakHappened = ${finalLineBreakExists}`);
+                        console.info(`Parsed all array children but finalBreakHappened = ${String(finalLineBreak.exists)}`);
                     }
                     const closingBracketIndex = parentDoc.indexOf("]");
                     const preBracketChild = parentDoc[closingBracketIndex - 1];
@@ -429,27 +414,27 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                             parentDoc.splice(closingBracketIndex - 1, 0, preBracketChild);
                         });
                     }
-                    parentDoc.splice(closingBracketIndex - 1, 0, doc.builders.hardlineWithoutBreakParent);
+                    parentDoc.splice(closingBracketIndex - 1, 0, prettier.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,
+                    assertDefined(oldIndentContentChild);
+                    indentContents[1] = prettier.doc.builders.group([
+                        prettier.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,
+                        prettier.doc.builders.group([
+                            prettier.doc.builders.hardlineWithoutBreakParent,
                             ...indentedContent.parts,
                         ]),
                     ];
@@ -458,15 +443,15 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
                     });
                 }
                 if (arrayChildCount < wrapThreshold &&
-                    !lineCounts.length &&
+                    isEmpty(lineCounts) &&
                     !manualWrap) {
                     undoAllMutations();
                 }
                 hasProcessedOwnArray = true;
-                // don't walk any deeper
+                // Don't walk any deeper
                 return false;
             }
-            else if (debug) {
+            if (debug) {
                 console.info({
                     ignoring: currentDoc,
                 });
@@ -477,28 +462,28 @@ export function insertLinesIntoArray({ inputDoc, manualWrap, lineCounts, wrapThr
     if (debug) {
         console.info("final doc:", stringify(inputDoc));
     }
-    // return what is input because we perform mutations on it
+    // 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;
-            }
+    let relevantSetLineCountsKey = "";
+    const sortedTriggerKeys = getObjectTypedKeys(triggers).toSorted((firstKey, secondKey) => Number(firstKey) - Number(secondKey));
+    for (const currentKey of sortedTriggerKeys) {
+        if (Number(currentKey) >= currentLine) {
+            continue;
         }
-        return closestKey;
-    }, "");
-    const relevantSetLineCount = triggers[relevantSetLineCountsKey]?.data;
-    return relevantSetLineCount;
+        const currentData = safeCastTo(triggers[currentKey]);
+        if (currentData && currentData.lineEnd > currentLine) {
+            relevantSetLineCountsKey = currentKey;
+        }
+    }
+    const relevantTrigger = safeCastTo(triggers[relevantSetLineCountsKey]);
+    return relevantTrigger?.data;
 }
 export function printWithMultilineArrays({ originalFormattedOutput, path, inputOptions, debug, }) {
-    const rootNode = path.stack[0];
+    const rootNode = arrayFirst(path.stack);
     if (!rootNode) {
-        throw new Error(`Could not find valid root node in ${path.stack.map((entry) => entry.type).join(",")}`);
+        throw new Error(`Could not find valid root node in ${arrayJoin(path.stack.map((entry) => entry.type), ",")}`);
     }
     const node = path.getNode();
     if (debug) {
@@ -506,12 +491,12 @@ export function printWithMultilineArrays({ originalFormattedOutput, path, inputO
     }
     if (node && isArrayLikeNode(node)) {
         if (!node.loc) {
-            throw new Error(`Could not find location of node ${node.type}`);
+            throw new Error(`Could not find location of node ${String(node.type)}`);
         }
         const currentLineNumber = node.loc.start.line;
         const commentTriggers = getCommentTriggers(rootNode, debug);
         const originalText = inputOptions.originalText;
-        const splitOriginalText = originalText.split("\n");
+        const splitOriginalText = stringSplit(originalText, "\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
@@ -519,7 +504,7 @@ export function printWithMultilineArrays({ originalFormattedOutput, path, inputO
          * end so trailing-comma / leading-newline detection only inspects text
          * inside the actual array brackets.
          */
-        const typeAnnotationStart = node.typeAnnotation?.loc?.start;
+        const typeAnnotationStart = safeCastTo(node).typeAnnotation?.loc?.start;
         const arrayLoc = typeAnnotationStart
             ? {
                 start: node.loc.start,
@@ -554,7 +539,7 @@ export function printWithMultilineArrays({ originalFormattedOutput, path, inputO
                 : inputOptions.multilineArraysWrapThreshold);
         const includesCommentTrigger = (commentTriggers.nextWrapThresholds[currentLineNumber] ??
             relevantSetWrapCommentThreshold) != undefined ||
-            !!lineCounts.length;
+            lineCounts.length > 0;
         if (debug) {
             console.info(`======= Starting call to ${insertLinesIntoArray.name}: =======`);
             console.info({
@@ -564,17 +549,15 @@ export function printWithMultilineArrays({ originalFormattedOutput, path, inputO
                 },
             });
         }
-        const manualWrap = includesCommentTrigger
-            ? false
-            : includesTrailingComma || includesLeadingNewline;
-        const newDoc = insertLinesIntoArray({
+        const manualWrap = !includesCommentTrigger &&
+            (includesTrailingComma || includesLeadingNewline);
+        return insertLinesIntoArray({
             inputDoc: originalFormattedOutput,
             manualWrap,
             lineCounts,
             wrapThreshold,
             debug,
         });
-        return newDoc;
     }
     return originalFormattedOutput;
 }