vue_oxc_toolkit 0.6.0

---
source: crates/vue_oxc_toolkit/src/test.rs
expression: result
---
=============== Program ===============
Program {
    span: Span {
        start: 0,
        end: 120,
    },
    source_text: "<template>\n  <div>\n    \n  </div>\n</template>\n\n<script>\nexport default function () {\n  console.log(\"hello\")\n}\n</script>\n\n",
    comments: Vec(
        [],
    ),
    hashbang: None,
    directives: Vec(
        [],
    ),
    body: Vec(
        [
            ExportDefaultDeclaration(
                ExportDefaultDeclaration {
                    span: Span {
                        start: 55,
                        end: 108,
                    },
                    declaration: FunctionDeclaration(
                        Function {
                            span: Span {
                                start: 70,
                                end: 108,
                            },
                            id: None,
                            type_parameters: None,
                            this_param: None,
                            params: FormalParameters {
                                span: Span {
                                    start: 79,
                                    end: 81,
                                },
                                items: Vec(
                                    [],
                                ),
                                rest: None,
                                kind: FormalParameter,
                            },
                            return_type: None,
                            body: Some(
                                FunctionBody {
                                    span: Span {
                                        start: 82,
                                        end: 108,
                                    },
                                    directives: Vec(
                                        [],
                                    ),
                                    statements: Vec(
                                        [
                                            ExpressionStatement(
                                                ExpressionStatement {
                                                    span: Span {
                                                        start: 86,
                                                        end: 106,
                                                    },
                                                    expression: CallExpression(
                                                        CallExpression {
                                                            span: Span {
                                                                start: 86,
                                                                end: 106,
                                                            },
                                                            callee: StaticMemberExpression(
                                                                StaticMemberExpression {
                                                                    span: Span {
                                                                        start: 86,
                                                                        end: 97,
                                                                    },
                                                                    object: Identifier(
                                                                        IdentifierReference {
                                                                            span: Span {
                                                                                start: 86,
                                                                                end: 93,
                                                                            },
                                                                            name: "console",
                                                                            reference_id: Cell {
                                                                                value: None,
                                                                            },
                                                                        },
                                                                    ),
                                                                    property: IdentifierName {
                                                                        span: Span {
                                                                            start: 94,
                                                                            end: 97,
                                                                        },
                                                                        name: "log",
                                                                    },
                                                                    optional: false,
                                                                },
                                                            ),
                                                            type_arguments: None,
                                                            arguments: Vec(
                                                                [
                                                                    StringLiteral(
                                                                        StringLiteral {
                                                                            span: Span {
                                                                                start: 98,
                                                                                end: 105,
                                                                            },
                                                                            value: "hello",
                                                                            raw: Some(
                                                                                "\"hello\"",
                                                                            ),
                                                                            lone_surrogates: false,
                                                                        },
                                                                    ),
                                                                ],
                                                            ),
                                                            optional: false,
                                                            pure: false,
                                                        },
                                                    ),
                                                },
                                            ),
                                        ],
                                    ),
                                },
                            ),
                            scope_id: Cell {
                                value: None,
                            },
                            type: FunctionDeclaration,
                            generator: false,
                            async: false,
                            declare: false,
                            pure: false,
                            pife: false,
                        },
                    ),
                },
            ),
            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: 44,
                                                            },
                                                            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: 32,
                                                                            },
                                                                            opening_element: JSXOpeningElement {
                                                                                span: Span {
                                                                                    start: 13,
                                                                                    end: 18,
                                                                                },
                                                                                name: Identifier(
                                                                                    JSXIdentifier {
                                                                                        span: Span {
                                                                                            start: 14,
                                                                                            end: 17,
                                                                                        },
                                                                                        name: "div",
                                                                                    },
                                                                                ),
                                                                                type_arguments: None,
                                                                                attributes: Vec(
                                                                                    [],
                                                                                ),
                                                                            },
                                                                            children: Vec(
                                                                                [],
                                                                            ),
                                                                            closing_element: Some(
                                                                                JSXClosingElement {
                                                                                    span: Span {
                                                                                        start: 26,
                                                                                        end: 32,
                                                                                    },
                                                                                    name: Identifier(
                                                                                        JSXIdentifier {
                                                                                            span: Span {
                                                                                                start: 28,
                                                                                                end: 31,
                                                                                            },
                                                                                            name: "div",
                                                                                        },
                                                                                    ),
                                                                                },
                                                                            ),
                                                                        },
                                                                    ),
                                                                    Text(
                                                                        JSXText {
                                                                            span: Span {
                                                                                start: 32,
                                                                                end: 33,
                                                                            },
                                                                            value: "\n",
                                                                            raw: Some(
                                                                                "\n",
                                                                            ),
                                                                        },
                                                                    ),
                                                                ],
                                                            ),
                                                            closing_element: Some(
                                                                JSXClosingElement {
                                                                    span: Span {
                                                                        start: 33,
                                                                        end: 44,
                                                                    },
                                                                    name: Identifier(
                                                                        JSXIdentifier {
                                                                            span: Span {
                                                                                start: 35,
                                                                                end: 43,
                                                                            },
                                                                            name: "template",
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 44,
                                                                end: 46,
                                                            },
                                                            value: "\n\n",
                                                            raw: Some(
                                                                "\n\n",
                                                            ),
                                                        },
                                                    ),
                                                    Element(
                                                        JSXElement {
                                                            span: Span {
                                                                start: 46,
                                                                end: 118,
                                                            },
                                                            opening_element: JSXOpeningElement {
                                                                span: Span {
                                                                    start: 46,
                                                                    end: 54,
                                                                },
                                                                name: Identifier(
                                                                    JSXIdentifier {
                                                                        span: Span {
                                                                            start: 47,
                                                                            end: 53,
                                                                        },
                                                                        name: "script",
                                                                    },
                                                                ),
                                                                type_arguments: None,
                                                                attributes: Vec(
                                                                    [],
                                                                ),
                                                            },
                                                            children: Vec(
                                                                [],
                                                            ),
                                                            closing_element: Some(
                                                                JSXClosingElement {
                                                                    span: Span {
                                                                        start: 109,
                                                                        end: 118,
                                                                    },
                                                                    name: Identifier(
                                                                        JSXIdentifier {
                                                                            span: Span {
                                                                                start: 111,
                                                                                end: 117,
                                                                            },
                                                                            name: "script",
                                                                        },
                                                                    ),
                                                                },
                                                            ),
                                                        },
                                                    ),
                                                    Text(
                                                        JSXText {
                                                            span: Span {
                                                                start: 118,
                                                                end: 120,
                                                            },
                                                            value: "\n\n",
                                                            raw: Some(
                                                                "\n\n",
                                                            ),
                                                        },
                                                    ),
                                                ],
                                            ),
                                            closing_fragment: JSXClosingFragment {
                                                span: Span {
                                                    start: 0,
                                                    end: 0,
                                                },
                                            },
                                        },
                                    ),
                                },
                            ),
                        ],
                    ),
                    scope_id: Cell {
                        value: None,
                    },
                },
            ),
        ],
    ),
    scope_id: Cell {
        value: None,
    },
    source_type: SourceType {
        language: JavaScript,
        module_kind: Module,
        variant: Jsx,
    },
}

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

