vue_oxc_toolkit 0.6.0

---
source: crates/vue_oxc_toolkit/src/test.rs
expression: result
---
=============== Program ===============
Program {
    span: Span {
        start: 0,
        end: 159,
    },
    source_text: "<template>\n  <div :class=\"'w-100'\" />\n  <div :[some]=\"2\" />\n  <Some #default=\"{ a }\" />\n  <input v-model=\"text\" />\n  <Some v-bind:some.none=\"1\" />\n</template>\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: 158,
                                                            },
                                                            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: 37,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 13,
                                                                                    end: 37,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 14,
                                                                                            end: 17,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 18,
                                                                                                    end: 34,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 18,
                                                                                                            end: 24,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 18,
                                                                                                                end: 19,
                                                                                                            },
                                                                                                            name: "v-bind",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 19,
                                                                                                                end: 24,
                                                                                                            },
                                                                                                            name: "class",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 26,
                                                                                                                end: 33,
                                                                                                            },
                                                                                                            expression: StringLiteral(
                                                                                                                StringLiteral {
                                                                                                                    span: Span {
                                                                                                                        start: 26,
                                                                                                                        end: 33,
                                                                                                                    },
                                                                                                                    value: "w-100",
                                                                                                                    raw: Some(
                                                                                                                        "'w-100'",
                                                                                                                    ),
                                                                                                                    lone_surrogates: false,
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 37,
                                                                                end: 40,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 40,
                                                                                end: 59,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 40,
                                                                                    end: 59,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 41,
                                                                                            end: 44,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 45,
                                                                                                    end: 56,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 45,
                                                                                                            end: 52,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 45,
                                                                                                                end: 46,
                                                                                                            },
                                                                                                            name: "v-bind",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 46,
                                                                                                                end: 52,
                                                                                                            },
                                                                                                            name: "[some]",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 54,
                                                                                                                end: 55,
                                                                                                            },
                                                                                                            expression: ObjectExpression(
                                                                                                                ObjectExpression {
                                                                                                                    span: Span {
                                                                                                                        start: 0,
                                                                                                                        end: 0,
                                                                                                                    },
                                                                                                                    properties: Vec(
                                                                                                                        [
                                                                                                                            ObjectProperty(
                                                                                                                                ObjectProperty {
                                                                                                                                    span: Span {
                                                                                                                                        start: 0,
                                                                                                                                        end: 0,
                                                                                                                                    },
                                                                                                                                    key: Identifier(
                                                                                                                                        IdentifierReference {
                                                                                                                                            span: Span {
                                                                                                                                                start: 47,
                                                                                                                                                end: 51,
                                                                                                                                            },
                                                                                                                                            name: "some",
                                                                                                                                            reference_id: Cell {
                                                                                                                                                value: None,
                                                                                                                                            },
                                                                                                                                        },
                                                                                                                                    ),
                                                                                                                                    value: NumericLiteral(
                                                                                                                                        NumericLiteral {
                                                                                                                                            span: Span {
                                                                                                                                                start: 54,
                                                                                                                                                end: 55,
                                                                                                                                            },
                                                                                                                                            value: 2.0,
                                                                                                                                            raw: Some(
                                                                                                                                                "2",
                                                                                                                                            ),
                                                                                                                                            base: Decimal,
                                                                                                                                        },
                                                                                                                                    ),
                                                                                                                                    kind: Init,
                                                                                                                                    method: false,
                                                                                                                                    shorthand: false,
                                                                                                                                    computed: true,
                                                                                                                                },
                                                                                                                            ),
                                                                                                                        ],
                                                                                                                    ),
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 59,
                                                                                end: 62,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 62,
                                                                                end: 87,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 62,
                                                                                    end: 87,
                                                                                },
                                                                                name: IdentifierReference(
                                                                                    IdentifierReference {
                                                                                        span: Span {
                                                                                            start: 63,
                                                                                            end: 67,
                                                                                        },
                                                                                        name: "Some",
                                                                                        reference_id: Cell {
                                                                                            value: None,
                                                                                        },
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 68,
                                                                                                    end: 84,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 68,
                                                                                                            end: 76,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 68,
                                                                                                                end: 69,
                                                                                                            },
                                                                                                            name: "v-slot",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 69,
                                                                                                                end: 76,
                                                                                                            },
                                                                                                            name: "default",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 78,
                                                                                                                end: 83,
                                                                                                            },
                                                                                                            expression: EmptyExpression(
                                                                                                                JSXEmptyExpression {
                                                                                                                    span: Span {
                                                                                                                        start: 0,
                                                                                                                        end: 0,
                                                                                                                    },
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [
                                                                                    ExpressionContainer(
                                                                                        JSXExpressionContainer {
                                                                                            span: Span {
                                                                                                start: 0,
                                                                                                end: 0,
                                                                                            },
                                                                                            expression: ObjectExpression(
                                                                                                ObjectExpression {
                                                                                                    span: Span {
                                                                                                        start: 0,
                                                                                                        end: 0,
                                                                                                    },
                                                                                                    properties: Vec(
                                                                                                        [
                                                                                                            ObjectProperty(
                                                                                                                ObjectProperty {
                                                                                                                    span: Span {
                                                                                                                        start: 0,
                                                                                                                        end: 0,
                                                                                                                    },
                                                                                                                    key: StaticIdentifier(
                                                                                                                        IdentifierName {
                                                                                                                            span: Span {
                                                                                                                                start: 69,
                                                                                                                                end: 76,
                                                                                                                            },
                                                                                                                            name: "default",
                                                                                                                        },
                                                                                                                    ),
                                                                                                                    value: ArrowFunctionExpression(
                                                                                                                        ArrowFunctionExpression {
                                                                                                                            span: Span {
                                                                                                                                start: 0,
                                                                                                                                end: 0,
                                                                                                                            },
                                                                                                                            type_parameters: None,
                                                                                                                            params: FormalParameters {
                                                                                                                                span: Span {
                                                                                                                                    start: 77,
                                                                                                                                    end: 84,
                                                                                                                                },
                                                                                                                                items: Vec(
                                                                                                                                    [
                                                                                                                                        FormalParameter {
                                                                                                                                            span: Span {
                                                                                                                                                start: 78,
                                                                                                                                                end: 83,
                                                                                                                                            },
                                                                                                                                            decorators: Vec(
                                                                                                                                                [],
                                                                                                                                            ),
                                                                                                                                            pattern: ObjectPattern(
                                                                                                                                                ObjectPattern {
                                                                                                                                                    span: Span {
                                                                                                                                                        start: 78,
                                                                                                                                                        end: 83,
                                                                                                                                                    },
                                                                                                                                                    properties: Vec(
                                                                                                                                                        [
                                                                                                                                                            BindingProperty {
                                                                                                                                                                span: Span {
                                                                                                                                                                    start: 80,
                                                                                                                                                                    end: 81,
                                                                                                                                                                },
                                                                                                                                                                key: StaticIdentifier(
                                                                                                                                                                    IdentifierName {
                                                                                                                                                                        span: Span {
                                                                                                                                                                            start: 80,
                                                                                                                                                                            end: 81,
                                                                                                                                                                        },
                                                                                                                                                                        name: "a",
                                                                                                                                                                    },
                                                                                                                                                                ),
                                                                                                                                                                value: BindingIdentifier(
                                                                                                                                                                    BindingIdentifier {
                                                                                                                                                                        span: Span {
                                                                                                                                                                            start: 80,
                                                                                                                                                                            end: 81,
                                                                                                                                                                        },
                                                                                                                                                                        name: "a",
                                                                                                                                                                        symbol_id: Cell {
                                                                                                                                                                            value: None,
                                                                                                                                                                        },
                                                                                                                                                                    },
                                                                                                                                                                ),
                                                                                                                                                                shorthand: true,
                                                                                                                                                                computed: false,
                                                                                                                                                            },
                                                                                                                                                        ],
                                                                                                                                                    ),
                                                                                                                                                    rest: None,
                                                                                                                                                },
                                                                                                                                            ),
                                                                                                                                            type_annotation: None,
                                                                                                                                            initializer: None,
                                                                                                                                            optional: false,
                                                                                                                                            accessibility: None,
                                                                                                                                            readonly: false,
                                                                                                                                            override: false,
                                                                                                                                        },
                                                                                                                                    ],
                                                                                                                                ),
                                                                                                                                rest: None,
                                                                                                                                kind: ArrowFormalParameters,
                                                                                                                            },
                                                                                                                            return_type: None,
                                                                                                                            body: FunctionBody {
                                                                                                                                span: Span {
                                                                                                                                    start: 0,
                                                                                                                                    end: 0,
                                                                                                                                },
                                                                                                                                directives: Vec(
                                                                                                                                    [],
                                                                                                                                ),
                                                                                                                                statements: 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(
                                                                                                                                                            [],
                                                                                                                                                        ),
                                                                                                                                                        closing_fragment: JSXClosingFragment {
                                                                                                                                                            span: Span {
                                                                                                                                                                start: 0,
                                                                                                                                                                end: 0,
                                                                                                                                                            },
                                                                                                                                                        },
                                                                                                                                                    },
                                                                                                                                                ),
                                                                                                                                            },
                                                                                                                                        ),
                                                                                                                                    ],
                                                                                                                                ),
                                                                                                                            },
                                                                                                                            scope_id: Cell {
                                                                                                                                value: None,
                                                                                                                            },
                                                                                                                            expression: true,
                                                                                                                            async: false,
                                                                                                                            pure: false,
                                                                                                                            pife: false,
                                                                                                                        },
                                                                                                                    ),
                                                                                                                    kind: Init,
                                                                                                                    method: false,
                                                                                                                    shorthand: false,
                                                                                                                    computed: false,
                                                                                                                },
                                                                                                            ),
                                                                                                        ],
                                                                                                    ),
                                                                                                },
                                                                                            ),
                                                                                        },
                                                                                    ),
                                                                                ],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 87,
                                                                                end: 90,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 90,
                                                                                end: 114,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 90,
                                                                                    end: 114,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 91,
                                                                                            end: 96,
                                                                                        },
                                                                                        name: "input",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 97,
                                                                                                    end: 111,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 97,
                                                                                                            end: 104,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 97,
                                                                                                                end: 104,
                                                                                                            },
                                                                                                            name: "v-model",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 0,
                                                                                                                end: 0,
                                                                                                            },
                                                                                                            name: "",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 106,
                                                                                                                end: 110,
                                                                                                            },
                                                                                                            expression: Identifier(
                                                                                                                IdentifierReference {
                                                                                                                    span: Span {
                                                                                                                        start: 106,
                                                                                                                        end: 110,
                                                                                                                    },
                                                                                                                    name: "text",
                                                                                                                    reference_id: Cell {
                                                                                                                        value: None,
                                                                                                                    },
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 114,
                                                                                end: 117,
                                                                            },
                                                                            value: "\n  ",
                                                                            raw: Some(
                                                                                "\n  ",
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Element(
                                                                        JSXElement {
                                                                            span: Span {
                                                                                start: 117,
                                                                                end: 146,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 117,
                                                                                    end: 146,
                                                                                },
                                                                                name: IdentifierReference(
                                                                                    IdentifierReference {
                                                                                        span: Span {
                                                                                            start: 118,
                                                                                            end: 122,
                                                                                        },
                                                                                        name: "Some",
                                                                                        reference_id: Cell {
                                                                                            value: None,
                                                                                        },
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [
                                                                                        Attribute(
                                                                                            JSXAttribute {
                                                                                                span: Span {
                                                                                                    start: 123,
                                                                                                    end: 143,
                                                                                                },
                                                                                                name: NamespacedName(
                                                                                                    JSXNamespacedName {
                                                                                                        span: Span {
                                                                                                            start: 123,
                                                                                                            end: 139,
                                                                                                        },
                                                                                                        namespace: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 123,
                                                                                                                end: 129,
                                                                                                            },
                                                                                                            name: "v-bind",
                                                                                                        },
                                                                                                        name: JSXIdentifier {
                                                                                                            span: Span {
                                                                                                                start: 130,
                                                                                                                end: 139,
                                                                                                            },
                                                                                                            name: "some.none",
                                                                                                        },
                                                                                                    },
                                                                                                ),
                                                                                                value: Some(
                                                                                                    ExpressionContainer(
                                                                                                        JSXExpressionContainer {
                                                                                                            span: Span {
                                                                                                                start: 141,
                                                                                                                end: 142,
                                                                                                            },
                                                                                                            expression: NumericLiteral(
                                                                                                                NumericLiteral {
                                                                                                                    span: Span {
                                                                                                                        start: 141,
                                                                                                                        end: 142,
                                                                                                                    },
                                                                                                                    value: 1.0,
                                                                                                                    raw: Some(
                                                                                                                        "1",
                                                                                                                    ),
                                                                                                                    base: Decimal,
                                                                                                                },
                                                                                                            ),
                                                                                                        },
                                                                                                    ),
                                                                                                ),
                                                                                            },
                                                                                        ),
                                                                                    ],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: None,
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 146,
                                                                                end: 147,
                                                                            },
                                                                            value: "\n",
                                                                            raw: Some(
                                                                                "\n",
                                                                            ),
                                                                        },
                                                                    ),
                                                                ],
                                                            ),
                                                            closing_element: Some(
                                                                JSXClosingElement {
                                                                    span: Span {
                                                                        start: 147,
                                                                        end: 158,
                                                                    },
                                                                    name: Identifier(
                                                                        JSXIdentifier {
                                                                            span: Span {
                                                                                start: 149,
                                                                                end: 157,
                                                                            },
                                                                            name: "template",
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 158,
                                                                end: 159,
                                                            },
                                                            value: "\n",
                                                            raw: Some(
                                                                "\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: Module,
        variant: Jsx,
    },
}

===============  Error  ===============
[]

=============== Codegen ===============
{
	<><template>
  <div v-bind:class={"w-100"} />
  <div v-bind:[some]={{ [some]: 2 }} />
  <Some v-slot:default={} />{{ default: ({ a }) => <></> }}
  <input v-model:={text} />
  <Some v-bind:some.none={1} />
</template>
</>;
}


===============  Spans  ===============
Slice: "<template>\n  <div :class=\"'w-100'\" />\n  ..[OMIT]..ome v-bind:some.none=\"1\" />\n</template>\n"; 
Span: (0, 159); 
Type: Program; 

Slice: "<template>\n  <div :class=\"'w-100'\" />\n  ..[OMIT]..Some v-bind:some.none=\"1\" />\n</template>"; 
Span: (0, 158); 
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 :class=\"'w-100'\" />"; 
Span: (13, 37); 
Type: JSXElement; 

Slice: "<div :class=\"'w-100'\" />"; 
Span: (13, 37); 
Type: JSXOpeningElement; 

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

Slice: ":class=\"'w-100'\""; 
Span: (18, 34); 
Type: JSXAttribute; 

Slice: ":class"; 
Span: (18, 24); 
Type: JSXNamespacedName; 

Slice: ":"; 
Span: (18, 19); 
Type: JSXIdentifier; 

Slice: "class"; 
Span: (19, 24); 
Type: JSXIdentifier; 

Slice: "'w-100'"; 
Span: (26, 33); 
Type: JSXExpressionContainer; 

Slice: "'w-100'"; 
Span: (26, 33); 
Type: StringLiteral; 

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

Slice: "<div :[some]=\"2\" />"; 
Span: (40, 59); 
Type: JSXElement; 

Slice: "<div :[some]=\"2\" />"; 
Span: (40, 59); 
Type: JSXOpeningElement; 

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

Slice: ":[some]=\"2\""; 
Span: (45, 56); 
Type: JSXAttribute; 

Slice: ":[some]"; 
Span: (45, 52); 
Type: JSXNamespacedName; 

Slice: ":"; 
Span: (45, 46); 
Type: JSXIdentifier; 

Slice: "[some]"; 
Span: (46, 52); 
Type: JSXIdentifier; 

Slice: "2"; 
Span: (54, 55); 
Type: JSXExpressionContainer; 

Slice: "some"; 
Span: (47, 51); 
Type: IdentifierReference; 

Slice: "2"; 
Span: (54, 55); 
Type: NumericLiteral; 

Slice: "\n  "; 
Span: (59, 62); 
Type: JSXText; 

Slice: "<Some #default=\"{ a }\" />"; 
Span: (62, 87); 
Type: JSXElement; 

Slice: "<Some #default=\"{ a }\" />"; 
Span: (62, 87); 
Type: JSXOpeningElement; 

Slice: "Some"; 
Span: (63, 67); 
Type: IdentifierReference; 

Slice: "#default=\"{ a }\""; 
Span: (68, 84); 
Type: JSXAttribute; 

Slice: "#default"; 
Span: (68, 76); 
Type: JSXNamespacedName; 

Slice: "#"; 
Span: (68, 69); 
Type: JSXIdentifier; 

Slice: "default"; 
Span: (69, 76); 
Type: JSXIdentifier; 

Slice: "{ a }"; 
Span: (78, 83); 
Type: JSXExpressionContainer; 

Slice: "default"; 
Span: (69, 76); 
Type: IdentifierName; 

Slice: "\"{ a }\""; 
Span: (77, 84); 
Type: FormalParameters; 

Slice: "{ a }"; 
Span: (78, 83); 
Type: FormalParameter; 

Slice: "{ a }"; 
Span: (78, 83); 
Type: ObjectPattern; 

Slice: "a"; 
Span: (80, 81); 
Type: BindingProperty; 

Slice: "a"; 
Span: (80, 81); 
Type: IdentifierName; 

Slice: "a"; 
Span: (80, 81); 
Type: BindingIdentifier; 

Slice: "\n  "; 
Span: (87, 90); 
Type: JSXText; 

Slice: "<input v-model=\"text\" />"; 
Span: (90, 114); 
Type: JSXElement; 

Slice: "<input v-model=\"text\" />"; 
Span: (90, 114); 
Type: JSXOpeningElement; 

Slice: "input"; 
Span: (91, 96); 
Type: JSXIdentifier; 

Slice: "v-model=\"text\""; 
Span: (97, 111); 
Type: JSXAttribute; 

Slice: "v-model"; 
Span: (97, 104); 
Type: JSXNamespacedName; 

Slice: "v-model"; 
Span: (97, 104); 
Type: JSXIdentifier; 

Slice: "text"; 
Span: (106, 110); 
Type: JSXExpressionContainer; 

Slice: "text"; 
Span: (106, 110); 
Type: IdentifierReference; 

Slice: "\n  "; 
Span: (114, 117); 
Type: JSXText; 

Slice: "<Some v-bind:some.none=\"1\" />"; 
Span: (117, 146); 
Type: JSXElement; 

Slice: "<Some v-bind:some.none=\"1\" />"; 
Span: (117, 146); 
Type: JSXOpeningElement; 

Slice: "Some"; 
Span: (118, 122); 
Type: IdentifierReference; 

Slice: "v-bind:some.none=\"1\""; 
Span: (123, 143); 
Type: JSXAttribute; 

Slice: "v-bind:some.none"; 
Span: (123, 139); 
Type: JSXNamespacedName; 

Slice: "v-bind"; 
Span: (123, 129); 
Type: JSXIdentifier; 

Slice: "some.none"; 
Span: (130, 139); 
Type: JSXIdentifier; 

Slice: "1"; 
Span: (141, 142); 
Type: JSXExpressionContainer; 

Slice: "1"; 
Span: (141, 142); 
Type: NumericLiteral; 

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

Slice: "</template>"; 
Span: (147, 158); 
Type: JSXClosingElement; 

Slice: "template"; 
Span: (149, 157); 
Type: JSXIdentifier; 

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