DefinitionTree {
    definitions: [
        Namespace(
            NamespaceDefinition {
                namespace: Keyword {
                    value: "namespace",
                    position: 0,
                },
                name: Identifier {
                    position: 10,
                    value: "where",
                },
                semicolon: 15,
                definitions: [
                    Constant(
                        ConstantDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            const: Keyword {
                                value: "const",
                                position: 18,
                            },
                            type_definition: UnsignedInteger(
                                U8(
                                    Keyword {
                                        value: "u8",
                                        position: 24,
                                    },
                                ),
                            ),
                            name: Identifier {
                                position: 27,
                                value: "where",
                            },
                            equals: 33,
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        value: "1",
                                        position: 35,
                                    },
                                ),
                            ),
                            semicolon: 36,
                        },
                    ),
                    Interface(
                        InterfaceDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            interface: Keyword {
                                value: "interface",
                                position: 38,
                            },
                            name: Identifier {
                                position: 48,
                                value: "where",
                            },
                            templates: None,
                            extends: None,
                            body: InterfaceDefinitionBody {
                                left_brace: 54,
                                members: [],
                                right_brace: 55,
                            },
                        },
                    ),
                    Class(
                        ClassDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ModifierGroupDefinition {
                                position: 57,
                                modifiers: [],
                            },
                            class: Keyword {
                                value: "class",
                                position: 57,
                            },
                            name: Identifier {
                                position: 63,
                                value: "where",
                            },
                            templates: None,
                            extends: None,
                            implements: None,
                            body: ClassDefinitionBody {
                                left_brace: 69,
                                members: [
                                    Constant(
                                        ClassishConstantDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: ModifierGroupDefinition {
                                                position: 82,
                                                modifiers: [
                                                    Public(
                                                        Keyword {
                                                            value: "public",
                                                            position: 75,
                                                        },
                                                    ),
                                                ],
                                            },
                                            const: Keyword {
                                                value: "const",
                                                position: 82,
                                            },
                                            type_definition: UnsignedInteger(
                                                U8(
                                                    Keyword {
                                                        value: "u8",
                                                        position: 88,
                                                    },
                                                ),
                                            ),
                                            name: Identifier {
                                                position: 91,
                                                value: "where",
                                            },
                                            equals: 97,
                                            value: Literal(
                                                Integer(
                                                    LiteralInteger {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        value: "1",
                                                        position: 99,
                                                    },
                                                ),
                                            ),
                                            semicolon: 100,
                                        },
                                    ),
                                    Method(
                                        MethodDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: ModifierGroupDefinition {
                                                position: 114,
                                                modifiers: [
                                                    Public(
                                                        Keyword {
                                                            value: "public",
                                                            position: 107,
                                                        },
                                                    ),
                                                ],
                                            },
                                            function: Keyword {
                                                value: "function",
                                                position: 114,
                                            },
                                            name: Identifier {
                                                position: 123,
                                                value: "where",
                                            },
                                            templates: None,
                                            parameters: MethodParameterListDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_parenthesis: 128,
                                                parameters: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_parenthesis: 129,
                                            },
                                            return_type: Some(
                                                FunctionLikeReturnTypeDefinition {
                                                    colon: 130,
                                                    type_definition: Void(
                                                        Keyword {
                                                            value: "void",
                                                            position: 132,
                                                        },
                                                    ),
                                                },
                                            ),
                                            constraints: None,
                                            body: Concrete(
                                                BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 137,
                                                    statements: [],
                                                    right_brace: 138,
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 140,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: Keyword {
                                value: "function",
                                position: 143,
                            },
                            name: Identifier {
                                position: 152,
                                value: "where",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 157,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 158,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 159,
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 161,
                                            value: "where",
                                        },
                                        templates: None,
                                    },
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 167,
                                statements: [
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 173,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 180,
                                                    right: Identifier(
                                                        Identifier {
                                                            position: 182,
                                                            value: "where",
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 187,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 193,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 200,
                                                    right: ClassOperation(
                                                        Initialization {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            new: Keyword {
                                                                value: "new",
                                                                position: 202,
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 206,
                                                                    value: "where",
                                                                },
                                                            ),
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 211,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 212,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 213,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 219,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 226,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 228,
                                                                    value: "where",
                                                                },
                                                            ),
                                                            double_colon: 233,
                                                            constant: Identifier {
                                                                position: 235,
                                                                value: "where",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 240,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 246,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 253,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 255,
                                                                    value: "where",
                                                                },
                                                            ),
                                                            double_colon: 260,
                                                            method: Identifier {
                                                                position: 262,
                                                                value: "where",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 267,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 268,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 269,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 275,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 282,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 284,
                                                                            value: "where",
                                                                        },
                                                                    ),
                                                                    double_colon: 289,
                                                                    constant: Identifier {
                                                                        position: 291,
                                                                        value: "where",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 296,
                                                            constant: Identifier {
                                                                position: 298,
                                                                value: "where",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 303,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 309,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 316,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 318,
                                                                            value: "where",
                                                                        },
                                                                    ),
                                                                    double_colon: 323,
                                                                    constant: Identifier {
                                                                        position: 325,
                                                                        value: "where",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 330,
                                                            method: Identifier {
                                                                position: 332,
                                                                value: "where",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 337,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 338,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 339,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 345,
                                                            name: "$where",
                                                        },
                                                    ),
                                                    equals: 352,
                                                    right: ObjectOperation(
                                                        MethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            object: Variable(
                                                                Variable {
                                                                    position: 354,
                                                                    name: "$where",
                                                                },
                                                            ),
                                                            arrow: 360,
                                                            method: Identifier {
                                                                position: 362,
                                                                value: "where",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 367,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 368,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 369,
                                        },
                                    ),
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Variable(
                                                Variable {
                                                    position: 376,
                                                    name: "$where",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 383,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: Keyword {
                                value: "function",
                                position: 386,
                            },
                            name: Identifier {
                                position: 395,
                                value: "where",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 400,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 401,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 402,
                                type_definition: SignedInteger(
                                    Default(
                                        Keyword {
                                            value: "int",
                                            position: 404,
                                        },
                                    ),
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 408,
                                statements: [
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Identifier(
                                                Identifier {
                                                    position: 414,
                                                    value: "where",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 420,
                            },
                        },
                    ),
                ],
            },
        ),
        Namespace(
            NamespaceDefinition {
                namespace: Keyword {
                    value: "namespace",
                    position: 423,
                },
                name: Identifier {
                    position: 433,
                    value: "type",
                },
                semicolon: 437,
                definitions: [
                    Constant(
                        ConstantDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            const: Keyword {
                                value: "const",
                                position: 440,
                            },
                            type_definition: UnsignedInteger(
                                U8(
                                    Keyword {
                                        value: "u8",
                                        position: 446,
                                    },
                                ),
                            ),
                            name: Identifier {
                                position: 449,
                                value: "type",
                            },
                            equals: 454,
                            value: Literal(
                                Integer(
                                    LiteralInteger {
                                        comments: CommentGroup {
                                            comments: [],
                                        },
                                        value: "1",
                                        position: 456,
                                    },
                                ),
                            ),
                            semicolon: 457,
                        },
                    ),
                    Interface(
                        InterfaceDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            interface: Keyword {
                                value: "interface",
                                position: 459,
                            },
                            name: Identifier {
                                position: 469,
                                value: "type",
                            },
                            templates: None,
                            extends: None,
                            body: InterfaceDefinitionBody {
                                left_brace: 474,
                                members: [],
                                right_brace: 475,
                            },
                        },
                    ),
                    Class(
                        ClassDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            modifiers: ModifierGroupDefinition {
                                position: 477,
                                modifiers: [],
                            },
                            class: Keyword {
                                value: "class",
                                position: 477,
                            },
                            name: Identifier {
                                position: 483,
                                value: "type",
                            },
                            templates: None,
                            extends: None,
                            implements: None,
                            body: ClassDefinitionBody {
                                left_brace: 488,
                                members: [
                                    Constant(
                                        ClassishConstantDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: ModifierGroupDefinition {
                                                position: 501,
                                                modifiers: [
                                                    Public(
                                                        Keyword {
                                                            value: "public",
                                                            position: 494,
                                                        },
                                                    ),
                                                ],
                                            },
                                            const: Keyword {
                                                value: "const",
                                                position: 501,
                                            },
                                            type_definition: UnsignedInteger(
                                                U8(
                                                    Keyword {
                                                        value: "u8",
                                                        position: 507,
                                                    },
                                                ),
                                            ),
                                            name: Identifier {
                                                position: 510,
                                                value: "type",
                                            },
                                            equals: 515,
                                            value: Literal(
                                                Integer(
                                                    LiteralInteger {
                                                        comments: CommentGroup {
                                                            comments: [],
                                                        },
                                                        value: "1",
                                                        position: 517,
                                                    },
                                                ),
                                            ),
                                            semicolon: 518,
                                        },
                                    ),
                                    Method(
                                        MethodDefinition {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            attributes: [],
                                            modifiers: ModifierGroupDefinition {
                                                position: 532,
                                                modifiers: [
                                                    Public(
                                                        Keyword {
                                                            value: "public",
                                                            position: 525,
                                                        },
                                                    ),
                                                ],
                                            },
                                            function: Keyword {
                                                value: "function",
                                                position: 532,
                                            },
                                            name: Identifier {
                                                position: 541,
                                                value: "type",
                                            },
                                            templates: None,
                                            parameters: MethodParameterListDefinition {
                                                comments: CommentGroup {
                                                    comments: [],
                                                },
                                                left_parenthesis: 545,
                                                parameters: CommaSeparated {
                                                    inner: [],
                                                    commas: [],
                                                },
                                                right_parenthesis: 546,
                                            },
                                            return_type: Some(
                                                FunctionLikeReturnTypeDefinition {
                                                    colon: 547,
                                                    type_definition: Void(
                                                        Keyword {
                                                            value: "void",
                                                            position: 549,
                                                        },
                                                    ),
                                                },
                                            ),
                                            constraints: None,
                                            body: Concrete(
                                                BlockStatement {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left_brace: 554,
                                                    statements: [],
                                                    right_brace: 555,
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 557,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: Keyword {
                                value: "function",
                                position: 560,
                            },
                            name: Identifier {
                                position: 569,
                                value: "type",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 573,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 574,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 575,
                                type_definition: Identifier(
                                    TemplatedIdentifier {
                                        name: Identifier {
                                            position: 577,
                                            value: "type",
                                        },
                                        templates: None,
                                    },
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 582,
                                statements: [
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 588,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 594,
                                                    right: Identifier(
                                                        Identifier {
                                                            position: 596,
                                                            value: "type",
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 600,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 606,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 612,
                                                    right: ClassOperation(
                                                        Initialization {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            new: Keyword {
                                                                value: "new",
                                                                position: 614,
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 618,
                                                                    value: "type",
                                                                },
                                                            ),
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 622,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 623,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 624,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 630,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 636,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 638,
                                                                    value: "type",
                                                                },
                                                            ),
                                                            double_colon: 642,
                                                            constant: Identifier {
                                                                position: 644,
                                                                value: "type",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 648,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 654,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 660,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: Identifier(
                                                                Identifier {
                                                                    position: 662,
                                                                    value: "type",
                                                                },
                                                            ),
                                                            double_colon: 666,
                                                            method: Identifier {
                                                                position: 668,
                                                                value: "type",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 672,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 673,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 674,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 680,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 686,
                                                    right: ClassOperation(
                                                        ConstantFetch {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 688,
                                                                            value: "type",
                                                                        },
                                                                    ),
                                                                    double_colon: 692,
                                                                    constant: Identifier {
                                                                        position: 694,
                                                                        value: "type",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 698,
                                                            constant: Identifier {
                                                                position: 700,
                                                                value: "type",
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 704,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 710,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 716,
                                                    right: ClassOperation(
                                                        StaticMethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            class: ClassOperation(
                                                                ConstantFetch {
                                                                    comments: CommentGroup {
                                                                        comments: [],
                                                                    },
                                                                    class: Identifier(
                                                                        Identifier {
                                                                            position: 718,
                                                                            value: "type",
                                                                        },
                                                                    ),
                                                                    double_colon: 722,
                                                                    constant: Identifier {
                                                                        position: 724,
                                                                        value: "type",
                                                                    },
                                                                },
                                                            ),
                                                            double_colon: 728,
                                                            method: Identifier {
                                                                position: 730,
                                                                value: "type",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 734,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 735,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 736,
                                        },
                                    ),
                                    Expression(
                                        ExpressionStatement {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: AssignmentOperation(
                                                Assignment {
                                                    comments: CommentGroup {
                                                        comments: [],
                                                    },
                                                    left: Variable(
                                                        Variable {
                                                            position: 742,
                                                            name: "$type",
                                                        },
                                                    ),
                                                    equals: 748,
                                                    right: ObjectOperation(
                                                        MethodCall {
                                                            comments: CommentGroup {
                                                                comments: [],
                                                            },
                                                            object: Variable(
                                                                Variable {
                                                                    position: 750,
                                                                    name: "$type",
                                                                },
                                                            ),
                                                            arrow: 755,
                                                            method: Identifier {
                                                                position: 757,
                                                                value: "type",
                                                            },
                                                            generics: None,
                                                            arguments: ArgumentListExpression {
                                                                comments: CommentGroup {
                                                                    comments: [],
                                                                },
                                                                left_parenthesis: 761,
                                                                arguments: CommaSeparated {
                                                                    inner: [],
                                                                    commas: [],
                                                                },
                                                                right_parenthesis: 762,
                                                            },
                                                        },
                                                    ),
                                                },
                                            ),
                                            semicolon: 763,
                                        },
                                    ),
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Variable(
                                                Variable {
                                                    position: 770,
                                                    name: "$type",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 776,
                            },
                        },
                    ),
                    Function(
                        FunctionDefinition {
                            comments: CommentGroup {
                                comments: [],
                            },
                            attributes: [],
                            function: Keyword {
                                value: "function",
                                position: 779,
                            },
                            name: Identifier {
                                position: 788,
                                value: "type",
                            },
                            templates: None,
                            parameters: FunctionLikeParameterListDefinition {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_parenthesis: 792,
                                parameters: CommaSeparated {
                                    inner: [],
                                    commas: [],
                                },
                                right_parenthesis: 793,
                            },
                            return_type: FunctionLikeReturnTypeDefinition {
                                colon: 794,
                                type_definition: SignedInteger(
                                    Default(
                                        Keyword {
                                            value: "int",
                                            position: 796,
                                        },
                                    ),
                                ),
                            },
                            body: BlockStatement {
                                comments: CommentGroup {
                                    comments: [],
                                },
                                left_brace: 800,
                                statements: [
                                    Return(
                                        Implicit {
                                            comments: CommentGroup {
                                                comments: [],
                                            },
                                            expression: Identifier(
                                                Identifier {
                                                    position: 806,
                                                    value: "type",
                                                },
                                            ),
                                        },
                                    ),
                                ],
                                right_brace: 811,
                            },
                        },
                    ),
                ],
            },
        ),
    ],
    eof: 813,
}