[
    FullOpeningTag(
        FullOpeningTagStatement {
            span: Span {
                line: 1,
                column: 1,
                position: 0,
            },
        },
    ),
    Namespace(
        Braced(
            BracedNamespace {
                namespace: Span {
                    line: 3,
                    column: 1,
                    position: 7,
                },
                name: None,
                body: BracedNamespaceBody {
                    start: Span {
                        line: 3,
                        column: 11,
                        position: 17,
                    },
                    end: Span {
                        line: 5,
                        column: 1,
                        position: 48,
                    },
                    statements: [
                        Function(
                            FunctionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                function: Span {
                                    line: 4,
                                    column: 5,
                                    position: 23,
                                },
                                ampersand: None,
                                name: SimpleIdentifier {
                                    span: Span {
                                        line: 4,
                                        column: 14,
                                        position: 32,
                                    },
                                    value: "globalFunc",
                                },
                                parameters: FunctionParameterList {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 4,
                                        column: 24,
                                        position: 42,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    right_parenthesis: Span {
                                        line: 4,
                                        column: 25,
                                        position: 43,
                                    },
                                },
                                return_type: None,
                                body: FunctionBody {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 4,
                                        column: 27,
                                        position: 45,
                                    },
                                    statements: [],
                                    right_brace: Span {
                                        line: 4,
                                        column: 28,
                                        position: 46,
                                    },
                                },
                            },
                        ),
                    ],
                },
            },
        ),
    ),
    Namespace(
        Braced(
            BracedNamespace {
                namespace: Span {
                    line: 7,
                    column: 1,
                    position: 51,
                },
                name: Some(
                    SimpleIdentifier {
                        span: Span {
                            line: 7,
                            column: 11,
                            position: 61,
                        },
                        value: "foo",
                    },
                ),
                body: BracedNamespaceBody {
                    start: Span {
                        line: 7,
                        column: 15,
                        position: 65,
                    },
                    end: Span {
                        line: 16,
                        column: 1,
                        position: 289,
                    },
                    statements: [
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 8,
                                                        column: 5,
                                                        position: 71,
                                                    },
                                                    name: "$a",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 8,
                                            column: 8,
                                            position: 74,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: None,
                                                function: Span {
                                                    line: 8,
                                                    column: 10,
                                                    position: 76,
                                                },
                                                ampersand: None,
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 8,
                                                        column: 19,
                                                        position: 85,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 8,
                                                        column: 20,
                                                        position: 86,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 8,
                                                        column: 22,
                                                        position: 88,
                                                    },
                                                    statements: [],
                                                    right_brace: Span {
                                                        line: 8,
                                                        column: 23,
                                                        position: 89,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 8,
                                        column: 24,
                                        position: 90,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 9,
                                                        column: 5,
                                                        position: 96,
                                                    },
                                                    name: "$b",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 9,
                                            column: 8,
                                            position: 99,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: None,
                                                function: Span {
                                                    line: 9,
                                                    column: 10,
                                                    position: 101,
                                                },
                                                ampersand: None,
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 9,
                                                        column: 19,
                                                        position: 110,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 9,
                                                                        column: 21,
                                                                        position: 112,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 9,
                                                                        column: 21,
                                                                        position: 112,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 9,
                                                        column: 23,
                                                        position: 114,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 9,
                                                        column: 25,
                                                        position: 116,
                                                    },
                                                    statements: [],
                                                    right_brace: Span {
                                                        line: 9,
                                                        column: 26,
                                                        position: 117,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 9,
                                        column: 27,
                                        position: 118,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 10,
                                                        column: 5,
                                                        position: 124,
                                                    },
                                                    name: "$c",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 10,
                                            column: 8,
                                            position: 127,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: None,
                                                function: Span {
                                                    line: 10,
                                                    column: 10,
                                                    position: 129,
                                                },
                                                ampersand: Some(
                                                    Span {
                                                        line: 10,
                                                        column: 19,
                                                        position: 138,
                                                    },
                                                ),
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 10,
                                                        column: 20,
                                                        position: 139,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 10,
                                                        column: 21,
                                                        position: 140,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 10,
                                                        column: 23,
                                                        position: 142,
                                                    },
                                                    statements: [],
                                                    right_brace: Span {
                                                        line: 10,
                                                        column: 24,
                                                        position: 143,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 10,
                                        column: 25,
                                        position: 144,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 11,
                                                        column: 5,
                                                        position: 150,
                                                    },
                                                    name: "$d",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 11,
                                            column: 8,
                                            position: 153,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: None,
                                                function: Span {
                                                    line: 11,
                                                    column: 10,
                                                    position: 155,
                                                },
                                                ampersand: Some(
                                                    Span {
                                                        line: 11,
                                                        column: 19,
                                                        position: 164,
                                                    },
                                                ),
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 11,
                                                        column: 20,
                                                        position: 165,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 11,
                                                                        column: 22,
                                                                        position: 167,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 11,
                                                                        column: 22,
                                                                        position: 167,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 11,
                                                        column: 24,
                                                        position: 169,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 11,
                                                        column: 26,
                                                        position: 171,
                                                    },
                                                    statements: [
                                                        Return(
                                                            ReturnStatement {
                                                                return: Span {
                                                                    line: 11,
                                                                    column: 28,
                                                                    position: 173,
                                                                },
                                                                value: Some(
                                                                    Variable(
                                                                        SimpleVariable(
                                                                            SimpleVariable {
                                                                                span: Span {
                                                                                    line: 11,
                                                                                    column: 35,
                                                                                    position: 180,
                                                                                },
                                                                                name: "$b",
                                                                            },
                                                                        ),
                                                                    ),
                                                                ),
                                                                ending: Semicolon(
                                                                    Span {
                                                                        line: 11,
                                                                        column: 37,
                                                                        position: 182,
                                                                    },
                                                                ),
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: Span {
                                                        line: 11,
                                                        column: 39,
                                                        position: 184,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 11,
                                        column: 40,
                                        position: 185,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 12,
                                                        column: 5,
                                                        position: 191,
                                                    },
                                                    name: "$e",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 12,
                                            column: 8,
                                            position: 194,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: None,
                                                ampersand: None,
                                                fn: Span {
                                                    line: 12,
                                                    column: 10,
                                                    position: 196,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 12,
                                                        column: 13,
                                                        position: 199,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 12,
                                                        column: 14,
                                                        position: 200,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 12,
                                                    column: 16,
                                                    position: 202,
                                                },
                                                body: Null,
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 12,
                                        column: 23,
                                        position: 209,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 13,
                                                        column: 5,
                                                        position: 215,
                                                    },
                                                    name: "$f",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 13,
                                            column: 8,
                                            position: 218,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: None,
                                                ampersand: None,
                                                fn: Span {
                                                    line: 13,
                                                    column: 10,
                                                    position: 220,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 13,
                                                        column: 13,
                                                        position: 223,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 13,
                                                                        column: 15,
                                                                        position: 225,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 13,
                                                                        column: 15,
                                                                        position: 225,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 13,
                                                        column: 17,
                                                        position: 227,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 13,
                                                    column: 19,
                                                    position: 229,
                                                },
                                                body: Null,
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 13,
                                        column: 26,
                                        position: 236,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 14,
                                                        column: 5,
                                                        position: 242,
                                                    },
                                                    name: "$g",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 14,
                                            column: 8,
                                            position: 245,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: None,
                                                ampersand: Some(
                                                    Span {
                                                        line: 14,
                                                        column: 13,
                                                        position: 250,
                                                    },
                                                ),
                                                fn: Span {
                                                    line: 14,
                                                    column: 10,
                                                    position: 247,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 14,
                                                        column: 14,
                                                        position: 251,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 14,
                                                        column: 15,
                                                        position: 252,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 14,
                                                    column: 17,
                                                    position: 254,
                                                },
                                                body: Null,
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 14,
                                        column: 24,
                                        position: 261,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 15,
                                                        column: 5,
                                                        position: 267,
                                                    },
                                                    name: "$h",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 15,
                                            column: 8,
                                            position: 270,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: None,
                                                ampersand: Some(
                                                    Span {
                                                        line: 15,
                                                        column: 13,
                                                        position: 275,
                                                    },
                                                ),
                                                fn: Span {
                                                    line: 15,
                                                    column: 10,
                                                    position: 272,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 15,
                                                        column: 14,
                                                        position: 276,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 15,
                                                                        column: 16,
                                                                        position: 278,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 15,
                                                                        column: 16,
                                                                        position: 278,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 15,
                                                        column: 18,
                                                        position: 280,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 15,
                                                    column: 20,
                                                    position: 282,
                                                },
                                                body: Variable(
                                                    SimpleVariable(
                                                        SimpleVariable {
                                                            span: Span {
                                                                line: 15,
                                                                column: 23,
                                                                position: 285,
                                                            },
                                                            name: "$b",
                                                        },
                                                    ),
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 15,
                                        column: 25,
                                        position: 287,
                                    },
                                ),
                            },
                        ),
                    ],
                },
            },
        ),
    ),
    Namespace(
        Braced(
            BracedNamespace {
                namespace: Span {
                    line: 18,
                    column: 1,
                    position: 292,
                },
                name: Some(
                    SimpleIdentifier {
                        span: Span {
                            line: 18,
                            column: 11,
                            position: 302,
                        },
                        value: "bar",
                    },
                ),
                body: BracedNamespaceBody {
                    start: Span {
                        line: 18,
                        column: 15,
                        position: 306,
                    },
                    end: Span {
                        line: 27,
                        column: 1,
                        position: 586,
                    },
                    statements: [
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 19,
                                                        column: 5,
                                                        position: 312,
                                                    },
                                                    name: "$a",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 19,
                                            column: 8,
                                            position: 315,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: Some(
                                                    Span {
                                                        line: 19,
                                                        column: 10,
                                                        position: 317,
                                                    },
                                                ),
                                                function: Span {
                                                    line: 19,
                                                    column: 17,
                                                    position: 324,
                                                },
                                                ampersand: None,
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 19,
                                                        column: 26,
                                                        position: 333,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 19,
                                                        column: 27,
                                                        position: 334,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 19,
                                                        column: 29,
                                                        position: 336,
                                                    },
                                                    statements: [],
                                                    right_brace: Span {
                                                        line: 19,
                                                        column: 30,
                                                        position: 337,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 19,
                                        column: 31,
                                        position: 338,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 20,
                                                        column: 5,
                                                        position: 344,
                                                    },
                                                    name: "$b",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 20,
                                            column: 8,
                                            position: 347,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: Some(
                                                    Span {
                                                        line: 20,
                                                        column: 10,
                                                        position: 349,
                                                    },
                                                ),
                                                function: Span {
                                                    line: 20,
                                                    column: 17,
                                                    position: 356,
                                                },
                                                ampersand: None,
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 20,
                                                        column: 26,
                                                        position: 365,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 20,
                                                                        column: 28,
                                                                        position: 367,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 20,
                                                                        column: 28,
                                                                        position: 367,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 20,
                                                        column: 30,
                                                        position: 369,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 20,
                                                        column: 32,
                                                        position: 371,
                                                    },
                                                    statements: [],
                                                    right_brace: Span {
                                                        line: 20,
                                                        column: 33,
                                                        position: 372,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 20,
                                        column: 34,
                                        position: 373,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 21,
                                                        column: 5,
                                                        position: 379,
                                                    },
                                                    name: "$c",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 21,
                                            column: 8,
                                            position: 382,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: Some(
                                                    Span {
                                                        line: 21,
                                                        column: 10,
                                                        position: 384,
                                                    },
                                                ),
                                                function: Span {
                                                    line: 21,
                                                    column: 17,
                                                    position: 391,
                                                },
                                                ampersand: Some(
                                                    Span {
                                                        line: 21,
                                                        column: 26,
                                                        position: 400,
                                                    },
                                                ),
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 21,
                                                        column: 27,
                                                        position: 401,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 21,
                                                        column: 28,
                                                        position: 402,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 21,
                                                        column: 30,
                                                        position: 404,
                                                    },
                                                    statements: [],
                                                    right_brace: Span {
                                                        line: 21,
                                                        column: 31,
                                                        position: 405,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 21,
                                        column: 32,
                                        position: 406,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 22,
                                                        column: 5,
                                                        position: 412,
                                                    },
                                                    name: "$d",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 22,
                                            column: 8,
                                            position: 415,
                                        },
                                        right: Closure(
                                            ClosureExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                attributes: [],
                                                static: Some(
                                                    Span {
                                                        line: 22,
                                                        column: 10,
                                                        position: 417,
                                                    },
                                                ),
                                                function: Span {
                                                    line: 22,
                                                    column: 17,
                                                    position: 424,
                                                },
                                                ampersand: Some(
                                                    Span {
                                                        line: 22,
                                                        column: 26,
                                                        position: 433,
                                                    },
                                                ),
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 22,
                                                        column: 27,
                                                        position: 434,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 22,
                                                                        column: 29,
                                                                        position: 436,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 22,
                                                                        column: 29,
                                                                        position: 436,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 22,
                                                        column: 31,
                                                        position: 438,
                                                    },
                                                },
                                                uses: None,
                                                return_type: None,
                                                body: FunctionBody {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: Span {
                                                        line: 22,
                                                        column: 33,
                                                        position: 440,
                                                    },
                                                    statements: [
                                                        Return(
                                                            ReturnStatement {
                                                                return: Span {
                                                                    line: 22,
                                                                    column: 35,
                                                                    position: 442,
                                                                },
                                                                value: Some(
                                                                    Variable(
                                                                        SimpleVariable(
                                                                            SimpleVariable {
                                                                                span: Span {
                                                                                    line: 22,
                                                                                    column: 42,
                                                                                    position: 449,
                                                                                },
                                                                                name: "$b",
                                                                            },
                                                                        ),
                                                                    ),
                                                                ),
                                                                ending: Semicolon(
                                                                    Span {
                                                                        line: 22,
                                                                        column: 44,
                                                                        position: 451,
                                                                    },
                                                                ),
                                                            },
                                                        ),
                                                    ],
                                                    right_brace: Span {
                                                        line: 22,
                                                        column: 46,
                                                        position: 453,
                                                    },
                                                },
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 22,
                                        column: 47,
                                        position: 454,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 23,
                                                        column: 5,
                                                        position: 460,
                                                    },
                                                    name: "$e",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 23,
                                            column: 8,
                                            position: 463,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: Some(
                                                    Span {
                                                        line: 23,
                                                        column: 10,
                                                        position: 465,
                                                    },
                                                ),
                                                ampersand: None,
                                                fn: Span {
                                                    line: 23,
                                                    column: 17,
                                                    position: 472,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 23,
                                                        column: 20,
                                                        position: 475,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 23,
                                                        column: 21,
                                                        position: 476,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 23,
                                                    column: 23,
                                                    position: 478,
                                                },
                                                body: Null,
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 23,
                                        column: 30,
                                        position: 485,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 24,
                                                        column: 5,
                                                        position: 491,
                                                    },
                                                    name: "$f",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 24,
                                            column: 8,
                                            position: 494,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: Some(
                                                    Span {
                                                        line: 24,
                                                        column: 10,
                                                        position: 496,
                                                    },
                                                ),
                                                ampersand: None,
                                                fn: Span {
                                                    line: 24,
                                                    column: 17,
                                                    position: 503,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 24,
                                                        column: 20,
                                                        position: 506,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 24,
                                                                        column: 22,
                                                                        position: 508,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 24,
                                                                        column: 22,
                                                                        position: 508,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 24,
                                                        column: 24,
                                                        position: 510,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 24,
                                                    column: 26,
                                                    position: 512,
                                                },
                                                body: Null,
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 24,
                                        column: 33,
                                        position: 519,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 25,
                                                        column: 5,
                                                        position: 525,
                                                    },
                                                    name: "$g",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 25,
                                            column: 8,
                                            position: 528,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: Some(
                                                    Span {
                                                        line: 25,
                                                        column: 10,
                                                        position: 530,
                                                    },
                                                ),
                                                ampersand: Some(
                                                    Span {
                                                        line: 25,
                                                        column: 20,
                                                        position: 540,
                                                    },
                                                ),
                                                fn: Span {
                                                    line: 25,
                                                    column: 17,
                                                    position: 537,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 25,
                                                        column: 21,
                                                        position: 541,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 25,
                                                        column: 22,
                                                        position: 542,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 25,
                                                    column: 24,
                                                    position: 544,
                                                },
                                                body: Null,
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 25,
                                        column: 31,
                                        position: 551,
                                    },
                                ),
                            },
                        ),
                        Expression(
                            ExpressionStatement {
                                expression: AssignmentOperation(
                                    Assign {
                                        left: Variable(
                                            SimpleVariable(
                                                SimpleVariable {
                                                    span: Span {
                                                        line: 26,
                                                        column: 5,
                                                        position: 557,
                                                    },
                                                    name: "$h",
                                                },
                                            ),
                                        ),
                                        equals: Span {
                                            line: 26,
                                            column: 8,
                                            position: 560,
                                        },
                                        right: ArrowFunction(
                                            ArrowFunctionExpression {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                static: Some(
                                                    Span {
                                                        line: 26,
                                                        column: 10,
                                                        position: 562,
                                                    },
                                                ),
                                                ampersand: Some(
                                                    Span {
                                                        line: 26,
                                                        column: 20,
                                                        position: 572,
                                                    },
                                                ),
                                                fn: Span {
                                                    line: 26,
                                                    column: 17,
                                                    position: 569,
                                                },
                                                attributes: [],
                                                parameters: FunctionParameterList {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_parenthesis: Span {
                                                        line: 26,
                                                        column: 21,
                                                        position: 573,
                                                    },
                                                    parameters: CommaSeparated {
                                                        inner: [
                                                            FunctionParameter {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                name: SimpleVariable {
                                                                    span: Span {
                                                                        line: 26,
                                                                        column: 23,
                                                                        position: 575,
                                                                    },
                                                                    name: "$b",
                                                                },
                                                                attributes: [],
                                                                data_type: None,
                                                                ellipsis: None,
                                                                default: None,
                                                                ampersand: Some(
                                                                    Span {
                                                                        line: 26,
                                                                        column: 23,
                                                                        position: 575,
                                                                    },
                                                                ),
                                                            },
                                                        ],
                                                        commas: [],
                                                    },
                                                    right_parenthesis: Span {
                                                        line: 26,
                                                        column: 25,
                                                        position: 577,
                                                    },
                                                },
                                                return_type: None,
                                                double_arrow: Span {
                                                    line: 26,
                                                    column: 27,
                                                    position: 579,
                                                },
                                                body: Variable(
                                                    SimpleVariable(
                                                        SimpleVariable {
                                                            span: Span {
                                                                line: 26,
                                                                column: 30,
                                                                position: 582,
                                                            },
                                                            name: "$b",
                                                        },
                                                    ),
                                                ),
                                            },
                                        ),
                                    },
                                ),
                                ending: Semicolon(
                                    Span {
                                        line: 26,
                                        column: 32,
                                        position: 584,
                                    },
                                ),
                            },
                        ),
                    ],
                },
            },
        ),
    ),
    Namespace(
        Braced(
            BracedNamespace {
                namespace: Span {
                    line: 29,
                    column: 1,
                    position: 589,
                },
                name: Some(
                    SimpleIdentifier {
                        span: Span {
                            line: 29,
                            column: 11,
                            position: 599,
                        },
                        value: "baz",
                    },
                ),
                body: BracedNamespaceBody {
                    start: Span {
                        line: 29,
                        column: 15,
                        position: 603,
                    },
                    end: Span {
                        line: 33,
                        column: 1,
                        position: 696,
                    },
                    statements: [
                        Function(
                            FunctionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                function: Span {
                                    line: 30,
                                    column: 5,
                                    position: 609,
                                },
                                ampersand: None,
                                name: SimpleIdentifier {
                                    span: Span {
                                        line: 30,
                                        column: 14,
                                        position: 618,
                                    },
                                    value: "a",
                                },
                                parameters: FunctionParameterList {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 30,
                                        column: 15,
                                        position: 619,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [
                                            FunctionParameter {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                name: SimpleVariable {
                                                    span: Span {
                                                        line: 30,
                                                        column: 17,
                                                        position: 621,
                                                    },
                                                    name: "$b",
                                                },
                                                attributes: [],
                                                data_type: None,
                                                ellipsis: None,
                                                default: None,
                                                ampersand: Some(
                                                    Span {
                                                        line: 30,
                                                        column: 17,
                                                        position: 621,
                                                    },
                                                ),
                                            },
                                        ],
                                        commas: [],
                                    },
                                    right_parenthesis: Span {
                                        line: 30,
                                        column: 19,
                                        position: 623,
                                    },
                                },
                                return_type: None,
                                body: FunctionBody {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 30,
                                        column: 21,
                                        position: 625,
                                    },
                                    statements: [],
                                    right_brace: Span {
                                        line: 30,
                                        column: 22,
                                        position: 626,
                                    },
                                },
                            },
                        ),
                        Function(
                            FunctionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                function: Span {
                                    line: 31,
                                    column: 5,
                                    position: 632,
                                },
                                ampersand: Some(
                                    Span {
                                        line: 31,
                                        column: 14,
                                        position: 641,
                                    },
                                ),
                                name: SimpleIdentifier {
                                    span: Span {
                                        line: 31,
                                        column: 15,
                                        position: 642,
                                    },
                                    value: "b",
                                },
                                parameters: FunctionParameterList {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 31,
                                        column: 16,
                                        position: 643,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [
                                            FunctionParameter {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                name: SimpleVariable {
                                                    span: Span {
                                                        line: 31,
                                                        column: 17,
                                                        position: 644,
                                                    },
                                                    name: "$b",
                                                },
                                                attributes: [],
                                                data_type: None,
                                                ellipsis: None,
                                                default: None,
                                                ampersand: None,
                                            },
                                        ],
                                        commas: [],
                                    },
                                    right_parenthesis: Span {
                                        line: 31,
                                        column: 19,
                                        position: 646,
                                    },
                                },
                                return_type: None,
                                body: FunctionBody {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 31,
                                        column: 21,
                                        position: 648,
                                    },
                                    statements: [
                                        Return(
                                            ReturnStatement {
                                                return: Span {
                                                    line: 31,
                                                    column: 23,
                                                    position: 650,
                                                },
                                                value: Some(
                                                    Variable(
                                                        SimpleVariable(
                                                            SimpleVariable {
                                                                span: Span {
                                                                    line: 31,
                                                                    column: 30,
                                                                    position: 657,
                                                                },
                                                                name: "$b",
                                                            },
                                                        ),
                                                    ),
                                                ),
                                                ending: Semicolon(
                                                    Span {
                                                        line: 31,
                                                        column: 32,
                                                        position: 659,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    right_brace: Span {
                                        line: 31,
                                        column: 34,
                                        position: 661,
                                    },
                                },
                            },
                        ),
                        Function(
                            FunctionStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                attributes: [],
                                function: Span {
                                    line: 32,
                                    column: 5,
                                    position: 667,
                                },
                                ampersand: Some(
                                    Span {
                                        line: 32,
                                        column: 14,
                                        position: 676,
                                    },
                                ),
                                name: SimpleIdentifier {
                                    span: Span {
                                        line: 32,
                                        column: 15,
                                        position: 677,
                                    },
                                    value: "c",
                                },
                                parameters: FunctionParameterList {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_parenthesis: Span {
                                        line: 32,
                                        column: 16,
                                        position: 678,
                                    },
                                    parameters: CommaSeparated {
                                        inner: [],
                                        commas: [],
                                    },
                                    right_parenthesis: Span {
                                        line: 32,
                                        column: 17,
                                        position: 679,
                                    },
                                },
                                return_type: None,
                                body: FunctionBody {
                                    comments: CommentGroup {
                                        comments: [],
                                    },
                                    left_brace: Span {
                                        line: 32,
                                        column: 19,
                                        position: 681,
                                    },
                                    statements: [
                                        Return(
                                            ReturnStatement {
                                                return: Span {
                                                    line: 32,
                                                    column: 21,
                                                    position: 683,
                                                },
                                                value: Some(
                                                    Variable(
                                                        SimpleVariable(
                                                            SimpleVariable {
                                                                span: Span {
                                                                    line: 32,
                                                                    column: 28,
                                                                    position: 690,
                                                                },
                                                                name: "$b",
                                                            },
                                                        ),
                                                    ),
                                                ),
                                                ending: Semicolon(
                                                    Span {
                                                        line: 32,
                                                        column: 30,
                                                        position: 692,
                                                    },
                                                ),
                                            },
                                        ),
                                    ],
                                    right_brace: Span {
                                        line: 32,
                                        column: 32,
                                        position: 694,
                                    },
                                },
                            },
                        ),
                    ],
                },
            },
        ),
    ),
]