=============== Codegen ===============
export default function() {
	console.log("hello");
}
{
	<><template>
  <div></div>
</template>

<script></script>

</>;
}


===============  Spans  ===============
Slice: "<template>\n  <div>\n    \n  </div>\n</templ..[OMIT]..) {\n  console.log(\"hello\")\n}\n</script>\n\n"; 
Span: (0, 120); 
Type: Program; 

Slice: "export default function () {\n  console.log(\"hello\")\n}"; 
Span: (55, 108); 
Type: ExportDefaultDeclaration; 

Slice: "function () {\n  console.log(\"hello\")\n}"; 
Span: (70, 108); 
Type: Function; 

Slice: "()"; 
Span: (79, 81); 
Type: FormalParameters; 

Slice: "{\n  console.log(\"hello\")\n}"; 
Span: (82, 108); 
Type: FunctionBody; 

Slice: "console.log(\"hello\")"; 
Span: (86, 106); 
Type: ExpressionStatement; 

Slice: "console.log(\"hello\")"; 
Span: (86, 106); 
Type: CallExpression; 

Slice: "console.log"; 
Span: (86, 97); 
Type: StaticMemberExpression; 

Slice: "console"; 
Span: (86, 93); 
Type: IdentifierReference; 

Slice: "log"; 
Span: (94, 97); 
Type: IdentifierName; 

Slice: "\"hello\""; 
Span: (98, 105); 
Type: StringLiteral; 

Slice: "<template>\n  <div>\n    \n  </div>\n</template>"; 
Span: (0, 44); 
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>\n    \n  </div>"; 
Span: (13, 32); 
Type: JSXElement; 

Slice: "<div>"; 
Span: (13, 18); 
Type: JSXOpeningElement; 

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

Slice: "</div>"; 
Span: (26, 32); 
Type: JSXClosingElement; 

Slice: "div"; 
Span: (28, 31); 
Type: JSXIdentifier; 

Slice: "\n"; 
Span: (32, 33); 
Type: JSXText; 

Slice: "</template>"; 
Span: (33, 44); 
Type: JSXClosingElement; 

Slice: "template"; 
Span: (35, 43); 
Type: JSXIdentifier; 

Slice: "\n\n"; 
Span: (44, 46); 
Type: JSXText; 

Slice: "<script>\nexport default function () {\n  console.log(\"hello\")\n}\n</script>"; 
Span: (46, 118); 
Type: JSXElement; 

Slice: "<script>"; 
Span: (46, 54); 
Type: JSXOpeningElement; 

Slice: "script"; 
Span: (47, 53); 
Type: JSXIdentifier; 

Slice: "</script>"; 
Span: (109, 118); 
Type: JSXClosingElement; 

Slice: "script"; 
Span: (111, 117); 
Type: JSXIdentifier; 

Slice: "\n\n"; 
Span: (118, 120); 
Type: JSXText;