vue_oxc_toolkit 0.7.2

---
source: crates/vue_oxc_toolkit/src/test.rs
expression: result
---
=============== Program ===============
Program {
    span: Span {
        start: 0,
        end: 161,
    },
    source_text: "<template>\n  <div v-else-if=\"1\" />\n  <div v-else />\n\n  <div v-if=\"1\" />\n  <div v-if=\"\" />\n  <div v-if />\n  <div v-else-if=\"\" />\n  <div v-else-if />\n</template>\n\n",
    comments: Vec(
        [],
    ),
    hashbang: None,
    directives: Vec(
        [],
    ),
    body: Vec(
        [
            BlockStatement(
                BlockStatement {
                    span: Span {
                        start: 0,
                        end: 0,
                    },
                    body: Vec(
                        [
                            ExpressionStatement(
                                ExpressionStatement {
                                    span: Span {
                                        start: 0,
                                        end: 0,
                                    },
                                    expression: JSXFragment(
                                        JSXFragment {
                                            span: Span {
                                                start: 0,
                                                end: 0,
                                            },
                                            opening_fragment: JSXOpeningFragment {
                                                span: Span {
                                                    start: 0,
                                                    end: 0,
                                                },
                                            },
                                            children: Vec(
                                                [
                                                    Element(
                                                        JSXElement {
                                                            span: Span {
                                                                start: 0,
                                                                end: 159,
                                                            },
                                                            opening_element: JSXOpeningElement {
                                                                span: Span {
                                                                    start: 0,
                                                                    end: 10,
                                                                },
                                                                name: Identifier(
                                                                    JSXIdentifier {
                                                                        span: Span {
                                                                            start: 1,
                                                                            end: 9,
                                                                        },
                                                                        name: "template",
                                                                    },
                                                                ),
                                                                type_arguments: None,
                                                                attributes: Vec(
                                                                    [],
                                                                ),
                                                            },
                                                            children: Vec(
                                                                [
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 10,
                                                                                end: 13,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 13,
                                                                                end: 34,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 13,
                                                                                    end: 34,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 14,
                                                                                            end: 17,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 18,
                                                                                                    end: 31,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 18,
                                                                                                            end: 27,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 18,
                                                                                                                end: 27,
                                                                                                            },
                                                                                                            name: "v-else-if",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 0,
                                                                                                                end: 0,
                                                                                                            },
                                                                                                            name: "",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 28,
                                                                                                                end: 31,
                                                                                                            },
                                                                                                            expression: EmptyExpression(
                                                                                                                JSXEmptyExpression {
                                                                                                                    span: Span {
                                                                                                                        start: 0,
                                                                                                                        end: 0,
                                                                                                                    },
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 34,
                                                                                end: 37,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 37,
                                                                                end: 51,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 37,
                                                                                    end: 51,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 38,
                                                                                            end: 41,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 42,
                                                                                                    end: 48,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 42,
                                                                                                            end: 48,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 42,
                                                                                                                end: 48,
                                                                                                            },
                                                                                                            name: "v-else",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 0,
                                                                                                                end: 0,
                                                                                                            },
                                                                                                            name: "",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: None,
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 51,
                                                                                end: 55,
                                                                            },
                                                                            value: "\n\n  ",
                                                                            raw: Some(
                                                                                "\n\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 71,
                                                                                end: 74,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    ExpressionContainer(
                                                                        JSXExpressionContainer {
                                                                            span: Span {
                                                                                start: 0,
                                                                                end: 0,
                                                                            },
                                                                            expression: ConditionalExpression(
                                                                                ConditionalExpression {
                                                                                    span: Span {
                                                                                        start: 0,
                                                                                        end: 0,
                                                                                    },
                                                                                    test: NumericLiteral(
                                                                                        NumericLiteral {
                                                                                            span: Span {
                                                                                                start: 66,
                                                                                                end: 67,
                                                                                            },
                                                                                            value: 1.0,
                                                                                            raw: Some(
                                                                                                "1",
                                                                                            ),
                                                                                            base: Decimal,
                                                                                        },
                                                                                    ),
                                                                                    consequent: JSXFragment(
                                                                                        JSXFragment {
                                                                                            span: Span {
                                                                                                start: 0,
                                                                                                end: 0,
                                                                                            },
                                                                                            opening_fragment: JSXOpeningFragment {
                                                                                                span: Span {
                                                                                                    start: 0,
                                                                                                    end: 0,
                                                                                                },
                                                                                            },
                                                                                            children: Vec(
                                                                                                [
                                                                                                    Element(
                                                                                                        JSXElement {
                                                                                                            span: Span {
                                                                                                                start: 55,
                                                                                                                end: 71,
                                                                                                            },
                                                                                                            opening_element: JSXOpeningElement {
                                                                                                                span: Span {
                                                                                                                    start: 55,
                                                                                                                    end: 71,
                                                                                                                },
                                                                                                                name: Identifier(
                                                                                                                    JSXIdentifier {
                                                                                                                        span: Span {
                                                                                                                            start: 56,
                                                                                                                            end: 59,
                                                                                                                        },
                                                                                                                        name: "div",
                                                                                                                    },
                                                                                                                ),
                                                                                                                type_arguments: None,
                                                                                                                attributes: Vec(
                                                                                                                    [
                                                                                                                        Attribute(
                                                                                                                            JSXAttribute {
                                                                                                                                span: Span {
                                                                                                                                    start: 60,
                                                                                                                                    end: 68,
                                                                                                                                },
                                                                                                                                name: NamespacedName(
                                                                                                                                    JSXNamespacedName {
                                                                                                                                        span: Span {
                                                                                                                                            start: 60,
                                                                                                                                            end: 64,
                                                                                                                                        },
                                                                                                                                        namespace: JSXIdentifier {
                                                                                                                                            span: Span {
                                                                                                                                                start: 60,
                                                                                                                                                end: 64,
                                                                                                                                            },
                                                                                                                                            name: "v-if",
                                                                                                                                        },
                                                                                                                                        name: JSXIdentifier {
                                                                                                                                            span: Span {
                                                                                                                                                start: 0,
                                                                                                                                                end: 0,
                                                                                                                                            },
                                                                                                                                            name: "",
                                                                                                                                        },
                                                                                                                                    },
                                                                                                                                ),
                                                                                                                                value: Some(
                                                                                                                                    ExpressionContainer(
                                                                                                                                        JSXExpressionContainer {
                                                                                                                                            span: Span {
                                                                                                                                                start: 65,
                                                                                                                                                end: 68,
                                                                                                                                            },
                                                                                                                                            expression: EmptyExpression(
                                                                                                                                                JSXEmptyExpression {
                                                                                                                                                    span: Span {
                                                                                                                                                        start: 0,
                                                                                                                                                        end: 0,
                                                                                                                                                    },
                                                                                                                                                },
                                                                                                                                            ),
                                                                                                                                        },
                                                                                                                                    ),
                                                                                                                                ),
                                                                                                                            },
                                                                                                                        ),
                                                                                                                    ],
                                                                                                                ),
                                                                                                            },
                                                                                                            children: Vec(
                                                                                                                [],
                                                                                                            ),
                                                                                                            closing_element: None,
                                                                                                        },
                                                                                                    ),
                                                                                                ],
                                                                                            ),
                                                                                            closing_fragment: JSXClosingFragment {
                                                                                                span: Span {
                                                                                                    start: 0,
                                                                                                    end: 0,
                                                                                                },
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                    alternate: Identifier(
                                                                                        IdentifierReference {
                                                                                            span: Span {
                                                                                                start: 0,
                                                                                                end: 0,
                                                                                            },
                                                                                            name: "undefined",
                                                                                            reference_id: Cell {
                                                                                                value: None,
                                                                                            },
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 74,
                                                                                end: 89,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 74,
                                                                                    end: 89,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 75,
                                                                                            end: 78,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 79,
                                                                                                    end: 86,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 79,
                                                                                                            end: 83,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 79,
                                                                                                                end: 83,
                                                                                                            },
                                                                                                            name: "v-if",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 0,
                                                                                                                end: 0,
                                                                                                            },
                                                                                                            name: "",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 84,
                                                                                                                end: 86,
                                                                                                            },
                                                                                                            expression: EmptyExpression(
                                                                                                                JSXEmptyExpression {
                                                                                                                    span: Span {
                                                                                                                        start: 0,
                                                                                                                        end: 0,
                                                                                                                    },
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 89,
                                                                                end: 92,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 92,
                                                                                end: 104,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 92,
                                                                                    end: 104,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 93,
                                                                                            end: 96,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 97,
                                                                                                    end: 101,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 97,
                                                                                                            end: 101,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 97,
                                                                                                                end: 101,
                                                                                                            },
                                                                                                            name: "v-if",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 0,
                                                                                                                end: 0,
                                                                                                            },
                                                                                                            name: "",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: None,
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 104,
                                                                                end: 107,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 107,
                                                                                end: 127,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 107,
                                                                                    end: 127,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 108,
                                                                                            end: 111,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 112,
                                                                                                    end: 124,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 112,
                                                                                                            end: 121,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 112,
                                                                                                                end: 121,
                                                                                                            },
                                                                                                            name: "v-else-if",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 0,
                                                                                                                end: 0,
                                                                                                            },
                                                                                                            name: "",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 122,
                                                                                                                end: 124,
                                                                                                            },
                                                                                                            expression: EmptyExpression(
                                                                                                                JSXEmptyExpression {
                                                                                                                    span: Span {
                                                                                                                        start: 0,
                                                                                                                        end: 0,
                                                                                                                    },
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 127,
                                                                                end: 130,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 130,
                                                                                end: 147,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 130,
                                                                                    end: 147,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 131,
                                                                                            end: 134,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 135,
                                                                                                    end: 144,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 135,
                                                                                                            end: 144,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 135,
                                                                                                                end: 144,
                                                                                                            },
                                                                                                            name: "v-else-if",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 0,
                                                                                                                end: 0,
                                                                                                            },
                                                                                                            name: "",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: None,
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 147,
                                                                                end: 148,
                                                                            },
                                                                            value: "\n",
                                                                            raw: Some(
                                                                                "\n",
                                                                            ),
                                                                        },
                                                                    ),
                                                                ],
                                                            ),
                                                            closing_element: Some(
                                                                JSXClosingElement {
                                                                    span: Span {
                                                                        start: 148,
                                                                        end: 159,
                                                                    },
                                                                    name: Identifier(
                                                                        JSXIdentifier {
                                                                            span: Span {
                                                                                start: 150,
                                                                                end: 158,
                                                                            },
                                                                            name: "template",
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 159,
                                                                end: 161,
                                                            },
                                                            value: "\n\n",
                                                            raw: Some(
                                                                "\n\n",
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            ),
                                            closing_fragment: JSXClosingFragment {
                                                span: Span {
                                                    start: 0,
                                                    end: 0,
                                                },
                                            },
                                        },
                                    ),
                                },
                            ),
                        ],
                    ),
                    scope_id: Cell {
                        value: None,
                    },
                },
            ),
        ],
    ),
    scope_id: Cell {
        value: None,
    },
    source_type: SourceType {
        language: JavaScript,
        module_kind: Unambiguous,
        variant: Jsx,
        extension: None,
    },
}

===============  Error  ===============
[
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "v-else/v-else-if has no adjacent v-if or v-else-if.",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                13,
                            ),
                            length: 21,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "v-else/v-else-if has no adjacent v-if or v-else-if.",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                37,
                            ),
                            length: 14,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "v-if/v-else-if is missing expression.",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                79,
                            ),
                            length: 8,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "Empty parenthesized expression",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                84,
                            ),
                            length: 2,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "v-if/v-else-if is missing expression.",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                97,
                            ),
                            length: 5,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "v-if/v-else-if is missing expression.",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                112,
                            ),
                            length: 13,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "Empty parenthesized expression",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                122,
                            ),
                            length: 2,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
    OxcDiagnostic {
        inner: OxcDiagnosticInner {
            message: "v-if/v-else-if is missing expression.",
            labels: Some(
                [
                    LabeledSpan {
                        label: None,
                        span: SourceSpan {
                            offset: SourceOffset(
                                135,
                            ),
                            length: 10,
                        },
                        primary: false,
                    },
                ],
            ),
            help: None,
            note: None,
            severity: Error,
            code: OxcCode {
                scope: None,
                number: None,
            },
            url: None,
        },
    },
]

