~~ lineWidth: 40 ~~
== should print ==
test&&other   ||asdf;

[expect]
test && other || asdf;

== should print hanging when exceeding line width ==
test && other || asdf && test || asdf && asdf;

[expect]
test && other || asdf && test
    || asdf && asdf;

== should print hanging when exceeding line width multiple times ==
test && other || asdf && test || asdf && asdf || asdf && asdf || test && other || asdf && test || asdf && asdf;

[expect]
test && other || asdf && test
    || asdf && asdf || asdf && asdf
    || test && other || asdf && test
    || asdf && asdf;

== should handle comments on a different line in-between ==
testingtest
    // some comment
    && container.pos !== container.end;

[expect]
testingtest
    // some comment
    && container.pos !== container.end;

== should handle comments on a different line in-between when the operator is on the preceding line ==
testingtest &&
    // some comment
    container.pos !== container.end;

[expect]
testingtest
    // some comment
    && container.pos !== container.end;

== should decide based on the left side's open paren token if it should be on a newline ==
(test && other) && (
    test && other
);

(test && other) &&
(
    test || other
);

[expect]
(test && other) && (
    test && other
);

(test && other)
    && (
        test || other
    );

== should not cut off an inner expression midway ==
testing && this.testing && other.testing;

[expect]
testing && this.testing
    && other.testing;

== should support the nullish coalescing operator ==
test = test ?? 5;

[expect]
test = test ?? 5;

== should get comments that are trailing of the left expression ==
testingtest(test)
    // test
    // asdf
    && asdf;

[expect]
testingtest(test)
    // test
    // asdf
    && asdf;

== should handle when the comments are after the operator ==
testingtest(test) &&
    // test
    // asdf
    asdf;

[expect]
testingtest(test)
    // test
    // asdf
    && asdf;

== should indent according to the kind ==
a
    && b
    || c
    && d
    && e
    || f
    || g
    || h
    && j
    || k
    || l
    || m
    || n;

[expect]
a
        && b
    || c
        && d
        && e
    || f
    || g
    || h
        && j
    || k
    || l
    || m
    || n;

== should only indent once when it has binary expressions nested within ==
a === b
    || a !== b
    || a !== b
    || a === b;

[expect]
a === b
    || a !== b
    || a !== b
    || a === b;

== should indent only once when parens are inlined ==
a === b && (c === d
    && d === 4
    || e === 3);

[expect]
a === b && (c === d
        && d === 4
    || e === 3);

== should indent twice if the parens start on a different line ==
a === b
    && (c === d
        && d === 4
        || e === 3);

[expect]
a === b
    && (c === d
            && d === 4
        || e === 3);