---
Function {
    argument: None,
    arguments: FunctionArguments {
        arguments: [
            FunctionArgument {
                identifier: "withDebug",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (13, 15),
                    },
                ),
            },
            FunctionArgument {
                identifier: "withIPv6",
                default: Some(
                    Variable {
                        identifier: "true",
                        position: (12, 14),
                    },
                ),
            },
            FunctionArgument {
                identifier: "openssl",
                default: Some(
                    Variable {
                        identifier: "null",
                        position: (11, 29),
                    },
                ),
            },
            FunctionArgument {
                identifier: "withSSL",
                default: Some(
                    Variable {
                        identifier: "true",
                        position: (11, 13),
                    },
                ),
            },
            FunctionArgument {
                identifier: "ruby_2_7",
                default: None,
            },
            FunctionArgument {
                identifier: "withRuby_2_7",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (10, 18),
                    },
                ),
            },
            FunctionArgument {
                identifier: "perldevel",
                default: None,
            },
            FunctionArgument {
                identifier: "withPerldevel",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (9, 19),
                    },
                ),
            },
            FunctionArgument {
                identifier: "perl534",
                default: None,
            },
            FunctionArgument {
                identifier: "withPerl534",
                default: Some(
                    Variable {
                        identifier: "true",
                        position: (8, 17),
                    },
                ),
            },
            FunctionArgument {
                identifier: "perl532",
                default: None,
            },
            FunctionArgument {
                identifier: "withPerl532",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (7, 17),
                    },
                ),
            },
            FunctionArgument {
                identifier: "php80",
                default: None,
            },
            FunctionArgument {
                identifier: "withPHP80",
                default: Some(
                    Variable {
                        identifier: "true",
                        position: (6, 15),
                    },
                ),
            },
            FunctionArgument {
                identifier: "php74",
                default: None,
            },
            FunctionArgument {
                identifier: "withPHP74",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (5, 15),
                    },
                ),
            },
            FunctionArgument {
                identifier: "ncurses",
                default: None,
            },
            FunctionArgument {
                identifier: "python3",
                default: None,
            },
            FunctionArgument {
                identifier: "withPython3",
                default: Some(
                    Variable {
                        identifier: "true",
                        position: (4, 17),
                    },
                ),
            },
            FunctionArgument {
                identifier: "python2",
                default: None,
            },
            FunctionArgument {
                identifier: "withPython2",
                default: Some(
                    Variable {
                        identifier: "false",
                        position: (3, 17),
                    },
                ),
            },
            FunctionArgument {
                identifier: "pcre2",
                default: None,
            },
            FunctionArgument {
                identifier: "which",
                default: None,
            },
            FunctionArgument {
                identifier: "nixosTests",
                default: None,
            },
            FunctionArgument {
                identifier: "fetchFromGitHub",
                default: None,
            },
            FunctionArgument {
                identifier: "stdenv",
                default: None,
            },
            FunctionArgument {
                identifier: "lib",
                default: None,
            },
        ],
        ellipsis: false,
    },
    definition: With {
        expression: Variable {
            identifier: "lib",
            position: (16, 6),
        },
        target: LetIn {
            bindings: [
                KeyValue(
                    AttributePath {
                        attributes: [
                            Raw {
                                content: "phpConfig",
                                position: (19, 3),
                            },
                        ],
                    },
                    Map {
                        bindings: [
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "embedSupport",
                                            position: (20, 5),
                                        },
                                    ],
                                },
                                Variable {
                                    identifier: "true",
                                    position: (20, 20),
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "apxs2Support",
                                            position: (21, 5),
                                        },
                                    ],
                                },
                                Variable {
                                    identifier: "false",
                                    position: (21, 20),
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "systemdSupport",
                                            position: (22, 5),
                                        },
                                    ],
                                },
                                Variable {
                                    identifier: "false",
                                    position: (22, 22),
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "phpdbgSupport",
                                            position: (23, 5),
                                        },
                                    ],
                                },
                                Variable {
                                    identifier: "false",
                                    position: (23, 21),
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "cgiSupport",
                                            position: (24, 5),
                                        },
                                    ],
                                },
                                Variable {
                                    identifier: "false",
                                    position: (24, 18),
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "fpmSupport",
                                            position: (25, 5),
                                        },
                                    ],
                                },
                                Variable {
                                    identifier: "false",
                                    position: (25, 18),
                                },
                            ),
                        ],
                        recursive: false,
                    },
                ),
                KeyValue(
                    AttributePath {
                        attributes: [
                            Raw {
                                content: "php74-unit",
                                position: (28, 3),
                            },
                        ],
                    },
                    FunctionApplication {
                        function: PropertyAccess {
                            expression: Variable {
                                identifier: "php74",
                                position: (28, 16),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "override",
                                        position: (28, 22),
                                    },
                                ],
                            },
                            default: None,
                        },
                        arguments: [
                            Variable {
                                identifier: "phpConfig",
                                position: (28, 31),
                            },
                        ],
                    },
                ),
                KeyValue(
                    AttributePath {
                        attributes: [
                            Raw {
                                content: "php80-unit",
                                position: (29, 3),
                            },
                        ],
                    },
                    FunctionApplication {
                        function: PropertyAccess {
                            expression: Variable {
                                identifier: "php80",
                                position: (29, 16),
                            },
                            attribute_path: AttributePath {
                                attributes: [
                                    Raw {
                                        content: "override",
                                        position: (29, 22),
                                    },
                                ],
                            },
                            default: None,
                        },
                        arguments: [
                            Variable {
                                identifier: "phpConfig",
                                position: (29, 31),
                            },
                        ],
                    },
                ),
            ],
            target: FunctionApplication {
                function: PropertyAccess {
                    expression: Variable {
                        identifier: "stdenv",
                        position: (31, 4),
                    },
                    attribute_path: AttributePath {
                        attributes: [
                            Raw {
                                content: "mkDerivation",
                                position: (31, 11),
                            },
                        ],
                    },
                    default: None,
                },
                arguments: [
                    Map {
                        bindings: [
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "version",
                                            position: (32, 3),
                                        },
                                    ],
                                },
                                String {
                                    parts: [
                                        Raw {
                                            content: "1.26.1",
                                            position: (32, 14),
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "pname",
                                            position: (33, 3),
                                        },
                                    ],
                                },
                                String {
                                    parts: [
                                        Raw {
                                            content: "unit",
                                            position: (33, 12),
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "src",
                                            position: (35, 3),
                                        },
                                    ],
                                },
                                FunctionApplication {
                                    function: Variable {
                                        identifier: "fetchFromGitHub",
                                        position: (35, 9),
                                    },
                                    arguments: [
                                        Map {
                                            bindings: [
                                                KeyValue(
                                                    AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "owner",
                                                                position: (36, 5),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "nginx",
                                                                position: (36, 14),
                                                            },
                                                        ],
                                                    },
                                                ),
                                                KeyValue(
                                                    AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "repo",
                                                                position: (37, 5),
                                                            },
                                                        ],
                                                    },
                                                    Variable {
                                                        identifier: "pname",
                                                        position: (37, 12),
                                                    },
                                                ),
                                                KeyValue(
                                                    AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "rev",
                                                                position: (38, 5),
                                                            },
                                                        ],
                                                    },
                                                    Variable {
                                                        identifier: "version",
                                                        position: (38, 11),
                                                    },
                                                ),
                                                KeyValue(
                                                    AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "sha256",
                                                                position: (39, 5),
                                                            },
                                                        ],
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "sha256-rTT7EJSHepGOwNXVqlOBOhZayZQXyNo3B2Oa1oLf2FI=",
                                                                position: (39, 15),
                                                            },
                                                        ],
                                                    },
                                                ),
                                            ],
                                            recursive: false,
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "nativeBuildInputs",
                                            position: (42, 3),
                                        },
                                    ],
                                },
                                List {
                                    elements: [
                                        Variable {
                                            identifier: "which",
                                            position: (42, 25),
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "buildInputs",
                                            position: (44, 3),
                                        },
                                    ],
                                },
                                BinaryOperation {
                                    operator: Concatenation,
                                    operands: [
                                        List {
                                            elements: [
                                                PropertyAccess {
                                                    expression: Variable {
                                                        identifier: "pcre2",
                                                        position: (44, 19),
                                                    },
                                                    attribute_path: AttributePath {
                                                        attributes: [
                                                            Raw {
                                                                content: "dev",
                                                                position: (44, 25),
                                                            },
                                                        ],
                                                    },
                                                    default: None,
                                                },
                                            ],
                                        },
                                        BinaryOperation {
                                            operator: Concatenation,
                                            operands: [
                                                FunctionApplication {
                                                    function: Variable {
                                                        identifier: "optional",
                                                        position: (45, 8),
                                                    },
                                                    arguments: [
                                                        Variable {
                                                            identifier: "withPython2",
                                                            position: (45, 17),
                                                        },
                                                        Variable {
                                                            identifier: "python2",
                                                            position: (45, 29),
                                                        },
                                                    ],
                                                },
                                                BinaryOperation {
                                                    operator: Concatenation,
                                                    operands: [
                                                        FunctionApplication {
                                                            function: Variable {
                                                                identifier: "optionals",
                                                                position: (46, 8),
                                                            },
                                                            arguments: [
                                                                Variable {
                                                                    identifier: "withPython3",
                                                                    position: (46, 18),
                                                                },
                                                                List {
                                                                    elements: [
                                                                        Variable {
                                                                            identifier: "python3",
                                                                            position: (46, 32),
                                                                        },
                                                                        Variable {
                                                                            identifier: "ncurses",
                                                                            position: (46, 40),
                                                                        },
                                                                    ],
                                                                },
                                                            ],
                                                        },
                                                        BinaryOperation {
                                                            operator: Concatenation,
                                                            operands: [
                                                                FunctionApplication {
                                                                    function: Variable {
                                                                        identifier: "optional",
                                                                        position: (47, 8),
                                                                    },
                                                                    arguments: [
                                                                        Variable {
                                                                            identifier: "withPHP74",
                                                                            position: (47, 17),
                                                                        },
                                                                        Variable {
                                                                            identifier: "php74-unit",
                                                                            position: (47, 27),
                                                                        },
                                                                    ],
                                                                },
                                                                BinaryOperation {
                                                                    operator: Concatenation,
                                                                    operands: [
                                                                        FunctionApplication {
                                                                            function: Variable {
                                                                                identifier: "optional",
                                                                                position: (48, 8),
                                                                            },
                                                                            arguments: [
                                                                                Variable {
                                                                                    identifier: "withPHP80",
                                                                                    position: (48, 17),
                                                                                },
                                                                                Variable {
                                                                                    identifier: "php80-unit",
                                                                                    position: (48, 27),
                                                                                },
                                                                            ],
                                                                        },
                                                                        BinaryOperation {
                                                                            operator: Concatenation,
                                                                            operands: [
                                                                                FunctionApplication {
                                                                                    function: Variable {
                                                                                        identifier: "optional",
                                                                                        position: (49, 8),
                                                                                    },
                                                                                    arguments: [
                                                                                        Variable {
                                                                                            identifier: "withPerl532",
                                                                                            position: (49, 17),
                                                                                        },
                                                                                        Variable {
                                                                                            identifier: "perl532",
                                                                                            position: (49, 29),
                                                                                        },
                                                                                    ],
                                                                                },
                                                                                BinaryOperation {
                                                                                    operator: Concatenation,
                                                                                    operands: [
                                                                                        FunctionApplication {
                                                                                            function: Variable {
                                                                                                identifier: "optional",
                                                                                                position: (50, 8),
                                                                                            },
                                                                                            arguments: [
                                                                                                Variable {
                                                                                                    identifier: "withPerl534",
                                                                                                    position: (50, 17),
                                                                                                },
                                                                                                Variable {
                                                                                                    identifier: "perl534",
                                                                                                    position: (50, 29),
                                                                                                },
                                                                                            ],
                                                                                        },
                                                                                        BinaryOperation {
                                                                                            operator: Concatenation,
                                                                                            operands: [
                                                                                                FunctionApplication {
                                                                                                    function: Variable {
                                                                                                        identifier: "optional",
                                                                                                        position: (51, 8),
                                                                                                    },
                                                                                                    arguments: [
                                                                                                        Variable {
                                                                                                            identifier: "withPerldevel",
                                                                                                            position: (51, 17),
                                                                                                        },
                                                                                                        Variable {
                                                                                                            identifier: "perldevel",
                                                                                                            position: (51, 31),
                                                                                                        },
                                                                                                    ],
                                                                                                },
                                                                                                BinaryOperation {
                                                                                                    operator: Concatenation,
                                                                                                    operands: [
                                                                                                        FunctionApplication {
                                                                                                            function: Variable {
                                                                                                                identifier: "optional",
                                                                                                                position: (52, 8),
                                                                                                            },
                                                                                                            arguments: [
                                                                                                                Variable {
                                                                                                                    identifier: "withRuby_2_7",
                                                                                                                    position: (52, 17),
                                                                                                                },
                                                                                                                Variable {
                                                                                                                    identifier: "ruby_2_7",
                                                                                                                    position: (52, 30),
                                                                                                                },
                                                                                                            ],
                                                                                                        },
                                                                                                        FunctionApplication {
                                                                                                            function: Variable {
                                                                                                                identifier: "optional",
                                                                                                                position: (53, 8),
                                                                                                            },
                                                                                                            arguments: [
                                                                                                                Variable {
                                                                                                                    identifier: "withSSL",
                                                                                                                    position: (53, 17),
                                                                                                                },
                                                                                                                Variable {
                                                                                                                    identifier: "openssl",
                                                                                                                    position: (53, 25),
                                                                                                                },
                                                                                                            ],
                                                                                                        },
                                                                                                    ],
                                                                                                },
                                                                                            ],
                                                                                        },
                                                                                    ],
                                                                                },
                                                                            ],
                                                                        },
                                                                    ],
                                                                },
                                                            ],
                                                        },
                                                    ],
                                                },
                                            ],
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "configureFlags",
                                            position: (55, 3),
                                        },
                                    ],
                                },
                                BinaryOperation {
                                    operator: Concatenation,
                                    operands: [
                                        List {
                                            elements: [
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "--control=unix:/run/unit/control.unit.sock",
                                                            position: (56, 6),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "--pid=/run/unit/unit.pid",
                                                            position: (57, 6),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "--user=unit",
                                                            position: (58, 6),
                                                        },
                                                    ],
                                                },
                                                String {
                                                    parts: [
                                                        Raw {
                                                            content: "--group=unit",
                                                            position: (59, 6),
                                                        },
                                                    ],
                                                },
                                            ],
                                        },
                                        BinaryOperation {
                                            operator: Concatenation,
                                            operands: [
                                                FunctionApplication {
                                                    function: Variable {
                                                        identifier: "optional",
                                                        position: (60, 8),
                                                    },
                                                    arguments: [
                                                        Variable {
                                                            identifier: "withSSL",
                                                            position: (60, 17),
                                                        },
                                                        String {
                                                            parts: [
                                                                Raw {
                                                                    content: "--openssl",
                                                                    position: (60, 30),
                                                                },
                                                            ],
                                                        },
                                                    ],
                                                },
                                                BinaryOperation {
                                                    operator: Concatenation,
                                                    operands: [
                                                        FunctionApplication {
                                                            function: Variable {
                                                                identifier: "optional",
                                                                position: (61, 8),
                                                            },
                                                            arguments: [
                                                                UnaryOperation {
                                                                    operator: Not,
                                                                    operand: Variable {
                                                                        identifier: "withIPv6",
                                                                        position: (61, 19),
                                                                    },
                                                                },
                                                                String {
                                                                    parts: [
                                                                        Raw {
                                                                            content: "--no-ipv6",
                                                                            position: (61, 30),
                                                                        },
                                                                    ],
                                                                },
                                                            ],
                                                        },
                                                        FunctionApplication {
                                                            function: Variable {
                                                                identifier: "optional",
                                                                position: (62, 8),
                                                            },
                                                            arguments: [
                                                                Variable {
                                                                    identifier: "withDebug",
                                                                    position: (62, 17),
                                                                },
                                                                String {
                                                                    parts: [
                                                                        Raw {
                                                                            content: "--debug",
                                                                            position: (62, 30),
                                                                        },
                                                                    ],
                                                                },
                                                            ],
                                                        },
                                                    ],
                                                },
                                            ],
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "usedPhp74",
                                            position: (65, 3),
                                        },
                                    ],
                                },
                                FunctionApplication {
                                    function: Variable {
                                        identifier: "optionals",
                                        position: (65, 15),
                                    },
                                    arguments: [
                                        Variable {
                                            identifier: "withPHP74",
                                            position: (65, 25),
                                        },
                                        Variable {
                                            identifier: "php74-unit",
                                            position: (65, 35),
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "usedPhp80",
                                            position: (66, 3),
                                        },
                                    ],
                                },
                                FunctionApplication {
                                    function: Variable {
                                        identifier: "optionals",
                                        position: (66, 15),
                                    },
                                    arguments: [
                                        Variable {
                                            identifier: "withPHP80",
                                            position: (66, 25),
                                        },
                                        Variable {
                                            identifier: "php80-unit",
                                            position: (66, 35),
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "postConfigure",
                                            position: (68, 3),
                                        },
                                    ],
                                },
                                String {
                                    parts: [
                                        Raw {
                                            content: "",
                                            position: (69, 1),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (69, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withPython2",
                                                        position: (69, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure python --module=python2  --config=python2-config  --lib-path=",
                                                                position: (69, 38),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "python2",
                                                                    position: (69, 113),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/lib",
                                                                position: (69, 121),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (69, 127),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (70, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withPython3",
                                                        position: (70, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure python --module=python3  --config=python3-config  --lib-path=",
                                                                position: (70, 38),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "python3",
                                                                    position: (70, 113),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/lib",
                                                                position: (70, 121),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (70, 127),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (71, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withPHP74",
                                                        position: (71, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure php    --module=php74    --config=",
                                                                position: (71, 38),
                                                            },
                                                            Expression {
                                                                expression: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "php74-unit",
                                                                        position: (71, 86),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "unwrapped",
                                                                                position: (71, 97),
                                                                            },
                                                                            Raw {
                                                                                content: "dev",
                                                                                position: (71, 107),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/bin/php-config --lib-path=",
                                                                position: (71, 111),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "php74-unit",
                                                                    position: (71, 140),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/lib",
                                                                position: (71, 151),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (71, 157),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (72, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withPHP80",
                                                        position: (72, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure php    --module=php80    --config=",
                                                                position: (72, 38),
                                                            },
                                                            Expression {
                                                                expression: PropertyAccess {
                                                                    expression: Variable {
                                                                        identifier: "php80-unit",
                                                                        position: (72, 86),
                                                                    },
                                                                    attribute_path: AttributePath {
                                                                        attributes: [
                                                                            Raw {
                                                                                content: "unwrapped",
                                                                                position: (72, 97),
                                                                            },
                                                                            Raw {
                                                                                content: "dev",
                                                                                position: (72, 107),
                                                                            },
                                                                        ],
                                                                    },
                                                                    default: None,
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/bin/php-config --lib-path=",
                                                                position: (72, 111),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "php80-unit",
                                                                    position: (72, 140),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/lib",
                                                                position: (72, 151),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (72, 157),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (73, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withPerl532",
                                                        position: (73, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure perl   --module=perl532  --perl=",
                                                                position: (73, 38),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "perl532",
                                                                    position: (73, 84),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/bin/perl",
                                                                position: (73, 92),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (73, 103),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (74, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withPerl534",
                                                        position: (74, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure perl   --module=perl534  --perl=",
                                                                position: (74, 38),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "perl534",
                                                                    position: (74, 84),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/bin/perl",
                                                                position: (74, 92),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (74, 103),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (75, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withPerldevel",
                                                        position: (75, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure perl   --module=perldev  --perl=",
                                                                position: (75, 38),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "perldevel",
                                                                    position: (75, 84),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/bin/perl",
                                                                position: (75, 94),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (75, 105),
                                        },
                                        Expression {
                                            expression: FunctionApplication {
                                                function: Variable {
                                                    identifier: "optionalString",
                                                    position: (76, 7),
                                                },
                                                arguments: [
                                                    Variable {
                                                        identifier: "withRuby_2_7",
                                                        position: (76, 22),
                                                    },
                                                    String {
                                                        parts: [
                                                            Raw {
                                                                content: "./configure ruby   --module=ruby27   --ruby=",
                                                                position: (76, 38),
                                                            },
                                                            Expression {
                                                                expression: Variable {
                                                                    identifier: "ruby_2_7",
                                                                    position: (76, 84),
                                                                },
                                                            },
                                                            Raw {
                                                                content: "/bin/ruby",
                                                                position: (76, 93),
                                                            },
                                                        ],
                                                    },
                                                ],
                                            },
                                        },
                                        Raw {
                                            content: "\n",
                                            position: (76, 104),
                                        },
                                    ],
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "passthru",
                                            position: (79, 3),
                                        },
                                        Raw {
                                            content: "tests",
                                            position: (79, 12),
                                        },
                                        Raw {
                                            content: "unit-php",
                                            position: (79, 18),
                                        },
                                    ],
                                },
                                PropertyAccess {
                                    expression: Variable {
                                        identifier: "nixosTests",
                                        position: (79, 29),
                                    },
                                    attribute_path: AttributePath {
                                        attributes: [
                                            Raw {
                                                content: "unit-php",
                                                position: (79, 40),
                                            },
                                        ],
                                    },
                                    default: None,
                                },
                            ),
                            KeyValue(
                                AttributePath {
                                    attributes: [
                                        Raw {
                                            content: "meta",
                                            position: (81, 3),
                                        },
                                    ],
                                },
                                Map {
                                    bindings: [
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "description",
                                                        position: (82, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "Dynamic web and application server, designed to run applications in multiple languages",
                                                        position: (82, 20),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "homepage",
                                                        position: (83, 5),
                                                    },
                                                ],
                                            },
                                            String {
                                                parts: [
                                                    Raw {
                                                        content: "https://unit.nginx.org/",
                                                        position: (83, 20),
                                                    },
                                                ],
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "license",
                                                        position: (84, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "licenses",
                                                    position: (84, 19),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "asl20",
                                                            position: (84, 28),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "platforms",
                                                        position: (85, 5),
                                                    },
                                                ],
                                            },
                                            PropertyAccess {
                                                expression: Variable {
                                                    identifier: "platforms",
                                                    position: (85, 19),
                                                },
                                                attribute_path: AttributePath {
                                                    attributes: [
                                                        Raw {
                                                            content: "linux",
                                                            position: (85, 29),
                                                        },
                                                    ],
                                                },
                                                default: None,
                                            },
                                        ),
                                        KeyValue(
                                            AttributePath {
                                                attributes: [
                                                    Raw {
                                                        content: "maintainers",
                                                        position: (86, 5),
                                                    },
                                                ],
                                            },
                                            With {
                                                expression: Variable {
                                                    identifier: "maintainers",
                                                    position: (86, 24),
                                                },
                                                target: List {
                                                    elements: [
                                                        Variable {
                                                            identifier: "izorkin",
                                                            position: (86, 39),
                                                        },
                                                    ],
                                                },
                                            },
                                        ),
                                    ],
                                    recursive: false,
                                },
                            ),
                        ],
                        recursive: true,
                    },
                ],
            },
        },
    },
}