=============== Codegen ===============
{
	<><template>
  <div v-else-if:={} />
  <div v-else: />

  
  {1 ? <><div v-if:={} /></> : undefined}<div v-if:={} />
  <div v-if: />
  <div v-else-if:={} />
  <div v-else-if: />
</template>

</>;
}


===============  Spans  ===============
Slice: "<template>\n  <div v-else-if=\"1\" />\n  <di..[OMIT]..=\"\" />\n  <div v-else-if />\n</template>\n\n"; 
Span: (0, 161); 
Type: Program; 

Slice: "<template>\n  <div v-else-if=\"1\" />\n  <di..[OMIT]..if=\"\" />\n  <div v-else-if />\n</template>"; 
Span: (0, 159); 
Type: JSXElement; 

Slice: "<template>"; 
Span: (0, 10); 
Type: JSXOpeningElement; 

Slice: "template"; 
Span: (1, 9); 
Type: JSXIdentifier; 

Slice: "\n  "; 
Span: (10, 13); 
Type: JSXText; 

Slice: "<div v-else-if=\"1\" />"; 
Span: (13, 34); 
Type: JSXElement; 

Slice: "<div v-else-if=\"1\" />"; 
Span: (13, 34); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (14, 17); 
Type: JSXIdentifier; 

Slice: "v-else-if=\"1\""; 
Span: (18, 31); 
Type: JSXAttribute; 

Slice: "v-else-if"; 
Span: (18, 27); 
Type: JSXNamespacedName; 

Slice: "v-else-if"; 
Span: (18, 27); 
Type: JSXIdentifier; 

Slice: "\"1\""; 
Span: (28, 31); 
Type: JSXExpressionContainer; 

Slice: "\n  "; 
Span: (34, 37); 
Type: JSXText; 

Slice: "<div v-else />"; 
Span: (37, 51); 
Type: JSXElement; 

Slice: "<div v-else />"; 
Span: (37, 51); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (38, 41); 
Type: JSXIdentifier; 

Slice: "v-else"; 
Span: (42, 48); 
Type: JSXAttribute; 

Slice: "v-else"; 
Span: (42, 48); 
Type: JSXNamespacedName; 

Slice: "v-else"; 
Span: (42, 48); 
Type: JSXIdentifier; 

Slice: "\n\n  "; 
Span: (51, 55); 
Type: JSXText; 

Slice: "\n  "; 
Span: (71, 74); 
Type: JSXText; 

Slice: "1"; 
Span: (66, 67); 
Type: NumericLiteral; 

Slice: "<div v-if=\"1\" />"; 
Span: (55, 71); 
Type: JSXElement; 

Slice: "<div v-if=\"1\" />"; 
Span: (55, 71); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (56, 59); 
Type: JSXIdentifier; 

Slice: "v-if=\"1\""; 
Span: (60, 68); 
Type: JSXAttribute; 

Slice: "v-if"; 
Span: (60, 64); 
Type: JSXNamespacedName; 

Slice: "v-if"; 
Span: (60, 64); 
Type: JSXIdentifier; 

Slice: "\"1\""; 
Span: (65, 68); 
Type: JSXExpressionContainer; 

Slice: "<div v-if=\"\" />"; 
Span: (74, 89); 
Type: JSXElement; 

Slice: "<div v-if=\"\" />"; 
Span: (74, 89); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (75, 78); 
Type: JSXIdentifier; 

Slice: "v-if=\"\""; 
Span: (79, 86); 
Type: JSXAttribute; 

Slice: "v-if"; 
Span: (79, 83); 
Type: JSXNamespacedName; 

Slice: "v-if"; 
Span: (79, 83); 
Type: JSXIdentifier; 

Slice: "\"\""; 
Span: (84, 86); 
Type: JSXExpressionContainer; 

Slice: "\n  "; 
Span: (89, 92); 
Type: JSXText; 

Slice: "<div v-if />"; 
Span: (92, 104); 
Type: JSXElement; 

Slice: "<div v-if />"; 
Span: (92, 104); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (93, 96); 
Type: JSXIdentifier; 

Slice: "v-if"; 
Span: (97, 101); 
Type: JSXAttribute; 

Slice: "v-if"; 
Span: (97, 101); 
Type: JSXNamespacedName; 

Slice: "v-if"; 
Span: (97, 101); 
Type: JSXIdentifier; 

Slice: "\n  "; 
Span: (104, 107); 
Type: JSXText; 

Slice: "<div v-else-if=\"\" />"; 
Span: (107, 127); 
Type: JSXElement; 

Slice: "<div v-else-if=\"\" />"; 
Span: (107, 127); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (108, 111); 
Type: JSXIdentifier; 

Slice: "v-else-if=\"\""; 
Span: (112, 124); 
Type: JSXAttribute; 

Slice: "v-else-if"; 
Span: (112, 121); 
Type: JSXNamespacedName; 

Slice: "v-else-if"; 
Span: (112, 121); 
Type: JSXIdentifier; 

Slice: "\"\""; 
Span: (122, 124); 
Type: JSXExpressionContainer; 

Slice: "\n  "; 
Span: (127, 130); 
Type: JSXText; 

Slice: "<div v-else-if />"; 
Span: (130, 147); 
Type: JSXElement; 

Slice: "<div v-else-if />"; 
Span: (130, 147); 
Type: JSXOpeningElement; 

Slice: "div"; 
Span: (131, 134); 
Type: JSXIdentifier; 

Slice: "v-else-if"; 
Span: (135, 144); 
Type: JSXAttribute; 

Slice: "v-else-if"; 
Span: (135, 144); 
Type: JSXNamespacedName; 

Slice: "v-else-if"; 
Span: (135, 144); 
Type: JSXIdentifier; 

Slice: "\n"; 
Span: (147, 148); 
Type: JSXText; 

Slice: "</template>"; 
Span: (148, 159); 
Type: JSXClosingElement; 

Slice: "template"; 
Span: (150, 158); 
Type: JSXIdentifier; 

Slice: "\n\n"; 
Span: (159, 161); 
Type: JSXText;